File: Mathlib/Algebra/Group/Opposite.lean

full_name: MulOpposite.instNatCast
code: @[to_additive] instance instNatCast [NatCast α] : NatCast αᵐᵒᵖ 
goal: NatCast αᵐᵒᵖ

full_name: AddOpposite.instNatCast
code: @[to_additive] instance instNatCast [NatCast α] : NatCast αᵐᵒᵖ 
goal: NatCast αᵃᵒᵖ

full_name: MulOpposite.instIntCast
code: @[to_additive] instance instIntCast [IntCast α] : IntCast αᵐᵒᵖ 
goal: IntCast αᵐᵒᵖ

full_name: AddOpposite.instIntCast
code: @[to_additive] instance instIntCast [IntCast α] : IntCast αᵐᵒᵖ 
goal: IntCast αᵃᵒᵖ

full_name: MulOpposite.instAddSemigroup
code: instance instAddSemigroup [AddSemigroup α] : AddSemigroup αᵐᵒᵖ 
goal: AddSemigroup αᵐᵒᵖ

full_name: MulOpposite.instAddLeftCancelSemigroup
code: instance instAddLeftCancelSemigroup [AddLeftCancelSemigroup α] : AddLeftCancelSemigroup αᵐᵒᵖ 
goal: AddLeftCancelSemigroup αᵐᵒᵖ

full_name: MulOpposite.instAddRightCancelSemigroup
code: instance instAddRightCancelSemigroup [AddRightCancelSemigroup α] : AddRightCancelSemigroup αᵐᵒᵖ 
goal: AddRightCancelSemigroup αᵐᵒᵖ

full_name: MulOpposite.instAddCommSemigroup
code: instance instAddCommSemigroup [AddCommSemigroup α] : AddCommSemigroup αᵐᵒᵖ 
goal: AddCommSemigroup αᵐᵒᵖ

full_name: MulOpposite.instAddZeroClass
code: instance instAddZeroClass [AddZeroClass α] : AddZeroClass αᵐᵒᵖ 
goal: AddZeroClass αᵐᵒᵖ

full_name: MulOpposite.instAddMonoid
code: instance instAddMonoid [AddMonoid α] : AddMonoid αᵐᵒᵖ 
goal: AddMonoid αᵐᵒᵖ

full_name: MulOpposite.instAddCommMonoid
code: instance instAddCommMonoid [AddCommMonoid α] : AddCommMonoid αᵐᵒᵖ 
goal: AddCommMonoid αᵐᵒᵖ

full_name: MulOpposite.instAddMonoidWithOne
code: instance instAddMonoidWithOne [AddMonoidWithOne α] : AddMonoidWithOne αᵐᵒᵖ 
goal: AddMonoidWithOne αᵐᵒᵖ

full_name: MulOpposite.instAddCommMonoidWithOne
code: instance instAddCommMonoidWithOne [AddCommMonoidWithOne α] : AddCommMonoidWithOne αᵐᵒᵖ 
goal: AddCommMonoidWithOne αᵐᵒᵖ

full_name: MulOpposite.instSubNegMonoid
code: instance instSubNegMonoid [SubNegMonoid α] : SubNegMonoid αᵐᵒᵖ 
goal: SubNegMonoid αᵐᵒᵖ

full_name: MulOpposite.instAddGroup
code: instance instAddGroup [AddGroup α] : AddGroup αᵐᵒᵖ 
goal: AddGroup αᵐᵒᵖ

full_name: MulOpposite.instAddCommGroup
code: instance instAddCommGroup [AddCommGroup α] : AddCommGroup αᵐᵒᵖ 
goal: AddCommGroup αᵐᵒᵖ

full_name: MulOpposite.instAddGroupWithOne
code: instance instAddGroupWithOne [AddGroupWithOne α] : AddGroupWithOne αᵐᵒᵖ 
goal: AddGroupWithOne αᵐᵒᵖ

full_name: MulOpposite.instAddCommGroupWithOne
code: instance instAddCommGroupWithOne [AddCommGroupWithOne α] : AddCommGroupWithOne αᵐᵒᵖ 
goal: AddCommGroupWithOne αᵐᵒᵖ

full_name: AddOpposite.instIsAddRightCancel
code: @[to_additive]
instance instIsRightCancelMul [Mul α] [IsLeftCancelMul α] : IsRightCancelMul αᵐᵒᵖ 
goal: IsRightCancelAdd αᵃᵒᵖ

full_name: MulOpposite.instIsRightCancelMul
code: @[to_additive]
instance instIsRightCancelMul [Mul α] [IsLeftCancelMul α] : IsRightCancelMul αᵐᵒᵖ 
goal: IsRightCancelMul αᵐᵒᵖ

full_name: AddOpposite.instIsAddLeftCancel
code: @[to_additive]
instance instIsLeftCancelMul [Mul α] [IsRightCancelMul α] : IsLeftCancelMul αᵐᵒᵖ 
goal: IsLeftCancelAdd αᵃᵒᵖ

full_name: MulOpposite.instIsLeftCancelMul
code: @[to_additive]
instance instIsLeftCancelMul [Mul α] [IsRightCancelMul α] : IsLeftCancelMul αᵐᵒᵖ 
goal: IsLeftCancelMul αᵐᵒᵖ

full_name: MulOpposite.instSemigroup
code: @[to_additive]
instance instSemigroup [Semigroup α] : Semigroup αᵐᵒᵖ 
goal: Semigroup αᵐᵒᵖ

full_name: AddOpposite.instAddSemigroup
code: @[to_additive]
instance instSemigroup [Semigroup α] : Semigroup αᵐᵒᵖ 
goal: AddSemigroup αᵃᵒᵖ

full_name: AddOpposite.instAddLeftCancelSemigroup
code: @[to_additive]
instance instLeftCancelSemigroup [RightCancelSemigroup α] : LeftCancelSemigroup αᵐᵒᵖ 
goal: AddLeftCancelSemigroup αᵃᵒᵖ

full_name: MulOpposite.instLeftCancelSemigroup
code: @[to_additive]
instance instLeftCancelSemigroup [RightCancelSemigroup α] : LeftCancelSemigroup αᵐᵒᵖ 
goal: LeftCancelSemigroup αᵐᵒᵖ

full_name: MulOpposite.instRightCancelSemigroup
code: @[to_additive]
instance instRightCancelSemigroup [LeftCancelSemigroup α] : RightCancelSemigroup αᵐᵒᵖ 
goal: RightCancelSemigroup αᵐᵒᵖ

full_name: AddOpposite.instAddRightCancelSemigroup
code: @[to_additive]
instance instRightCancelSemigroup [LeftCancelSemigroup α] : RightCancelSemigroup αᵐᵒᵖ 
goal: AddRightCancelSemigroup αᵃᵒᵖ

full_name: AddOpposite.instAddCommSemigroup
code: @[to_additive]
instance instCommSemigroup [CommSemigroup α] : CommSemigroup αᵐᵒᵖ 
goal: AddCommSemigroup αᵃᵒᵖ

full_name: MulOpposite.instCommSemigroup
code: @[to_additive]
instance instCommSemigroup [CommSemigroup α] : CommSemigroup αᵐᵒᵖ 
goal: CommSemigroup αᵐᵒᵖ

full_name: AddOpposite.instAddZeroClass
code: @[to_additive]
instance instMulOneClass [MulOneClass α] : MulOneClass αᵐᵒᵖ 
goal: AddZeroClass αᵃᵒᵖ

full_name: MulOpposite.instMulOneClass
code: @[to_additive]
instance instMulOneClass [MulOneClass α] : MulOneClass αᵐᵒᵖ 
goal: MulOneClass αᵐᵒᵖ

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

full_name: AddOpposite.instAddMonoid
code: @[to_additive]
instance instMonoid [Monoid α] : Monoid αᵐᵒᵖ 
goal: AddMonoid αᵃᵒᵖ

full_name: MulOpposite.instLeftCancelMonoid
code: @[to_additive]
instance instLeftCancelMonoid [RightCancelMonoid α] : LeftCancelMonoid αᵐᵒᵖ 
goal: LeftCancelMonoid αᵐᵒᵖ

full_name: AddOpposite.instAddLeftCancelMonoid
code: @[to_additive]
instance instLeftCancelMonoid [RightCancelMonoid α] : LeftCancelMonoid αᵐᵒᵖ 
goal: AddLeftCancelMonoid αᵃᵒᵖ

full_name: AddOpposite.instAddRightCancelMonoid
code: @[to_additive]
instance instRightCancelMonoid [LeftCancelMonoid α] : RightCancelMonoid αᵐᵒᵖ 
goal: AddRightCancelMonoid αᵃᵒᵖ

full_name: MulOpposite.instRightCancelMonoid
code: @[to_additive]
instance instRightCancelMonoid [LeftCancelMonoid α] : RightCancelMonoid αᵐᵒᵖ 
goal: RightCancelMonoid αᵐᵒᵖ

full_name: AddOpposite.instAddCancelMonoid
code: @[to_additive]
instance instCancelMonoid [CancelMonoid α] : CancelMonoid αᵐᵒᵖ 
goal: AddCancelMonoid αᵃᵒᵖ

full_name: MulOpposite.instCancelMonoid
code: @[to_additive]
instance instCancelMonoid [CancelMonoid α] : CancelMonoid αᵐᵒᵖ 
goal: CancelMonoid αᵐᵒᵖ

full_name: AddOpposite.instAddCommMonoid
code: @[to_additive]
instance instCommMonoid [CommMonoid α] : CommMonoid αᵐᵒᵖ 
goal: AddCommMonoid αᵃᵒᵖ

full_name: MulOpposite.instCommMonoid
code: @[to_additive]
instance instCommMonoid [CommMonoid α] : CommMonoid αᵐᵒᵖ 
goal: CommMonoid αᵐᵒᵖ

full_name: MulOpposite.instCancelCommMonoid
code: @[to_additive]
instance instCancelCommMonoid [CancelCommMonoid α] : CancelCommMonoid αᵐᵒᵖ 
goal: CancelCommMonoid αᵐᵒᵖ

