File: Mathlib/Algebra/Opposites.lean

full_name: PreOpposite.op'
code: /-- Auxiliary type to implement `MulOpposite` and `AddOpposite`.

It turns out to be convenient to have `MulOpposite α = AddOpposite α` true by definition, in the
same way that it is convenient to have `Additive α = α`; this means that we also get the defeq
`AddOpposite (Additive α) = MulOpposite α`, which is convenient when working with quotients.

This is a compromise between making `MulOpposite α = AddOpposite α = α` (what we had in Lean 3) and
having no defeqs within those three types (which we had as of mathlib4#1036). -/
structure PreOpposite (α : Type*) : Type _ where
  /-- The element of `PreOpposite α` that represents `x : α`. -/ op' ::
  /-- The element of `α` represented by `x : PreOpposite α`. -/ unop' : α
goal: PreOpposite α

full_name: PreOpposite
code: /-- Auxiliary type to implement `MulOpposite` and `AddOpposite`.

It turns out to be convenient to have `MulOpposite α = AddOpposite α` true by definition, in the
same way that it is convenient to have `Additive α = α`; this means that we also get the defeq
`AddOpposite (Additive α) = MulOpposite α`, which is convenient when working with quotients.

This is a compromise between making `MulOpposite α = AddOpposite α = α` (what we had in Lean 3) and
having no defeqs within those three types (which we had as of mathlib4#1036). -/
structure PreOpposite (α : Type*) : Type _ where
  /-- The element of `PreOpposite α` that represents `x : α`. -/ op' ::
  /-- The element of `α` represented by `x : PreOpposite α`. -/ unop' : α
goal: Type u_3

full_name: PreOpposite.unop'
code: /-- Auxiliary type to implement `MulOpposite` and `AddOpposite`.

It turns out to be convenient to have `MulOpposite α = AddOpposite α` true by definition, in the
same way that it is convenient to have `Additive α = α`; this means that we also get the defeq
`AddOpposite (Additive α) = MulOpposite α`, which is convenient when working with quotients.

This is a compromise between making `MulOpposite α = AddOpposite α = α` (what we had in Lean 3) and
having no defeqs within those three types (which we had as of mathlib4#1036). -/
structure PreOpposite (α : Type*) : Type _ where
  /-- The element of `PreOpposite α` that represents `x : α`. -/ op' ::
  /-- The element of `α` represented by `x : PreOpposite α`. -/ unop' : α
goal: α

full_name: AddOpposite
code: /-- Multiplicative opposite of a type. This type inherits all additive structures on `α` and
reverses left and right in multiplication. -/
@[to_additive
      "Additive opposite of a type. This type inherits all multiplicative structures on `α` and
      reverses left and right in addition."]
def MulOpposite (α : Type*) : Type _ 
goal: Type u_3

full_name: MulOpposite
code: /-- Multiplicative opposite of a type. This type inherits all additive structures on `α` and
reverses left and right in multiplication. -/
@[to_additive
      "Additive opposite of a type. This type inherits all multiplicative structures on `α` and
      reverses left and right in addition."]
def MulOpposite (α : Type*) : Type _ 
goal: Type u_3

full_name: _aux_Mathlib_Algebra_Opposites___unexpand_MulOpposite_1
code: /-- Multiplicative opposite of a type. -/
postfix:max "ᵐᵒᵖ" => MulOpposite
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Algebra_Opposites___macroRules_term_ᵐᵒᵖ_1»
code: /-- Multiplicative opposite of a type. -/
postfix:max "ᵐᵒᵖ" => MulOpposite
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Opposites___unexpand_AddOpposite_1
code: /-- Additive opposite of a type. -/
postfix:max "ᵃᵒᵖ" => AddOpposite
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Algebra_Opposites___macroRules_term_ᵃᵒᵖ_1»
code: /-- Additive opposite of a type. -/
postfix:max "ᵃᵒᵖ" => AddOpposite
goal: Lean.Macro

full_name: MulOpposite.op
code: /-- The element of `MulOpposite α` that represents `x : α`. -/
@[to_additive "The element of `αᵃᵒᵖ` that represents `x : α`."]
def op : α → αᵐᵒᵖ 
goal: α → αᵐᵒᵖ

full_name: AddOpposite.op
code: /-- The element of `MulOpposite α` that represents `x : α`. -/
@[to_additive "The element of `αᵃᵒᵖ` that represents `x : α`."]
def op : α → αᵐᵒᵖ 
goal: α → αᵃᵒᵖ

full_name: MulOpposite.unop
code: /-- The element of `α` represented by `x : αᵐᵒᵖ`. -/
@[to_additive (attr := pp_nodot) "The element of `α` represented by `x : αᵃᵒᵖ`."]
def unop : αᵐᵒᵖ → α 
goal: αᵐᵒᵖ → α

full_name: AddOpposite.unop
code: /-- The element of `α` represented by `x : αᵐᵒᵖ`. -/
@[to_additive (attr := pp_nodot) "The element of `α` represented by `x : αᵃᵒᵖ`."]
def unop : αᵐᵒᵖ → α 
goal: αᵃᵒᵖ → α

full_name: AddOpposite.unop_op
code: @[to_additive (attr := simp)]
theorem unop_op (x : α) : unop (op x) = x 
goal: AddOpposite.unop (AddOpposite.op x) = x

full_name: MulOpposite.unop_op
code: @[to_additive (attr := simp)]
theorem unop_op (x : α) : unop (op x) = x 
goal: MulOpposite.unop (MulOpposite.op x) = x

full_name: MulOpposite.op_unop
code: @[to_additive (attr := simp)]
theorem op_unop (x : αᵐᵒᵖ) : op (unop x) = x 
goal: MulOpposite.op (MulOpposite.unop x) = x

full_name: AddOpposite.op_unop
code: @[to_additive (attr := simp)]
theorem op_unop (x : αᵐᵒᵖ) : op (unop x) = x 
goal: AddOpposite.op (AddOpposite.unop x) = x

full_name: MulOpposite.op_comp_unop
code: @[to_additive (attr := simp)]
theorem op_comp_unop : (op : α → αᵐᵒᵖ) ∘ unop = id 
goal: MulOpposite.op ∘ MulOpposite.unop = id

full_name: AddOpposite.op_comp_unop
code: @[to_additive (attr := simp)]
theorem op_comp_unop : (op : α → αᵐᵒᵖ) ∘ unop = id 
goal: AddOpposite.op ∘ AddOpposite.unop = id

full_name: AddOpposite.unop_comp_op
code: @[to_additive (attr := simp)]
theorem unop_comp_op : (unop : αᵐᵒᵖ → α) ∘ op = id 
goal: AddOpposite.unop ∘ AddOpposite.op = id

full_name: MulOpposite.unop_comp_op
code: @[to_additive (attr := simp)]
theorem unop_comp_op : (unop : αᵐᵒᵖ → α) ∘ op = id 
goal: MulOpposite.unop ∘ MulOpposite.op = id

full_name: AddOpposite.rec'
code: /-- A recursor for `MulOpposite`. Use as `induction x`. -/
@[to_additive (attr := simp, elab_as_elim, induction_eliminator, cases_eliminator)
  "A recursor for `AddOpposite`. Use as `induction x`."]
protected def rec' {F : αᵐᵒᵖ → Sort*} (h : ∀ X, F (op X)) : ∀ X, F X 
goal: F X

full_name: MulOpposite.rec'
code: /-- A recursor for `MulOpposite`. Use as `induction x`. -/
@[to_additive (attr := simp, elab_as_elim, induction_eliminator, cases_eliminator)
  "A recursor for `AddOpposite`. Use as `induction x`."]
protected def rec' {F : αᵐᵒᵖ → Sort*} (h : ∀ X, F (op X)) : ∀ X, F X 
goal: F X

full_name: MulOpposite.opEquiv_apply
code: /-- The canonical bijection between `α` and `αᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn) apply symm_apply)
  "The canonical bijection between `α` and `αᵃᵒᵖ`."]
def opEquiv : α ≃ αᵐᵒᵖ 
goal: ⇑MulOpposite.opEquiv = MulOpposite.op

full_name: AddOpposite.opEquiv_apply
code: /-- The canonical bijection between `α` and `αᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn) apply symm_apply)
  "The canonical bijection between `α` and `αᵃᵒᵖ`."]
def opEquiv : α ≃ αᵐᵒᵖ 
goal: ⇑AddOpposite.opEquiv = AddOpposite.op

full_name: AddOpposite.opEquiv_symm_apply
code: /-- The canonical bijection between `α` and `αᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn) apply symm_apply)
  "The canonical bijection between `α` and `αᵃᵒᵖ`."]
def opEquiv : α ≃ αᵐᵒᵖ 
goal: ⇑AddOpposite.opEquiv.symm = AddOpposite.unop

full_name: MulOpposite.opEquiv_symm_apply
code: /-- The canonical bijection between `α` and `αᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn) apply symm_apply)
  "The canonical bijection between `α` and `αᵃᵒᵖ`."]
