File: Mathlib/Algebra/Order/Group/Synonym.lean

full_name: instZeroOrderDual
code: @[to_additive]
instance [h : One α] : One αᵒᵈ 
goal: Zero αᵒᵈ

full_name: instOneOrderDual
code: @[to_additive]
instance [h : One α] : One αᵒᵈ 
goal: One αᵒᵈ

full_name: instAddOrderDual
code: @[to_additive]
instance [h : Mul α] : Mul αᵒᵈ 
goal: Add αᵒᵈ

full_name: instMulOrderDual
code: @[to_additive]
instance [h : Mul α] : Mul αᵒᵈ 
goal: Mul αᵒᵈ

full_name: instInvOrderDual
code: @[to_additive]
instance [h : Inv α] : Inv αᵒᵈ 
goal: Inv αᵒᵈ

full_name: instNegOrderDual
code: @[to_additive]
instance [h : Inv α] : Inv αᵒᵈ 
goal: Neg αᵒᵈ

full_name: instDivOrderDual
code: @[to_additive]
instance [h : Div α] : Div αᵒᵈ 
goal: Div αᵒᵈ

full_name: instSubOrderDual
code: @[to_additive]
instance [h : Div α] : Div αᵒᵈ 
goal: Sub αᵒᵈ

full_name: OrderDual.instVAdd
code: @[to_additive (attr := to_additive) (reorder := 1 2) OrderDual.instSMul]
instance OrderDual.instPow [h : Pow α β] : Pow αᵒᵈ β 
goal: VAdd β αᵒᵈ

full_name: OrderDual.instPow
code: @[to_additive (attr := to_additive) (reorder := 1 2) OrderDual.instSMul]
instance OrderDual.instPow [h : Pow α β] : Pow αᵒᵈ β 
goal: Pow αᵒᵈ β

full_name: OrderDual.instSMul
code: @[to_additive (attr := to_additive) (reorder := 1 2) OrderDual.instSMul]
instance OrderDual.instPow [h : Pow α β] : Pow αᵒᵈ β 
goal: SMul β αᵒᵈ