full_name: AddOpposite.instAddCancelCommMonoid
code: @[to_additive]
instance instCancelCommMonoid [CancelCommMonoid α] : CancelCommMonoid αᵐᵒᵖ 
goal: AddCancelCommMonoid αᵃᵒᵖ

full_name: AddOpposite.instSubNegMonoid
code: @[to_additive AddOpposite.instSubNegMonoid]
instance instDivInvMonoid [DivInvMonoid α] : DivInvMonoid αᵐᵒᵖ 
goal: SubNegMonoid αᵃᵒᵖ

full_name: MulOpposite.instDivInvMonoid
code: @[to_additive AddOpposite.instSubNegMonoid]
instance instDivInvMonoid [DivInvMonoid α] : DivInvMonoid αᵐᵒᵖ 
goal: DivInvMonoid αᵐᵒᵖ

full_name: MulOpposite.instDivisionMonoid
code: @[to_additive AddOpposite.instSubtractionMonoid]
instance instDivisionMonoid [DivisionMonoid α] : DivisionMonoid αᵐᵒᵖ 
goal: DivisionMonoid αᵐᵒᵖ

full_name: AddOpposite.instSubtractionMonoid
code: @[to_additive AddOpposite.instSubtractionMonoid]
instance instDivisionMonoid [DivisionMonoid α] : DivisionMonoid αᵐᵒᵖ 
goal: SubtractionMonoid αᵃᵒᵖ

full_name: MulOpposite.instDivisionCommMonoid
code: @[to_additive AddOpposite.instSubtractionCommMonoid]
instance instDivisionCommMonoid [DivisionCommMonoid α] : DivisionCommMonoid αᵐᵒᵖ 
goal: DivisionCommMonoid αᵐᵒᵖ

full_name: AddOpposite.instSubtractionCommMonoid
code: @[to_additive AddOpposite.instSubtractionCommMonoid]
instance instDivisionCommMonoid [DivisionCommMonoid α] : DivisionCommMonoid αᵐᵒᵖ 
goal: SubtractionCommMonoid αᵃᵒᵖ

full_name: MulOpposite.instGroup
code: @[to_additive]
instance instGroup [Group α] : Group αᵐᵒᵖ 
goal: Group αᵐᵒᵖ

full_name: AddOpposite.instAddGroup
code: @[to_additive]
instance instGroup [Group α] : Group αᵐᵒᵖ 
goal: AddGroup αᵃᵒᵖ

full_name: AddOpposite.instAddCommGroup
code: @[to_additive]
instance instCommGroup [CommGroup α] : CommGroup αᵐᵒᵖ 
goal: AddCommGroup αᵃᵒᵖ

full_name: MulOpposite.instCommGroup
code: @[to_additive]
instance instCommGroup [CommGroup α] : CommGroup αᵐᵒᵖ 
goal: CommGroup αᵐᵒᵖ

full_name: MulOpposite.op_pow
code: @[simp] lemma op_pow (x : α) (n : ℕ) : op (x ^ n) = op x ^ n 
goal: MulOpposite.op (x ^ n) = MulOpposite.op x ^ n

full_name: MulOpposite.unop_pow
code: @[simp] lemma unop_pow (x : αᵐᵒᵖ) (n : ℕ) : unop (x ^ n) = unop x ^ n 
goal: MulOpposite.unop (x ^ n) = MulOpposite.unop x ^ n

full_name: MulOpposite.op_zpow
code: @[simp] lemma op_zpow (x : α) (z : ℤ) : op (x ^ z) = op x ^ z 
goal: MulOpposite.op (x ^ z) = MulOpposite.op x ^ z

full_name: MulOpposite.unop_zpow
code: @[simp] lemma unop_zpow (x : αᵐᵒᵖ) (z : ℤ) : unop (x ^ z) = unop x ^ z 
goal: MulOpposite.unop (x ^ z) = MulOpposite.unop x ^ z

full_name: AddOpposite.op_natCast
code: @[to_additive (attr := simp, norm_cast)]
theorem op_natCast [NatCast α] (n : ℕ) : op (n : α) = n 
goal: AddOpposite.op ↑n = ↑n

full_name: MulOpposite.op_natCast
code: @[to_additive (attr := simp, norm_cast)]
theorem op_natCast [NatCast α] (n : ℕ) : op (n : α) = n 
goal: MulOpposite.op ↑n = ↑n

full_name: AddOpposite.op_ofNat
code: @[to_additive (attr := simp)]
theorem op_ofNat [NatCast α] (n : ℕ) [n.AtLeastTwo] :
    op (no_index (OfNat.ofNat n : α)) = OfNat.ofNat n 
goal: AddOpposite.op (OfNat.ofNat n) = OfNat.ofNat n

full_name: MulOpposite.op_ofNat
code: @[to_additive (attr := simp)]
theorem op_ofNat [NatCast α] (n : ℕ) [n.AtLeastTwo] :
    op (no_index (OfNat.ofNat n : α)) = OfNat.ofNat n 
goal: MulOpposite.op (OfNat.ofNat n) = OfNat.ofNat n

full_name: AddOpposite.op_intCast
code: @[to_additive (attr := simp, norm_cast)]
theorem op_intCast [IntCast α] (n : ℤ) : op (n : α) = n 
goal: AddOpposite.op ↑n = ↑n

full_name: MulOpposite.op_intCast
code: @[to_additive (attr := simp, norm_cast)]
theorem op_intCast [IntCast α] (n : ℤ) : op (n : α) = n 
goal: MulOpposite.op ↑n = ↑n

full_name: MulOpposite.unop_natCast
code: @[to_additive (attr := simp, norm_cast)]
theorem unop_natCast [NatCast α] (n : ℕ) : unop (n : αᵐᵒᵖ) = n 
goal: MulOpposite.unop ↑n = ↑n

full_name: AddOpposite.unop_natCast
code: @[to_additive (attr := simp, norm_cast)]
theorem unop_natCast [NatCast α] (n : ℕ) : unop (n : αᵐᵒᵖ) = n 
goal: AddOpposite.unop ↑n = ↑n

full_name: MulOpposite.unop_ofNat
code: @[to_additive (attr := simp)]
theorem unop_ofNat [NatCast α] (n : ℕ) [n.AtLeastTwo] :
    unop (no_index (OfNat.ofNat n : αᵐᵒᵖ)) = OfNat.ofNat n 
goal: MulOpposite.unop (OfNat.ofNat n) = OfNat.ofNat n

full_name: AddOpposite.unop_ofNat
code: @[to_additive (attr := simp)]
theorem unop_ofNat [NatCast α] (n : ℕ) [n.AtLeastTwo] :
    unop (no_index (OfNat.ofNat n : αᵐᵒᵖ)) = OfNat.ofNat n 
goal: AddOpposite.unop (OfNat.ofNat n) = OfNat.ofNat n

full_name: MulOpposite.unop_intCast
code: @[to_additive (attr := simp, norm_cast)]
theorem unop_intCast [IntCast α] (n : ℤ) : unop (n : αᵐᵒᵖ) = n 
goal: MulOpposite.unop ↑n = ↑n

full_name: AddOpposite.unop_intCast
code: @[to_additive (attr := simp, norm_cast)]
theorem unop_intCast [IntCast α] (n : ℤ) : unop (n : αᵐᵒᵖ) = n 
goal: AddOpposite.unop ↑n = ↑n

full_name: AddOpposite.unop_sub
code: @[to_additive (attr := simp)]
theorem unop_div [DivInvMonoid α] (x y : αᵐᵒᵖ) : unop (x / y) = (unop y)⁻¹ * unop x 
goal: AddOpposite.unop (x - y) = -AddOpposite.unop y + AddOpposite.unop x

full_name: MulOpposite.unop_div
code: @[to_additive (attr := simp)]
theorem unop_div [DivInvMonoid α] (x y : αᵐᵒᵖ) : unop (x / y) = (unop y)⁻¹ * unop x 
goal: MulOpposite.unop (x / y) = (MulOpposite.unop y)⁻¹ * MulOpposite.unop x

full_name: AddOpposite.op_sub
code: @[to_additive (attr := simp)]
theorem op_div [DivInvMonoid α] (x y : α) : op (x / y) = (op y)⁻¹ * op x 
goal: AddOpposite.op (x - y) = -AddOpposite.op y + AddOpposite.op x

full_name: MulOpposite.op_div
code: @[to_additive (attr := simp)]
theorem op_div [DivInvMonoid α] (x y : α) : op (x / y) = (op y)⁻¹ * op x 
goal: MulOpposite.op (x / y) = (MulOpposite.op y)⁻¹ * MulOpposite.op x

full_name: AddOpposite.addSemiconjBy_op
code: @[to_additive (attr := simp)]
theorem semiconjBy_op [Mul α] {a x y : α} : SemiconjBy (op a) (op y) (op x) ↔ SemiconjBy a x y 
goal: AddSemiconjBy (AddOpposite.op a) (AddOpposite.op y) (AddOpposite.op x) ↔ AddSemiconjBy a x y

full_name: MulOpposite.semiconjBy_op
code: @[to_additive (attr := simp)]
theorem semiconjBy_op [Mul α] {a x y : α} : SemiconjBy (op a) (op y) (op x) ↔ SemiconjBy a x y 
goal: SemiconjBy (MulOpposite.op a) (MulOpposite.op y) (MulOpposite.op x) ↔ SemiconjBy a x y

full_name: MulOpposite.semiconjBy_unop
code: @[to_additive (attr := simp, nolint simpComm)]
theorem semiconjBy_unop [Mul α] {a x y : αᵐᵒᵖ} :
    SemiconjBy (unop a) (unop y) (unop x) ↔ SemiconjBy a x y 
goal: SemiconjBy (MulOpposite.unop a) (MulOpposite.unop y) (MulOpposite.unop x) ↔ SemiconjBy a x y