def opEquiv : α ≃ αᵐᵒᵖ 
goal: ⇑MulOpposite.opEquiv.symm = MulOpposite.unop

full_name: AddOpposite.opEquiv
code: /-- The canonical bijection between `α` and `αᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn) apply symm_apply)
  "The canonical bijection between `α` and `αᵃᵒᵖ`."]
def opEquiv : α ≃ αᵐᵒᵖ 
goal: α ≃ αᵃᵒᵖ

full_name: MulOpposite.opEquiv
code: /-- The canonical bijection between `α` and `αᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn) apply symm_apply)
  "The canonical bijection between `α` and `αᵃᵒᵖ`."]
def opEquiv : α ≃ αᵐᵒᵖ 
goal: α ≃ αᵐᵒᵖ

full_name: MulOpposite.op_bijective
code: @[to_additive]
theorem op_bijective : Bijective (op : α → αᵐᵒᵖ) 
goal: Function.Bijective MulOpposite.op

full_name: AddOpposite.op_bijective
code: @[to_additive]
theorem op_bijective : Bijective (op : α → αᵐᵒᵖ) 
goal: Function.Bijective AddOpposite.op

full_name: AddOpposite.unop_bijective
code: @[to_additive]
theorem unop_bijective : Bijective (unop : αᵐᵒᵖ → α) 
goal: Function.Bijective AddOpposite.unop