full_name: OrderDual.instSMul'
code: @[to_additive (attr := to_additive) (reorder := 1 2) OrderDual.instSMul']
instance OrderDual.instPow' [h : Pow α β] : Pow α βᵒᵈ 
goal: SMul βᵒᵈ α

full_name: OrderDual.instVAdd'
code: @[to_additive (attr := to_additive) (reorder := 1 2) OrderDual.instSMul']
instance OrderDual.instPow' [h : Pow α β] : Pow α βᵒᵈ 
goal: VAdd βᵒᵈ α

full_name: OrderDual.instPow'
code: @[to_additive (attr := to_additive) (reorder := 1 2) OrderDual.instSMul']
instance OrderDual.instPow' [h : Pow α β] : Pow α βᵒᵈ 
goal: Pow α βᵒᵈ

full_name: instSemigroupOrderDual
code: @[to_additive]
instance [h : Semigroup α] : Semigroup αᵒᵈ 
goal: Semigroup αᵒᵈ

full_name: instAddSemigroupOrderDual
code: @[to_additive]
instance [h : Semigroup α] : Semigroup αᵒᵈ 
goal: AddSemigroup αᵒᵈ

full_name: instAddCommSemigroupOrderDual
code: @[to_additive]
instance [h : CommSemigroup α] : CommSemigroup αᵒᵈ 
goal: AddCommSemigroup αᵒᵈ

full_name: instCommSemigroupOrderDual
code: @[to_additive]
instance [h : CommSemigroup α] : CommSemigroup αᵒᵈ 
goal: CommSemigroup αᵒᵈ

full_name: instIsAddLeftCancelOrderDual
code: @[to_additive]
instance [Mul α] [h : IsLeftCancelMul α] : IsLeftCancelMul αᵒᵈ 
goal: IsLeftCancelAdd αᵒᵈ

full_name: instIsLeftCancelMulOrderDual
code: @[to_additive]
instance [Mul α] [h : IsLeftCancelMul α] : IsLeftCancelMul αᵒᵈ 
goal: IsLeftCancelMul αᵒᵈ

full_name: instIsAddRightCancelOrderDual
code: @[to_additive]
instance [Mul α] [h : IsRightCancelMul α] : IsRightCancelMul αᵒᵈ 
goal: IsRightCancelAdd αᵒᵈ

full_name: instIsRightCancelMulOrderDual
code: @[to_additive]
instance [Mul α] [h : IsRightCancelMul α] : IsRightCancelMul αᵒᵈ 
goal: IsRightCancelMul αᵒᵈ

full_name: instIsAddCancelOrderDual
code: @[to_additive]
instance [Mul α] [h : IsCancelMul α] : IsCancelMul αᵒᵈ 
goal: IsCancelAdd αᵒᵈ

full_name: instIsCancelMulOrderDual
code: @[to_additive]
instance [Mul α] [h : IsCancelMul α] : IsCancelMul αᵒᵈ 
goal: IsCancelMul αᵒᵈ

full_name: instAddLeftCancelSemigroupOrderDual
code: @[to_additive]
instance [h : LeftCancelSemigroup α] : LeftCancelSemigroup αᵒᵈ 
goal: AddLeftCancelSemigroup αᵒᵈ

full_name: instLeftCancelSemigroupOrderDual
code: @[to_additive]
instance [h : LeftCancelSemigroup α] : LeftCancelSemigroup αᵒᵈ 
goal: LeftCancelSemigroup αᵒᵈ

full_name: instAddRightCancelSemigroupOrderDual
code: @[to_additive]
instance [h : RightCancelSemigroup α] : RightCancelSemigroup αᵒᵈ 
goal: AddRightCancelSemigroup αᵒᵈ

full_name: instRightCancelSemigroupOrderDual
code: @[to_additive]
instance [h : RightCancelSemigroup α] : RightCancelSemigroup αᵒᵈ 
goal: RightCancelSemigroup αᵒᵈ

full_name: instMulOneClassOrderDual
code: @[to_additive]
instance [h : MulOneClass α] : MulOneClass αᵒᵈ 
goal: MulOneClass αᵒᵈ

full_name: instAddZeroClassOrderDual
code: @[to_additive]
instance [h : MulOneClass α] : MulOneClass αᵒᵈ 
goal: AddZeroClass αᵒᵈ

full_name: instAddMonoidOrderDual
code: @[to_additive]
instance [h : Monoid α] : Monoid αᵒᵈ 
goal: AddMonoid αᵒᵈ

full_name: instMonoidOrderDual
code: @[to_additive]
instance [h : Monoid α] : Monoid αᵒᵈ 
goal: Monoid αᵒᵈ

full_name: OrderDual.instAddCommMonoid
code: @[to_additive]
instance OrderDual.instCommMonoid [h : CommMonoid α] : CommMonoid αᵒᵈ 
goal: AddCommMonoid αᵒᵈ

full_name: OrderDual.instCommMonoid
code: @[to_additive]
instance OrderDual.instCommMonoid [h : CommMonoid α] : CommMonoid αᵒᵈ 
goal: CommMonoid αᵒᵈ

full_name: instAddLeftCancelMonoidOrderDual
code: @[to_additive]
instance [h : LeftCancelMonoid α] : LeftCancelMonoid αᵒᵈ 
goal: AddLeftCancelMonoid αᵒᵈ

full_name: instLeftCancelMonoidOrderDual
code: @[to_additive]
instance [h : LeftCancelMonoid α] : LeftCancelMonoid αᵒᵈ 
goal: LeftCancelMonoid αᵒᵈ

full_name: instRightCancelMonoidOrderDual
code: @[to_additive]
instance [h : RightCancelMonoid α] : RightCancelMonoid αᵒᵈ 
goal: RightCancelMonoid αᵒᵈ

full_name: instAddRightCancelMonoidOrderDual
code: @[to_additive]
instance [h : RightCancelMonoid α] : RightCancelMonoid αᵒᵈ 
goal: AddRightCancelMonoid αᵒᵈ

full_name: instAddCancelMonoidOrderDual
code: @[to_additive]
instance [h : CancelMonoid α] : CancelMonoid αᵒᵈ 
goal: AddCancelMonoid αᵒᵈ

full_name: instCancelMonoidOrderDual
code: @[to_additive]
instance [h : CancelMonoid α] : CancelMonoid αᵒᵈ 
goal: CancelMonoid αᵒᵈ

full_name: OrderDual.instAddCancelCommMonoid
code: @[to_additive]
instance OrderDual.instCancelCommMonoid [h : CancelCommMonoid α] : CancelCommMonoid αᵒᵈ 
goal: AddCancelCommMonoid αᵒᵈ

full_name: OrderDual.instCancelCommMonoid
code: @[to_additive]
instance OrderDual.instCancelCommMonoid [h : CancelCommMonoid α] : CancelCommMonoid αᵒᵈ 
goal: CancelCommMonoid αᵒᵈ

full_name: instInvolutiveNegOrderDual
code: @[to_additive]
instance [h : InvolutiveInv α] : InvolutiveInv αᵒᵈ 
goal: InvolutiveNeg αᵒᵈ

full_name: instInvolutiveInvOrderDual
code: @[to_additive]
instance [h : InvolutiveInv α] : InvolutiveInv αᵒᵈ 
goal: InvolutiveInv αᵒᵈ

full_name: instSubNegAddMonoidOrderDual
code: @[to_additive]
instance [h : DivInvMonoid α] : DivInvMonoid αᵒᵈ 
goal: SubNegMonoid αᵒᵈ

full_name: instDivInvMonoidOrderDual
code: @[to_additive]
instance [h : DivInvMonoid α] : DivInvMonoid αᵒᵈ 
goal: DivInvMonoid αᵒᵈ

full_name: instDivisionMonoidOrderDual
code: @[to_additive OrderDual.subtractionMonoid]
instance [h : DivisionMonoid α] : DivisionMonoid αᵒᵈ 
goal: DivisionMonoid αᵒᵈ

full_name: OrderDual.subtractionMonoid
code: @[to_additive OrderDual.subtractionMonoid]
instance [h : DivisionMonoid α] : DivisionMonoid αᵒᵈ 
goal: SubtractionMonoid αᵒᵈ

full_name: instDivisionCommMonoidOrderDual
code: @[to_additive OrderDual.subtractionCommMonoid]
instance [h : DivisionCommMonoid α] : DivisionCommMonoid αᵒᵈ 
goal: DivisionCommMonoid αᵒᵈ

full_name: OrderDual.subtractionCommMonoid
code: @[to_additive OrderDual.subtractionCommMonoid]
instance [h : DivisionCommMonoid α] : DivisionCommMonoid αᵒᵈ 
goal: SubtractionCommMonoid αᵒᵈ

full_name: OrderDual.instAddGroup
code: @[to_additive]
instance OrderDual.instGroup [h : Group α] : Group αᵒᵈ 
goal: AddGroup αᵒᵈ

full_name: OrderDual.instGroup
code: @[to_additive]
instance OrderDual.instGroup [h : Group α] : Group αᵒᵈ 
goal: Group αᵒᵈ

full_name: instCommGroupOrderDual
code: @[to_additive]
instance [h : CommGroup α] : CommGroup αᵒᵈ 
goal: CommGroup αᵒᵈ

full_name: instAddCommGroupOrderDual
code: @[to_additive]
instance [h : CommGroup α] : CommGroup αᵒᵈ 
goal: AddCommGroup αᵒᵈ

full_name: toDual_one
code: @[to_additive (attr := simp)]
theorem toDual_one [One α] : toDual (1 : α) = 1 
goal: OrderDual.toDual 1 = 1

full_name: toDual_zero
code: @[to_additive (attr := simp)]
theorem toDual_one [One α] : toDual (1 : α) = 1 
goal: OrderDual.toDual 0 = 0

full_name: ofDual_zero
code: @[to_additive (attr := simp)]
theorem ofDual_one [One α] : (ofDual 1 : α) = 1 
goal: OrderDual.ofDual 0 = 0

full_name: ofDual_one
code: @[to_additive (attr := simp)]
theorem ofDual_one [One α] : (ofDual 1 : α) = 1 
goal: OrderDual.ofDual 1 = 1

full_name: toDual_mul
code: @[to_additive (attr := simp)]
theorem toDual_mul [Mul α] (a b : α) : toDual (a * b) = toDual a * toDual b 
goal: OrderDual.toDual (a * b) = OrderDual.toDual a * OrderDual.toDual b

full_name: toDual_add
code: @[to_additive (attr := simp)]
theorem toDual_mul [Mul α] (a b : α) : toDual (a * b) = toDual a * toDual b 
goal: OrderDual.toDual (a + b) = OrderDual.toDual a + OrderDual.toDual b

full_name: ofDual_mul
code: @[to_additive (attr := simp)]
theorem ofDual_mul [Mul α] (a b : αᵒᵈ) : ofDual (a * b) = ofDual a * ofDual b 
goal: OrderDual.ofDual (a * b) = OrderDual.ofDual a * OrderDual.ofDual b

full_name: ofDual_add
code: @[to_additive (attr := simp)]
theorem ofDual_mul [Mul α] (a b : αᵒᵈ) : ofDual (a * b) = ofDual a * ofDual b 
goal: OrderDual.ofDual (a + b) = OrderDual.ofDual a + OrderDual.ofDual b

full_name: toDual_inv
code: @[to_additive (attr := simp)]
theorem toDual_inv [Inv α] (a : α) : toDual a⁻¹ = (toDual a)⁻¹ 
goal: OrderDual.toDual a⁻¹ = (OrderDual.toDual a)⁻¹

full_name: toDual_neg
code: @[to_additive (attr := simp)]
theorem toDual_inv [Inv α] (a : α) : toDual a⁻¹ = (toDual a)⁻¹ 
goal: OrderDual.toDual (-a) = -OrderDual.toDual a

full_name: ofDual_neg
code: @[to_additive (attr := simp)]
theorem ofDual_inv [Inv α] (a : αᵒᵈ) : ofDual a⁻¹ = (ofDual a)⁻¹ 
goal: OrderDual.ofDual (-a) = -OrderDual.ofDual a

full_name: ofDual_inv
code: @[to_additive (attr := simp)]
theorem ofDual_inv [Inv α] (a : αᵒᵈ) : ofDual a⁻¹ = (ofDual a)⁻¹ 
goal: OrderDual.ofDual a⁻¹ = (OrderDual.ofDual a)⁻¹

full_name: toDual_sub
code: @[to_additive (attr := simp)]
theorem toDual_div [Div α] (a b : α) : toDual (a / b) = toDual a / toDual b 
goal: OrderDual.toDual (a - b) = OrderDual.toDual a - OrderDual.toDual b

full_name: toDual_div
code: @[to_additive (attr := simp)]
theorem toDual_div [Div α] (a b : α) : toDual (a / b) = toDual a / toDual b 
goal: OrderDual.toDual (a / b) = OrderDual.toDual a / OrderDual.toDual b

full_name: ofDual_div
code: @[to_additive (attr := simp)]
theorem ofDual_div [Div α] (a b : αᵒᵈ) : ofDual (a / b) = ofDual a / ofDual b 
goal: OrderDual.ofDual (a / b) = OrderDual.ofDual a / OrderDual.ofDual b

full_name: ofDual_sub
code: @[to_additive (attr := simp)]
theorem ofDual_div [Div α] (a b : αᵒᵈ) : ofDual (a / b) = ofDual a / ofDual b 
goal: OrderDual.ofDual (a - b) = OrderDual.ofDual a - OrderDual.ofDual b

full_name: toDual_vadd
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) toDual_smul]
theorem toDual_pow [Pow α β] (a : α) (b : β) : toDual (a ^ b) = toDual a ^ b 
goal: OrderDual.toDual (b +ᵥ a) = b +ᵥ OrderDual.toDual a

full_name: toDual_pow
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) toDual_smul]
theorem toDual_pow [Pow α β] (a : α) (b : β) : toDual (a ^ b) = toDual a ^ b 
goal: OrderDual.toDual (a ^ b) = OrderDual.toDual a ^ b

