ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AddOpposite.addSemiconjBy_unop
@[to_additive (attr := simp, nolint simpComm)]
theorem semiconjBy_unop [Mul α] {a x y : αᵐᵒᵖ} :
    SemiconjBy (unop a) (unop y) (unop x) ↔ SemiconjBy a x y 
Arguments: {α : Type u_1} [Add α] {a x y : αᵃᵒᵖ}
Goal: AddSemiconjBy (AddOpposite.unop a) (AddOpposite.unop y) (AddOpposite.unop x) ↔ AddSemiconjBy a x y
-- SemiconjBy.op
@[to_additive]
theorem _root_.SemiconjBy.op [Mul α] {a x y : α} (h : SemiconjBy a x y) :
    SemiconjBy (op a) (op y) (op x) 
Arguments: {α : Type u_1} [Mul α] {a x y : α} (h : SemiconjBy a x y)
Goal: SemiconjBy (MulOpposite.op a) (MulOpposite.op y) (MulOpposite.op x)
-- AddSemiconjBy.op
@[to_additive]
theorem _root_.SemiconjBy.op [Mul α] {a x y : α} (h : SemiconjBy a x y) :
    SemiconjBy (op a) (op y) (op x) 
Arguments: {α : Type u_1} [Add α] {a x y : α} (h : AddSemiconjBy a x y)
Goal: AddSemiconjBy (AddOpposite.op a) (AddOpposite.op y) (AddOpposite.op x)
-- AddSemiconjBy.unop
@[to_additive]
theorem _root_.SemiconjBy.unop [Mul α] {a x y : αᵐᵒᵖ} (h : SemiconjBy a x y) :
    SemiconjBy (unop a) (unop y) (unop x) 
Arguments: {α : Type u_1} [Add α] {a x y : αᵃᵒᵖ} (h : AddSemiconjBy a x y)
Goal: AddSemiconjBy (AddOpposite.unop a) (AddOpposite.unop y) (AddOpposite.unop x)
-- SemiconjBy.unop
@[to_additive]
theorem _root_.SemiconjBy.unop [Mul α] {a x y : αᵐᵒᵖ} (h : SemiconjBy a x y) :
    SemiconjBy (unop a) (unop y) (unop x) 
Arguments: {α : Type u_1} [Mul α] {a x y : αᵐᵒᵖ} (h : SemiconjBy a x y)
Goal: SemiconjBy (MulOpposite.unop a) (MulOpposite.unop y) (MulOpposite.unop x)
-- Commute.op
@[to_additive]
theorem _root_.Commute.op [Mul α] {x y : α} (h : Commute x y) : Commute (op x) (op y) 
Arguments: {α : Type u_1} [Mul α] {x y : α} (h : Commute x y)
Goal: Commute (MulOpposite.op x) (MulOpposite.op y)
-- AddCommute.op
@[to_additive]
theorem _root_.Commute.op [Mul α] {x y : α} (h : Commute x y) : Commute (op x) (op y) 
Arguments: {α : Type u_1} [Add α] {x y : α} (h : AddCommute x y)
Goal: AddCommute (AddOpposite.op x) (AddOpposite.op y)
-- AddCommute.unop
@[to_additive]
nonrec theorem _root_.Commute.unop [Mul α] {x y : αᵐᵒᵖ} (h : Commute x y) :
    Commute (unop x) (unop y) 
Arguments: {α : Type u_1} [Add α] {x y : αᵃᵒᵖ} (h : AddCommute x y)
Goal: AddCommute (AddOpposite.unop x) (AddOpposite.unop y)
-- Commute.unop
@[to_additive]
nonrec theorem _root_.Commute.unop [Mul α] {x y : αᵐᵒᵖ} (h : Commute x y) :
    Commute (unop x) (unop y) 