full_name: MulOpposite.unop_bijective
code: @[to_additive]
theorem unop_bijective : Bijective (unop : αᵐᵒᵖ → α) 
goal: Function.Bijective MulOpposite.unop

full_name: MulOpposite.op_injective
code: @[to_additive]
theorem op_injective : Injective (op : α → αᵐᵒᵖ) 
goal: Function.Injective MulOpposite.op

full_name: AddOpposite.op_injective
code: @[to_additive]
theorem op_injective : Injective (op : α → αᵐᵒᵖ) 
goal: Function.Injective AddOpposite.op

full_name: AddOpposite.op_surjective
code: @[to_additive]
theorem op_surjective : Surjective (op : α → αᵐᵒᵖ) 
goal: Function.Surjective AddOpposite.op

full_name: MulOpposite.op_surjective
code: @[to_additive]
theorem op_surjective : Surjective (op : α → αᵐᵒᵖ) 
goal: Function.Surjective MulOpposite.op

full_name: AddOpposite.unop_injective
code: @[to_additive]
theorem unop_injective : Injective (unop : αᵐᵒᵖ → α) 
goal: Function.Injective AddOpposite.unop

full_name: MulOpposite.unop_injective
code: @[to_additive]
theorem unop_injective : Injective (unop : αᵐᵒᵖ → α) 
goal: Function.Injective MulOpposite.unop

full_name: AddOpposite.unop_surjective
code: @[to_additive]
theorem unop_surjective : Surjective (unop : αᵐᵒᵖ → α) 
goal: Function.Surjective AddOpposite.unop