full_name: toDual_smul
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) toDual_smul]
theorem toDual_pow [Pow α β] (a : α) (b : β) : toDual (a ^ b) = toDual a ^ b 
goal: OrderDual.toDual (b • a) = b • OrderDual.toDual a

full_name: ofDual_vadd
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) ofDual_smul]
theorem ofDual_pow [Pow α β] (a : αᵒᵈ) (b : β) : ofDual (a ^ b) = ofDual a ^ b 
goal: OrderDual.ofDual (b +ᵥ a) = b +ᵥ OrderDual.ofDual a

full_name: ofDual_pow
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) ofDual_smul]
theorem ofDual_pow [Pow α β] (a : αᵒᵈ) (b : β) : ofDual (a ^ b) = ofDual a ^ b 
goal: OrderDual.ofDual (a ^ b) = OrderDual.ofDual a ^ b

full_name: ofDual_smul
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) ofDual_smul]
theorem ofDual_pow [Pow α β] (a : αᵒᵈ) (b : β) : ofDual (a ^ b) = ofDual a ^ b 
goal: OrderDual.ofDual (b • a) = b • OrderDual.ofDual a

full_name: toDual_smul'
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) toDual_smul']
theorem pow_toDual [Pow α β] (a : α) (b : β) : a ^ toDual b = a ^ b 
goal: OrderDual.toDual b • a = b • a

