ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Submonoid.mem_iSup
@[to_additive]
theorem mem_iSup {ι : Sort*} (p : ι → Submonoid M) {m : M} :
    (m ∈ ⨆ i, p i) ↔ ∀ N, (∀ i, p i ≤ N) → m ∈ N 
Arguments: {M : Type u_1} [MulOneClass M] {ι : Sort u_4} (p : ι → Submonoid M) {m : M}
Goal: m ∈ ⨆ i, p i ↔ ∀ (N : Submonoid M), (∀ (i : ι), p i ≤ N) → m ∈ N
-- Submonoid.iSup_eq_closure
@[to_additive]
theorem iSup_eq_closure {ι : Sort*} (p : ι → Submonoid M) :
    ⨆ i, p i = Submonoid.closure (⋃ i, (p i : Set M)) 
Arguments: {M : Type u_1} [MulOneClass M] {ι : Sort u_4} (p : ι → Submonoid M)
Goal: ⨆ i, p i = Submonoid.closure (⋃ i, ↑(p i))
-- AddSubmonoid.iSup_eq_closure
@[to_additive]
theorem iSup_eq_closure {ι : Sort*} (p : ι → Submonoid M) :
    ⨆ i, p i = Submonoid.closure (⋃ i, (p i : Set M)) 
Arguments: {M : Type u_1} [AddZeroClass M] {ι : Sort u_4} (p : ι → AddSubmonoid M)
Goal: ⨆ i, p i = AddSubmonoid.closure (⋃ i, ↑(p i))
-- AddSubmonoid.disjoint_def
@[to_additive]
theorem disjoint_def {p₁ p₂ : Submonoid M} :
    Disjoint p₁ p₂ ↔ ∀ {x : M}, x ∈ p₁ → x ∈ p₂ → x = 1 
Arguments: {M : Type u_1} [AddZeroClass M] {p₁ p₂ : AddSubmonoid M}
Goal: Disjoint p₁ p₂ ↔ ∀ {x : M}, x ∈ p₁ → x ∈ p₂ → x = 0
-- Submonoid.disjoint_def
@[to_additive]
theorem disjoint_def {p₁ p₂ : Submonoid M} :
    Disjoint p₁ p₂ ↔ ∀ {x : M}, x ∈ p₁ → x ∈ p₂ → x = 1 
Arguments: {M : Type u_1} [MulOneClass M] {p₁ p₂ : Submonoid M}
Goal: Disjoint p₁ p₂ ↔ ∀ {x : M}, x ∈ p₁ → x ∈ p₂ → x = 1
-- Submonoid.disjoint_def'
@[to_additive]
theorem disjoint_def' {p₁ p₂ : Submonoid M} :
    Disjoint p₁ p₂ ↔ ∀ {x y : M}, x ∈ p₁ → y ∈ p₂ → x = y → x = 1 
Arguments: {M : Type u_1} [MulOneClass M] {p₁ p₂ : Submonoid M}
Goal: Disjoint p₁ p₂ ↔ ∀ {x y : M}, x ∈ p₁ → y ∈ p₂ → x = y → x = 1
-- AddSubmonoid.disjoint_def'
@[to_additive]
theorem disjoint_def' {p₁ p₂ : Submonoid M} :
    Disjoint p₁ p₂ ↔ ∀ {x y : M}, x ∈ p₁ → y ∈ p₂ → x = y → x = 1 