full_name: AddOpposite.addSemiconjBy_unop
code: @[to_additive (attr := simp, nolint simpComm)]
theorem semiconjBy_unop [Mul α] {a x y : αᵐᵒᵖ} :
    SemiconjBy (unop a) (unop y) (unop x) ↔ SemiconjBy a x y 
goal: AddSemiconjBy (AddOpposite.unop a) (AddOpposite.unop y) (AddOpposite.unop x) ↔ AddSemiconjBy a x y

full_name: SemiconjBy.op
code: @[to_additive]
theorem _root_.SemiconjBy.op [Mul α] {a x y : α} (h : SemiconjBy a x y) :
    SemiconjBy (op a) (op y) (op x) 
goal: SemiconjBy (MulOpposite.op a) (MulOpposite.op y) (MulOpposite.op x)

full_name: AddSemiconjBy.op
code: @[to_additive]
theorem _root_.SemiconjBy.op [Mul α] {a x y : α} (h : SemiconjBy a x y) :
    SemiconjBy (op a) (op y) (op x) 
goal: AddSemiconjBy (AddOpposite.op a) (AddOpposite.op y) (AddOpposite.op x)

full_name: AddSemiconjBy.unop
code: @[to_additive]
theorem _root_.SemiconjBy.unop [Mul α] {a x y : αᵐᵒᵖ} (h : SemiconjBy a x y) :
    SemiconjBy (unop a) (unop y) (unop x) 
goal: AddSemiconjBy (AddOpposite.unop a) (AddOpposite.unop y) (AddOpposite.unop x)

full_name: SemiconjBy.unop
code: @[to_additive]
theorem _root_.SemiconjBy.unop [Mul α] {a x y : αᵐᵒᵖ} (h : SemiconjBy a x y) :
    SemiconjBy (unop a) (unop y) (unop x) 
goal: SemiconjBy (MulOpposite.unop a) (MulOpposite.unop y) (MulOpposite.unop x)

full_name: Commute.op
code: @[to_additive]
theorem _root_.Commute.op [Mul α] {x y : α} (h : Commute x y) : Commute (op x) (op y) 
goal: Commute (MulOpposite.op x) (MulOpposite.op y)

full_name: AddCommute.op
code: @[to_additive]
theorem _root_.Commute.op [Mul α] {x y : α} (h : Commute x y) : Commute (op x) (op y) 
goal: AddCommute (AddOpposite.op x) (AddOpposite.op y)

full_name: AddCommute.unop
code: @[to_additive]
nonrec theorem _root_.Commute.unop [Mul α] {x y : αᵐᵒᵖ} (h : Commute x y) :
    Commute (unop x) (unop y) 
goal: AddCommute (AddOpposite.unop x) (AddOpposite.unop y)

full_name: Commute.unop
code: @[to_additive]
nonrec theorem _root_.Commute.unop [Mul α] {x y : αᵐᵒᵖ} (h : Commute x y) :
    Commute (unop x) (unop y) 
goal: Commute (MulOpposite.unop x) (MulOpposite.unop y)

full_name: AddOpposite.addCommute_op
code: @[to_additive (attr := simp)]
theorem commute_op [Mul α] {x y : α} : Commute (op x) (op y) ↔ Commute x y 
goal: AddCommute (AddOpposite.op x) (AddOpposite.op y) ↔ AddCommute x y

full_name: MulOpposite.commute_op
code: @[to_additive (attr := simp)]
theorem commute_op [Mul α] {x y : α} : Commute (op x) (op y) ↔ Commute x y 
goal: Commute (MulOpposite.op x) (MulOpposite.op y) ↔ Commute x y

full_name: MulOpposite.commute_unop
code: @[to_additive (attr := simp, nolint simpComm)]
theorem commute_unop [Mul α] {x y : αᵐᵒᵖ} : Commute (unop x) (unop y) ↔ Commute x y 
goal: Commute (MulOpposite.unop x) (MulOpposite.unop y) ↔ Commute x y

full_name: AddOpposite.addCommute_unop
code: @[to_additive (attr := simp, nolint simpComm)]
theorem commute_unop [Mul α] {x y : αᵐᵒᵖ} : Commute (unop x) (unop y) ↔ Commute x y 
goal: AddCommute (AddOpposite.unop x) (AddOpposite.unop y) ↔ AddCommute x y

full_name: MulOpposite.opAddEquiv_symm_apply
code: /-- The function `MulOpposite.op` is an additive equivalence. -/
@[simps! (config := { fullyApplied := false, simpRhs := true }) apply symm_apply]
def opAddEquiv [Add α] : α ≃+ αᵐᵒᵖ 
goal: ⇑MulOpposite.opAddEquiv.symm = MulOpposite.unop

full_name: MulOpposite.opAddEquiv
code: /-- The function `MulOpposite.op` is an additive equivalence. -/
@[simps! (config := { fullyApplied := false, simpRhs := true }) apply symm_apply]
def opAddEquiv [Add α] : α ≃+ αᵐᵒᵖ 
goal: α ≃+ αᵐᵒᵖ

full_name: MulOpposite.opAddEquiv_apply
code: /-- The function `MulOpposite.op` is an additive equivalence. -/
@[simps! (config := { fullyApplied := false, simpRhs := true }) apply symm_apply]
def opAddEquiv [Add α] : α ≃+ αᵐᵒᵖ 
goal: ⇑MulOpposite.opAddEquiv = MulOpposite.op

full_name: MulOpposite.opAddEquiv_toEquiv
code: @[simp]
theorem opAddEquiv_toEquiv [Add α] : ((opAddEquiv : α ≃+ αᵐᵒᵖ) : α ≃ αᵐᵒᵖ) = opEquiv 
goal: ↑MulOpposite.opAddEquiv = MulOpposite.opEquiv

full_name: AddOpposite.instSemigroup
code: instance instSemigroup [Semigroup α] : Semigroup αᵃᵒᵖ 
goal: Semigroup αᵃᵒᵖ

full_name: AddOpposite.instLeftCancelSemigroup
code: instance instLeftCancelSemigroup [LeftCancelSemigroup α] : LeftCancelSemigroup αᵃᵒᵖ 
goal: LeftCancelSemigroup αᵃᵒᵖ

full_name: AddOpposite.instRightCancelSemigroup
code: instance instRightCancelSemigroup [RightCancelSemigroup α] : RightCancelSemigroup αᵃᵒᵖ 
goal: RightCancelSemigroup αᵃᵒᵖ

full_name: AddOpposite.instCommSemigroup
code: instance instCommSemigroup [CommSemigroup α] : CommSemigroup αᵃᵒᵖ 
goal: CommSemigroup αᵃᵒᵖ

full_name: AddOpposite.instMulOneClass
code: instance instMulOneClass [MulOneClass α] : MulOneClass αᵃᵒᵖ 
goal: MulOneClass αᵃᵒᵖ

full_name: AddOpposite.pow
code: instance pow {β} [Pow α β] : Pow αᵃᵒᵖ β 
goal: Pow αᵃᵒᵖ β

full_name: AddOpposite.op_pow
code: @[simp]
theorem op_pow {β} [Pow α β] (a : α) (b : β) : op (a ^ b) = op a ^ b 
goal: AddOpposite.op (a ^ b) = AddOpposite.op a ^ b

full_name: AddOpposite.unop_pow
code: @[simp]
theorem unop_pow {β} [Pow α β] (a : αᵃᵒᵖ) (b : β) : unop (a ^ b) = unop a ^ b 
goal: AddOpposite.unop (a ^ b) = AddOpposite.unop a ^ b

full_name: AddOpposite.instMonoid
code: instance instMonoid [Monoid α] : Monoid αᵃᵒᵖ 
goal: Monoid αᵃᵒᵖ

full_name: AddOpposite.instCommMonoid
code: instance instCommMonoid [CommMonoid α] : CommMonoid αᵃᵒᵖ 
goal: CommMonoid αᵃᵒᵖ

full_name: AddOpposite.instDivInvMonoid
code: instance instDivInvMonoid [DivInvMonoid α] : DivInvMonoid αᵃᵒᵖ 
goal: DivInvMonoid αᵃᵒᵖ

full_name: AddOpposite.instGroup
code: instance instGroup [Group α] : Group αᵃᵒᵖ 
goal: Group αᵃᵒᵖ

full_name: AddOpposite.instCommGroup
code: instance instCommGroup [CommGroup α] : CommGroup αᵃᵒᵖ 
goal: CommGroup αᵃᵒᵖ

full_name: AddOpposite.instAddCommMonoidWithOne
code: instance instAddCommMonoidWithOne [AddCommMonoidWithOne α] : AddCommMonoidWithOne αᵃᵒᵖ 
goal: AddCommMonoidWithOne αᵃᵒᵖ

full_name: AddOpposite.instAddCommGroupWithOne
code: instance instAddCommGroupWithOne [AddCommGroupWithOne α] : AddCommGroupWithOne αᵃᵒᵖ 
goal: AddCommGroupWithOne αᵃᵒᵖ

full_name: AddOpposite.opMulEquiv_symm_apply
code: /-- The function `AddOpposite.op` is a multiplicative equivalence. -/
@[simps! (config := { fullyApplied := false, simpRhs := true })]
def opMulEquiv [Mul α] : α ≃* αᵃᵒᵖ 
goal: ⇑AddOpposite.opMulEquiv.symm = AddOpposite.unop

full_name: AddOpposite.opMulEquiv_apply
code: /-- The function `AddOpposite.op` is a multiplicative equivalence. -/
@[simps! (config := { fullyApplied := false, simpRhs := true })]
def opMulEquiv [Mul α] : α ≃* αᵃᵒᵖ 
goal: ⇑AddOpposite.opMulEquiv = AddOpposite.op

full_name: AddOpposite.opMulEquiv
code: /-- The function `AddOpposite.op` is a multiplicative equivalence. -/
@[simps! (config := { fullyApplied := false, simpRhs := true })]
def opMulEquiv [Mul α] : α ≃* αᵃᵒᵖ 
goal: α ≃* αᵃᵒᵖ