full_name: toDual_vadd'
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) toDual_smul']
theorem pow_toDual [Pow α β] (a : α) (b : β) : a ^ toDual b = a ^ b 
goal: OrderDual.toDual b +ᵥ a = b +ᵥ a

full_name: pow_toDual
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) toDual_smul']
theorem pow_toDual [Pow α β] (a : α) (b : β) : a ^ toDual b = a ^ b 
goal: a ^ OrderDual.toDual b = a ^ b

full_name: ofDual_smul'
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) ofDual_smul']
theorem pow_ofDual [Pow α β] (a : α) (b : βᵒᵈ) : a ^ ofDual b = a ^ b 
goal: OrderDual.ofDual b • a = b • a

full_name: pow_ofDual
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) ofDual_smul']
theorem pow_ofDual [Pow α β] (a : α) (b : βᵒᵈ) : a ^ ofDual b = a ^ b 
goal: a ^ OrderDual.ofDual b = a ^ b

full_name: ofDual_vadd'
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) ofDual_smul']
theorem pow_ofDual [Pow α β] (a : α) (b : βᵒᵈ) : a ^ ofDual b = a ^ b 
goal: OrderDual.ofDual b +ᵥ a = b +ᵥ a

full_name: instZeroLex
code: @[to_additive]
instance [h : One α] : One (Lex α) 
goal: Zero (Lex α)