full_name: MulOpposite.unop_surjective
code: @[to_additive]
theorem unop_surjective : Surjective (unop : αᵐᵒᵖ → α) 
goal: Function.Surjective MulOpposite.unop

full_name: AddOpposite.op_inj
code: @[to_additive (attr := simp)]
theorem op_inj {x y : α} : op x = op y ↔ x = y 
goal: AddOpposite.op x = AddOpposite.op y ↔ x = y

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

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

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

full_name: MulOpposite.instNontrivial
code: @[to_additive] instance instNontrivial [Nontrivial α] : Nontrivial αᵐᵒᵖ 
goal: Nontrivial αᵐᵒᵖ

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

full_name: MulOpposite.instInhabited
code: @[to_additive] instance instInhabited [Inhabited α] : Inhabited αᵐᵒᵖ 
goal: Inhabited αᵐᵒᵖ

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

full_name: MulOpposite.instSubsingleton
code: @[to_additive]
instance instSubsingleton [Subsingleton α] : Subsingleton αᵐᵒᵖ 
goal: Subsingleton αᵐᵒᵖ

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

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

full_name: MulOpposite.instUnique
code: @[to_additive] instance instUnique [Unique α] : Unique αᵐᵒᵖ 
goal: Unique αᵐᵒᵖ

full_name: MulOpposite.instIsEmpty
code: @[to_additive] instance instIsEmpty [IsEmpty α] : IsEmpty αᵐᵒᵖ 
goal: IsEmpty αᵐᵒᵖ

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

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

full_name: MulOpposite.instDecidableEq
code: @[to_additive]
instance instDecidableEq [DecidableEq α] : DecidableEq αᵐᵒᵖ 
goal: DecidableEq αᵐᵒᵖ

full_name: MulOpposite.instZero
code: instance instZero [Zero α] : Zero αᵐᵒᵖ 
goal: Zero αᵐᵒᵖ

full_name: AddOpposite.instZero
code: @[to_additive] instance instOne [One α] : One αᵐᵒᵖ 
goal: Zero αᵃᵒᵖ

full_name: MulOpposite.instOne
code: @[to_additive] instance instOne [One α] : One αᵐᵒᵖ 
goal: One αᵐᵒᵖ

full_name: MulOpposite.instAdd
code: instance instAdd [Add α] : Add αᵐᵒᵖ 
goal: Add αᵐᵒᵖ

full_name: MulOpposite.instSub
code: instance instSub [Sub α] : Sub αᵐᵒᵖ 
goal: Sub αᵐᵒᵖ

full_name: MulOpposite.instNeg
code: instance instNeg [Neg α] : Neg αᵐᵒᵖ 
goal: Neg αᵐᵒᵖ

full_name: MulOpposite.instInvolutiveNeg
code: instance instInvolutiveNeg [InvolutiveNeg α] : InvolutiveNeg αᵐᵒᵖ 
goal: InvolutiveNeg αᵐᵒᵖ

full_name: AddOpposite.instAdd
code: @[to_additive] instance instMul [Mul α] : Mul αᵐᵒᵖ 
goal: Add αᵃᵒᵖ

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

full_name: AddOpposite.instNeg
code: @[to_additive] instance instInv [Inv α] : Inv αᵐᵒᵖ 
goal: Neg αᵃᵒᵖ

full_name: MulOpposite.instInv
code: @[to_additive] instance instInv [Inv α] : Inv αᵐᵒᵖ 
goal: Inv αᵐᵒᵖ

full_name: MulOpposite.instInvolutiveInv
code: @[to_additive]
instance instInvolutiveInv [InvolutiveInv α] : InvolutiveInv αᵐᵒᵖ 
goal: InvolutiveInv αᵐᵒᵖ

full_name: AddOpposite.instInvolutiveNeg
code: @[to_additive]
instance instInvolutiveInv [InvolutiveInv α] : InvolutiveInv αᵐᵒᵖ 
goal: InvolutiveNeg αᵃᵒᵖ