full_name: AddOpposite.opMulEquiv_toEquiv
code: @[simp]
theorem opMulEquiv_toEquiv [Mul α] : ((opMulEquiv : α ≃* αᵃᵒᵖ) : α ≃ αᵃᵒᵖ) = opEquiv 
goal: ↑AddOpposite.opMulEquiv = AddOpposite.opEquiv

full_name: AddEquiv.neg'_apply
code: /-- Inversion on a group is a `MulEquiv` to the opposite group. When `G` is commutative, there is
`MulEquiv.inv`. -/
@[to_additive (attr := simps! (config := { fullyApplied := false, simpRhs := true }))
      "Negation on an additive group is an `AddEquiv` to the opposite group. When `G`
      is commutative, there is `AddEquiv.inv`."]
def MulEquiv.inv' (G : Type*) [DivisionMonoid G] : G ≃* Gᵐᵒᵖ 
goal: ⇑(AddEquiv.neg' G) = AddOpposite.op ∘ Neg.neg

full_name: AddEquiv.neg'_symm_apply
code: /-- Inversion on a group is a `MulEquiv` to the opposite group. When `G` is commutative, there is
`MulEquiv.inv`. -/
@[to_additive (attr := simps! (config := { fullyApplied := false, simpRhs := true }))
      "Negation on an additive group is an `AddEquiv` to the opposite group. When `G`
      is commutative, there is `AddEquiv.inv`."]
def MulEquiv.inv' (G : Type*) [DivisionMonoid G] : G ≃* Gᵐᵒᵖ 
goal: ⇑(AddEquiv.neg' G).symm = Neg.neg ∘ AddOpposite.unop

full_name: MulEquiv.inv'_apply
code: /-- Inversion on a group is a `MulEquiv` to the opposite group. When `G` is commutative, there is
`MulEquiv.inv`. -/
@[to_additive (attr := simps! (config := { fullyApplied := false, simpRhs := true }))
      "Negation on an additive group is an `AddEquiv` to the opposite group. When `G`
      is commutative, there is `AddEquiv.inv`."]
def MulEquiv.inv' (G : Type*) [DivisionMonoid G] : G ≃* Gᵐᵒᵖ 
goal: ⇑(MulEquiv.inv' G) = MulOpposite.op ∘ Inv.inv

full_name: AddEquiv.neg'
code: /-- Inversion on a group is a `MulEquiv` to the opposite group. When `G` is commutative, there is
`MulEquiv.inv`. -/
@[to_additive (attr := simps! (config := { fullyApplied := false, simpRhs := true }))
      "Negation on an additive group is an `AddEquiv` to the opposite group. When `G`
      is commutative, there is `AddEquiv.inv`."]
def MulEquiv.inv' (G : Type*) [DivisionMonoid G] : G ≃* Gᵐᵒᵖ 
goal: G ≃+ Gᵃᵒᵖ

full_name: MulEquiv.inv'_symm_apply
code: /-- Inversion on a group is a `MulEquiv` to the opposite group. When `G` is commutative, there is
`MulEquiv.inv`. -/
@[to_additive (attr := simps! (config := { fullyApplied := false, simpRhs := true }))
      "Negation on an additive group is an `AddEquiv` to the opposite group. When `G`
      is commutative, there is `AddEquiv.inv`."]
def MulEquiv.inv' (G : Type*) [DivisionMonoid G] : G ≃* Gᵐᵒᵖ 
goal: ⇑(MulEquiv.inv' G).symm = Inv.inv ∘ MulOpposite.unop

full_name: MulEquiv.inv'
code: /-- Inversion on a group is a `MulEquiv` to the opposite group. When `G` is commutative, there is
`MulEquiv.inv`. -/
@[to_additive (attr := simps! (config := { fullyApplied := false, simpRhs := true }))
      "Negation on an additive group is an `AddEquiv` to the opposite group. When `G`
      is commutative, there is `AddEquiv.inv`."]
def MulEquiv.inv' (G : Type*) [DivisionMonoid G] : G ≃* Gᵐᵒᵖ 
goal: G ≃* Gᵐᵒᵖ

full_name: MulHom.toOpposite
code: /-- A semigroup homomorphism `f : M →ₙ* N` such that `f x` commutes with `f y` for all `x, y`
defines a semigroup homomorphism to `Nᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn))
      "An additive semigroup homomorphism `f : AddHom M N` such that `f x` additively
      commutes with `f y` for all `x, y` defines an additive semigroup homomorphism to `Sᵃᵒᵖ`."]
def MulHom.toOpposite {M N : Type*} [Mul M] [Mul N] (f : M →ₙ* N)
    (hf : ∀ x y, Commute (f x) (f y)) : M →ₙ* Nᵐᵒᵖ 
goal: M →ₙ* Nᵐᵒᵖ

full_name: MulHom.toOpposite_apply
code: /-- A semigroup homomorphism `f : M →ₙ* N` such that `f x` commutes with `f y` for all `x, y`
defines a semigroup homomorphism to `Nᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn))
      "An additive semigroup homomorphism `f : AddHom M N` such that `f x` additively
      commutes with `f y` for all `x, y` defines an additive semigroup homomorphism to `Sᵃᵒᵖ`."]
def MulHom.toOpposite {M N : Type*} [Mul M] [Mul N] (f : M →ₙ* N)
    (hf : ∀ x y, Commute (f x) (f y)) : M →ₙ* Nᵐᵒᵖ 
goal: ⇑(f.toOpposite hf) = MulOpposite.op ∘ ⇑f

full_name: AddHom.toOpposite_apply
code: /-- A semigroup homomorphism `f : M →ₙ* N` such that `f x` commutes with `f y` for all `x, y`
defines a semigroup homomorphism to `Nᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn))
      "An additive semigroup homomorphism `f : AddHom M N` such that `f x` additively
      commutes with `f y` for all `x, y` defines an additive semigroup homomorphism to `Sᵃᵒᵖ`."]
def MulHom.toOpposite {M N : Type*} [Mul M] [Mul N] (f : M →ₙ* N)
    (hf : ∀ x y, Commute (f x) (f y)) : M →ₙ* Nᵐᵒᵖ 
goal: ⇑(f.toOpposite hf) = AddOpposite.op ∘ ⇑f

full_name: AddHom.toOpposite
code: /-- A semigroup homomorphism `f : M →ₙ* N` such that `f x` commutes with `f y` for all `x, y`
defines a semigroup homomorphism to `Nᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn))
      "An additive semigroup homomorphism `f : AddHom M N` such that `f x` additively
      commutes with `f y` for all `x, y` defines an additive semigroup homomorphism to `Sᵃᵒᵖ`."]
def MulHom.toOpposite {M N : Type*} [Mul M] [Mul N] (f : M →ₙ* N)
    (hf : ∀ x y, Commute (f x) (f y)) : M →ₙ* Nᵐᵒᵖ 
goal: AddHom M Nᵃᵒᵖ

full_name: MulHom.fromOpposite
code: /-- A semigroup homomorphism `f : M →ₙ* N` such that `f x` commutes with `f y` for all `x, y`
defines a semigroup homomorphism from `Mᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn))
      "An additive semigroup homomorphism `f : AddHom M N` such that `f x` additively
      commutes with `f y` for all `x`, `y` defines an additive semigroup homomorphism from `Mᵃᵒᵖ`."]
def MulHom.fromOpposite {M N : Type*} [Mul M] [Mul N] (f : M →ₙ* N)
    (hf : ∀ x y, Commute (f x) (f y)) : Mᵐᵒᵖ →ₙ* N 
goal: Mᵐᵒᵖ →ₙ* N

full_name: AddHom.fromOpposite_apply
code: /-- A semigroup homomorphism `f : M →ₙ* N` such that `f x` commutes with `f y` for all `x, y`
defines a semigroup homomorphism from `Mᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn))
      "An additive semigroup homomorphism `f : AddHom M N` such that `f x` additively
      commutes with `f y` for all `x`, `y` defines an additive semigroup homomorphism from `Mᵃᵒᵖ`."]
def MulHom.fromOpposite {M N : Type*} [Mul M] [Mul N] (f : M →ₙ* N)
    (hf : ∀ x y, Commute (f x) (f y)) : Mᵐᵒᵖ →ₙ* N 
goal: ⇑(f.fromOpposite hf) = ⇑f ∘ AddOpposite.unop

full_name: AddHom.fromOpposite
code: /-- A semigroup homomorphism `f : M →ₙ* N` such that `f x` commutes with `f y` for all `x, y`
defines a semigroup homomorphism from `Mᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn))
      "An additive semigroup homomorphism `f : AddHom M N` such that `f x` additively
      commutes with `f y` for all `x`, `y` defines an additive semigroup homomorphism from `Mᵃᵒᵖ`."]
def MulHom.fromOpposite {M N : Type*} [Mul M] [Mul N] (f : M →ₙ* N)
    (hf : ∀ x y, Commute (f x) (f y)) : Mᵐᵒᵖ →ₙ* N 
goal: AddHom Mᵃᵒᵖ N

full_name: MulHom.fromOpposite_apply
code: /-- A semigroup homomorphism `f : M →ₙ* N` such that `f x` commutes with `f y` for all `x, y`
defines a semigroup homomorphism from `Mᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn))
      "An additive semigroup homomorphism `f : AddHom M N` such that `f x` additively
      commutes with `f y` for all `x`, `y` defines an additive semigroup homomorphism from `Mᵃᵒᵖ`."]
def MulHom.fromOpposite {M N : Type*} [Mul M] [Mul N] (f : M →ₙ* N)
    (hf : ∀ x y, Commute (f x) (f y)) : Mᵐᵒᵖ →ₙ* N 
goal: ⇑(f.fromOpposite hf) = ⇑f ∘ MulOpposite.unop

full_name: AddMonoidHom.toOpposite
code: /-- A monoid homomorphism `f : M →* N` such that `f x` commutes with `f y` for all `x, y` defines
a monoid homomorphism to `Nᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn))
      "An additive monoid homomorphism `f : M →+ N` such that `f x` additively commutes
      with `f y` for all `x, y` defines an additive monoid homomorphism to `Sᵃᵒᵖ`."]
def MonoidHom.toOpposite {M N : Type*} [MulOneClass M] [MulOneClass N] (f : M →* N)
    (hf : ∀ x y, Commute (f x) (f y)) : M →* Nᵐᵒᵖ 
goal: M →+ Nᵃᵒᵖ

full_name: MonoidHom.toOpposite
code: /-- A monoid homomorphism `f : M →* N` such that `f x` commutes with `f y` for all `x, y` defines
a monoid homomorphism to `Nᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn))
      "An additive monoid homomorphism `f : M →+ N` such that `f x` additively commutes
      with `f y` for all `x, y` defines an additive monoid homomorphism to `Sᵃᵒᵖ`."]