Arguments: {α : Type u_1} [Mul α] {x y : αᵐᵒᵖ} (h : Commute x y)
Goal: Commute (MulOpposite.unop x) (MulOpposite.unop y)
-- AddOpposite.addCommute_op
@[to_additive (attr := simp)]
theorem commute_op [Mul α] {x y : α} : Commute (op x) (op y) ↔ Commute x y 
Arguments: {α : Type u_1} [Add α] {x y : α}
Goal: AddCommute (AddOpposite.op x) (AddOpposite.op y) ↔ AddCommute x y
-- MulOpposite.commute_op
@[to_additive (attr := simp)]
theorem commute_op [Mul α] {x y : α} : Commute (op x) (op y) ↔ Commute x y 
Arguments: {α : Type u_1} [Mul α] {x y : α}
Goal: Commute (MulOpposite.op x) (MulOpposite.op y) ↔ Commute x y
-- MulOpposite.commute_unop
@[to_additive (attr := simp, nolint simpComm)]
theorem commute_unop [Mul α] {x y : αᵐᵒᵖ} : Commute (unop x) (unop y) ↔ Commute x y 
Arguments: {α : Type u_1} [Mul α] {x y : αᵐᵒᵖ}
Goal: Commute (MulOpposite.unop x) (MulOpposite.unop y) ↔ Commute x y
-- AddOpposite.addCommute_unop
@[to_additive (attr := simp, nolint simpComm)]
theorem commute_unop [Mul α] {x y : αᵐᵒᵖ} : Commute (unop x) (unop y) ↔ Commute x y 
Arguments: {α : Type u_1} [Add α] {x y : αᵃᵒᵖ}
Goal: AddCommute (AddOpposite.unop x) (AddOpposite.unop y) ↔ AddCommute x y
-- MulOpposite.opAddEquiv_symm_apply
@[simps! (config := { fullyApplied := false, simpRhs := true }) apply symm_apply]
def opAddEquiv [Add α] : α ≃+ αᵐᵒᵖ 
Arguments: {α : Type u_1} [Add α]
Goal: ⇑MulOpposite.opAddEquiv.symm = MulOpposite.unop
-- MulOpposite.opAddEquiv_apply
@[simps! (config := { fullyApplied := false, simpRhs := true }) apply symm_apply]
def opAddEquiv [Add α] : α ≃+ αᵐᵒᵖ 
Arguments: {α : Type u_1} [Add α]
Goal: ⇑MulOpposite.opAddEquiv = MulOpposite.op
-- MulOpposite.opAddEquiv_toEquiv
@[simp]
theorem opAddEquiv_toEquiv [Add α] : ((opAddEquiv : α ≃+ αᵐᵒᵖ) : α ≃ αᵐᵒᵖ) = opEquiv 
Arguments: {α : Type u_1} [Add α]
Goal: ↑MulOpposite.opAddEquiv = MulOpposite.opEquiv
-- AddOpposite.op_pow
@[simp]
theorem op_pow {β} [Pow α β] (a : α) (b : β) : op (a ^ b) = op a ^ b 
Arguments: {α : Type u_1} {β : Type u_2} [Pow α β] (a : α) (b : β)
Goal: AddOpposite.op (a ^ b) = AddOpposite.op a ^ b
-- AddOpposite.unop_pow
@[simp]
theorem unop_pow {β} [Pow α β] (a : αᵃᵒᵖ) (b : β) : unop (a ^ b) = unop a ^ b 
Arguments: {α : Type u_1} {β : Type u_2} [Pow α β] (a : αᵃᵒᵖ) (b : β)
Goal: AddOpposite.unop (a ^ b) = AddOpposite.unop a ^ b
-- AddOpposite.opMulEquiv_symm_apply
@[simps! (config := { fullyApplied := false, simpRhs := true })]
def opMulEquiv [Mul α] : α ≃* αᵃᵒᵖ 
Arguments: {α : Type u_1} [Mul α]
Goal: ⇑AddOpposite.opMulEquiv.symm = AddOpposite.unop
-- AddOpposite.opMulEquiv_apply
@[simps! (config := { fullyApplied := false, simpRhs := true })]
def opMulEquiv [Mul α] : α ≃* αᵃᵒᵖ 
Arguments: {α : Type u_1} [Mul α]
Goal: ⇑AddOpposite.opMulEquiv = AddOpposite.op
-- AddOpposite.opMulEquiv_toEquiv
@[simp]
theorem opMulEquiv_toEquiv [Mul α] : ((opMulEquiv : α ≃* αᵃᵒᵖ) : α ≃ αᵃᵒᵖ) = opEquiv 
Arguments: {α : Type u_1} [Mul α]
Goal: ↑AddOpposite.opMulEquiv = AddOpposite.opEquiv
-- AddEquiv.neg'_apply
@[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ᵐᵒᵖ 
Arguments: (G : Type u_2) [SubtractionMonoid G]
Goal: ⇑(AddEquiv.neg' G) = AddOpposite.op ∘ Neg.neg
-- AddEquiv.neg'_symm_apply
@[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ᵐᵒᵖ 
Arguments: (G : Type u_2) [SubtractionMonoid G]
Goal: ⇑(AddEquiv.neg' G).symm = Neg.neg ∘ AddOpposite.unop
-- MulEquiv.inv'_apply
@[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ᵐᵒᵖ 
Arguments: (G : Type u_2) [DivisionMonoid G]
Goal: ⇑(MulEquiv.inv' G) = MulOpposite.op ∘ Inv.inv
-- MulEquiv.inv'_symm_apply
@[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ᵐᵒᵖ 
Arguments: (G : Type u_2) [DivisionMonoid G]
Goal: ⇑(MulEquiv.inv' G).symm = Inv.inv ∘ MulOpposite.unop
-- MulHom.toOpposite_apply
@[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ᵐᵒᵖ 
Arguments: {M : Type u_2} {N : Type u_3} [Mul M] [Mul N] (f : M →ₙ* N) (hf : ∀ (x y : M), Commute (f x) (f y))
Goal: ⇑(f.toOpposite hf) = MulOpposite.op ∘ ⇑f
-- AddHom.toOpposite_apply
@[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ᵐᵒᵖ 
Arguments: {M : Type u_2} {N : Type u_3} [Add M] [Add N] (f : AddHom M N) (hf : ∀ (x y : M), AddCommute (f x) (f y))
Goal: ⇑(f.toOpposite hf) = AddOpposite.op ∘ ⇑f
-- AddHom.fromOpposite_apply
@[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 
Arguments: {M : Type u_2} {N : Type u_3} [Add M] [Add N] (f : AddHom M N) (hf : ∀ (x y : M), AddCommute (f x) (f y))
Goal: ⇑(f.fromOpposite hf) = ⇑f ∘ AddOpposite.unop
-- MulHom.fromOpposite_apply
@[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 
Arguments: {M : Type u_2} {N : Type u_3} [Mul M] [Mul N] (f : M →ₙ* N) (hf : ∀ (x y : M), Commute (f x) (f y))
Goal: ⇑(f.fromOpposite hf) = ⇑f ∘ MulOpposite.unop
-- AddMonoidHom.toOpposite_apply
@[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ᵐᵒᵖ 
Arguments: {M : Type u_2} {N : Type u_3} [AddZeroClass M] [AddZeroClass N] (f : M →+ N) (hf : ∀ (x y : M), AddCommute (f x) (f y))
Goal: ⇑(f.toOpposite hf) = AddOpposite.op ∘ ⇑f
-- MonoidHom.toOpposite_apply
@[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ᵐᵒᵖ 
Arguments: {M : Type u_2} {N : Type u_3} [MulOneClass M] [MulOneClass N] (f : M →* N) (hf : ∀ (x y : M), Commute (f x) (f y))
Goal: ⇑(f.toOpposite hf) = MulOpposite.op ∘ ⇑f
-- MonoidHom.fromOpposite_apply
@[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 
Arguments: {M : Type u_2} {N : Type u_3} [MulOneClass M] [MulOneClass N] (f : M →* N) (hf : ∀ (x y : M), Commute (f x) (f y))
Goal: ⇑(f.fromOpposite hf) = ⇑f ∘ MulOpposite.unop
-- AddMonoidHom.fromOpposite_apply
@[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 
Arguments: {M : Type u_2} {N : Type u_3} [AddZeroClass M] [AddZeroClass N] (f : M →+ N) (hf : ∀ (x y : M), AddCommute (f x) (f y))
Goal: ⇑(f.fromOpposite hf) = ⇑f ∘ AddOpposite.unop
-- Units.coe_unop_opEquiv
@[to_additive (attr := simp)]
theorem Units.coe_unop_opEquiv {M} [Monoid M] (u : Mᵐᵒᵖˣ) :
    ((Units.opEquiv u).unop : M) = unop (u : Mᵐᵒᵖ) 
Arguments: {M : Type u_2} [Monoid M] (u : Mᵐᵒᵖˣ)
Goal: ↑(MulOpposite.unop (Units.opEquiv u)) = MulOpposite.unop ↑u
-- AddUnits.coe_unop_opEquiv
@[to_additive (attr := simp)]
theorem Units.coe_unop_opEquiv {M} [Monoid M] (u : Mᵐᵒᵖˣ) :
    ((Units.opEquiv u).unop : M) = unop (u : Mᵐᵒᵖ) 
Arguments: {M : Type u_2} [AddMonoid M] (u : AddUnits Mᵃᵒᵖ)
Goal: ↑(AddOpposite.unop (AddUnits.opEquiv u)) = AddOpposite.unop ↑u
-- AddUnits.coe_opEquiv_symm
@[to_additive (attr := simp)]
theorem Units.coe_opEquiv_symm {M} [Monoid M] (u : Mˣᵐᵒᵖ) :
    (Units.opEquiv.symm u : Mᵐᵒᵖ) = op (u.unop : M) 
Arguments: {M : Type u_2} [AddMonoid M] (u : (AddUnits M)ᵃᵒᵖ)
Goal: ↑(AddUnits.opEquiv.symm u) = AddOpposite.op ↑(AddOpposite.unop u)
-- Units.coe_opEquiv_symm
@[to_additive (attr := simp)]
theorem Units.coe_opEquiv_symm {M} [Monoid M] (u : Mˣᵐᵒᵖ) :
    (Units.opEquiv.symm u : Mᵐᵒᵖ) = op (u.unop : M) 
Arguments: {M : Type u_2} [Monoid M] (u : Mˣᵐᵒᵖ)
Goal: ↑(Units.opEquiv.symm u) = MulOpposite.op ↑(MulOpposite.unop u)
-- IsAddUnit.op
@[to_additive]
nonrec theorem IsUnit.op {M} [Monoid M] {m : M} (h : IsUnit m) : IsUnit (op m) 
Arguments: {M : Type u_2} [AddMonoid M] {m : M} (h : IsAddUnit m)
Goal: IsAddUnit (AddOpposite.op m)
-- IsUnit.op
@[to_additive]
nonrec theorem IsUnit.op {M} [Monoid M] {m : M} (h : IsUnit m) : IsUnit (op m) 
Arguments: {M : Type u_2} [Monoid M] {m : M} (h : IsUnit m)
Goal: IsUnit (MulOpposite.op m)
-- IsUnit.unop
@[to_additive]
nonrec theorem IsUnit.unop {M} [Monoid M] {m : Mᵐᵒᵖ} (h : IsUnit m) : IsUnit (unop m) 
Arguments: {M : Type u_2} [Monoid M] {m : Mᵐᵒᵖ} (h : IsUnit m)
Goal: IsUnit (MulOpposite.unop m)
-- IsAddUnit.unop
@[to_additive]
nonrec theorem IsUnit.unop {M} [Monoid M] {m : Mᵐᵒᵖ} (h : IsUnit m) : IsUnit (unop m) 
Arguments: {M : Type u_2} [AddMonoid M] {m : Mᵃᵒᵖ} (h : IsAddUnit m)
Goal: IsAddUnit (AddOpposite.unop m)
-- isAddUnit_op
@[to_additive (attr := simp)]
theorem isUnit_op {M} [Monoid M] {m : M} : IsUnit (op m) ↔ IsUnit m 
Arguments: {M : Type u_2} [AddMonoid M] {m : M}
Goal: IsAddUnit (AddOpposite.op m) ↔ IsAddUnit m
-- isUnit_op
@[to_additive (attr := simp)]
theorem isUnit_op {M} [Monoid M] {m : M} : IsUnit (op m) ↔ IsUnit m 
Arguments: {M : Type u_2} [Monoid M] {m : M}
Goal: IsUnit (MulOpposite.op m) ↔ IsUnit m
-- isAddUnit_unop
@[to_additive (attr := simp)]
theorem isUnit_unop {M} [Monoid M] {m : Mᵐᵒᵖ} : IsUnit (unop m) ↔ IsUnit m 
Arguments: {M : Type u_2} [AddMonoid M] {m : Mᵃᵒᵖ}
Goal: IsAddUnit (AddOpposite.unop m) ↔ IsAddUnit m
-- isUnit_unop
@[to_additive (attr := simp)]
theorem isUnit_unop {M} [Monoid M] {m : Mᵐᵒᵖ} : IsUnit (unop m) ↔ IsUnit m 
Arguments: {M : Type u_2} [Monoid M] {m : Mᵐᵒᵖ}
Goal: IsUnit (MulOpposite.unop m) ↔ IsUnit m
-- AddHom.op_apply_apply
@[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ᵐᵒᵖ) 
Arguments: {M : Type u_2} {N : Type u_3} [Add M] [Add N] (f : AddHom M N)
Goal: ∀ (a : Mᵃᵒᵖ), (AddHom.op f) a = (AddOpposite.op ∘ ⇑f ∘ AddOpposite.unop) a
-- MulHom.op_symm_apply_apply
@[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ᵐᵒᵖ) 
Arguments: {M : Type u_2} {N : Type u_3} [Mul M] [Mul N] (f : Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ)
Goal: ∀ (a : M), (MulHom.op.symm f) a = (MulOpposite.unop ∘ ⇑f ∘ MulOpposite.op) a
-- MulHom.op_apply_apply
@[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ᵐᵒᵖ) 
Arguments: {M : Type u_2} {N : Type u_3} [Mul M] [Mul N] (f : M →ₙ* N)
Goal: ∀ (a : Mᵐᵒᵖ), (MulHom.op f) a = (MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) a
-- AddHom.op_symm_apply_apply
@[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ᵐᵒᵖ) 
Arguments: {M : Type u_2} {N : Type u_3} [Add M] [Add N] (f : AddHom Mᵃᵒᵖ Nᵃᵒᵖ)
Goal: ∀ (a : M), (AddHom.op.symm f) a = (AddOpposite.unop ∘ ⇑f ∘ AddOpposite.op) a
-- AddHom.mulOp_apply_apply
@[simps]
def AddHom.mulOp {M N} [Add M] [Add N] : AddHom M N ≃ AddHom Mᵐᵒᵖ Nᵐᵒᵖ 
Arguments: {M : Type u_2} {N : Type u_3} [Add M] [Add N] (f : AddHom M N)
Goal: ∀ (a : Mᵐᵒᵖ), (AddHom.mulOp f) a = (MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) a
-- AddHom.mulOp_symm_apply_apply
@[simps]
def AddHom.mulOp {M N} [Add M] [Add N] : AddHom M N ≃ AddHom Mᵐᵒᵖ Nᵐᵒᵖ 
Arguments: {M : Type u_2} {N : Type u_3} [Add M] [Add N] (f : AddHom Mᵐᵒᵖ Nᵐᵒᵖ)
Goal: ∀ (a : M), (AddHom.mulOp.symm f) a = (MulOpposite.unop ∘ ⇑f ∘ MulOpposite.op) a
-- AddMonoidHom.op_symm_apply_apply
@[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ᵐᵒᵖ) 
Arguments: {M : Type u_2} {N : Type u_3} [AddZeroClass M] [AddZeroClass N] (f : Mᵃᵒᵖ →+ Nᵃᵒᵖ)
Goal: ∀ (a : M), (AddMonoidHom.op.symm f) a = (AddOpposite.unop ∘ ⇑f ∘ AddOpposite.op) a
-- MonoidHom.op_apply_apply
@[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ᵐᵒᵖ) 
Arguments: {M : Type u_2} {N : Type u_3} [MulOneClass M] [MulOneClass N] (f : M →* N)
Goal: ∀ (a : Mᵐᵒᵖ), (MonoidHom.op f) a = (MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) a
-- AddMonoidHom.op_apply_apply
@[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ᵐᵒᵖ) 
Arguments: {M : Type u_2} {N : Type u_3} [AddZeroClass M] [AddZeroClass N] (f : M →+ N)
Goal: ∀ (a : Mᵃᵒᵖ), (AddMonoidHom.op f) a = (AddOpposite.op ∘ ⇑f ∘ AddOpposite.unop) a
-- MonoidHom.op_symm_apply_apply
@[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ᵐᵒᵖ) 
Arguments: {M : Type u_2} {N : Type u_3} [MulOneClass M] [MulOneClass N] (f : Mᵐᵒᵖ →* Nᵐᵒᵖ)
Goal: ∀ (a : M), (MonoidHom.op.symm f) a = (MulOpposite.unop ∘ ⇑f ∘ MulOpposite.op) a
-- MulEquiv.opOp_symm_apply
@[to_additive (attr := simps!)
      "A additive monoid is isomorphic to the opposite of its opposite."]
def MulEquiv.opOp (M : Type*) [Mul M] : M ≃* Mᵐᵒᵖᵐᵒᵖ 
Arguments: (M : Type u_2) [Mul M]
Goal: ∀ (a : Mᵐᵒᵖᵐᵒᵖ), (MulEquiv.opOp M).symm a = MulOpposite.unop (MulOpposite.unop a)
-- AddEquiv.opOp_apply
@[to_additive (attr := simps!)
      "A additive monoid is isomorphic to the opposite of its opposite."]
def MulEquiv.opOp (M : Type*) [Mul M] : M ≃* Mᵐᵒᵖᵐᵒᵖ 
Arguments: (M : Type u_2) [Add M]
Goal: ∀ (a : M), (AddEquiv.opOp M) a = AddOpposite.op (AddOpposite.op a)
-- MulEquiv.opOp_apply
@[to_additive (attr := simps!)
      "A additive monoid is isomorphic to the opposite of its opposite."]
def MulEquiv.opOp (M : Type*) [Mul M] : M ≃* Mᵐᵒᵖᵐᵒᵖ 
Arguments: (M : Type u_2) [Mul M]
Goal: ∀ (a : M), (MulEquiv.opOp M) a = MulOpposite.op (MulOpposite.op a)
-- AddEquiv.opOp_symm_apply
@[to_additive (attr := simps!)
      "A additive monoid is isomorphic to the opposite of its opposite."]
def MulEquiv.opOp (M : Type*) [Mul M] : M ≃* Mᵐᵒᵖᵐᵒᵖ 
Arguments: (M : Type u_2) [Add M]
Goal: ∀ (a : Mᵃᵒᵖᵃᵒᵖ), (AddEquiv.opOp M).symm a = AddOpposite.unop (AddOpposite.unop a)
-- AddMonoidHom.mulOp_symm_apply_apply
@[simps]
def AddMonoidHom.mulOp {M N} [AddZeroClass M] [AddZeroClass N] : (M →+ N) ≃ (Mᵐᵒᵖ →+ Nᵐᵒᵖ) 
Arguments: {M : Type u_2} {N : Type u_3} [AddZeroClass M] [AddZeroClass N] (f : Mᵐᵒᵖ →+ Nᵐᵒᵖ)
Goal: ∀ (a : M), (AddMonoidHom.mulOp.symm f) a = (MulOpposite.unop ∘ ⇑f ∘ MulOpposite.op) a
-- AddMonoidHom.mulOp_apply_apply
@[simps]
def AddMonoidHom.mulOp {M N} [AddZeroClass M] [AddZeroClass N] : (M →+ N) ≃ (Mᵐᵒᵖ →+ Nᵐᵒᵖ) 
Arguments: {M : Type u_2} {N : Type u_3} [AddZeroClass M] [AddZeroClass N] (f : M →+ N)
Goal: ∀ (a : Mᵐᵒᵖ), (AddMonoidHom.mulOp f) a = (MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) a
-- AddEquiv.mulOp_apply
@[simps]
def AddEquiv.mulOp {α β} [Add α] [Add β] : α ≃+ β ≃ (αᵐᵒᵖ ≃+ βᵐᵒᵖ) 
Arguments: {α : Type u_2} {β : Type u_3} [Add α] [Add β] (f : α ≃+ β)
Goal: AddEquiv.mulOp f = MulOpposite.opAddEquiv.symm.trans (f.trans MulOpposite.opAddEquiv)
-- AddEquiv.mulOp_symm_apply
@[simps]
def AddEquiv.mulOp {α β} [Add α] [Add β] : α ≃+ β ≃ (αᵐᵒᵖ ≃+ βᵐᵒᵖ) 
Arguments: {α : Type u_2} {β : Type u_3} [Add α] [Add β] (f : αᵐᵒᵖ ≃+ βᵐᵒᵖ)
Goal: AddEquiv.mulOp.symm f = MulOpposite.opAddEquiv.trans (f.trans MulOpposite.opAddEquiv.symm)
-- MulEquiv.op_apply_symm_apply
@[to_additive (attr := simps)
  "An iso `α ≃+ β` can equivalently be viewed as an iso `αᵃᵒᵖ ≃+ βᵃᵒᵖ`."]
def MulEquiv.op {α β} [Mul α] [Mul β] : α ≃* β ≃ (αᵐᵒᵖ ≃* βᵐᵒᵖ) 
Arguments: {α : Type u_2} {β : Type u_3} [Mul α] [Mul β] (f : α ≃* β)
Goal: ∀ (a : βᵐᵒᵖ), (MulEquiv.op f).symm a = (MulOpposite.op ∘ ⇑f.symm ∘ MulOpposite.unop) a
-- MulEquiv.op_symm_apply_symm_apply
@[to_additive (attr := simps)
  "An iso `α ≃+ β` can equivalently be viewed as an iso `αᵃᵒᵖ ≃+ βᵃᵒᵖ`."]
def MulEquiv.op {α β} [Mul α] [Mul β] : α ≃* β ≃ (αᵐᵒᵖ ≃* βᵐᵒᵖ) 
Arguments: {α : Type u_2} {β : Type u_3} [Mul α] [Mul β] (f : αᵐᵒᵖ ≃* βᵐᵒᵖ)
Goal: ∀ (a : β), (MulEquiv.op.symm f).symm a = (MulOpposite.unop ∘ ⇑f.symm ∘ MulOpposite.op) a
-- AddEquiv.op_symm_apply_apply
@[to_additive (attr := simps)
  "An iso `α ≃+ β` can equivalently be viewed as an iso `αᵃᵒᵖ ≃+ βᵃᵒᵖ`."]
def MulEquiv.op {α β} [Mul α] [Mul β] : α ≃* β ≃ (αᵐᵒᵖ ≃* βᵐᵒᵖ) 
Arguments: {α : Type u_2} {β : Type u_3} [Add α] [Add β] (f : αᵃᵒᵖ ≃+ βᵃᵒᵖ)
Goal: ∀ (a : α), (AddEquiv.op.symm f) a = (AddOpposite.unop ∘ ⇑f ∘ AddOpposite.op) a
-- AddEquiv.op_apply_apply
@[to_additive (attr := simps)
  "An iso `α ≃+ β` can equivalently be viewed as an iso `αᵃᵒᵖ ≃+ βᵃᵒᵖ`."]
def MulEquiv.op {α β} [Mul α] [Mul β] : α ≃* β ≃ (αᵐᵒᵖ ≃* βᵐᵒᵖ) 
Arguments: {α : Type u_2} {β : Type u_3} [Add α] [Add β] (f : α ≃+ β)
Goal: ∀ (a : αᵃᵒᵖ), (AddEquiv.op f) a = (AddOpposite.op ∘ ⇑f ∘ AddOpposite.unop) a
-- AddEquiv.op_symm_apply_symm_apply
@[to_additive (attr := simps)
  "An iso `α ≃+ β` can equivalently be viewed as an iso `αᵃᵒᵖ ≃+ βᵃᵒᵖ`."]
def MulEquiv.op {α β} [Mul α] [Mul β] : α ≃* β ≃ (αᵐᵒᵖ ≃* βᵐᵒᵖ) 
Arguments: {α : Type u_2} {β : Type u_3} [Add α] [Add β] (f : αᵃᵒᵖ ≃+ βᵃᵒᵖ)
Goal: ∀ (a : β), (AddEquiv.op.symm f).symm a = (AddOpposite.unop ∘ ⇑f.symm ∘ AddOpposite.op) a
-- AddEquiv.op_apply_symm_apply
@[to_additive (attr := simps)
  "An iso `α ≃+ β` can equivalently be viewed as an iso `αᵃᵒᵖ ≃+ βᵃᵒᵖ`."]
def MulEquiv.op {α β} [Mul α] [Mul β] : α ≃* β ≃ (αᵐᵒᵖ ≃* βᵐᵒᵖ) 
Arguments: {α : Type u_2} {β : Type u_3} [Add α] [Add β] (f : α ≃+ β)
Goal: ∀ (a : βᵃᵒᵖ), (AddEquiv.op f).symm a = (AddOpposite.op ∘ ⇑f.symm ∘ AddOpposite.unop) a
-- MulEquiv.op_symm_apply_apply
@[to_additive (attr := simps)
  "An iso `α ≃+ β` can equivalently be viewed as an iso `αᵃᵒᵖ ≃+ βᵃᵒᵖ`."]
def MulEquiv.op {α β} [Mul α] [Mul β] : α ≃* β ≃ (αᵐᵒᵖ ≃* βᵐᵒᵖ) 
Arguments: {α : Type u_2} {β : Type u_3} [Mul α] [Mul β] (f : αᵐᵒᵖ ≃* βᵐᵒᵖ)
Goal: ∀ (a : α), (MulEquiv.op.symm f) a = (MulOpposite.unop ∘ ⇑f ∘ MulOpposite.op) a
-- MulEquiv.op_apply_apply
@[to_additive (attr := simps)
  "An iso `α ≃+ β` can equivalently be viewed as an iso `αᵃᵒᵖ ≃+ βᵃᵒᵖ`."]
def MulEquiv.op {α β} [Mul α] [Mul β] : α ≃* β ≃ (αᵐᵒᵖ ≃* βᵐᵒᵖ) 
Arguments: {α : Type u_2} {β : Type u_3} [Mul α] [Mul β] (f : α ≃* β)
Goal: ∀ (a : αᵐᵒᵖ), (MulEquiv.op f) a = (MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) a