Arguments: {M : Type u_1} [AddZeroClass M] {p₁ p₂ : AddSubmonoid M}
Goal: Disjoint p₁ p₂ ↔ ∀ {x y : M}, x ∈ p₁ → y ∈ p₂ → x = y → x = 0
-- AddMonoidHom.eqLocusM_same
@[to_additive (attr := simp)]
theorem eqLocusM_same (f : M →* N) : f.eqLocusM f = ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (f : M →+ N)
Goal: f.eqLocusM f = ⊤
-- MonoidHom.eqLocusM_same
@[to_additive (attr := simp)]
theorem eqLocusM_same (f : M →* N) : f.eqLocusM f = ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (f : M →* N)
Goal: f.eqLocusM f = ⊤
-- AddMonoidHom.eqOn_closureM
@[to_additive
      "If two monoid homomorphisms are equal on a set, then they are equal on its submonoid
      closure."]
theorem eqOn_closureM {f g : M →* N} {s : Set M} (h : Set.EqOn f g s) : Set.EqOn f g (closure s) 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {f g : M →+ N} {s : Set M} (h : Set.EqOn (⇑f) (⇑g) s)
Goal: Set.EqOn ⇑f ⇑g ↑(AddSubmonoid.closure s)
-- MonoidHom.eqOn_closureM
@[to_additive
      "If two monoid homomorphisms are equal on a set, then they are equal on its submonoid
      closure."]
theorem eqOn_closureM {f g : M →* N} {s : Set M} (h : Set.EqOn f g s) : Set.EqOn f g (closure s) 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {f g : M →* N} {s : Set M} (h : Set.EqOn (⇑f) (⇑g) s)
Goal: Set.EqOn ⇑f ⇑g ↑(Submonoid.closure s)
-- AddMonoidHom.eq_of_eqOn_topM
@[to_additive]
theorem eq_of_eqOn_topM {f g : M →* N} (h : Set.EqOn f g (⊤ : Submonoid M)) : f = g 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {f g : M →+ N} (h : Set.EqOn ⇑f ⇑g ↑⊤)
Goal: f = g
-- MonoidHom.eq_of_eqOn_topM
@[to_additive]
theorem eq_of_eqOn_topM {f g : M →* N} (h : Set.EqOn f g (⊤ : Submonoid M)) : f = g 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {f g : M →* N} (h : Set.EqOn ⇑f ⇑g ↑⊤)
Goal: f = g
-- AddMonoidHom.eq_of_eqOn_denseM
@[to_additive]
theorem eq_of_eqOn_denseM {s : Set M} (hs : closure s = ⊤) {f g : M →* N} (h : s.EqOn f g) :
    f = g 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {s : Set M} (hs : AddSubmonoid.closure s = ⊤) {f g : M →+ N} (h : Set.EqOn (⇑f) (⇑g) s)
Goal: f = g
-- MonoidHom.eq_of_eqOn_denseM
@[to_additive]
theorem eq_of_eqOn_denseM {s : Set M} (hs : closure s = ⊤) {f g : M →* N} (h : s.EqOn f g) :
    f = g 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {s : Set M} (hs : Submonoid.closure s = ⊤) {f g : M →* N} (h : Set.EqOn (⇑f) (⇑g) s)
Goal: f = g
-- IsAddUnit.mem_addSubmonoid_iff
@[to_additive]
theorem IsUnit.mem_submonoid_iff {M : Type*} [Monoid M] (a : M) :
    a ∈ IsUnit.submonoid M ↔ IsUnit a 
Arguments: {M : Type u_4} [AddMonoid M] (a : M)
Goal: a ∈ IsAddUnit.addSubmonoid M ↔ IsAddUnit a
-- IsUnit.mem_submonoid_iff
@[to_additive]
theorem IsUnit.mem_submonoid_iff {M : Type*} [Monoid M] (a : M) :
    a ∈ IsUnit.submonoid M ↔ IsUnit a 
Arguments: {M : Type u_4} [Monoid M] (a : M)
Goal: a ∈ IsUnit.submonoid M ↔ IsUnit a
-- MonoidHom.coe_ofClosureMEqTopLeft
@[to_additive (attr := simp, norm_cast)]
theorem coe_ofClosureMEqTopLeft (f : M → N) (hs : closure s = ⊤) (h1 hmul) :
    ⇑(ofClosureMEqTopLeft f hs h1 hmul) = f 
Arguments: {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] {s : Set M} (f : M → N) (hs : Submonoid.closure s = ⊤) (h1 : f 1 = 1) (hmul : ∀ x ∈ s, ∀ (y : M), f (x * y) = f x * f y)
Goal: ⇑(MonoidHom.ofClosureMEqTopLeft f hs h1 hmul) = f
-- AddMonoidHom.coe_ofClosureMEqTopLeft
@[to_additive (attr := simp, norm_cast)]
theorem coe_ofClosureMEqTopLeft (f : M → N) (hs : closure s = ⊤) (h1 hmul) :
    ⇑(ofClosureMEqTopLeft f hs h1 hmul) = f 
Arguments: {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] {s : Set M} (f : M → N) (hs : AddSubmonoid.closure s = ⊤) (h1 : f 0 = 0) (hmul : ∀ x ∈ s, ∀ (y : M), f (x + y) = f x + f y)
Goal: ⇑(AddMonoidHom.ofClosureMEqTopLeft f hs h1 hmul) = f
-- MonoidHom.coe_ofClosureMEqTopRight
@[to_additive (attr := simp, norm_cast)]
theorem coe_ofClosureMEqTopRight (f : M → N) (hs : closure s = ⊤) (h1 hmul) :
    ⇑(ofClosureMEqTopRight f hs h1 hmul) = f 
Arguments: {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] {s : Set M} (f : M → N) (hs : Submonoid.closure s = ⊤) (h1 : f 1 = 1) (hmul : ∀ (x y : M), y ∈ s → f (x * y) = f x * f y)
Goal: ⇑(MonoidHom.ofClosureMEqTopRight f hs h1 hmul) = f
-- AddMonoidHom.coe_ofClosureMEqTopRight
@[to_additive (attr := simp, norm_cast)]
theorem coe_ofClosureMEqTopRight (f : M → N) (hs : closure s = ⊤) (h1 hmul) :
    ⇑(ofClosureMEqTopRight f hs h1 hmul) = f 
Arguments: {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] {s : Set M} (f : M → N) (hs : AddSubmonoid.closure s = ⊤) (h1 : f 0 = 0) (hmul : ∀ (x y : M), y ∈ s → f (x + y) = f x + f y)
Goal: ⇑(AddMonoidHom.ofClosureMEqTopRight f hs h1 hmul) = f
-- pow_dite
@[to_additive (attr := simp) dite_smul]
lemma pow_dite (p : Prop) [Decidable p] (a : α) (b : p → β) (c : ¬ p → β) :
    a ^ (if h : p then b h else c h) = if h : p then a ^ b h else a ^ c h 
Arguments: {α : Type u_1} {β : Type u_2} [Pow α β] (p : Prop) [Decidable p] (a : α) (b : p → β) (c : ¬p → β)
Goal: (a ^ if h : p then b h else c h) = if h : p then a ^ b h else a ^ c h
-- dite_smul
@[to_additive (attr := simp) dite_smul]
lemma pow_dite (p : Prop) [Decidable p] (a : α) (b : p → β) (c : ¬ p → β) :
    a ^ (if h : p then b h else c h) = if h : p then a ^ b h else a ^ c h 
Arguments: {α : Type u_1} {β : Type u_2} [SMul β α] (p : Prop) [Decidable p] (a : α) (b : p → β) (c : ¬p → β)
Goal: (if h : p then b h else c h) • a = if h : p then b h • a else c h • a
-- dite_pow
@[to_additive (attr := simp) smul_dite]
lemma dite_pow (p : Prop) [Decidable p] (a : p → α) (b : ¬ p → α) (c : β) :
    (if h : p then a h else b h) ^ c = if h : p then a h ^ c else b h ^ c 
Arguments: {α : Type u_1} {β : Type u_2} [Pow α β] (p : Prop) [Decidable p] (a : p → α) (b : ¬p → α) (c : β)
Goal: (if h : p then a h else b h) ^ c = if h : p then a h ^ c else b h ^ c
-- smul_dite
@[to_additive (attr := simp) smul_dite]
lemma dite_pow (p : Prop) [Decidable p] (a : p → α) (b : ¬ p → α) (c : β) :
    (if h : p then a h else b h) ^ c = if h : p then a h ^ c else b h ^ c 
Arguments: {α : Type u_1} {β : Type u_2} [SMul β α] (p : Prop) [Decidable p] (a : p → α) (b : ¬p → α) (c : β)
Goal: (c • if h : p then a h else b h) = if h : p then c • a h else c • b h
-- ite_smul
@[to_additive (attr := simp) ite_smul]
lemma pow_ite (p : Prop) [Decidable p] (a : α) (b c : β) :
    a ^ (if p then b else c) = if p then a ^ b else a ^ c 
Arguments: {α : Type u_1} {β : Type u_2} [SMul β α] (p : Prop) [Decidable p] (a : α) (b c : β)
Goal: (if p then b else c) • a = if p then b • a else c • a
-- pow_ite
@[to_additive (attr := simp) ite_smul]
lemma pow_ite (p : Prop) [Decidable p] (a : α) (b c : β) :
    a ^ (if p then b else c) = if p then a ^ b else a ^ c 
Arguments: {α : Type u_1} {β : Type u_2} [Pow α β] (p : Prop) [Decidable p] (a : α) (b c : β)
Goal: (a ^ if p then b else c) = if p then a ^ b else a ^ c
-- ite_pow
@[to_additive (attr := simp) smul_ite]
lemma ite_pow (p : Prop) [Decidable p] (a b : α) (c : β) :
    (if p then a else b) ^ c = if p then a ^ c else b ^ c 
Arguments: {α : Type u_1} {β : Type u_2} [Pow α β] (p : Prop) [Decidable p] (a b : α) (c : β)
Goal: (if p then a else b) ^ c = if p then a ^ c else b ^ c
-- smul_ite
@[to_additive (attr := simp) smul_ite]
lemma ite_pow (p : Prop) [Decidable p] (a b : α) (c : β) :
    (if p then a else b) ^ c = if p then a ^ c else b ^ c 
Arguments: {α : Type u_1} {β : Type u_2} [SMul β α] (p : Prop) [Decidable p] (a b : α) (c : β)
Goal: (c • if p then a else b) = if p then c • a else c • b
-- add_right_injective
@[to_additive]
theorem mul_right_injective (a : G) : Injective (a * ·) 
Arguments: {G : Type u_3} [Add G] [IsLeftCancelAdd G] (a : G)
Goal: Function.Injective fun x => a + x
-- mul_right_injective
@[to_additive]
theorem mul_right_injective (a : G) : Injective (a * ·) 
Arguments: {G : Type u_3} [Mul G] [IsLeftCancelMul G] (a : G)
Goal: Function.Injective fun x => a * x
-- add_right_inj
@[to_additive (attr := simp)]
theorem mul_right_inj (a : G) {b c : G} : a * b = a * c ↔ b = c 
Arguments: {G : Type u_3} [Add G] [IsLeftCancelAdd G] (a : G) {b c : G}
Goal: a + b = a + c ↔ b = c
-- mul_right_inj
@[to_additive (attr := simp)]
theorem mul_right_inj (a : G) {b c : G} : a * b = a * c ↔ b = c 
Arguments: {G : Type u_3} [Mul G] [IsLeftCancelMul G] (a : G) {b c : G}
Goal: a * b = a * c ↔ b = c
-- mul_ne_mul_right
@[to_additive]
theorem mul_ne_mul_right (a : G) {b c : G} : a * b ≠ a * c ↔ b ≠ c 
Arguments: {G : Type u_3} [Mul G] [IsLeftCancelMul G] (a : G) {b c : G}
Goal: a * b ≠ a * c ↔ b ≠ c
-- add_ne_add_right
@[to_additive]
theorem mul_ne_mul_right (a : G) {b c : G} : a * b ≠ a * c ↔ b ≠ c 
Arguments: {G : Type u_3} [Add G] [IsLeftCancelAdd G] (a : G) {b c : G}
Goal: a + b ≠ a + c ↔ b ≠ c
-- add_left_injective
@[to_additive]
theorem mul_left_injective (a : G) : Function.Injective (· * a) 
Arguments: {G : Type u_3} [Add G] [IsRightCancelAdd G] (a : G)
Goal: Function.Injective fun x => x + a
-- mul_left_injective
@[to_additive]
theorem mul_left_injective (a : G) : Function.Injective (· * a) 
Arguments: {G : Type u_3} [Mul G] [IsRightCancelMul G] (a : G)
Goal: Function.Injective fun x => x * a
-- add_left_inj
@[to_additive (attr := simp)]
theorem mul_left_inj (a : G) {b c : G} : b * a = c * a ↔ b = c 
Arguments: {G : Type u_3} [Add G] [IsRightCancelAdd G] (a : G) {b c : G}
Goal: b + a = c + a ↔ b = c
-- mul_left_inj
@[to_additive (attr := simp)]
theorem mul_left_inj (a : G) {b c : G} : b * a = c * a ↔ b = c 
Arguments: {G : Type u_3} [Mul G] [IsRightCancelMul G] (a : G) {b c : G}
Goal: b * a = c * a ↔ b = c
-- add_ne_add_left
@[to_additive]
theorem mul_ne_mul_left (a : G) {b c : G} : b * a ≠ c * a ↔ b ≠ c 
Arguments: {G : Type u_3} [Add G] [IsRightCancelAdd G] (a : G) {b c : G}
Goal: b + a ≠ c + a ↔ b ≠ c
-- mul_ne_mul_left
@[to_additive]
theorem mul_ne_mul_left (a : G) {b c : G} : b * a ≠ c * a ↔ b ≠ c 
Arguments: {G : Type u_3} [Mul G] [IsRightCancelMul G] (a : G) {b c : G}
Goal: b * a ≠ c * a ↔ b ≠ c
-- comp_add_left
@[to_additive (attr := simp) "Composing two additions on the left by `y` then `x`
is equal to an addition on the left by `x + y`."]
theorem comp_mul_left (x y : α) : (x * ·) ∘ (y * ·) = (x * y * ·) 
Arguments: {α : Type u_1} [AddSemigroup α] (x y : α)
Goal: ((fun x_1 => x + x_1) ∘ fun x => y + x) = fun x_1 => x + y + x_1
-- comp_mul_left
@[to_additive (attr := simp) "Composing two additions on the left by `y` then `x`
is equal to an addition on the left by `x + y`."]
theorem comp_mul_left (x y : α) : (x * ·) ∘ (y * ·) = (x * y * ·) 
Arguments: {α : Type u_1} [Semigroup α] (x y : α)
Goal: ((fun x_1 => x * x_1) ∘ fun x => y * x) = fun x_1 => x * y * x_1
-- comp_mul_right
@[to_additive (attr := simp) "Composing two additions on the right by `y` and `x`
is equal to an addition on the right by `y + x`."]
theorem comp_mul_right (x y : α) : (· * x) ∘ (· * y) = (· * (y * x)) 
Arguments: {α : Type u_1} [Semigroup α] (x y : α)
Goal: ((fun x_1 => x_1 * x) ∘ fun x => x * y) = fun x_1 => x_1 * (y * x)
-- comp_add_right
@[to_additive (attr := simp) "Composing two additions on the right by `y` and `x`
is equal to an addition on the right by `y + x`."]
theorem comp_mul_right (x y : α) : (· * x) ∘ (· * y) = (· * (y * x)) 
Arguments: {α : Type u_1} [AddSemigroup α] (x y : α)
Goal: ((fun x_1 => x_1 + x) ∘ fun x => x + y) = fun x_1 => x_1 + (y + x)
-- ite_add_zero
@[to_additive]
theorem ite_mul_one {P : Prop} [Decidable P] {a b : M} :
    ite P (a * b) 1 = ite P a 1 * ite P b 1 
Arguments: {M : Type u} [AddZeroClass M] {P : Prop} [Decidable P] {a b : M}
Goal: (if P then a + b else 0) = (if P then a else 0) + if P then b else 0
-- ite_mul_one
@[to_additive]
theorem ite_mul_one {P : Prop} [Decidable P] {a b : M} :
    ite P (a * b) 1 = ite P a 1 * ite P b 1 
Arguments: {M : Type u} [MulOneClass M] {P : Prop} [Decidable P] {a b : M}
Goal: (if P then a * b else 1) = (if P then a else 1) * if P then b else 1
-- ite_zero_add
@[to_additive]
theorem ite_one_mul {P : Prop} [Decidable P] {a b : M} :
    ite P 1 (a * b) = ite P 1 a * ite P 1 b 
Arguments: {M : Type u} [AddZeroClass M] {P : Prop} [Decidable P] {a b : M}
Goal: (if P then 0 else a + b) = (if P then 0 else a) + if P then 0 else b
-- ite_one_mul
@[to_additive]
theorem ite_one_mul {P : Prop} [Decidable P] {a b : M} :
    ite P 1 (a * b) = ite P 1 a * ite P 1 b 
Arguments: {M : Type u} [MulOneClass M] {P : Prop} [Decidable P] {a b : M}
Goal: (if P then 1 else a * b) = (if P then 1 else a) * if P then 1 else b
-- eq_zero_iff_eq_zero_of_add_eq_zero
@[to_additive]
theorem eq_one_iff_eq_one_of_mul_eq_one {a b : M} (h : a * b = 1) : a = 1 ↔ b = 1 
Arguments: {M : Type u} [AddZeroClass M] {a b : M} (h : a + b = 0)
Goal: a = 0 ↔ b = 0
-- eq_one_iff_eq_one_of_mul_eq_one
@[to_additive]
theorem eq_one_iff_eq_one_of_mul_eq_one {a b : M} (h : a * b = 1) : a = 1 ↔ b = 1 
Arguments: {M : Type u} [MulOneClass M] {a b : M} (h : a * b = 1)
Goal: a = 1 ↔ b = 1
-- zero_add_eq_id
@[to_additive]
theorem one_mul_eq_id : ((1 : M) * ·) = id 
Arguments: {M : Type u} [AddZeroClass M]
Goal: (fun x => 0 + x) = id
-- one_mul_eq_id
@[to_additive]
theorem one_mul_eq_id : ((1 : M) * ·) = id 
Arguments: {M : Type u} [MulOneClass M]
Goal: (fun x => 1 * x) = id
-- mul_one_eq_id
@[to_additive]
theorem mul_one_eq_id : (· * (1 : M)) = id 
Arguments: {M : Type u} [MulOneClass M]
Goal: (fun x => x * 1) = id
-- add_zero_eq_id
@[to_additive]
theorem mul_one_eq_id : (· * (1 : M)) = id 
Arguments: {M : Type u} [AddZeroClass M]
Goal: (fun x => x + 0) = id
-- add_left_comm
@[to_additive]
theorem mul_left_comm : ∀ a b c : G, a * (b * c) = b * (a * c) 
Arguments: {G : Type u_3} [AddCommSemigroup G] (a b c : G)
Goal: a + (b + c) = b + (a + c)
-- mul_left_comm
@[to_additive]
theorem mul_left_comm : ∀ a b c : G, a * (b * c) = b * (a * c) 
Arguments: {G : Type u_3} [CommSemigroup G] (a b c : G)
Goal: a * (b * c) = b * (a * c)
-- mul_right_comm
@[to_additive]
theorem mul_right_comm : ∀ a b c : G, a * b * c = a * c * b 
Arguments: {G : Type u_3} [CommSemigroup G] (a b c : G)
Goal: a * b * c = a * c * b
-- add_right_comm
@[to_additive]
theorem mul_right_comm : ∀ a b c : G, a * b * c = a * c * b 
Arguments: {G : Type u_3} [AddCommSemigroup G] (a b c : G)
Goal: a + b + c = a + c + b
-- mul_mul_mul_comm
@[to_additive]
theorem mul_mul_mul_comm (a b c d : G) : a * b * (c * d) = a * c * (b * d) 
Arguments: {G : Type u_3} [CommSemigroup G] (a b c d : G)
Goal: a * b * (c * d) = a * c * (b * d)
-- add_add_add_comm
@[to_additive]
theorem mul_mul_mul_comm (a b c d : G) : a * b * (c * d) = a * c * (b * d) 
Arguments: {G : Type u_3} [AddCommSemigroup G] (a b c d : G)
Goal: a + b + (c + d) = a + c + (b + d)
-- add_rotate
@[to_additive]
theorem mul_rotate (a b c : G) : a * b * c = b * c * a 
Arguments: {G : Type u_3} [AddCommSemigroup G] (a b c : G)
Goal: a + b + c = b + c + a
-- mul_rotate
@[to_additive]
theorem mul_rotate (a b c : G) : a * b * c = b * c * a 
Arguments: {G : Type u_3} [CommSemigroup G] (a b c : G)
Goal: a * b * c = b * c * a
-- mul_rotate'
@[to_additive]
theorem mul_rotate' (a b c : G) : a * (b * c) = b * (c * a) 
Arguments: {G : Type u_3} [CommSemigroup G] (a b c : G)
Goal: a * (b * c) = b * (c * a)
-- add_rotate'
@[to_additive]
theorem mul_rotate' (a b c : G) : a * (b * c) = b * (c * a) 
Arguments: {G : Type u_3} [AddCommSemigroup G] (a b c : G)
Goal: a + (b + c) = b + (c + a)
-- boole_nsmul
@[to_additive boole_nsmul]
lemma pow_boole (P : Prop) [Decidable P] (a : M) :
    (a ^ if P then 1 else 0) = if P then a else 1 
Arguments: {M : Type u_4} [AddMonoid M] (P : Prop) [Decidable P] (a : M)
Goal: (if P then 1 else 0) • a = if P then a else 0
-- pow_boole
@[to_additive boole_nsmul]
lemma pow_boole (P : Prop) [Decidable P] (a : M) :
    (a ^ if P then 1 else 0) = if P then a else 1 
Arguments: {M : Type u_4} [Monoid M] (P : Prop) [Decidable P] (a : M)
Goal: (a ^ if P then 1 else 0) = if P then a else 1
-- nsmul_add_sub_nsmul
@[to_additive nsmul_add_sub_nsmul]
lemma pow_mul_pow_sub (a : M) (h : m ≤ n) : a ^ m * a ^ (n - m) = a ^ n 
Arguments: {M : Type u_4} [AddMonoid M] {m n : ℕ} (a : M) (h : m ≤ n)
Goal: m • a + (n - m) • a = n • a
-- pow_mul_pow_sub
@[to_additive nsmul_add_sub_nsmul]
lemma pow_mul_pow_sub (a : M) (h : m ≤ n) : a ^ m * a ^ (n - m) = a ^ n 
Arguments: {M : Type u_4} [Monoid M] {m n : ℕ} (a : M) (h : m ≤ n)
Goal: a ^ m * a ^ (n - m) = a ^ n
-- pow_sub_mul_pow
@[to_additive sub_nsmul_nsmul_add]
lemma pow_sub_mul_pow (a : M) (h : m ≤ n) : a ^ (n - m) * a ^ m = a ^ n 
Arguments: {M : Type u_4} [Monoid M] {m n : ℕ} (a : M) (h : m ≤ n)
Goal: a ^ (n - m) * a ^ m = a ^ n
-- sub_nsmul_nsmul_add
@[to_additive sub_nsmul_nsmul_add]
lemma pow_sub_mul_pow (a : M) (h : m ≤ n) : a ^ (n - m) * a ^ m = a ^ n 
Arguments: {M : Type u_4} [AddMonoid M] {m n : ℕ} (a : M) (h : m ≤ n)
Goal: (n - m) • a + m • a = n • a
-- sub_one_nsmul_add
@[to_additive sub_one_nsmul_add]
lemma mul_pow_sub_one (hn : n ≠ 0) (a : M) : a * a ^ (n - 1) = a ^ n 
Arguments: {M : Type u_4} [AddMonoid M] {n : ℕ} (hn : n ≠ 0) (a : M)
Goal: a + (n - 1) • a = n • a
-- mul_pow_sub_one
@[to_additive sub_one_nsmul_add]
lemma mul_pow_sub_one (hn : n ≠ 0) (a : M) : a * a ^ (n - 1) = a ^ n 
Arguments: {M : Type u_4} [Monoid M] {n : ℕ} (hn : n ≠ 0) (a : M)
Goal: a * a ^ (n - 1) = a ^ n
-- pow_sub_one_mul
@[to_additive add_sub_one_nsmul]
lemma pow_sub_one_mul (hn : n ≠ 0) (a : M) : a ^ (n - 1) * a = a ^ n 
Arguments: {M : Type u_4} [Monoid M] {n : ℕ} (hn : n ≠ 0) (a : M)
Goal: a ^ (n - 1) * a = a ^ n
-- add_sub_one_nsmul
@[to_additive add_sub_one_nsmul]
lemma pow_sub_one_mul (hn : n ≠ 0) (a : M) : a ^ (n - 1) * a = a ^ n 
Arguments: {M : Type u_4} [AddMonoid M] {n : ℕ} (hn : n ≠ 0) (a : M)
Goal: (n - 1) • a + a = n • a
-- nsmul_eq_mod_nsmul
@[to_additive nsmul_eq_mod_nsmul "If `n • x = 0`, then `m • x` is the same as `(m % n) • x`"]
lemma pow_eq_pow_mod (m : ℕ) (ha : a ^ n = 1) : a ^ m = a ^ (m % n) 
Arguments: {M : Type u_4} [AddMonoid M] {a : M} {n : ℕ} (m : ℕ) (ha : n • a = 0)
Goal: m • a = (m % n) • a
-- pow_eq_pow_mod
@[to_additive nsmul_eq_mod_nsmul "If `n • x = 0`, then `m • x` is the same as `(m % n) • x`"]
lemma pow_eq_pow_mod (m : ℕ) (ha : a ^ n = 1) : a ^ m = a ^ (m % n) 
Arguments: {M : Type u_4} [Monoid M] {a : M} {n : ℕ} (m : ℕ) (ha : a ^ n = 1)
Goal: a ^ m = a ^ (m % n)
-- pow_mul_pow_eq_one
@[to_additive] lemma pow_mul_pow_eq_one : ∀ n, a * b = 1 → a ^ n * b ^ n = 1
  
Arguments: {M : Type u_4} [Monoid M] {a b : M} (n : ℕ)
Goal: a * b = 1 → a ^ n * b ^ n = 1
-- nsmul_add_nsmul_eq_zero
@[to_additive] lemma pow_mul_pow_eq_one : ∀ n, a * b = 1 → a ^ n * b ^ n = 1
  
Arguments: {M : Type u_4} [AddMonoid M] {a b : M} (n : ℕ)
Goal: a + b = 0 → n • a + n • b = 0
-- inv_unique
@[to_additive]
theorem inv_unique (hy : x * y = 1) (hz : x * z = 1) : y = z 
Arguments: {M : Type u_4} [CommMonoid M] {x y z : M} (hy : x * y = 1) (hz : x * z = 1)
Goal: y = z
-- neg_unique
@[to_additive]
theorem inv_unique (hy : x * y = 1) (hz : x * z = 1) : y = z 
Arguments: {M : Type u_4} [AddCommMonoid M] {x y z : M} (hy : x + y = 0) (hz : x + z = 0)
Goal: y = z
-- mul_pow
@[to_additive nsmul_add] lemma mul_pow (a b : M) : ∀ n, (a * b) ^ n = a ^ n * b ^ n
  
Arguments: {M : Type u_4} [CommMonoid M] (a b : M) (n : ℕ)
Goal: (a * b) ^ n = a ^ n * b ^ n
-- nsmul_add
@[to_additive nsmul_add] lemma mul_pow (a b : M) : ∀ n, (a * b) ^ n = a ^ n * b ^ n
  
Arguments: {M : Type u_4} [AddCommMonoid M] (a b : M) (n : ℕ)
Goal: n • (a + b) = n • a + n • b
-- mul_right_eq_self
@[to_additive (attr := simp)]
theorem mul_right_eq_self : a * b = a ↔ b = 1 
Arguments: {M : Type u} [LeftCancelMonoid M] {a b : M}
Goal: a * b = a ↔ b = 1
-- add_right_eq_self
@[to_additive (attr := simp)]
theorem mul_right_eq_self : a * b = a ↔ b = 1 
Arguments: {M : Type u} [AddLeftCancelMonoid M] {a b : M}
Goal: a + b = a ↔ b = 0
-- self_eq_mul_right
@[to_additive (attr := simp)]
theorem self_eq_mul_right : a = a * b ↔ b = 1 
Arguments: {M : Type u} [LeftCancelMonoid M] {a b : M}
Goal: a = a * b ↔ b = 1
-- self_eq_add_right
@[to_additive (attr := simp)]
theorem self_eq_mul_right : a = a * b ↔ b = 1 
Arguments: {M : Type u} [AddLeftCancelMonoid M] {a b : M}
Goal: a = a + b ↔ b = 0
-- mul_right_ne_self
@[to_additive]
theorem mul_right_ne_self : a * b ≠ a ↔ b ≠ 1 
Arguments: {M : Type u} [LeftCancelMonoid M] {a b : M}
Goal: a * b ≠ a ↔ b ≠ 1
-- add_right_ne_self
@[to_additive]
theorem mul_right_ne_self : a * b ≠ a ↔ b ≠ 1 
Arguments: {M : Type u} [AddLeftCancelMonoid M] {a b : M}
Goal: a + b ≠ a ↔ b ≠ 0
-- self_ne_add_right
@[to_additive]
theorem self_ne_mul_right : a ≠ a * b ↔ b ≠ 1 
Arguments: {M : Type u} [AddLeftCancelMonoid M] {a b : M}
Goal: a ≠ a + b ↔ b ≠ 0
-- self_ne_mul_right
@[to_additive]
theorem self_ne_mul_right : a ≠ a * b ↔ b ≠ 1 
Arguments: {M : Type u} [LeftCancelMonoid M] {a b : M}
Goal: a ≠ a * b ↔ b ≠ 1
-- mul_left_eq_self
@[to_additive (attr := simp)]
theorem mul_left_eq_self : a * b = b ↔ a = 1 
Arguments: {M : Type u} [RightCancelMonoid M] {a b : M}
Goal: a * b = b ↔ a = 1
-- add_left_eq_self
@[to_additive (attr := simp)]
theorem mul_left_eq_self : a * b = b ↔ a = 1 
Arguments: {M : Type u} [AddRightCancelMonoid M] {a b : M}
Goal: a + b = b ↔ a = 0
-- self_eq_add_left
@[to_additive (attr := simp)]
theorem self_eq_mul_left : b = a * b ↔ a = 1 
Arguments: {M : Type u} [AddRightCancelMonoid M] {a b : M}
Goal: b = a + b ↔ a = 0
-- self_eq_mul_left
@[to_additive (attr := simp)]
theorem self_eq_mul_left : b = a * b ↔ a = 1 
Arguments: {M : Type u} [RightCancelMonoid M] {a b : M}
Goal: b = a * b ↔ a = 1
-- mul_left_ne_self
@[to_additive]
theorem mul_left_ne_self : a * b ≠ b ↔ a ≠ 1 
Arguments: {M : Type u} [RightCancelMonoid M] {a b : M}
Goal: a * b ≠ b ↔ a ≠ 1
-- add_left_ne_self
@[to_additive]
theorem mul_left_ne_self : a * b ≠ b ↔ a ≠ 1 
Arguments: {M : Type u} [AddRightCancelMonoid M] {a b : M}
Goal: a + b ≠ b ↔ a ≠ 0
-- self_ne_add_left
@[to_additive]
theorem self_ne_mul_left : b ≠ a * b ↔ a ≠ 1 
Arguments: {M : Type u} [AddRightCancelMonoid M] {a b : M}
Goal: b ≠ a + b ↔ a ≠ 0
-- self_ne_mul_left
@[to_additive]
theorem self_ne_mul_left : b ≠ a * b ↔ a ≠ 1 
Arguments: {M : Type u} [RightCancelMonoid M] {a b : M}
Goal: b ≠ a * b ↔ a ≠ 1
-- eq_iff_eq_of_add_eq_add
@[to_additive] lemma eq_iff_eq_of_mul_eq_mul (h : a * b = c * d) : a = c ↔ b = d 
Arguments: {α : Type u_1} [AddCancelCommMonoid α] {a b c d : α} (h : a + b = c + d)
Goal: a = c ↔ b = d