full_name: instOneLex
code: @[to_additive]
instance [h : One α] : One (Lex α) 
goal: One (Lex α)

full_name: instAddLex
code: @[to_additive]
instance [h : Mul α] : Mul (Lex α) 
goal: Add (Lex α)

full_name: instMulLex
code: @[to_additive]
instance [h : Mul α] : Mul (Lex α) 
goal: Mul (Lex α)

full_name: instInvLex
code: @[to_additive]
instance [h : Inv α] : Inv (Lex α) 
goal: Inv (Lex α)

full_name: instNegLex
code: @[to_additive]
instance [h : Inv α] : Inv (Lex α) 
goal: Neg (Lex α)

full_name: instDivLex
code: @[to_additive]
instance [h : Div α] : Div (Lex α) 
goal: Div (Lex α)

full_name: instSubLex
code: @[to_additive]
instance [h : Div α] : Div (Lex α) 
goal: Sub (Lex α)

full_name: Lex.instVAdd
code: @[to_additive (attr := to_additive) (reorder := 1 2) Lex.instSMul]
instance Lex.instPow [h : Pow α β] : Pow (Lex α) β 
goal: VAdd β (Lex α)

full_name: Lex.instPow
code: @[to_additive (attr := to_additive) (reorder := 1 2) Lex.instSMul]
instance Lex.instPow [h : Pow α β] : Pow (Lex α) β 
goal: Pow (Lex α) β

full_name: Lex.instSMul
code: @[to_additive (attr := to_additive) (reorder := 1 2) Lex.instSMul]
instance Lex.instPow [h : Pow α β] : Pow (Lex α) β 
goal: SMul β (Lex α)