full_name: AddOpposite.instVAdd
code: @[to_additive] instance instSMul [SMul α β] : SMul α βᵐᵒᵖ 
goal: VAdd α βᵃᵒᵖ

full_name: MulOpposite.instSMul
code: @[to_additive] instance instSMul [SMul α β] : SMul α βᵐᵒᵖ 
goal: SMul α βᵐᵒᵖ

full_name: MulOpposite.op_zero
code: @[simp] lemma op_zero [Zero α] : op (0 : α) = 0 
goal: MulOpposite.op 0 = 0

full_name: MulOpposite.unop_zero
code: @[simp] lemma unop_zero [Zero α] : unop (0 : αᵐᵒᵖ) = 0 
goal: MulOpposite.unop 0 = 0

full_name: AddOpposite.op_zero
code: @[to_additive (attr := simp)] lemma op_one [One α] : op (1 : α) = 1 
goal: AddOpposite.op 0 = 0

full_name: MulOpposite.op_one
code: @[to_additive (attr := simp)] lemma op_one [One α] : op (1 : α) = 1 
goal: MulOpposite.op 1 = 1

full_name: AddOpposite.unop_zero
code: @[to_additive (attr := simp)] lemma unop_one [One α] : unop (1 : αᵐᵒᵖ) = 1 
goal: AddOpposite.unop 0 = 0

full_name: MulOpposite.unop_one
code: @[to_additive (attr := simp)] lemma unop_one [One α] : unop (1 : αᵐᵒᵖ) = 1 
goal: MulOpposite.unop 1 = 1

full_name: MulOpposite.op_add
code: @[simp] lemma op_add [Add α] (x y : α) : op (x + y) = op x + op y 
goal: MulOpposite.op (x + y) = MulOpposite.op x + MulOpposite.op y

full_name: MulOpposite.unop_add
code: @[simp] lemma unop_add [Add α] (x y : αᵐᵒᵖ) : unop (x + y) = unop x + unop y 
goal: MulOpposite.unop (x + y) = MulOpposite.unop x + MulOpposite.unop y

full_name: MulOpposite.op_neg
code: @[simp] lemma op_neg [Neg α] (x : α) : op (-x) = -op x 
goal: MulOpposite.op (-x) = -MulOpposite.op x

full_name: MulOpposite.unop_neg
code: @[simp] lemma unop_neg [Neg α] (x : αᵐᵒᵖ) : unop (-x) = -unop x 
goal: MulOpposite.unop (-x) = -MulOpposite.unop x

full_name: AddOpposite.op_add
code: @[to_additive (attr := simp)] lemma op_mul [Mul α] (x y : α) : op (x * y) = op y * op x 
goal: AddOpposite.op (x + y) = AddOpposite.op y + AddOpposite.op x

full_name: MulOpposite.op_mul
code: @[to_additive (attr := simp)] lemma op_mul [Mul α] (x y : α) : op (x * y) = op y * op x 
goal: MulOpposite.op (x * y) = MulOpposite.op y * MulOpposite.op x

full_name: MulOpposite.unop_mul
code: @[to_additive (attr := simp)]
lemma unop_mul [Mul α] (x y : αᵐᵒᵖ) : unop (x * y) = unop y * unop x 
goal: MulOpposite.unop (x * y) = MulOpposite.unop y * MulOpposite.unop x

full_name: AddOpposite.unop_add
code: @[to_additive (attr := simp)]
lemma unop_mul [Mul α] (x y : αᵐᵒᵖ) : unop (x * y) = unop y * unop x 
goal: AddOpposite.unop (x + y) = AddOpposite.unop y + AddOpposite.unop x

full_name: AddOpposite.op_neg
code: @[to_additive (attr := simp)] lemma op_inv [Inv α] (x : α) : op x⁻¹ = (op x)⁻¹ 
goal: AddOpposite.op (-x) = -AddOpposite.op x

