ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Nat.even_mul_succ_self
lemma even_mul_succ_self (n : ℕ) : Even (n * (n + 1)) 
Arguments: (n : ℕ)
Goal: Even (n * (n + 1))
-- Nat.even_mul_pred_self
lemma even_mul_pred_self : ∀ n : ℕ, Even (n * (n - 1))
  
Arguments: (n : ℕ)
Goal: Even (n * (n - 1))
-- Nat.two_mul_div_two_of_even
lemma two_mul_div_two_of_even : Even n → 2 * (n / 2) = n 
Arguments: {n : ℕ}
Goal: Even n → 2 * (n / 2) = n
-- Nat.div_two_mul_two_of_even
lemma div_two_mul_two_of_even : Even n → n / 2 * 2 = n 
Arguments: {n : ℕ}
Goal: Even n → n / 2 * 2 = n
-- Nat.units_eq_one
lemma units_eq_one (u : ℕˣ) : u = 1 
Arguments: (u : ℕˣ)
Goal: u = 1
-- Nat.addUnits_eq_zero
lemma addUnits_eq_zero (u : AddUnits ℕ) : u = 0 
Arguments: (u : AddUnits ℕ)
Goal: u = 0
-- Nat.isUnit_iff
@[simp] protected lemma isUnit_iff {n : ℕ} : IsUnit n ↔ n = 1 
Arguments: {n : ℕ}
Goal: IsUnit n ↔ n = 1
-- VAdd.vadd_eq_hVAdd
@[to_additive]
theorem SMul.smul_eq_hSMul {α β} [SMul α β] : (SMul.smul : α → β → β) = HSMul.hSMul 
Arguments: {α : Type u_1} {β : Type u_2} [VAdd α β]
Goal: VAdd.vadd = HVAdd.hVAdd
-- SMul.smul_eq_hSMul
@[to_additive]
theorem SMul.smul_eq_hSMul {α β} [SMul α β] : (SMul.smul : α → β → β) = HSMul.hSMul 
Arguments: {α : Type u_1} {β : Type u_2} [SMul α β]
Goal: SMul.smul = HSMul.hSMul
-- IsLeftCancelMul.mul_left_cancel
class IsLeftCancelMul (G : Type u) [Mul G] : Prop where
    protected mul_left_cancel : ∀ a b c : G, a * b = a * c → b = c
Arguments: {G : Type u} [Mul G] [self : IsLeftCancelMul G] (a b c : G)
Goal: a * b = a * c → b = c
-- IsRightCancelMul.mul_right_cancel
class IsRightCancelMul (G : Type u) [Mul G] : Prop where
    protected mul_right_cancel : ∀ a b c : G, a * b = c * b → a = c
Arguments: {G : Type u} [Mul G] [self : IsRightCancelMul G] (a b c : G)
Goal: a * b = c * b → a = c
-- IsLeftCancelAdd.add_left_cancel
class IsLeftCancelAdd (G : Type u) [Add G] : Prop where
    protected add_left_cancel : ∀ a b c : G, a + b = a + c → b = c
Arguments: {G : Type u} [Add G] [self : IsLeftCancelAdd G] (a b c : G)
Goal: a + b = a + c → b = c
-- IsRightCancelAdd.add_right_cancel
class IsRightCancelAdd (G : Type u) [Add G] : Prop where
    protected add_right_cancel : ∀ a b c : G, a + b = c + b → a = c