full_name: Lex.instSMul'
code: @[to_additive (attr := to_additive) (reorder := 1 2) Lex.instSMul']
instance Lex.instPow' [h : Pow α β] : Pow α (Lex β) 
goal: SMul (Lex β) α

full_name: Lex.instVAdd'
code: @[to_additive (attr := to_additive) (reorder := 1 2) Lex.instSMul']
instance Lex.instPow' [h : Pow α β] : Pow α (Lex β) 
goal: VAdd (Lex β) α

full_name: Lex.instPow'
code: @[to_additive (attr := to_additive) (reorder := 1 2) Lex.instSMul']
instance Lex.instPow' [h : Pow α β] : Pow α (Lex β) 
goal: Pow α (Lex β)

full_name: instAddSemigroupLex
code: @[to_additive]
instance [h : Semigroup α] : Semigroup (Lex α) 
goal: AddSemigroup (Lex α)

full_name: instSemigroupLex
code: @[to_additive]
instance [h : Semigroup α] : Semigroup (Lex α) 
goal: Semigroup (Lex α)

full_name: instCommSemigroupLex
code: @[to_additive]
instance [h : CommSemigroup α] : CommSemigroup (Lex α) 
goal: CommSemigroup (Lex α)

full_name: instAddCommSemigroupLex
code: @[to_additive]
instance [h : CommSemigroup α] : CommSemigroup (Lex α) 
goal: AddCommSemigroup (Lex α)

full_name: instAddLeftCancelSemigroupLex
code: @[to_additive]
instance [h : LeftCancelSemigroup α] : LeftCancelSemigroup (Lex α) 
goal: AddLeftCancelSemigroup (Lex α)

full_name: instLeftCancelSemigroupLex
code: @[to_additive]
instance [h : LeftCancelSemigroup α] : LeftCancelSemigroup (Lex α) 
goal: LeftCancelSemigroup (Lex α)

full_name: instAddRightCancelSemigroupLex
code: @[to_additive]
instance [h : RightCancelSemigroup α] : RightCancelSemigroup (Lex α) 
goal: AddRightCancelSemigroup (Lex α)

full_name: instRightCancelSemigroupLex
code: @[to_additive]
instance [h : RightCancelSemigroup α] : RightCancelSemigroup (Lex α) 
goal: RightCancelSemigroup (Lex α)

full_name: instAddZeroClassLex
code: @[to_additive]
instance [h : MulOneClass α] : MulOneClass (Lex α) 
goal: AddZeroClass (Lex α)

full_name: instMulOneClassLex
code: @[to_additive]
instance [h : MulOneClass α] : MulOneClass (Lex α) 
goal: MulOneClass (Lex α)

full_name: instMonoidLex
code: @[to_additive]
instance [h : Monoid α] : Monoid (Lex α) 
goal: Monoid (Lex α)

full_name: instAddMonoidLex
code: @[to_additive]
instance [h : Monoid α] : Monoid (Lex α) 
goal: AddMonoid (Lex α)

full_name: instCommMonoidLex
code: @[to_additive]
instance [h : CommMonoid α] : CommMonoid (Lex α) 
goal: CommMonoid (Lex α)

full_name: instAddCommMonoidLex
code: @[to_additive]
instance [h : CommMonoid α] : CommMonoid (Lex α) 
goal: AddCommMonoid (Lex α)

full_name: instLeftCancelMonoidLex
code: @[to_additive]
instance [h : LeftCancelMonoid α] : LeftCancelMonoid (Lex α) 
goal: LeftCancelMonoid (Lex α)

full_name: instAddLeftCancelMonoidLex
code: @[to_additive]
instance [h : LeftCancelMonoid α] : LeftCancelMonoid (Lex α) 
goal: AddLeftCancelMonoid (Lex α)

full_name: instRightCancelMonoidLex
code: @[to_additive]
instance [h : RightCancelMonoid α] : RightCancelMonoid (Lex α) 
goal: RightCancelMonoid (Lex α)

full_name: instAddRightCancelMonoidLex
code: @[to_additive]
instance [h : RightCancelMonoid α] : RightCancelMonoid (Lex α) 
goal: AddRightCancelMonoid (Lex α)

full_name: instCancelMonoidLex
code: @[to_additive]
instance [h : CancelMonoid α] : CancelMonoid (Lex α) 
goal: CancelMonoid (Lex α)

full_name: instAddCancelMonoidLex
code: @[to_additive]
instance [h : CancelMonoid α] : CancelMonoid (Lex α) 
goal: AddCancelMonoid (Lex α)

full_name: instCancelCommMonoidLex
code: @[to_additive]
instance [h : CancelCommMonoid α] : CancelCommMonoid (Lex α) 
goal: CancelCommMonoid (Lex α)

full_name: instAddCancelCommMonoidLex
code: @[to_additive]
instance [h : CancelCommMonoid α] : CancelCommMonoid (Lex α) 
goal: AddCancelCommMonoid (Lex α)

full_name: instInvolutiveNegLex
code: @[to_additive]
instance [h : InvolutiveInv α] : InvolutiveInv (Lex α) 
goal: InvolutiveNeg (Lex α)

full_name: instInvolutiveInvLex
code: @[to_additive]
instance [h : InvolutiveInv α] : InvolutiveInv (Lex α) 
goal: InvolutiveInv (Lex α)

full_name: instDivInvMonoidLex
code: @[to_additive]
instance [h : DivInvMonoid α] : DivInvMonoid (Lex α) 
goal: DivInvMonoid (Lex α)

full_name: instSubNegAddMonoidLex
code: @[to_additive]
instance [h : DivInvMonoid α] : DivInvMonoid (Lex α) 
goal: SubNegMonoid (Lex α)

full_name: instDivisionMonoidLex
code: @[to_additive existing OrderDual.subtractionMonoid]
instance [h : DivisionMonoid α] : DivisionMonoid (Lex α) 
goal: DivisionMonoid (Lex α)

full_name: instDivisionCommMonoidLex
code: @[to_additive existing OrderDual.subtractionCommMonoid]
instance [h : DivisionCommMonoid α] : DivisionCommMonoid (Lex α) 
goal: DivisionCommMonoid (Lex α)

full_name: instGroupLex
code: @[to_additive]
instance [h : Group α] : Group (Lex α) 
goal: Group (Lex α)

full_name: instAddGroupLex
code: @[to_additive]
instance [h : Group α] : Group (Lex α) 
goal: AddGroup (Lex α)

full_name: instCommGroupLex
code: @[to_additive]
instance [h : CommGroup α] : CommGroup (Lex α) 
goal: CommGroup (Lex α)

full_name: instAddCommGroupLex
code: @[to_additive]
instance [h : CommGroup α] : CommGroup (Lex α) 
goal: AddCommGroup (Lex α)

full_name: toLex_one
code: @[to_additive (attr := simp)]
theorem toLex_one [One α] : toLex (1 : α) = 1 
goal: toLex 1 = 1

full_name: toLex_zero
code: @[to_additive (attr := simp)]
theorem toLex_one [One α] : toLex (1 : α) = 1 
goal: toLex 0 = 0

full_name: ofLex_one
code: @[to_additive (attr := simp)]
theorem ofLex_one [One α] : (ofLex 1 : α) = 1 
goal: ofLex 1 = 1

full_name: ofLex_zero
code: @[to_additive (attr := simp)]
theorem ofLex_one [One α] : (ofLex 1 : α) = 1 
goal: ofLex 0 = 0

full_name: toLex_add
code: @[to_additive (attr := simp)]
theorem toLex_mul [Mul α] (a b : α) : toLex (a * b) = toLex a * toLex b 
goal: toLex (a + b) = toLex a + toLex b

full_name: toLex_mul
code: @[to_additive (attr := simp)]
theorem toLex_mul [Mul α] (a b : α) : toLex (a * b) = toLex a * toLex b 
goal: toLex (a * b) = toLex a * toLex b

full_name: ofLex_mul
code: @[to_additive (attr := simp)]
theorem ofLex_mul [Mul α] (a b : Lex α) : ofLex (a * b) = ofLex a * ofLex b 
goal: ofLex (a * b) = ofLex a * ofLex b

full_name: ofLex_add
code: @[to_additive (attr := simp)]
theorem ofLex_mul [Mul α] (a b : Lex α) : ofLex (a * b) = ofLex a * ofLex b 
goal: ofLex (a + b) = ofLex a + ofLex b

full_name: toLex_inv
code: @[to_additive (attr := simp)]
theorem toLex_inv [Inv α] (a : α) : toLex a⁻¹ = (toLex a)⁻¹ 
goal: toLex a⁻¹ = (toLex a)⁻¹

full_name: toLex_neg
code: @[to_additive (attr := simp)]
theorem toLex_inv [Inv α] (a : α) : toLex a⁻¹ = (toLex a)⁻¹ 
goal: toLex (-a) = -toLex a

full_name: ofLex_neg
code: @[to_additive (attr := simp)]
theorem ofLex_inv [Inv α] (a : Lex α) : ofLex a⁻¹ = (ofLex a)⁻¹ 
goal: ofLex (-a) = -ofLex a

full_name: ofLex_inv
code: @[to_additive (attr := simp)]
theorem ofLex_inv [Inv α] (a : Lex α) : ofLex a⁻¹ = (ofLex a)⁻¹ 
goal: ofLex a⁻¹ = (ofLex a)⁻¹

full_name: toLex_div
code: @[to_additive (attr := simp)]
theorem toLex_div [Div α] (a b : α) : toLex (a / b) = toLex a / toLex b 
goal: toLex (a / b) = toLex a / toLex b

full_name: toLex_sub
code: @[to_additive (attr := simp)]
theorem toLex_div [Div α] (a b : α) : toLex (a / b) = toLex a / toLex b 
goal: toLex (a - b) = toLex a - toLex b

full_name: ofLex_sub
code: @[to_additive (attr := simp)]
theorem ofLex_div [Div α] (a b : Lex α) : ofLex (a / b) = ofLex a / ofLex b 
goal: ofLex (a - b) = ofLex a - ofLex b

full_name: ofLex_div
code: @[to_additive (attr := simp)]
theorem ofLex_div [Div α] (a b : Lex α) : ofLex (a / b) = ofLex a / ofLex b 
goal: ofLex (a / b) = ofLex a / ofLex b

full_name: toLex_pow
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) toLex_smul]
theorem toLex_pow [Pow α β] (a : α) (b : β) : toLex (a ^ b) = toLex a ^ b 
goal: toLex (a ^ b) = toLex a ^ b

full_name: toLex_smul
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) toLex_smul]
theorem toLex_pow [Pow α β] (a : α) (b : β) : toLex (a ^ b) = toLex a ^ b 
goal: toLex (b • a) = b • toLex a