full_name: MulOpposite.op_inv
code: @[to_additive (attr := simp)] lemma op_inv [Inv α] (x : α) : op x⁻¹ = (op x)⁻¹ 
goal: MulOpposite.op x⁻¹ = (MulOpposite.op x)⁻¹

full_name: MulOpposite.unop_inv
code: @[to_additive (attr := simp)] lemma unop_inv [Inv α] (x : αᵐᵒᵖ) : unop x⁻¹ = (unop x)⁻¹ 
goal: MulOpposite.unop x⁻¹ = (MulOpposite.unop x)⁻¹

full_name: AddOpposite.unop_neg
code: @[to_additive (attr := simp)] lemma unop_inv [Inv α] (x : αᵐᵒᵖ) : unop x⁻¹ = (unop x)⁻¹ 
goal: AddOpposite.unop (-x) = -AddOpposite.unop x

full_name: MulOpposite.op_sub
code: @[simp] lemma op_sub [Sub α] (x y : α) : op (x - y) = op x - op y 
goal: MulOpposite.op (x - y) = MulOpposite.op x - MulOpposite.op y

full_name: MulOpposite.unop_sub
code: @[simp] lemma unop_sub [Sub α] (x y : αᵐᵒᵖ) : unop (x - y) = unop x - unop y 
goal: MulOpposite.unop (x - y) = MulOpposite.unop x - MulOpposite.unop y

full_name: MulOpposite.op_smul
code: @[to_additive (attr := simp)]
lemma op_smul [SMul α β] (a : α) (b : β) : op (a • b) = a • op b 
goal: MulOpposite.op (a • b) = a • MulOpposite.op b

full_name: AddOpposite.op_vadd
code: @[to_additive (attr := simp)]
lemma op_smul [SMul α β] (a : α) (b : β) : op (a • b) = a • op b 
goal: AddOpposite.op (a +ᵥ b) = a +ᵥ AddOpposite.op b

full_name: AddOpposite.unop_vadd
code: @[to_additive (attr := simp)]
lemma unop_smul [SMul α β] (a : α) (b : βᵐᵒᵖ) : unop (a • b) = a • unop b 
goal: AddOpposite.unop (a +ᵥ b) = a +ᵥ AddOpposite.unop b

full_name: MulOpposite.unop_smul
code: @[to_additive (attr := simp)]
lemma unop_smul [SMul α β] (a : α) (b : βᵐᵒᵖ) : unop (a • b) = a • unop b 
goal: MulOpposite.unop (a • b) = a • MulOpposite.unop b

full_name: MulOpposite.unop_eq_zero_iff
code: @[simp, nolint simpComm]
theorem unop_eq_zero_iff [Zero α] (a : αᵐᵒᵖ) : a.unop = (0 : α) ↔ a = (0 : αᵐᵒᵖ) 
goal: MulOpposite.unop a = 0 ↔ a = 0

full_name: MulOpposite.op_eq_zero_iff
code: @[simp]
theorem op_eq_zero_iff [Zero α] (a : α) : op a = (0 : αᵐᵒᵖ) ↔ a = (0 : α) 
goal: MulOpposite.op a = 0 ↔ a = 0

full_name: MulOpposite.unop_ne_zero_iff
code: theorem unop_ne_zero_iff [Zero α] (a : αᵐᵒᵖ) : a.unop ≠ (0 : α) ↔ a ≠ (0 : αᵐᵒᵖ) 
goal: MulOpposite.unop a ≠ 0 ↔ a ≠ 0

full_name: MulOpposite.op_ne_zero_iff
code: theorem op_ne_zero_iff [Zero α] (a : α) : op a ≠ (0 : αᵐᵒᵖ) ↔ a ≠ (0 : α) 
goal: MulOpposite.op a ≠ 0 ↔ a ≠ 0

full_name: AddOpposite.unop_eq_zero_iff
code: @[to_additive (attr := simp, nolint simpComm)]
theorem unop_eq_one_iff [One α] (a : αᵐᵒᵖ) : a.unop = 1 ↔ a = 1 
goal: AddOpposite.unop a = 0 ↔ a = 0