Arguments: {G : Type u} [Add G] [self : IsRightCancelAdd G] (a b c : G)
Goal: a + b = c + b → a = c
-- add_left_cancel
@[to_additive]
theorem mul_left_cancel : a * b = a * c → b = c 
Arguments: {G : Type u_1} [Add G] [IsLeftCancelAdd G] {a b c : G}
Goal: a + b = a + c → b = c
-- mul_left_cancel
@[to_additive]
theorem mul_left_cancel : a * b = a * c → b = c 
Arguments: {G : Type u_1} [Mul G] [IsLeftCancelMul G] {a b c : G}
Goal: a * b = a * c → b = c
-- mul_left_cancel_iff
@[to_additive]
theorem mul_left_cancel_iff : a * b = a * c ↔ b = c 
Arguments: {G : Type u_1} [Mul G] [IsLeftCancelMul G] {a b c : G}
Goal: a * b = a * c ↔ b = c
-- add_left_cancel_iff
@[to_additive]
theorem mul_left_cancel_iff : a * b = a * c ↔ b = c 
Arguments: {G : Type u_1} [Add G] [IsLeftCancelAdd G] {a b c : G}
Goal: a + b = a + c ↔ b = c
-- add_right_cancel
@[to_additive]
theorem mul_right_cancel : a * b = c * b → a = c 
Arguments: {G : Type u_1} [Add G] [IsRightCancelAdd G] {a b c : G}
Goal: a + b = c + b → a = c
-- mul_right_cancel
@[to_additive]
theorem mul_right_cancel : a * b = c * b → a = c 
Arguments: {G : Type u_1} [Mul G] [IsRightCancelMul G] {a b c : G}
Goal: a * b = c * b → a = c
-- add_right_cancel_iff
@[to_additive]
theorem mul_right_cancel_iff : b * a = c * a ↔ b = c 
Arguments: {G : Type u_1} [Add G] [IsRightCancelAdd G] {a b c : G}
Goal: b + a = c + a ↔ b = c
-- mul_right_cancel_iff
@[to_additive]
theorem mul_right_cancel_iff : b * a = c * a ↔ b = c 
Arguments: {G : Type u_1} [Mul G] [IsRightCancelMul G] {a b c : G}
Goal: b * a = c * a ↔ b = c
-- Semigroup.mul_assoc
@[ext]
class Semigroup (G : Type u) extends Mul G where
    protected mul_assoc : ∀ a b c : G, a * b * c = a * (b * c)
Arguments: {G : Type u} [self : Semigroup G] (a b c : G)
Goal: a * b * c = a * (b * c)
-- AddSemigroup.add_assoc
@[ext]
class AddSemigroup (G : Type u) extends Add G where
    protected add_assoc : ∀ a b c : G, a + b + c = a + (b + c)
Arguments: {G : Type u} [self : AddSemigroup G] (a b c : G)
Goal: a + b + c = a + (b + c)
-- mul_assoc
@[to_additive]
theorem mul_assoc : ∀ a b c : G, a * b * c = a * (b * c) 
Arguments: {G : Type u_1} [Semigroup G] (a b c : G)
Goal: a * b * c = a * (b * c)
-- add_assoc
@[to_additive]
theorem mul_assoc : ∀ a b c : G, a * b * c = a * (b * c) 
Arguments: {G : Type u_1} [AddSemigroup G] (a b c : G)
Goal: a + b + c = a + (b + c)
-- AddCommMagma.add_comm
@[ext]
class AddCommMagma (G : Type u) extends Add G where
    protected add_comm : ∀ a b : G, a + b = b + a
Arguments: {G : Type u} [self : AddCommMagma G] (a b : G)
Goal: a + b = b + a
-- CommMagma.mul_comm
@[ext]
class CommMagma (G : Type u) extends Mul G where
    protected mul_comm : ∀ a b : G, a * b = b * a