def MonoidHom.toOpposite {M N : Type*} [MulOneClass M] [MulOneClass N] (f : M →* N)
    (hf : ∀ x y, Commute (f x) (f y)) : M →* Nᵐᵒᵖ 
goal: M →* Nᵐᵒᵖ

full_name: AddMonoidHom.toOpposite_apply
code: /-- A monoid homomorphism `f : M →* N` such that `f x` commutes with `f y` for all `x, y` defines
a monoid homomorphism to `Nᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn))
      "An additive monoid homomorphism `f : M →+ N` such that `f x` additively commutes
      with `f y` for all `x, y` defines an additive monoid homomorphism to `Sᵃᵒᵖ`."]
def MonoidHom.toOpposite {M N : Type*} [MulOneClass M] [MulOneClass N] (f : M →* N)
    (hf : ∀ x y, Commute (f x) (f y)) : M →* Nᵐᵒᵖ 
goal: ⇑(f.toOpposite hf) = AddOpposite.op ∘ ⇑f

full_name: MonoidHom.toOpposite_apply
code: /-- A monoid homomorphism `f : M →* N` such that `f x` commutes with `f y` for all `x, y` defines
a monoid homomorphism to `Nᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn))
      "An additive monoid homomorphism `f : M →+ N` such that `f x` additively commutes
      with `f y` for all `x, y` defines an additive monoid homomorphism to `Sᵃᵒᵖ`."]
def MonoidHom.toOpposite {M N : Type*} [MulOneClass M] [MulOneClass N] (f : M →* N)
    (hf : ∀ x y, Commute (f x) (f y)) : M →* Nᵐᵒᵖ 
goal: ⇑(f.toOpposite hf) = MulOpposite.op ∘ ⇑f

full_name: MonoidHom.fromOpposite
code: /-- A monoid homomorphism `f : M →* N` such that `f x` commutes with `f y` for all `x, y` defines
a monoid homomorphism from `Mᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn))
      "An additive monoid homomorphism `f : M →+ N` such that `f x` additively commutes
      with `f y` for all `x`, `y` defines an additive monoid homomorphism from `Mᵃᵒᵖ`."]
def MonoidHom.fromOpposite {M N : Type*} [MulOneClass M] [MulOneClass N] (f : M →* N)
    (hf : ∀ x y, Commute (f x) (f y)) : Mᵐᵒᵖ →* N 
goal: Mᵐᵒᵖ →* N

full_name: AddMonoidHom.fromOpposite
code: /-- A monoid homomorphism `f : M →* N` such that `f x` commutes with `f y` for all `x, y` defines
a monoid homomorphism from `Mᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn))
      "An additive monoid homomorphism `f : M →+ N` such that `f x` additively commutes
      with `f y` for all `x`, `y` defines an additive monoid homomorphism from `Mᵃᵒᵖ`."]
def MonoidHom.fromOpposite {M N : Type*} [MulOneClass M] [MulOneClass N] (f : M →* N)
    (hf : ∀ x y, Commute (f x) (f y)) : Mᵐᵒᵖ →* N 
goal: Mᵃᵒᵖ →+ N

full_name: MonoidHom.fromOpposite_apply
code: /-- A monoid homomorphism `f : M →* N` such that `f x` commutes with `f y` for all `x, y` defines
a monoid homomorphism from `Mᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn))
      "An additive monoid homomorphism `f : M →+ N` such that `f x` additively commutes
      with `f y` for all `x`, `y` defines an additive monoid homomorphism from `Mᵃᵒᵖ`."]
def MonoidHom.fromOpposite {M N : Type*} [MulOneClass M] [MulOneClass N] (f : M →* N)
    (hf : ∀ x y, Commute (f x) (f y)) : Mᵐᵒᵖ →* N 
goal: ⇑(f.fromOpposite hf) = ⇑f ∘ MulOpposite.unop

full_name: AddMonoidHom.fromOpposite_apply
code: /-- A monoid homomorphism `f : M →* N` such that `f x` commutes with `f y` for all `x, y` defines
a monoid homomorphism from `Mᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn))
      "An additive monoid homomorphism `f : M →+ N` such that `f x` additively commutes
      with `f y` for all `x`, `y` defines an additive monoid homomorphism from `Mᵃᵒᵖ`."]
def MonoidHom.fromOpposite {M N : Type*} [MulOneClass M] [MulOneClass N] (f : M →* N)
    (hf : ∀ x y, Commute (f x) (f y)) : Mᵐᵒᵖ →* N 
goal: ⇑(f.fromOpposite hf) = ⇑f ∘ AddOpposite.unop