full_name: MulOpposite.unop_eq_one_iff
code: @[to_additive (attr := simp, nolint simpComm)]
theorem unop_eq_one_iff [One α] (a : αᵐᵒᵖ) : a.unop = 1 ↔ a = 1 
goal: MulOpposite.unop a = 1 ↔ a = 1

full_name: AddOpposite.op_eq_zero_iff
code: @[to_additive (attr := simp)]
lemma op_eq_one_iff [One α] (a : α) : op a = 1 ↔ a = 1 
goal: AddOpposite.op a = 0 ↔ a = 0

full_name: MulOpposite.op_eq_one_iff
code: @[to_additive (attr := simp)]
lemma op_eq_one_iff [One α] (a : α) : op a = 1 ↔ a = 1 
goal: MulOpposite.op a = 1 ↔ a = 1

full_name: AddOpposite.instOne
code: instance instOne [One α] : One αᵃᵒᵖ 
goal: One αᵃᵒᵖ

full_name: AddOpposite.op_one
code: @[simp] lemma op_one [One α] : op (1 : α) = 1 
goal: AddOpposite.op 1 = 1

full_name: AddOpposite.unop_one
code: @[simp] lemma unop_one [One α] : unop 1 = (1 : α) 
goal: AddOpposite.unop 1 = 1

full_name: AddOpposite.op_eq_one_iff
code: @[simp] lemma op_eq_one_iff [One α] {a : α} : op a = 1 ↔ a = 1 
goal: AddOpposite.op a = 1 ↔ a = 1

full_name: AddOpposite.unop_eq_one_iff
code: @[simp] lemma unop_eq_one_iff [One α] {a : αᵃᵒᵖ} : unop a = 1 ↔ a = 1 
goal: AddOpposite.unop a = 1 ↔ a = 1

full_name: AddOpposite.instMul
code: instance instMul [Mul α] : Mul αᵃᵒᵖ 
goal: Mul αᵃᵒᵖ

full_name: AddOpposite.op_mul
code: @[simp] lemma op_mul [Mul α] (a b : α) : op (a * b) = op a * op b 
goal: AddOpposite.op (a * b) = AddOpposite.op a * AddOpposite.op b

full_name: AddOpposite.unop_mul
code: @[simp] lemma unop_mul [Mul α] (a b : αᵃᵒᵖ) : unop (a * b) = unop a * unop b 
goal: AddOpposite.unop (a * b) = AddOpposite.unop a * AddOpposite.unop b

full_name: AddOpposite.instInv
code: instance instInv [Inv α] : Inv αᵃᵒᵖ 
goal: Inv αᵃᵒᵖ

full_name: AddOpposite.instInvolutiveInv
code: instance instInvolutiveInv [InvolutiveInv α] : InvolutiveInv αᵃᵒᵖ 
goal: InvolutiveInv αᵃᵒᵖ

full_name: AddOpposite.op_inv
code: @[simp] lemma op_inv [Inv α] (a : α) : op a⁻¹ = (op a)⁻¹ 
goal: AddOpposite.op a⁻¹ = (AddOpposite.op a)⁻¹

full_name: AddOpposite.unop_inv
code: @[simp] lemma unop_inv [Inv α] (a : αᵃᵒᵖ) : unop a⁻¹ = (unop a)⁻¹ 
goal: AddOpposite.unop a⁻¹ = (AddOpposite.unop a)⁻¹

full_name: AddOpposite.instDiv
code: instance instDiv [Div α] : Div αᵃᵒᵖ 
goal: Div αᵃᵒᵖ

full_name: AddOpposite.op_div
code: @[simp] lemma op_div [Div α] (a b : α) : op (a / b) = op a / op b 
goal: AddOpposite.op (a / b) = AddOpposite.op a / AddOpposite.op b

full_name: AddOpposite.unop_div
code: @[simp] lemma unop_div [Div α] (a b : αᵃᵒᵖ) : unop (a / b) = unop a / unop b 
goal: AddOpposite.unop (a / b) = AddOpposite.unop a / AddOpposite.unop b