Arguments: {G : Type u} [self : CommMagma G] (a b : G)
Goal: a * b = b * a
-- mul_comm
@[to_additive]
theorem mul_comm : ∀ a b : G, a * b = b * a 
Arguments: {G : Type u_1} [CommMagma G] (a b : G)
Goal: a * b = b * a
-- add_comm
@[to_additive]
theorem mul_comm : ∀ a b : G, a * b = b * a 
Arguments: {G : Type u_1} [AddCommMagma G] (a b : G)
Goal: a + b = b + a
-- AddCommMagma.IsRightCancelAdd.toIsLeftCancelAdd
@[to_additive AddCommMagma.IsRightCancelAdd.toIsLeftCancelAdd "Any `AddCommMagma G` that satisfies
`IsRightCancelAdd G` also satisfies `IsLeftCancelAdd G`."]
lemma CommMagma.IsRightCancelMul.toIsLeftCancelMul (G : Type u) [CommMagma G] [IsRightCancelMul G] :
    IsLeftCancelMul G 
Arguments: (G : Type u) [AddCommMagma G] [IsRightCancelAdd G]
Goal: IsLeftCancelAdd G
-- CommMagma.IsRightCancelMul.toIsLeftCancelMul
@[to_additive AddCommMagma.IsRightCancelAdd.toIsLeftCancelAdd "Any `AddCommMagma G` that satisfies
`IsRightCancelAdd G` also satisfies `IsLeftCancelAdd G`."]
lemma CommMagma.IsRightCancelMul.toIsLeftCancelMul (G : Type u) [CommMagma G] [IsRightCancelMul G] :
    IsLeftCancelMul G 
Arguments: (G : Type u) [CommMagma G] [IsRightCancelMul G]
Goal: IsLeftCancelMul G
-- CommMagma.IsLeftCancelMul.toIsRightCancelMul
@[to_additive AddCommMagma.IsLeftCancelAdd.toIsRightCancelAdd "Any `AddCommMagma G` that satisfies
`IsLeftCancelAdd G` also satisfies `IsRightCancelAdd G`."]
lemma CommMagma.IsLeftCancelMul.toIsRightCancelMul (G : Type u) [CommMagma G] [IsLeftCancelMul G] :
    IsRightCancelMul G 
Arguments: (G : Type u) [CommMagma G] [IsLeftCancelMul G]
Goal: IsRightCancelMul G
-- AddCommMagma.IsLeftCancelAdd.toIsRightCancelAdd
@[to_additive AddCommMagma.IsLeftCancelAdd.toIsRightCancelAdd "Any `AddCommMagma G` that satisfies
`IsLeftCancelAdd G` also satisfies `IsRightCancelAdd G`."]
lemma CommMagma.IsLeftCancelMul.toIsRightCancelMul (G : Type u) [CommMagma G] [IsLeftCancelMul G] :
    IsRightCancelMul G 
Arguments: (G : Type u) [AddCommMagma G] [IsLeftCancelAdd G]
Goal: IsRightCancelAdd G
-- CommMagma.IsLeftCancelMul.toIsCancelMul
@[to_additive AddCommMagma.IsLeftCancelAdd.toIsCancelAdd "Any `AddCommMagma G` that satisfies
`IsLeftCancelAdd G` also satisfies `IsCancelAdd G`."]
lemma CommMagma.IsLeftCancelMul.toIsCancelMul (G : Type u) [CommMagma G] [IsLeftCancelMul G] :
    IsCancelMul G 
Arguments: (G : Type u) [CommMagma G] [IsLeftCancelMul G]
Goal: IsCancelMul G
-- AddCommMagma.IsLeftCancelAdd.toIsCancelAdd
@[to_additive AddCommMagma.IsLeftCancelAdd.toIsCancelAdd "Any `AddCommMagma G` that satisfies
`IsLeftCancelAdd G` also satisfies `IsCancelAdd G`."]
lemma CommMagma.IsLeftCancelMul.toIsCancelMul (G : Type u) [CommMagma G] [IsLeftCancelMul G] :
    IsCancelMul G 
Arguments: (G : Type u) [AddCommMagma G] [IsLeftCancelAdd G]
Goal: IsCancelAdd G
-- CommMagma.IsRightCancelMul.toIsCancelMul
@[to_additive AddCommMagma.IsRightCancelAdd.toIsCancelAdd "Any `AddCommMagma G` that satisfies
`IsRightCancelAdd G` also satisfies `IsCancelAdd G`."]
lemma CommMagma.IsRightCancelMul.toIsCancelMul (G : Type u) [CommMagma G] [IsRightCancelMul G] :
    IsCancelMul G 
Arguments: (G : Type u) [CommMagma G] [IsRightCancelMul G]
Goal: IsCancelMul G
-- AddCommMagma.IsRightCancelAdd.toIsCancelAdd
@[to_additive AddCommMagma.IsRightCancelAdd.toIsCancelAdd "Any `AddCommMagma G` that satisfies
`IsRightCancelAdd G` also satisfies `IsCancelAdd G`."]
lemma CommMagma.IsRightCancelMul.toIsCancelMul (G : Type u) [CommMagma G] [IsRightCancelMul G] :
    IsCancelMul G 
Arguments: (G : Type u) [AddCommMagma G] [IsRightCancelAdd G]
Goal: IsCancelAdd G
-- LeftCancelSemigroup.mul_left_cancel
@[ext]
class LeftCancelSemigroup (G : Type u) extends Semigroup G where
  protected mul_left_cancel : ∀ a b c : G, a * b = a * c → b = c
Arguments: {G : Type u} [self : LeftCancelSemigroup G] (a b c : G)
Goal: a * b = a * c → b = c
-- AddLeftCancelSemigroup.add_left_cancel
@[ext]
class AddLeftCancelSemigroup (G : Type u) extends AddSemigroup G where
  protected add_left_cancel : ∀ a b c : G, a + b = a + c → b = c
Arguments: {G : Type u} [self : AddLeftCancelSemigroup G] (a b c : G)
Goal: a + b = a + c → b = c
-- RightCancelSemigroup.mul_right_cancel
@[ext]
class RightCancelSemigroup (G : Type u) extends Semigroup G where
  protected mul_right_cancel : ∀ a b c : G, a * b = c * b → a = c
Arguments: {G : Type u} [self : RightCancelSemigroup G] (a b c : G)
Goal: a * b = c * b → a = c
-- AddRightCancelSemigroup.add_right_cancel
@[ext]
class AddRightCancelSemigroup (G : Type u) extends AddSemigroup G where
  protected add_right_cancel : ∀ a b c : G, a + b = c + b → a = c
Arguments: {G : Type u} [self : AddRightCancelSemigroup G] (a b c : G)
Goal: a + b = c + b → a = c
-- MulOneClass.one_mul
class MulOneClass (M : Type u) extends One M, Mul M where
    protected one_mul : ∀ a : M, 1 * a = a
    protected mul_one : ∀ a : M, a * 1 = a
Arguments: {M : Type u} [self : MulOneClass M] (a : M)
Goal: 1 * a = a
-- MulOneClass.mul_one
class MulOneClass (M : Type u) extends One M, Mul M where
    protected one_mul : ∀ a : M, 1 * a = a
    protected mul_one : ∀ a : M, a * 1 = a
Arguments: {M : Type u} [self : MulOneClass M] (a : M)
Goal: a * 1 = a
-- AddZeroClass.add_zero
class AddZeroClass (M : Type u) extends Zero M, Add M where
    protected zero_add : ∀ a : M, 0 + a = a
    protected add_zero : ∀ a : M, a + 0 = a
Arguments: {M : Type u} [self : AddZeroClass M] (a : M)
Goal: a + 0 = a
-- AddZeroClass.zero_add
class AddZeroClass (M : Type u) extends Zero M, Add M where
    protected zero_add : ∀ a : M, 0 + a = a
    protected add_zero : ∀ a : M, a + 0 = a
Arguments: {M : Type u} [self : AddZeroClass M] (a : M)
Goal: 0 + a = a
-- AddZeroClass.ext
@[to_additive (attr := ext)]
theorem MulOneClass.ext {M : Type u} : ∀ ⦃m₁ m₂ : MulOneClass M⦄, m₁.mul = m₂.mul → m₁ = m₂ 
Arguments: {M : Type u} ⦃m₁ m₂ : AddZeroClass M⦄
Goal: Add.add = Add.add → m₁ = m₂
-- MulOneClass.ext
@[to_additive (attr := ext)]
theorem MulOneClass.ext {M : Type u} : ∀ ⦃m₁ m₂ : MulOneClass M⦄, m₁.mul = m₂.mul → m₁ = m₂ 
Arguments: {M : Type u} ⦃m₁ m₂ : MulOneClass M⦄
Goal: Mul.mul = Mul.mul → m₁ = m₂
-- zero_add
@[to_additive (attr := simp)]
theorem one_mul : ∀ a : M, 1 * a = a 
Arguments: {M : Type u} [AddZeroClass M] (a : M)
Goal: 0 + a = a
-- one_mul
@[to_additive (attr := simp)]
theorem one_mul : ∀ a : M, 1 * a = a 
Arguments: {M : Type u} [MulOneClass M] (a : M)
Goal: 1 * a = a
-- add_zero
@[to_additive (attr := simp)]
theorem mul_one : ∀ a : M, a * 1 = a 
Arguments: {M : Type u} [AddZeroClass M] (a : M)
Goal: a + 0 = a
-- mul_one
@[to_additive (attr := simp)]
theorem mul_one : ∀ a : M, a * 1 = a 
Arguments: {M : Type u} [MulOneClass M] (a : M)
Goal: a * 1 = a
-- AddMonoid.nsmul_zero
class AddMonoid (M : Type u) extends AddSemigroup M, AddZeroClass M where
    protected nsmul : ℕ → M → M
    protected nsmul_zero : ∀ x, nsmul 0 x = 0 := by intros; rfl
    protected nsmul_succ : ∀ (n : ℕ) (x), nsmul (n + 1) x = nsmul n x + x := by intros; rfl
Arguments: {M : Type u} [self : AddMonoid M] (x : M)
Goal: AddMonoid.nsmul 0 x = 0
-- AddMonoid.nsmul_succ
class AddMonoid (M : Type u) extends AddSemigroup M, AddZeroClass M where
    protected nsmul : ℕ → M → M
    protected nsmul_zero : ∀ x, nsmul 0 x = 0 := by intros; rfl
    protected nsmul_succ : ∀ (n : ℕ) (x), nsmul (n + 1) x = nsmul n x + x := by intros; rfl
Arguments: {M : Type u} [self : AddMonoid M] (n : ℕ) (x : M)
Goal: AddMonoid.nsmul (n + 1) x = AddMonoid.nsmul n x + x
-- Monoid.npow_zero
@[to_additive]
class Monoid (M : Type u) extends Semigroup M, MulOneClass M where
    protected npow : ℕ → M → M := npowRec
    protected npow_zero : ∀ x, npow 0 x = 1 := by intros; rfl
    protected npow_succ : ∀ (n : ℕ) (x), npow (n + 1) x = npow n x * x := by intros; rfl
Arguments: {M : Type u} [self : Monoid M] (x : M)
Goal: Monoid.npow 0 x = 1
-- Monoid.npow_succ
@[to_additive]
class Monoid (M : Type u) extends Semigroup M, MulOneClass M where
    protected npow : ℕ → M → M := npowRec
    protected npow_zero : ∀ x, npow 0 x = 1 := by intros; rfl
    protected npow_succ : ∀ (n : ℕ) (x), npow (n + 1) x = npow n x * x := by intros; rfl
Arguments: {M : Type u} [self : Monoid M] (n : ℕ) (x : M)
Goal: Monoid.npow (n + 1) x = Monoid.npow n x * x
-- nsmul_eq_smul
@[to_additive (attr := simp) nsmul_eq_smul]
theorem npow_eq_pow (n : ℕ) (x : M) : Monoid.npow n x = x ^ n 
Arguments: {M : Type u_2} [AddMonoid M] (n : ℕ) (x : M)
Goal: AddMonoid.nsmul n x = n • x
-- npow_eq_pow
@[to_additive (attr := simp) nsmul_eq_smul]
theorem npow_eq_pow (n : ℕ) (x : M) : Monoid.npow n x = x ^ n 
Arguments: {M : Type u_2} [Monoid M] (n : ℕ) (x : M)
Goal: Monoid.npow n x = x ^ n
-- left_neg_eq_right_neg
@[to_additive] lemma left_inv_eq_right_inv (hba : b * a = 1) (hac : a * c = 1) : b = c 
Arguments: {M : Type u_2} [AddMonoid M] {a b c : M} (hba : b + a = 0) (hac : a + c = 0)
Goal: b = c
-- left_inv_eq_right_inv
@[to_additive] lemma left_inv_eq_right_inv (hba : b * a = 1) (hac : a * c = 1) : b = c 
Arguments: {M : Type u_2} [Monoid M] {a b c : M} (hba : b * a = 1) (hac : a * c = 1)
Goal: b = c
-- pow_zero
@[to_additive zero_nsmul, simp]
theorem pow_zero (a : M) : a ^ 0 = 1 
Arguments: {M : Type u_2} [Monoid M] (a : M)
Goal: a ^ 0 = 1
-- zero_nsmul
@[to_additive zero_nsmul, simp]
theorem pow_zero (a : M) : a ^ 0 = 1 
Arguments: {M : Type u_2} [AddMonoid M] (a : M)
Goal: 0 • a = 0
-- succ_nsmul
@[to_additive succ_nsmul]
theorem pow_succ (a : M) (n : ℕ) : a ^ (n + 1) = a ^ n * a 
Arguments: {M : Type u_2} [AddMonoid M] (a : M) (n : ℕ)
Goal: (n + 1) • a = n • a + a
-- pow_succ
@[to_additive succ_nsmul]
theorem pow_succ (a : M) (n : ℕ) : a ^ (n + 1) = a ^ n * a 
Arguments: {M : Type u_2} [Monoid M] (a : M) (n : ℕ)
Goal: a ^ (n + 1) = a ^ n * a
-- pow_one
@[to_additive (attr := simp) one_nsmul]
lemma pow_one (a : M) : a ^ 1 = a 
Arguments: {M : Type u_2} [Monoid M] (a : M)
Goal: a ^ 1 = a
-- one_nsmul
@[to_additive (attr := simp) one_nsmul]
lemma pow_one (a : M) : a ^ 1 = a 
Arguments: {M : Type u_2} [AddMonoid M] (a : M)
Goal: 1 • a = a
-- pow_succ'
@[to_additive succ_nsmul'] lemma pow_succ' (a : M) : ∀ n, a ^ (n + 1) = a * a ^ n
  
Arguments: {M : Type u_2} [Monoid M] (a : M) (n : ℕ)
Goal: a ^ (n + 1) = a * a ^ n
-- succ_nsmul'
@[to_additive succ_nsmul'] lemma pow_succ' (a : M) : ∀ n, a ^ (n + 1) = a * a ^ n
  
Arguments: {M : Type u_2} [AddMonoid M] (a : M) (n : ℕ)
Goal: (n + 1) • a = a + n • a
-- nsmul_add_comm'
@[to_additive]
lemma pow_mul_comm' (a : M) (n : ℕ) : a ^ n * a = a * a ^ n 
Arguments: {M : Type u_2} [AddMonoid M] (a : M) (n : ℕ)
Goal: n • a + a = a + n • a
-- pow_mul_comm'
@[to_additive]
lemma pow_mul_comm' (a : M) (n : ℕ) : a ^ n * a = a * a ^ n 
Arguments: {M : Type u_2} [Monoid M] (a : M) (n : ℕ)
Goal: a ^ n * a = a * a ^ n
-- two_nsmul
@[to_additive two_nsmul] lemma pow_two (a : M) : a ^ 2 = a * a 
Arguments: {M : Type u_2} [AddMonoid M] (a : M)
Goal: 2 • a = a + a
-- pow_two
@[to_additive two_nsmul] lemma pow_two (a : M) : a ^ 2 = a * a 
Arguments: {M : Type u_2} [Monoid M] (a : M)
Goal: a ^ 2 = a * a
-- three'_nsmul
@[to_additive three'_nsmul]
lemma pow_three' (a : M) : a ^ 3 = a * a * a 
Arguments: {M : Type u_2} [AddMonoid M] (a : M)
Goal: 3 • a = a + a + a
-- pow_three'
@[to_additive three'_nsmul]
lemma pow_three' (a : M) : a ^ 3 = a * a * a 
Arguments: {M : Type u_2} [Monoid M] (a : M)
Goal: a ^ 3 = a * a * a
-- pow_three
@[to_additive three_nsmul]
lemma pow_three (a : M) : a ^ 3 = a * (a * a) 
Arguments: {M : Type u_2} [Monoid M] (a : M)
Goal: a ^ 3 = a * (a * a)
-- three_nsmul
@[to_additive three_nsmul]
lemma pow_three (a : M) : a ^ 3 = a * (a * a) 
Arguments: {M : Type u_2} [AddMonoid M] (a : M)
Goal: 3 • a = a + (a + a)
-- nsmul_zero
@[to_additive nsmul_zero, simp] lemma one_pow : ∀ n, (1 : M) ^ n = 1
  
Arguments: {M : Type u_2} [AddMonoid M] (n : ℕ)
Goal: n • 0 = 0
-- one_pow
@[to_additive nsmul_zero, simp] lemma one_pow : ∀ n, (1 : M) ^ n = 1
  
Arguments: {M : Type u_2} [Monoid M] (n : ℕ)
Goal: 1 ^ n = 1
-- add_nsmul
@[to_additive add_nsmul]
lemma pow_add (a : M) (m : ℕ) : ∀ n, a ^ (m + n) = a ^ m * a ^ n
  
Arguments: {M : Type u_2} [AddMonoid M] (a : M) (m n : ℕ)
Goal: (m + n) • a = m • a + n • a
-- pow_add
@[to_additive add_nsmul]
lemma pow_add (a : M) (m : ℕ) : ∀ n, a ^ (m + n) = a ^ m * a ^ n
  
Arguments: {M : Type u_2} [Monoid M] (a : M) (m n : ℕ)
Goal: a ^ (m + n) = a ^ m * a ^ n
-- pow_mul_comm
@[to_additive] lemma pow_mul_comm (a : M) (m n : ℕ) : a ^ m * a ^ n = a ^ n * a ^ m 
Arguments: {M : Type u_2} [Monoid M] (a : M) (m n : ℕ)
Goal: a ^ m * a ^ n = a ^ n * a ^ m
-- nsmul_add_comm
@[to_additive] lemma pow_mul_comm (a : M) (m n : ℕ) : a ^ m * a ^ n = a ^ n * a ^ m 
Arguments: {M : Type u_2} [AddMonoid M] (a : M) (m n : ℕ)
Goal: m • a + n • a = n • a + m • a
-- pow_mul
@[to_additive mul_nsmul] lemma pow_mul (a : M) (m : ℕ) : ∀ n, a ^ (m * n) = (a ^ m) ^ n
  
Arguments: {M : Type u_2} [Monoid M] (a : M) (m n : ℕ)
Goal: a ^ (m * n) = (a ^ m) ^ n
-- mul_nsmul
@[to_additive mul_nsmul] lemma pow_mul (a : M) (m : ℕ) : ∀ n, a ^ (m * n) = (a ^ m) ^ n
  
Arguments: {M : Type u_2} [AddMonoid M] (a : M) (m n : ℕ)
Goal: (m * n) • a = n • m • a
-- mul_nsmul'
@[to_additive mul_nsmul']
lemma pow_mul' (a : M) (m n : ℕ) : a ^ (m * n) = (a ^ n) ^ m 
Arguments: {M : Type u_2} [AddMonoid M] (a : M) (m n : ℕ)
Goal: (m * n) • a = m • n • a
-- pow_mul'
@[to_additive mul_nsmul']
lemma pow_mul' (a : M) (m n : ℕ) : a ^ (m * n) = (a ^ n) ^ m 
Arguments: {M : Type u_2} [Monoid M] (a : M) (m n : ℕ)
Goal: a ^ (m * n) = (a ^ n) ^ m
-- nsmul_left_comm
@[to_additive nsmul_left_comm]
lemma pow_right_comm (a : M) (m n : ℕ) : (a ^ m) ^ n = (a ^ n) ^ m 
Arguments: {M : Type u_2} [AddMonoid M] (a : M) (m n : ℕ)
Goal: n • m • a = m • n • a
-- pow_right_comm
@[to_additive nsmul_left_comm]
lemma pow_right_comm (a : M) (m n : ℕ) : (a ^ m) ^ n = (a ^ n) ^ m 
Arguments: {M : Type u_2} [Monoid M] (a : M) (m n : ℕ)
Goal: (a ^ m) ^ n = (a ^ n) ^ m
-- InvolutiveNeg.neg_neg
class InvolutiveNeg (A : Type*) extends Neg A where
  protected neg_neg : ∀ x : A, - -x = x
Arguments: {A : Type u_2} [self : InvolutiveNeg A] (x : A)
Goal: - -x = x
-- InvolutiveInv.inv_inv
@[to_additive]
class InvolutiveInv (G : Type*) extends Inv G where
  protected inv_inv : ∀ x : G, x⁻¹⁻¹ = x
Arguments: {G : Type u_2} [self : InvolutiveInv G] (x : G)
Goal: x⁻¹⁻¹ = x
-- neg_neg
@[to_additive (attr := simp)]
theorem inv_inv (a : G) : a⁻¹⁻¹ = a 
Arguments: {G : Type u_1} [InvolutiveNeg G] (a : G)
Goal: - -a = a
-- inv_inv
@[to_additive (attr := simp)]
theorem inv_inv (a : G) : a⁻¹⁻¹ = a 
Arguments: {G : Type u_1} [InvolutiveInv G] (a : G)
Goal: a⁻¹⁻¹ = a
-- DivInvMonoid.zpow_succ'
class DivInvMonoid (G : Type u) extends Monoid G, Inv G, Div G where
  protected div := DivInvMonoid.div'
    protected div_eq_mul_inv : ∀ a b : G, a / b = a * b⁻¹ := by intros; rfl
    protected zpow : ℤ → G → G := zpowRec npowRec
    protected zpow_zero' : ∀ a : G, zpow 0 a = 1 := by intros; rfl
    protected zpow_succ' (n : ℕ) (a : G) : zpow (Int.ofNat n.succ) a = zpow (Int.ofNat n) a  * a := by
    intros; rfl
    protected zpow_neg' (n : ℕ) (a : G) : zpow (Int.negSucc n) a = (zpow n.succ a)⁻¹ := by intros; rfl
Arguments: {G : Type u} [self : DivInvMonoid G] (n : ℕ) (a : G)
Goal: DivInvMonoid.zpow (Int.ofNat n.succ) a = DivInvMonoid.zpow (Int.ofNat n) a * a
-- DivInvMonoid.zpow_neg'
class DivInvMonoid (G : Type u) extends Monoid G, Inv G, Div G where
  protected div := DivInvMonoid.div'
    protected div_eq_mul_inv : ∀ a b : G, a / b = a * b⁻¹ := by intros; rfl
    protected zpow : ℤ → G → G := zpowRec npowRec
    protected zpow_zero' : ∀ a : G, zpow 0 a = 1 := by intros; rfl
    protected zpow_succ' (n : ℕ) (a : G) : zpow (Int.ofNat n.succ) a = zpow (Int.ofNat n) a  * a := by
    intros; rfl
    protected zpow_neg' (n : ℕ) (a : G) : zpow (Int.negSucc n) a = (zpow n.succ a)⁻¹ := by intros; rfl
Arguments: {G : Type u} [self : DivInvMonoid G] (n : ℕ) (a : G)
Goal: DivInvMonoid.zpow (Int.negSucc n) a = (DivInvMonoid.zpow (↑n.succ) a)⁻¹
-- DivInvMonoid.zpow_zero'
class DivInvMonoid (G : Type u) extends Monoid G, Inv G, Div G where
  protected div := DivInvMonoid.div'
    protected div_eq_mul_inv : ∀ a b : G, a / b = a * b⁻¹ := by intros; rfl
    protected zpow : ℤ → G → G := zpowRec npowRec
    protected zpow_zero' : ∀ a : G, zpow 0 a = 1 := by intros; rfl
    protected zpow_succ' (n : ℕ) (a : G) : zpow (Int.ofNat n.succ) a = zpow (Int.ofNat n) a  * a := by
    intros; rfl
    protected zpow_neg' (n : ℕ) (a : G) : zpow (Int.negSucc n) a = (zpow n.succ a)⁻¹ := by intros; rfl
Arguments: {G : Type u} [self : DivInvMonoid G] (a : G)
Goal: DivInvMonoid.zpow 0 a = 1
-- DivInvMonoid.div_eq_mul_inv
class DivInvMonoid (G : Type u) extends Monoid G, Inv G, Div G where
  protected div := DivInvMonoid.div'
    protected div_eq_mul_inv : ∀ a b : G, a / b = a * b⁻¹ := by intros; rfl
    protected zpow : ℤ → G → G := zpowRec npowRec
    protected zpow_zero' : ∀ a : G, zpow 0 a = 1 := by intros; rfl
    protected zpow_succ' (n : ℕ) (a : G) : zpow (Int.ofNat n.succ) a = zpow (Int.ofNat n) a  * a := by
    intros; rfl
    protected zpow_neg' (n : ℕ) (a : G) : zpow (Int.negSucc n) a = (zpow n.succ a)⁻¹ := by intros; rfl
Arguments: {G : Type u} [self : DivInvMonoid G] (a b : G)
Goal: a / b = a * b⁻¹
-- SubNegMonoid.zsmul_zero'
class SubNegMonoid (G : Type u) extends AddMonoid G, Neg G, Sub G where
  protected sub := SubNegMonoid.sub'
  protected sub_eq_add_neg : ∀ a b : G, a - b = a + -b := by intros; rfl
    protected zsmul : ℤ → G → G
  protected zsmul_zero' : ∀ a : G, zsmul 0 a = 0 := by intros; rfl
  protected zsmul_succ' (n : ℕ) (a : G) :
      zsmul (Int.ofNat n.succ) a = zsmul (Int.ofNat n) a + a := by
    intros; rfl
  protected zsmul_neg' (n : ℕ) (a : G) : zsmul (Int.negSucc n) a = -zsmul n.succ a := by
    intros; rfl
Arguments: {G : Type u} [self : SubNegMonoid G] (a : G)
Goal: SubNegMonoid.zsmul 0 a = 0
-- SubNegMonoid.zsmul_neg'
class SubNegMonoid (G : Type u) extends AddMonoid G, Neg G, Sub G where
  protected sub := SubNegMonoid.sub'
  protected sub_eq_add_neg : ∀ a b : G, a - b = a + -b := by intros; rfl
    protected zsmul : ℤ → G → G
  protected zsmul_zero' : ∀ a : G, zsmul 0 a = 0 := by intros; rfl
  protected zsmul_succ' (n : ℕ) (a : G) :
      zsmul (Int.ofNat n.succ) a = zsmul (Int.ofNat n) a + a := by
    intros; rfl
  protected zsmul_neg' (n : ℕ) (a : G) : zsmul (Int.negSucc n) a = -zsmul n.succ a := by
    intros; rfl
Arguments: {G : Type u} [self : SubNegMonoid G] (n : ℕ) (a : G)
Goal: SubNegMonoid.zsmul (Int.negSucc n) a = -SubNegMonoid.zsmul (↑n.succ) a
-- SubNegMonoid.sub_eq_add_neg
class SubNegMonoid (G : Type u) extends AddMonoid G, Neg G, Sub G where
  protected sub := SubNegMonoid.sub'
  protected sub_eq_add_neg : ∀ a b : G, a - b = a + -b := by intros; rfl
    protected zsmul : ℤ → G → G
  protected zsmul_zero' : ∀ a : G, zsmul 0 a = 0 := by intros; rfl
  protected zsmul_succ' (n : ℕ) (a : G) :
      zsmul (Int.ofNat n.succ) a = zsmul (Int.ofNat n) a + a := by
    intros; rfl
  protected zsmul_neg' (n : ℕ) (a : G) : zsmul (Int.negSucc n) a = -zsmul n.succ a := by
    intros; rfl
Arguments: {G : Type u} [self : SubNegMonoid G] (a b : G)
Goal: a - b = a + -b