full_name: toLex_vadd
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) toLex_smul]
theorem toLex_pow [Pow α β] (a : α) (b : β) : toLex (a ^ b) = toLex a ^ b 
goal: toLex (b +ᵥ a) = b +ᵥ toLex a

full_name: ofLex_pow
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) ofLex_smul]
theorem ofLex_pow [Pow α β] (a : Lex α) (b : β) : ofLex (a ^ b) = ofLex a ^ b 
goal: ofLex (a ^ b) = ofLex a ^ b

full_name: ofLex_smul
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) ofLex_smul]
theorem ofLex_pow [Pow α β] (a : Lex α) (b : β) : ofLex (a ^ b) = ofLex a ^ b 
goal: ofLex (b • a) = b • ofLex a

full_name: ofLex_vadd
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) ofLex_smul]
theorem ofLex_pow [Pow α β] (a : Lex α) (b : β) : ofLex (a ^ b) = ofLex a ^ b 
goal: ofLex (b +ᵥ a) = b +ᵥ ofLex a

full_name: toLex_smul'
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) toLex_smul']
theorem pow_toLex [Pow α β] (a : α) (b : β) : a ^ toLex b = a ^ b 
goal: toLex b • a = b • a

full_name: pow_toLex
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) toLex_smul']
theorem pow_toLex [Pow α β] (a : α) (b : β) : a ^ toLex b = a ^ b 
goal: a ^ toLex b = a ^ b

full_name: toLex_vadd'
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) toLex_smul']
theorem pow_toLex [Pow α β] (a : α) (b : β) : a ^ toLex b = a ^ b 
goal: toLex b +ᵥ a = b +ᵥ a

full_name: ofLex_vadd'
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) ofLex_smul']
theorem pow_ofLex [Pow α β] (a : α) (b : Lex β) : a ^ ofLex b = a ^ b 
goal: ofLex b +ᵥ a = b +ᵥ a

full_name: ofLex_smul'
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) ofLex_smul']
theorem pow_ofLex [Pow α β] (a : α) (b : Lex β) : a ^ ofLex b = a ^ b 
goal: ofLex b • a = b • a

full_name: pow_ofLex
code: @[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) ofLex_smul']
theorem pow_ofLex [Pow α β] (a : α) (b : Lex β) : a ^ ofLex b = a ^ b 
goal: a ^ ofLex b = a ^ b