full_name: AddUnits.opEquiv
code: /-- The units of the opposites are equivalent to the opposites of the units. -/
@[to_additive
      "The additive units of the additive opposites are equivalent to the additive opposites
      of the additive units."]
def Units.opEquiv {M} [Monoid M] : Mᵐᵒᵖˣ ≃* Mˣᵐᵒᵖ 
goal: AddUnits Mᵃᵒᵖ ≃+ (AddUnits M)ᵃᵒᵖ

full_name: Units.opEquiv
code: /-- The units of the opposites are equivalent to the opposites of the units. -/
@[to_additive
      "The additive units of the additive opposites are equivalent to the additive opposites
      of the additive units."]
def Units.opEquiv {M} [Monoid M] : Mᵐᵒᵖˣ ≃* Mˣᵐᵒᵖ 
goal: Mᵐᵒᵖˣ ≃* Mˣᵐᵒᵖ

full_name: Units.coe_unop_opEquiv
code: @[to_additive (attr := simp)]
theorem Units.coe_unop_opEquiv {M} [Monoid M] (u : Mᵐᵒᵖˣ) :
    ((Units.opEquiv u).unop : M) = unop (u : Mᵐᵒᵖ) 
goal: ↑(MulOpposite.unop (Units.opEquiv u)) = MulOpposite.unop ↑u

full_name: AddUnits.coe_unop_opEquiv
code: @[to_additive (attr := simp)]
theorem Units.coe_unop_opEquiv {M} [Monoid M] (u : Mᵐᵒᵖˣ) :
    ((Units.opEquiv u).unop : M) = unop (u : Mᵐᵒᵖ) 
goal: ↑(AddOpposite.unop (AddUnits.opEquiv u)) = AddOpposite.unop ↑u

full_name: AddUnits.coe_opEquiv_symm
code: @[to_additive (attr := simp)]
theorem Units.coe_opEquiv_symm {M} [Monoid M] (u : Mˣᵐᵒᵖ) :
    (Units.opEquiv.symm u : Mᵐᵒᵖ) = op (u.unop : M) 
goal: ↑(AddUnits.opEquiv.symm u) = AddOpposite.op ↑(AddOpposite.unop u)

full_name: Units.coe_opEquiv_symm
code: @[to_additive (attr := simp)]
theorem Units.coe_opEquiv_symm {M} [Monoid M] (u : Mˣᵐᵒᵖ) :
    (Units.opEquiv.symm u : Mᵐᵒᵖ) = op (u.unop : M) 
goal: ↑(Units.opEquiv.symm u) = MulOpposite.op ↑(MulOpposite.unop u)

full_name: IsAddUnit.op
code: @[to_additive]
nonrec theorem IsUnit.op {M} [Monoid M] {m : M} (h : IsUnit m) : IsUnit (op m) 
goal: IsAddUnit (AddOpposite.op m)

full_name: IsUnit.op
code: @[to_additive]
nonrec theorem IsUnit.op {M} [Monoid M] {m : M} (h : IsUnit m) : IsUnit (op m) 
goal: IsUnit (MulOpposite.op m)

full_name: IsUnit.unop
code: @[to_additive]
nonrec theorem IsUnit.unop {M} [Monoid M] {m : Mᵐᵒᵖ} (h : IsUnit m) : IsUnit (unop m) 
goal: IsUnit (MulOpposite.unop m)

full_name: IsAddUnit.unop
code: @[to_additive]
nonrec theorem IsUnit.unop {M} [Monoid M] {m : Mᵐᵒᵖ} (h : IsUnit m) : IsUnit (unop m) 
goal: IsAddUnit (AddOpposite.unop m)

full_name: isAddUnit_op
code: @[to_additive (attr := simp)]
theorem isUnit_op {M} [Monoid M] {m : M} : IsUnit (op m) ↔ IsUnit m 
goal: IsAddUnit (AddOpposite.op m) ↔ IsAddUnit m

full_name: isUnit_op
code: @[to_additive (attr := simp)]
theorem isUnit_op {M} [Monoid M] {m : M} : IsUnit (op m) ↔ IsUnit m 
goal: IsUnit (MulOpposite.op m) ↔ IsUnit m

full_name: isAddUnit_unop
code: @[to_additive (attr := simp)]
theorem isUnit_unop {M} [Monoid M] {m : Mᵐᵒᵖ} : IsUnit (unop m) ↔ IsUnit m 
goal: IsAddUnit (AddOpposite.unop m) ↔ IsAddUnit m

full_name: isUnit_unop
code: @[to_additive (attr := simp)]
theorem isUnit_unop {M} [Monoid M] {m : Mᵐᵒᵖ} : IsUnit (unop m) ↔ IsUnit m 
goal: IsUnit (MulOpposite.unop m) ↔ IsUnit m

full_name: MulHom.op
code: /-- A semigroup homomorphism `M →ₙ* N` can equivalently be viewed as a semigroup homomorphism
`Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[to_additive (attr := simps)
      "An additive semigroup homomorphism `AddHom M N` can equivalently be viewed as an
      additive semigroup homomorphism `AddHom Mᵃᵒᵖ Nᵃᵒᵖ`. This is the action of the
      (fully faithful)`ᵃᵒᵖ`-functor on morphisms."]
def MulHom.op {M N} [Mul M] [Mul N] : (M →ₙ* N) ≃ (Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ) 
goal: (M →ₙ* N) ≃ (Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ)

full_name: AddHom.op
code: /-- A semigroup homomorphism `M →ₙ* N` can equivalently be viewed as a semigroup homomorphism
`Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[to_additive (attr := simps)
      "An additive semigroup homomorphism `AddHom M N` can equivalently be viewed as an
      additive semigroup homomorphism `AddHom Mᵃᵒᵖ Nᵃᵒᵖ`. This is the action of the
      (fully faithful)`ᵃᵒᵖ`-functor on morphisms."]
def MulHom.op {M N} [Mul M] [Mul N] : (M →ₙ* N) ≃ (Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ) 
goal: AddHom M N ≃ AddHom Mᵃᵒᵖ Nᵃᵒᵖ

full_name: AddHom.op_apply_apply
code: /-- A semigroup homomorphism `M →ₙ* N` can equivalently be viewed as a semigroup homomorphism
`Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[to_additive (attr := simps)
      "An additive semigroup homomorphism `AddHom M N` can equivalently be viewed as an
      additive semigroup homomorphism `AddHom Mᵃᵒᵖ Nᵃᵒᵖ`. This is the action of the
      (fully faithful)`ᵃᵒᵖ`-functor on morphisms."]
def MulHom.op {M N} [Mul M] [Mul N] : (M →ₙ* N) ≃ (Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ) 
goal: ∀ (a : Mᵃᵒᵖ), (AddHom.op f) a = (AddOpposite.op ∘ ⇑f ∘ AddOpposite.unop) a

full_name: MulHom.op_symm_apply_apply
code: /-- A semigroup homomorphism `M →ₙ* N` can equivalently be viewed as a semigroup homomorphism
`Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[to_additive (attr := simps)
      "An additive semigroup homomorphism `AddHom M N` can equivalently be viewed as an
      additive semigroup homomorphism `AddHom Mᵃᵒᵖ Nᵃᵒᵖ`. This is the action of the
      (fully faithful)`ᵃᵒᵖ`-functor on morphisms."]
def MulHom.op {M N} [Mul M] [Mul N] : (M →ₙ* N) ≃ (Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ) 
goal: ∀ (a : M), (MulHom.op.symm f) a = (MulOpposite.unop ∘ ⇑f ∘ MulOpposite.op) a

full_name: MulHom.op_apply_apply
code: /-- A semigroup homomorphism `M →ₙ* N` can equivalently be viewed as a semigroup homomorphism
`Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[to_additive (attr := simps)
      "An additive semigroup homomorphism `AddHom M N` can equivalently be viewed as an
      additive semigroup homomorphism `AddHom Mᵃᵒᵖ Nᵃᵒᵖ`. This is the action of the
      (fully faithful)`ᵃᵒᵖ`-functor on morphisms."]
def MulHom.op {M N} [Mul M] [Mul N] : (M →ₙ* N) ≃ (Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ) 
goal: ∀ (a : Mᵐᵒᵖ), (MulHom.op f) a = (MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) a

full_name: AddHom.op_symm_apply_apply
code: /-- A semigroup homomorphism `M →ₙ* N` can equivalently be viewed as a semigroup homomorphism
`Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[to_additive (attr := simps)
      "An additive semigroup homomorphism `AddHom M N` can equivalently be viewed as an
      additive semigroup homomorphism `AddHom Mᵃᵒᵖ Nᵃᵒᵖ`. This is the action of the
      (fully faithful)`ᵃᵒᵖ`-functor on morphisms."]
def MulHom.op {M N} [Mul M] [Mul N] : (M →ₙ* N) ≃ (Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ) 
goal: ∀ (a : M), (AddHom.op.symm f) a = (AddOpposite.unop ∘ ⇑f ∘ AddOpposite.op) a

full_name: MulHom.unop
code: /-- The 'unopposite' of a semigroup homomorphism `Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ`. Inverse to `MulHom.op`. -/
@[to_additive (attr := simp)
      "The 'unopposite' of an additive semigroup homomorphism `Mᵃᵒᵖ →ₙ+ Nᵃᵒᵖ`. Inverse
      to `AddHom.op`."]
def MulHom.unop {M N} [Mul M] [Mul N] : (Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ) ≃ (M →ₙ* N) 
goal: (Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ) ≃ (M →ₙ* N)

full_name: AddHom.unop
code: /-- The 'unopposite' of a semigroup homomorphism `Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ`. Inverse to `MulHom.op`. -/
@[to_additive (attr := simp)
      "The 'unopposite' of an additive semigroup homomorphism `Mᵃᵒᵖ →ₙ+ Nᵃᵒᵖ`. Inverse
      to `AddHom.op`."]
def MulHom.unop {M N} [Mul M] [Mul N] : (Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ) ≃ (M →ₙ* N) 
goal: AddHom Mᵃᵒᵖ Nᵃᵒᵖ ≃ AddHom M N

full_name: AddHom.mulOp
code: /-- An additive semigroup homomorphism `AddHom M N` can equivalently be viewed as an additive
homomorphism `AddHom Mᵐᵒᵖ Nᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on
morphisms. -/
@[simps]
def AddHom.mulOp {M N} [Add M] [Add N] : AddHom M N ≃ AddHom Mᵐᵒᵖ Nᵐᵒᵖ 
goal: AddHom M N ≃ AddHom Mᵐᵒᵖ Nᵐᵒᵖ

full_name: AddHom.mulOp_apply_apply
code: /-- An additive semigroup homomorphism `AddHom M N` can equivalently be viewed as an additive
homomorphism `AddHom Mᵐᵒᵖ Nᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on
morphisms. -/
@[simps]
def AddHom.mulOp {M N} [Add M] [Add N] : AddHom M N ≃ AddHom Mᵐᵒᵖ Nᵐᵒᵖ 
goal: ∀ (a : Mᵐᵒᵖ), (AddHom.mulOp f) a = (MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) a

full_name: AddHom.mulOp_symm_apply_apply
code: /-- An additive semigroup homomorphism `AddHom M N` can equivalently be viewed as an additive
homomorphism `AddHom Mᵐᵒᵖ Nᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on
morphisms. -/
@[simps]
def AddHom.mulOp {M N} [Add M] [Add N] : AddHom M N ≃ AddHom Mᵐᵒᵖ Nᵐᵒᵖ 
goal: ∀ (a : M), (AddHom.mulOp.symm f) a = (MulOpposite.unop ∘ ⇑f ∘ MulOpposite.op) a

full_name: AddHom.mulUnop
code: /-- The 'unopposite' of an additive semigroup hom `αᵐᵒᵖ →+ βᵐᵒᵖ`. Inverse to
`AddHom.mul_op`. -/
@[simp]
def AddHom.mulUnop {α β} [Add α] [Add β] : AddHom αᵐᵒᵖ βᵐᵒᵖ ≃ AddHom α β 
goal: AddHom αᵐᵒᵖ βᵐᵒᵖ ≃ AddHom α β

full_name: AddMonoidHom.op_symm_apply_apply
code: /-- A monoid homomorphism `M →* N` can equivalently be viewed as a monoid homomorphism
`Mᵐᵒᵖ →* Nᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[to_additive (attr := simps)
      "An additive monoid homomorphism `M →+ N` can equivalently be viewed as an
      additive monoid homomorphism `Mᵃᵒᵖ →+ Nᵃᵒᵖ`. This is the action of the (fully faithful)
      `ᵃᵒᵖ`-functor on morphisms."]
def MonoidHom.op {M N} [MulOneClass M] [MulOneClass N] : (M →* N) ≃ (Mᵐᵒᵖ →* Nᵐᵒᵖ) 
goal: ∀ (a : M), (AddMonoidHom.op.symm f) a = (AddOpposite.unop ∘ ⇑f ∘ AddOpposite.op) a

full_name: MonoidHom.op
code: /-- A monoid homomorphism `M →* N` can equivalently be viewed as a monoid homomorphism
`Mᵐᵒᵖ →* Nᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[to_additive (attr := simps)
      "An additive monoid homomorphism `M →+ N` can equivalently be viewed as an
      additive monoid homomorphism `Mᵃᵒᵖ →+ Nᵃᵒᵖ`. This is the action of the (fully faithful)
      `ᵃᵒᵖ`-functor on morphisms."]
def MonoidHom.op {M N} [MulOneClass M] [MulOneClass N] : (M →* N) ≃ (Mᵐᵒᵖ →* Nᵐᵒᵖ) 
goal: (M →* N) ≃ (Mᵐᵒᵖ →* Nᵐᵒᵖ)

full_name: AddMonoidHom.op
code: /-- A monoid homomorphism `M →* N` can equivalently be viewed as a monoid homomorphism
`Mᵐᵒᵖ →* Nᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[to_additive (attr := simps)
      "An additive monoid homomorphism `M →+ N` can equivalently be viewed as an
      additive monoid homomorphism `Mᵃᵒᵖ →+ Nᵃᵒᵖ`. This is the action of the (fully faithful)
      `ᵃᵒᵖ`-functor on morphisms."]
def MonoidHom.op {M N} [MulOneClass M] [MulOneClass N] : (M →* N) ≃ (Mᵐᵒᵖ →* Nᵐᵒᵖ) 
goal: (M →+ N) ≃ (Mᵃᵒᵖ →+ Nᵃᵒᵖ)

full_name: MonoidHom.op_apply_apply
code: /-- A monoid homomorphism `M →* N` can equivalently be viewed as a monoid homomorphism
`Mᵐᵒᵖ →* Nᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[to_additive (attr := simps)
      "An additive monoid homomorphism `M →+ N` can equivalently be viewed as an
      additive monoid homomorphism `Mᵃᵒᵖ →+ Nᵃᵒᵖ`. This is the action of the (fully faithful)
      `ᵃᵒᵖ`-functor on morphisms."]
def MonoidHom.op {M N} [MulOneClass M] [MulOneClass N] : (M →* N) ≃ (Mᵐᵒᵖ →* Nᵐᵒᵖ) 
goal: ∀ (a : Mᵐᵒᵖ), (MonoidHom.op f) a = (MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) a

full_name: AddMonoidHom.op_apply_apply
code: /-- A monoid homomorphism `M →* N` can equivalently be viewed as a monoid homomorphism
`Mᵐᵒᵖ →* Nᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[to_additive (attr := simps)
      "An additive monoid homomorphism `M →+ N` can equivalently be viewed as an
      additive monoid homomorphism `Mᵃᵒᵖ →+ Nᵃᵒᵖ`. This is the action of the (fully faithful)
      `ᵃᵒᵖ`-functor on morphisms."]
def MonoidHom.op {M N} [MulOneClass M] [MulOneClass N] : (M →* N) ≃ (Mᵐᵒᵖ →* Nᵐᵒᵖ) 
goal: ∀ (a : Mᵃᵒᵖ), (AddMonoidHom.op f) a = (AddOpposite.op ∘ ⇑f ∘ AddOpposite.unop) a

full_name: MonoidHom.op_symm_apply_apply
code: /-- A monoid homomorphism `M →* N` can equivalently be viewed as a monoid homomorphism
`Mᵐᵒᵖ →* Nᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[to_additive (attr := simps)
      "An additive monoid homomorphism `M →+ N` can equivalently be viewed as an
      additive monoid homomorphism `Mᵃᵒᵖ →+ Nᵃᵒᵖ`. This is the action of the (fully faithful)
      `ᵃᵒᵖ`-functor on morphisms."]
def MonoidHom.op {M N} [MulOneClass M] [MulOneClass N] : (M →* N) ≃ (Mᵐᵒᵖ →* Nᵐᵒᵖ) 
goal: ∀ (a : M), (MonoidHom.op.symm f) a = (MulOpposite.unop ∘ ⇑f ∘ MulOpposite.op) a

full_name: MonoidHom.unop
code: /-- The 'unopposite' of a monoid homomorphism `Mᵐᵒᵖ →* Nᵐᵒᵖ`. Inverse to `MonoidHom.op`. -/
@[to_additive (attr := simp)
      "The 'unopposite' of an additive monoid homomorphism `Mᵃᵒᵖ →+ Nᵃᵒᵖ`. Inverse to
      `AddMonoidHom.op`."]
def MonoidHom.unop {M N} [MulOneClass M] [MulOneClass N] : (Mᵐᵒᵖ →* Nᵐᵒᵖ) ≃ (M →* N) 
goal: (Mᵐᵒᵖ →* Nᵐᵒᵖ) ≃ (M →* N)

full_name: AddMonoidHom.unop
code: /-- The 'unopposite' of a monoid homomorphism `Mᵐᵒᵖ →* Nᵐᵒᵖ`. Inverse to `MonoidHom.op`. -/
@[to_additive (attr := simp)
      "The 'unopposite' of an additive monoid homomorphism `Mᵃᵒᵖ →+ Nᵃᵒᵖ`. Inverse to
      `AddMonoidHom.op`."]
def MonoidHom.unop {M N} [MulOneClass M] [MulOneClass N] : (Mᵐᵒᵖ →* Nᵐᵒᵖ) ≃ (M →* N) 
goal: (Mᵃᵒᵖ →+ Nᵃᵒᵖ) ≃ (M →+ N)

full_name: MulEquiv.opOp_symm_apply
code: /-- A monoid is isomorphic to the opposite of its opposite. -/
@[to_additive (attr := simps!)
      "A additive monoid is isomorphic to the opposite of its opposite."]
def MulEquiv.opOp (M : Type*) [Mul M] : M ≃* Mᵐᵒᵖᵐᵒᵖ 
goal: ∀ (a : Mᵐᵒᵖᵐᵒᵖ), (MulEquiv.opOp M).symm a = MulOpposite.unop (MulOpposite.unop a)

full_name: AddEquiv.opOp
code: /-- A monoid is isomorphic to the opposite of its opposite. -/
@[to_additive (attr := simps!)
      "A additive monoid is isomorphic to the opposite of its opposite."]
def MulEquiv.opOp (M : Type*) [Mul M] : M ≃* Mᵐᵒᵖᵐᵒᵖ 
goal: M ≃+ Mᵃᵒᵖᵃᵒᵖ

full_name: AddEquiv.opOp_apply
code: /-- A monoid is isomorphic to the opposite of its opposite. -/
@[to_additive (attr := simps!)
      "A additive monoid is isomorphic to the opposite of its opposite."]
def MulEquiv.opOp (M : Type*) [Mul M] : M ≃* Mᵐᵒᵖᵐᵒᵖ 
goal: ∀ (a : M), (AddEquiv.opOp M) a = AddOpposite.op (AddOpposite.op a)

full_name: MulEquiv.opOp_apply
code: /-- A monoid is isomorphic to the opposite of its opposite. -/
@[to_additive (attr := simps!)
      "A additive monoid is isomorphic to the opposite of its opposite."]
def MulEquiv.opOp (M : Type*) [Mul M] : M ≃* Mᵐᵒᵖᵐᵒᵖ 
goal: ∀ (a : M), (MulEquiv.opOp M) a = MulOpposite.op (MulOpposite.op a)

full_name: AddEquiv.opOp_symm_apply
code: /-- A monoid is isomorphic to the opposite of its opposite. -/
@[to_additive (attr := simps!)
      "A additive monoid is isomorphic to the opposite of its opposite."]
def MulEquiv.opOp (M : Type*) [Mul M] : M ≃* Mᵐᵒᵖᵐᵒᵖ 
goal: ∀ (a : Mᵃᵒᵖᵃᵒᵖ), (AddEquiv.opOp M).symm a = AddOpposite.unop (AddOpposite.unop a)

full_name: MulEquiv.opOp
code: /-- A monoid is isomorphic to the opposite of its opposite. -/
@[to_additive (attr := simps!)
      "A additive monoid is isomorphic to the opposite of its opposite."]
def MulEquiv.opOp (M : Type*) [Mul M] : M ≃* Mᵐᵒᵖᵐᵒᵖ 
goal: M ≃* Mᵐᵒᵖᵐᵒᵖ

full_name: AddMonoidHom.mulOp_symm_apply_apply
code: /-- An additive homomorphism `M →+ N` can equivalently be viewed as an additive homomorphism
`Mᵐᵒᵖ →+ Nᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[simps]
def AddMonoidHom.mulOp {M N} [AddZeroClass M] [AddZeroClass N] : (M →+ N) ≃ (Mᵐᵒᵖ →+ Nᵐᵒᵖ) 
goal: ∀ (a : M), (AddMonoidHom.mulOp.symm f) a = (MulOpposite.unop ∘ ⇑f ∘ MulOpposite.op) a

full_name: AddMonoidHom.mulOp
code: /-- An additive homomorphism `M →+ N` can equivalently be viewed as an additive homomorphism
`Mᵐᵒᵖ →+ Nᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[simps]
def AddMonoidHom.mulOp {M N} [AddZeroClass M] [AddZeroClass N] : (M →+ N) ≃ (Mᵐᵒᵖ →+ Nᵐᵒᵖ) 
goal: (M →+ N) ≃ (Mᵐᵒᵖ →+ Nᵐᵒᵖ)

full_name: AddMonoidHom.mulOp_apply_apply
code: /-- An additive homomorphism `M →+ N` can equivalently be viewed as an additive homomorphism
`Mᵐᵒᵖ →+ Nᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[simps]
def AddMonoidHom.mulOp {M N} [AddZeroClass M] [AddZeroClass N] : (M →+ N) ≃ (Mᵐᵒᵖ →+ Nᵐᵒᵖ) 
goal: ∀ (a : Mᵐᵒᵖ), (AddMonoidHom.mulOp f) a = (MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) a

full_name: AddMonoidHom.mulUnop
code: /-- The 'unopposite' of an additive monoid hom `αᵐᵒᵖ →+ βᵐᵒᵖ`. Inverse to
`AddMonoidHom.mul_op`. -/
@[simp]
def AddMonoidHom.mulUnop {α β} [AddZeroClass α] [AddZeroClass β] : (αᵐᵒᵖ →+ βᵐᵒᵖ) ≃ (α →+ β) 
goal: (αᵐᵒᵖ →+ βᵐᵒᵖ) ≃ (α →+ β)

full_name: AddEquiv.mulOp
code: /-- An iso `α ≃+ β` can equivalently be viewed as an iso `αᵐᵒᵖ ≃+ βᵐᵒᵖ`. -/
@[simps]
def AddEquiv.mulOp {α β} [Add α] [Add β] : α ≃+ β ≃ (αᵐᵒᵖ ≃+ βᵐᵒᵖ) 
goal: α ≃+ β ≃ (αᵐᵒᵖ ≃+ βᵐᵒᵖ)

full_name: AddEquiv.mulOp_apply
code: /-- An iso `α ≃+ β` can equivalently be viewed as an iso `αᵐᵒᵖ ≃+ βᵐᵒᵖ`. -/
@[simps]
def AddEquiv.mulOp {α β} [Add α] [Add β] : α ≃+ β ≃ (αᵐᵒᵖ ≃+ βᵐᵒᵖ) 
goal: AddEquiv.mulOp f = MulOpposite.opAddEquiv.symm.trans (f.trans MulOpposite.opAddEquiv)

full_name: AddEquiv.mulOp_symm_apply
code: /-- An iso `α ≃+ β` can equivalently be viewed as an iso `αᵐᵒᵖ ≃+ βᵐᵒᵖ`. -/
@[simps]
def AddEquiv.mulOp {α β} [Add α] [Add β] : α ≃+ β ≃ (αᵐᵒᵖ ≃+ βᵐᵒᵖ) 
goal: AddEquiv.mulOp.symm f = MulOpposite.opAddEquiv.trans (f.trans MulOpposite.opAddEquiv.symm)

full_name: AddEquiv.mulUnop
code: /-- The 'unopposite' of an iso `αᵐᵒᵖ ≃+ βᵐᵒᵖ`. Inverse to `AddEquiv.mul_op`. -/
@[simp]
def AddEquiv.mulUnop {α β} [Add α] [Add β] : αᵐᵒᵖ ≃+ βᵐᵒᵖ ≃ (α ≃+ β) 
goal: αᵐᵒᵖ ≃+ βᵐᵒᵖ ≃ (α ≃+ β)

full_name: AddEquiv.op
code: /-- An iso `α ≃* β` can equivalently be viewed as an iso `αᵐᵒᵖ ≃* βᵐᵒᵖ`. -/
@[to_additive (attr := simps)
  "An iso `α ≃+ β` can equivalently be viewed as an iso `αᵃᵒᵖ ≃+ βᵃᵒᵖ`."]
def MulEquiv.op {α β} [Mul α] [Mul β] : α ≃* β ≃ (αᵐᵒᵖ ≃* βᵐᵒᵖ) 
goal: α ≃+ β ≃ (αᵃᵒᵖ ≃+ βᵃᵒᵖ)

full_name: MulEquiv.op_apply_symm_apply
code: /-- An iso `α ≃* β` can equivalently be viewed as an iso `αᵐᵒᵖ ≃* βᵐᵒᵖ`. -/
@[to_additive (attr := simps)
  "An iso `α ≃+ β` can equivalently be viewed as an iso `αᵃᵒᵖ ≃+ βᵃᵒᵖ`."]
def MulEquiv.op {α β} [Mul α] [Mul β] : α ≃* β ≃ (αᵐᵒᵖ ≃* βᵐᵒᵖ) 
goal: ∀ (a : βᵐᵒᵖ), (MulEquiv.op f).symm a = (MulOpposite.op ∘ ⇑f.symm ∘ MulOpposite.unop) a

full_name: MulEquiv.op_symm_apply_symm_apply
code: /-- An iso `α ≃* β` can equivalently be viewed as an iso `αᵐᵒᵖ ≃* βᵐᵒᵖ`. -/
@[to_additive (attr := simps)
  "An iso `α ≃+ β` can equivalently be viewed as an iso `αᵃᵒᵖ ≃+ βᵃᵒᵖ`."]
def MulEquiv.op {α β} [Mul α] [Mul β] : α ≃* β ≃ (αᵐᵒᵖ ≃* βᵐᵒᵖ) 
goal: ∀ (a : β), (MulEquiv.op.symm f).symm a = (MulOpposite.unop ∘ ⇑f.symm ∘ MulOpposite.op) a

full_name: AddEquiv.op_symm_apply_apply
code: /-- An iso `α ≃* β` can equivalently be viewed as an iso `αᵐᵒᵖ ≃* βᵐᵒᵖ`. -/
@[to_additive (attr := simps)
  "An iso `α ≃+ β` can equivalently be viewed as an iso `αᵃᵒᵖ ≃+ βᵃᵒᵖ`."]
def MulEquiv.op {α β} [Mul α] [Mul β] : α ≃* β ≃ (αᵐᵒᵖ ≃* βᵐᵒᵖ) 
goal: ∀ (a : α), (AddEquiv.op.symm f) a = (AddOpposite.unop ∘ ⇑f ∘ AddOpposite.op) a

full_name: AddEquiv.op_apply_apply
code: /-- An iso `α ≃* β` can equivalently be viewed as an iso `αᵐᵒᵖ ≃* βᵐᵒᵖ`. -/
@[to_additive (attr := simps)
  "An iso `α ≃+ β` can equivalently be viewed as an iso `αᵃᵒᵖ ≃+ βᵃᵒᵖ`."]
def MulEquiv.op {α β} [Mul α] [Mul β] : α ≃* β ≃ (αᵐᵒᵖ ≃* βᵐᵒᵖ) 
goal: ∀ (a : αᵃᵒᵖ), (AddEquiv.op f) a = (AddOpposite.op ∘ ⇑f ∘ AddOpposite.unop) a

full_name: AddEquiv.op_symm_apply_symm_apply
code: /-- An iso `α ≃* β` can equivalently be viewed as an iso `αᵐᵒᵖ ≃* βᵐᵒᵖ`. -/
@[to_additive (attr := simps)
  "An iso `α ≃+ β` can equivalently be viewed as an iso `αᵃᵒᵖ ≃+ βᵃᵒᵖ`."]
def MulEquiv.op {α β} [Mul α] [Mul β] : α ≃* β ≃ (αᵐᵒᵖ ≃* βᵐᵒᵖ) 
goal: ∀ (a : β), (AddEquiv.op.symm f).symm a = (AddOpposite.unop ∘ ⇑f.symm ∘ AddOpposite.op) a

full_name: MulEquiv.op
code: /-- An iso `α ≃* β` can equivalently be viewed as an iso `αᵐᵒᵖ ≃* βᵐᵒᵖ`. -/
@[to_additive (attr := simps)
  "An iso `α ≃+ β` can equivalently be viewed as an iso `αᵃᵒᵖ ≃+ βᵃᵒᵖ`."]
def MulEquiv.op {α β} [Mul α] [Mul β] : α ≃* β ≃ (αᵐᵒᵖ ≃* βᵐᵒᵖ) 
goal: α ≃* β ≃ (αᵐᵒᵖ ≃* βᵐᵒᵖ)

full_name: AddEquiv.op_apply_symm_apply
code: /-- An iso `α ≃* β` can equivalently be viewed as an iso `αᵐᵒᵖ ≃* βᵐᵒᵖ`. -/
@[to_additive (attr := simps)
  "An iso `α ≃+ β` can equivalently be viewed as an iso `αᵃᵒᵖ ≃+ βᵃᵒᵖ`."]
def MulEquiv.op {α β} [Mul α] [Mul β] : α ≃* β ≃ (αᵐᵒᵖ ≃* βᵐᵒᵖ) 
goal: ∀ (a : βᵃᵒᵖ), (AddEquiv.op f).symm a = (AddOpposite.op ∘ ⇑f.symm ∘ AddOpposite.unop) a

full_name: MulEquiv.op_symm_apply_apply
code: /-- An iso `α ≃* β` can equivalently be viewed as an iso `αᵐᵒᵖ ≃* βᵐᵒᵖ`. -/
@[to_additive (attr := simps)
  "An iso `α ≃+ β` can equivalently be viewed as an iso `αᵃᵒᵖ ≃+ βᵃᵒᵖ`."]
def MulEquiv.op {α β} [Mul α] [Mul β] : α ≃* β ≃ (αᵐᵒᵖ ≃* βᵐᵒᵖ) 
goal: ∀ (a : α), (MulEquiv.op.symm f) a = (MulOpposite.unop ∘ ⇑f ∘ MulOpposite.op) a

full_name: MulEquiv.op_apply_apply
code: /-- An iso `α ≃* β` can equivalently be viewed as an iso `αᵐᵒᵖ ≃* βᵐᵒᵖ`. -/
@[to_additive (attr := simps)
  "An iso `α ≃+ β` can equivalently be viewed as an iso `αᵃᵒᵖ ≃+ βᵃᵒᵖ`."]
def MulEquiv.op {α β} [Mul α] [Mul β] : α ≃* β ≃ (αᵐᵒᵖ ≃* βᵐᵒᵖ) 
goal: ∀ (a : αᵐᵒᵖ), (MulEquiv.op f) a = (MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) a

full_name: AddEquiv.unop
code: /-- The 'unopposite' of an iso `αᵐᵒᵖ ≃* βᵐᵒᵖ`. Inverse to `MulEquiv.op`. -/
@[to_additive (attr := simp)
  "The 'unopposite' of an iso `αᵃᵒᵖ ≃+ βᵃᵒᵖ`. Inverse to `AddEquiv.op`."]
def MulEquiv.unop {α β} [Mul α] [Mul β] : αᵐᵒᵖ ≃* βᵐᵒᵖ ≃ (α ≃* β) 
goal: αᵃᵒᵖ ≃+ βᵃᵒᵖ ≃ (α ≃+ β)

full_name: MulEquiv.unop
code: /-- The 'unopposite' of an iso `αᵐᵒᵖ ≃* βᵐᵒᵖ`. Inverse to `MulEquiv.op`. -/
@[to_additive (attr := simp)
  "The 'unopposite' of an iso `αᵃᵒᵖ ≃+ βᵃᵒᵖ`. Inverse to `AddEquiv.op`."]
def MulEquiv.unop {α β} [Mul α] [Mul β] : αᵐᵒᵖ ≃* βᵐᵒᵖ ≃ (α ≃* β) 
goal: αᵐᵒᵖ ≃* βᵐᵒᵖ ≃ (α ≃* β)

full_name: AddMonoidHom.mul_op_ext
code: /-- This ext lemma changes equalities on `αᵐᵒᵖ →+ β` to equalities on `α →+ β`.
This is useful because there are often ext lemmas for specific `α`s that will apply
to an equality of `α →+ β` such as `Finsupp.addHom_ext'`. -/
@[ext]
theorem AddMonoidHom.mul_op_ext {α β} [AddZeroClass α] [AddZeroClass β] (f g : αᵐᵒᵖ →+ β)
    (h :
      f.comp (opAddEquiv : α ≃+ αᵐᵒᵖ).toAddMonoidHom =
        g.comp (opAddEquiv : α ≃+ αᵐᵒᵖ).toAddMonoidHom) :
    f = g 
goal: f = g