File: Mathlib/Algebra/Group/Basic.lean

full_name: pow_dite
code: @[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 
goal: (a ^ if h : p then b h else c h) = if h : p then a ^ b h else a ^ c h

full_name: dite_smul
code: @[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 
goal: (if h : p then b h else c h) • a = if h : p then b h • a else c h • a

full_name: dite_pow
code: @[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 
goal: (if h : p then a h else b h) ^ c = if h : p then a h ^ c else b h ^ c

full_name: smul_dite
code: @[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 
goal: (c • if h : p then a h else b h) = if h : p then c • a h else c • b h

full_name: ite_smul
code: @[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 
goal: (if p then b else c) • a = if p then b • a else c • a

full_name: pow_ite
code: @[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 
goal: (a ^ if p then b else c) = if p then a ^ b else a ^ c

full_name: ite_pow
code: @[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 
goal: (if p then a else b) ^ c = if p then a ^ c else b ^ c

full_name: smul_ite
code: @[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 
goal: (c • if p then a else b) = if p then c • a else c • b

full_name: add_right_injective
code: @[to_additive]
theorem mul_right_injective (a : G) : Injective (a * ·) 
goal: Function.Injective fun x => a + x

full_name: mul_right_injective
code: @[to_additive]
theorem mul_right_injective (a : G) : Injective (a * ·) 
goal: Function.Injective fun x => a * x

full_name: add_right_inj
code: @[to_additive (attr := simp)]
theorem mul_right_inj (a : G) {b c : G} : a * b = a * c ↔ b = c 
goal: a + b = a + c ↔ b = c

full_name: mul_right_inj
code: @[to_additive (attr := simp)]
theorem mul_right_inj (a : G) {b c : G} : a * b = a * c ↔ b = c 
goal: a * b = a * c ↔ b = c

full_name: mul_ne_mul_right
code: @[to_additive]
theorem mul_ne_mul_right (a : G) {b c : G} : a * b ≠ a * c ↔ b ≠ c 
goal: a * b ≠ a * c ↔ b ≠ c

full_name: add_ne_add_right
code: @[to_additive]
theorem mul_ne_mul_right (a : G) {b c : G} : a * b ≠ a * c ↔ b ≠ c 
goal: a + b ≠ a + c ↔ b ≠ c

full_name: add_left_injective
code: @[to_additive]
theorem mul_left_injective (a : G) : Function.Injective (· * a) 
goal: Function.Injective fun x => x + a

full_name: mul_left_injective
code: @[to_additive]
theorem mul_left_injective (a : G) : Function.Injective (· * a) 
goal: Function.Injective fun x => x * a

full_name: add_left_inj
code: @[to_additive (attr := simp)]
theorem mul_left_inj (a : G) {b c : G} : b * a = c * a ↔ b = c 
goal: b + a = c + a ↔ b = c

full_name: mul_left_inj
code: @[to_additive (attr := simp)]
theorem mul_left_inj (a : G) {b c : G} : b * a = c * a ↔ b = c 
goal: b * a = c * a ↔ b = c

full_name: add_ne_add_left
code: @[to_additive]
theorem mul_ne_mul_left (a : G) {b c : G} : b * a ≠ c * a ↔ b ≠ c 
goal: b + a ≠ c + a ↔ b ≠ c

full_name: mul_ne_mul_left
code: @[to_additive]
theorem mul_ne_mul_left (a : G) {b c : G} : b * a ≠ c * a ↔ b ≠ c 
goal: b * a ≠ c * a ↔ b ≠ c

full_name: Semigroup.to_isAssociative
code: @[to_additive]
instance Semigroup.to_isAssociative : Std.Associative (α := α)  (· * ·) 
goal: Std.Associative fun x x_1 => x * x_1

full_name: AddSemigroup.to_isAssociative
code: @[to_additive]
instance Semigroup.to_isAssociative : Std.Associative (α := α)  (· * ·) 
goal: Std.Associative fun x x_1 => x + x_1

full_name: comp_add_left
code: /-- Composing two multiplications on the left by `y` then `x`
is equal to a multiplication on the left by `x * y`.
-/
@[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 * ·) 
goal: ((fun x_1 => x + x_1) ∘ fun x => y + x) = fun x_1 => x + y + x_1

full_name: comp_mul_left
code: /-- Composing two multiplications on the left by `y` then `x`
is equal to a multiplication on the left by `x * y`.
-/
@[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 * ·) 
goal: ((fun x_1 => x * x_1) ∘ fun x => y * x) = fun x_1 => x * y * x_1

full_name: comp_mul_right
code: /-- Composing two multiplications on the right by `y` and `x`
is equal to a multiplication on the right by `y * x`.
-/
@[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)) 
goal: ((fun x_1 => x_1 * x) ∘ fun x => x * y) = fun x_1 => x_1 * (y * x)

full_name: comp_add_right
code: /-- Composing two multiplications on the right by `y` and `x`
is equal to a multiplication on the right by `y * x`.
-/
@[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)) 
goal: ((fun x_1 => x_1 + x) ∘ fun x => x + y) = fun x_1 => x_1 + (y + x)

full_name: AddCommMagma.to_isCommutative
code: @[to_additive]
instance CommMagma.to_isCommutative [CommMagma G] : Std.Commutative (α := G) (· * ·) 
goal: Std.Commutative fun x x_1 => x + x_1

full_name: CommMagma.to_isCommutative
code: @[to_additive]
instance CommMagma.to_isCommutative [CommMagma G] : Std.Commutative (α := G) (· * ·) 
goal: Std.Commutative fun x x_1 => x * x_1

full_name: ite_add_zero
code: @[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 
goal: (if P then a + b else 0) = (if P then a else 0) + if P then b else 0

full_name: ite_mul_one
code: @[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 
goal: (if P then a * b else 1) = (if P then a else 1) * if P then b else 1

full_name: ite_zero_add
code: @[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 
goal: (if P then 0 else a + b) = (if P then 0 else a) + if P then 0 else b

full_name: ite_one_mul
code: @[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 
goal: (if P then 1 else a * b) = (if P then 1 else a) * if P then 1 else b

full_name: eq_zero_iff_eq_zero_of_add_eq_zero
code: @[to_additive]
theorem eq_one_iff_eq_one_of_mul_eq_one {a b : M} (h : a * b = 1) : a = 1 ↔ b = 1 
goal: a = 0 ↔ b = 0

full_name: eq_one_iff_eq_one_of_mul_eq_one
code: @[to_additive]
theorem eq_one_iff_eq_one_of_mul_eq_one {a b : M} (h : a * b = 1) : a = 1 ↔ b = 1 
goal: a = 1 ↔ b = 1

full_name: zero_add_eq_id
code: @[to_additive]
theorem one_mul_eq_id : ((1 : M) * ·) = id 
goal: (fun x => 0 + x) = id

full_name: one_mul_eq_id
code: @[to_additive]
theorem one_mul_eq_id : ((1 : M) * ·) = id 
goal: (fun x => 1 * x) = id

full_name: mul_one_eq_id
code: @[to_additive]
theorem mul_one_eq_id : (· * (1 : M)) = id 
goal: (fun x => x * 1) = id

full_name: add_zero_eq_id
code: @[to_additive]
theorem mul_one_eq_id : (· * (1 : M)) = id 
goal: (fun x => x + 0) = id

full_name: add_left_comm
code: @[to_additive]
theorem mul_left_comm : ∀ a b c : G, a * (b * c) = b * (a * c) 
goal: a + (b + c) = b + (a + c)

full_name: mul_left_comm
code: @[to_additive]
theorem mul_left_comm : ∀ a b c : G, a * (b * c) = b * (a * c) 
goal: a * (b * c) = b * (a * c)

full_name: mul_right_comm
code: @[to_additive]
theorem mul_right_comm : ∀ a b c : G, a * b * c = a * c * b 
goal: a * b * c = a * c * b

full_name: add_right_comm
code: @[to_additive]
theorem mul_right_comm : ∀ a b c : G, a * b * c = a * c * b 
goal: a + b + c = a + c + b

full_name: mul_mul_mul_comm
code: @[to_additive]
theorem mul_mul_mul_comm (a b c d : G) : a * b * (c * d) = a * c * (b * d) 
goal: a * b * (c * d) = a * c * (b * d)

full_name: add_add_add_comm
code: @[to_additive]
theorem mul_mul_mul_comm (a b c d : G) : a * b * (c * d) = a * c * (b * d) 
goal: a + b + (c + d) = a + c + (b + d)

full_name: add_rotate
code: @[to_additive]
theorem mul_rotate (a b c : G) : a * b * c = b * c * a 
goal: a + b + c = b + c + a

full_name: mul_rotate
code: @[to_additive]
theorem mul_rotate (a b c : G) : a * b * c = b * c * a 
goal: a * b * c = b * c * a

full_name: mul_rotate'
code: @[to_additive]
theorem mul_rotate' (a b c : G) : a * (b * c) = b * (c * a) 
goal: a * (b * c) = b * (c * a)

full_name: add_rotate'
code: @[to_additive]
theorem mul_rotate' (a b c : G) : a * (b * c) = b * (c * a) 
goal: a + (b + c) = b + (c + a)

full_name: boole_nsmul
code: @[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 
goal: (if P then 1 else 0) • a = if P then a else 0

full_name: pow_boole
code: @[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 
goal: (a ^ if P then 1 else 0) = if P then a else 1

full_name: nsmul_add_sub_nsmul
code: @[to_additive nsmul_add_sub_nsmul]
lemma pow_mul_pow_sub (a : M) (h : m ≤ n) : a ^ m * a ^ (n - m) = a ^ n 
goal: m • a + (n - m) • a = n • a

full_name: pow_mul_pow_sub
code: @[to_additive nsmul_add_sub_nsmul]
lemma pow_mul_pow_sub (a : M) (h : m ≤ n) : a ^ m * a ^ (n - m) = a ^ n 
goal: a ^ m * a ^ (n - m) = a ^ n

full_name: pow_sub_mul_pow
code: @[to_additive sub_nsmul_nsmul_add]
lemma pow_sub_mul_pow (a : M) (h : m ≤ n) : a ^ (n - m) * a ^ m = a ^ n 
goal: a ^ (n - m) * a ^ m = a ^ n

full_name: sub_nsmul_nsmul_add
code: @[to_additive sub_nsmul_nsmul_add]
lemma pow_sub_mul_pow (a : M) (h : m ≤ n) : a ^ (n - m) * a ^ m = a ^ n 
goal: (n - m) • a + m • a = n • a

full_name: sub_one_nsmul_add
code: @[to_additive sub_one_nsmul_add]
lemma mul_pow_sub_one (hn : n ≠ 0) (a : M) : a * a ^ (n - 1) = a ^ n 
goal: a + (n - 1) • a = n • a

full_name: mul_pow_sub_one
code: @[to_additive sub_one_nsmul_add]
lemma mul_pow_sub_one (hn : n ≠ 0) (a : M) : a * a ^ (n - 1) = a ^ n 
goal: a * a ^ (n - 1) = a ^ n

full_name: pow_sub_one_mul
code: @[to_additive add_sub_one_nsmul]
lemma pow_sub_one_mul (hn : n ≠ 0) (a : M) : a ^ (n - 1) * a = a ^ n 
goal: a ^ (n - 1) * a = a ^ n

full_name: add_sub_one_nsmul
code: @[to_additive add_sub_one_nsmul]
lemma pow_sub_one_mul (hn : n ≠ 0) (a : M) : a ^ (n - 1) * a = a ^ n 
goal: (n - 1) • a + a = n • a

full_name: nsmul_eq_mod_nsmul
code: /-- If `x ^ n = 1`, then `x ^ m` is the same as `x ^ (m % n)` -/
@[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) 
goal: m • a = (m % n) • a

full_name: pow_eq_pow_mod
code: /-- If `x ^ n = 1`, then `x ^ m` is the same as `x ^ (m % n)` -/
@[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) 
goal: a ^ m = a ^ (m % n)

full_name: pow_mul_pow_eq_one
code: @[to_additive] lemma pow_mul_pow_eq_one : ∀ n, a * b = 1 → a ^ n * b ^ n = 1
  
goal: a * b = 1 → a ^ n * b ^ n = 1

full_name: nsmul_add_nsmul_eq_zero
code: @[to_additive] lemma pow_mul_pow_eq_one : ∀ n, a * b = 1 → a ^ n * b ^ n = 1
  
goal: a + b = 0 → n • a + n • b = 0

full_name: inv_unique
code: @[to_additive]
theorem inv_unique (hy : x * y = 1) (hz : x * z = 1) : y = z 
goal: y = z

full_name: neg_unique
code: @[to_additive]
theorem inv_unique (hy : x * y = 1) (hz : x * z = 1) : y = z 
goal: y = z

full_name: mul_pow
code: @[to_additive nsmul_add] lemma mul_pow (a b : M) : ∀ n, (a * b) ^ n = a ^ n * b ^ n
  
goal: (a * b) ^ n = a ^ n * b ^ n

full_name: nsmul_add
code: @[to_additive nsmul_add] lemma mul_pow (a b : M) : ∀ n, (a * b) ^ n = a ^ n * b ^ n
  
goal: n • (a + b) = n • a + n • b

full_name: mul_right_eq_self
code: @[to_additive (attr := simp)]
theorem mul_right_eq_self : a * b = a ↔ b = 1 
goal: a * b = a ↔ b = 1

full_name: add_right_eq_self
code: @[to_additive (attr := simp)]
theorem mul_right_eq_self : a * b = a ↔ b = 1 
goal: a + b = a ↔ b = 0

full_name: self_eq_mul_right
code: @[to_additive (attr := simp)]
theorem self_eq_mul_right : a = a * b ↔ b = 1 
goal: a = a * b ↔ b = 1

full_name: self_eq_add_right
code: @[to_additive (attr := simp)]
theorem self_eq_mul_right : a = a * b ↔ b = 1 
goal: a = a + b ↔ b = 0

full_name: mul_right_ne_self
code: @[to_additive]
theorem mul_right_ne_self : a * b ≠ a ↔ b ≠ 1 
goal: a * b ≠ a ↔ b ≠ 1

full_name: add_right_ne_self
code: @[to_additive]
theorem mul_right_ne_self : a * b ≠ a ↔ b ≠ 1 
goal: a + b ≠ a ↔ b ≠ 0

full_name: self_ne_add_right
code: @[to_additive]
theorem self_ne_mul_right : a ≠ a * b ↔ b ≠ 1 
goal: a ≠ a + b ↔ b ≠ 0

full_name: self_ne_mul_right
code: @[to_additive]
theorem self_ne_mul_right : a ≠ a * b ↔ b ≠ 1 
goal: a ≠ a * b ↔ b ≠ 1

full_name: mul_left_eq_self
code: @[to_additive (attr := simp)]
theorem mul_left_eq_self : a * b = b ↔ a = 1 
goal: a * b = b ↔ a = 1

full_name: add_left_eq_self
code: @[to_additive (attr := simp)]
theorem mul_left_eq_self : a * b = b ↔ a = 1 
goal: a + b = b ↔ a = 0

full_name: self_eq_add_left
code: @[to_additive (attr := simp)]
theorem self_eq_mul_left : b = a * b ↔ a = 1 
goal: b = a + b ↔ a = 0

full_name: self_eq_mul_left
code: @[to_additive (attr := simp)]
theorem self_eq_mul_left : b = a * b ↔ a = 1 
goal: b = a * b ↔ a = 1

full_name: mul_left_ne_self
code: @[to_additive]
theorem mul_left_ne_self : a * b ≠ b ↔ a ≠ 1 
goal: a * b ≠ b ↔ a ≠ 1

full_name: add_left_ne_self
code: @[to_additive]
theorem mul_left_ne_self : a * b ≠ b ↔ a ≠ 1 
goal: a + b ≠ b ↔ a ≠ 0

full_name: self_ne_add_left
code: @[to_additive]
theorem self_ne_mul_left : b ≠ a * b ↔ a ≠ 1 
goal: b ≠ a + b ↔ a ≠ 0

full_name: self_ne_mul_left
code: @[to_additive]
theorem self_ne_mul_left : b ≠ a * b ↔ a ≠ 1 
goal: b ≠ a * b ↔ a ≠ 1

full_name: eq_iff_eq_of_add_eq_add
code: @[to_additive] lemma eq_iff_eq_of_mul_eq_mul (h : a * b = c * d) : a = c ↔ b = d 
goal: a = c ↔ b = d

full_name: eq_iff_eq_of_mul_eq_mul
code: @[to_additive] lemma eq_iff_eq_of_mul_eq_mul (h : a * b = c * d) : a = c ↔ b = d 
goal: a = c ↔ b = d

full_name: ne_iff_ne_of_add_eq_add
code: @[to_additive] lemma ne_iff_ne_of_mul_eq_mul (h : a * b = c * d) : a ≠ c ↔ b ≠ d 
goal: a ≠ c ↔ b ≠ d

full_name: ne_iff_ne_of_mul_eq_mul
code: @[to_additive] lemma ne_iff_ne_of_mul_eq_mul (h : a * b = c * d) : a ≠ c ↔ b ≠ d 
goal: a ≠ c ↔ b ≠ d

full_name: inv_involutive
code: @[to_additive (attr := simp)]
theorem inv_involutive : Function.Involutive (Inv.inv : G → G) 
goal: Function.Involutive Inv.inv

full_name: neg_involutive
code: @[to_additive (attr := simp)]
theorem inv_involutive : Function.Involutive (Inv.inv : G → G) 
goal: Function.Involutive Neg.neg

full_name: inv_surjective
code: @[to_additive (attr := simp)]
theorem inv_surjective : Function.Surjective (Inv.inv : G → G) 
goal: Function.Surjective Inv.inv

full_name: neg_surjective
code: @[to_additive (attr := simp)]
theorem inv_surjective : Function.Surjective (Inv.inv : G → G) 
goal: Function.Surjective Neg.neg

full_name: neg_injective
code: @[to_additive]
theorem inv_injective : Function.Injective (Inv.inv : G → G) 
goal: Function.Injective Neg.neg

full_name: inv_injective
code: @[to_additive]
theorem inv_injective : Function.Injective (Inv.inv : G → G) 
goal: Function.Injective Inv.inv

full_name: neg_inj
code: @[to_additive (attr := simp)]
theorem inv_inj : a⁻¹ = b⁻¹ ↔ a = b 
goal: -a = -b ↔ a = b

full_name: inv_inj
code: @[to_additive (attr := simp)]
theorem inv_inj : a⁻¹ = b⁻¹ ↔ a = b 
goal: a⁻¹ = b⁻¹ ↔ a = b

full_name: inv_eq_iff_eq_inv
code: @[to_additive]
theorem inv_eq_iff_eq_inv : a⁻¹ = b ↔ a = b⁻¹ 
goal: a⁻¹ = b ↔ a = b⁻¹

full_name: neg_eq_iff_eq_neg
code: @[to_additive]
theorem inv_eq_iff_eq_inv : a⁻¹ = b ↔ a = b⁻¹ 
goal: -a = b ↔ a = -b

full_name: inv_comp_inv
code: @[to_additive]
theorem inv_comp_inv : Inv.inv ∘ Inv.inv = @id G 
goal: Inv.inv ∘ Inv.inv = id

full_name: neg_comp_neg
code: @[to_additive]
theorem inv_comp_inv : Inv.inv ∘ Inv.inv = @id G 
goal: Neg.neg ∘ Neg.neg = id

full_name: leftInverse_inv
code: @[to_additive]
theorem leftInverse_inv : LeftInverse (fun a : G ↦ a⁻¹) fun a ↦ a⁻¹ 
goal: Function.LeftInverse (fun a => a⁻¹) fun a => a⁻¹

full_name: leftInverse_neg
code: @[to_additive]
theorem leftInverse_inv : LeftInverse (fun a : G ↦ a⁻¹) fun a ↦ a⁻¹ 
goal: Function.LeftInverse (fun a => -a) fun a => -a

full_name: rightInverse_neg
code: @[to_additive]
theorem rightInverse_inv : RightInverse (fun a : G ↦ a⁻¹) fun a ↦ a⁻¹ 
goal: Function.RightInverse (fun a => -a) fun a => -a

full_name: rightInverse_inv
code: @[to_additive]
theorem rightInverse_inv : RightInverse (fun a : G ↦ a⁻¹) fun a ↦ a⁻¹ 
goal: Function.RightInverse (fun a => a⁻¹) fun a => a⁻¹

full_name: neg_eq_zero_sub
code: @[to_additive, field_simps] -- The attributes are out of order on purpose
theorem inv_eq_one_div (x : G) : x⁻¹ = 1 / x 
goal: -x = 0 - x

full_name: inv_eq_one_div
code: @[to_additive, field_simps] -- The attributes are out of order on purpose
theorem inv_eq_one_div (x : G) : x⁻¹ = 1 / x 
goal: x⁻¹ = 1 / x

full_name: mul_one_div
code: @[to_additive]
theorem mul_one_div (x y : G) : x * (1 / y) = x / y 
goal: x * (1 / y) = x / y

full_name: add_zero_sub
code: @[to_additive]
theorem mul_one_div (x y : G) : x * (1 / y) = x / y 
goal: x + (0 - y) = x - y

full_name: mul_div_assoc
code: @[to_additive]
theorem mul_div_assoc (a b c : G) : a * b / c = a * (b / c) 
goal: a * b / c = a * (b / c)

full_name: add_sub_assoc
code: @[to_additive]
theorem mul_div_assoc (a b c : G) : a * b / c = a * (b / c) 
goal: a + b - c = a + (b - c)

full_name: mul_div_assoc'
code: @[to_additive, field_simps] -- The attributes are out of order on purpose
theorem mul_div_assoc' (a b c : G) : a * (b / c) = a * b / c 
goal: a * (b / c) = a * b / c

full_name: add_sub_assoc'
code: @[to_additive, field_simps] -- The attributes are out of order on purpose
theorem mul_div_assoc' (a b c : G) : a * (b / c) = a * b / c 
goal: a + (b - c) = a + b - c

full_name: one_div
code: @[to_additive (attr := simp)]
theorem one_div (a : G) : 1 / a = a⁻¹ 
goal: 1 / a = a⁻¹

full_name: zero_sub
code: @[to_additive (attr := simp)]
theorem one_div (a : G) : 1 / a = a⁻¹ 
goal: 0 - a = -a

full_name: mul_div
code: @[to_additive]
theorem mul_div (a b c : G) : a * (b / c) = a * b / c 
goal: a * (b / c) = a * b / c

full_name: add_sub
code: @[to_additive]
theorem mul_div (a b c : G) : a * (b / c) = a * b / c 
goal: a + (b - c) = a + b - c

full_name: sub_eq_add_zero_sub
code: @[to_additive]
theorem div_eq_mul_one_div (a b : G) : a / b = a * (1 / b) 
goal: a - b = a + (0 - b)

full_name: div_eq_mul_one_div
code: @[to_additive]
theorem div_eq_mul_one_div (a b : G) : a / b = a * (1 / b) 
goal: a / b = a * (1 / b)

full_name: sub_zero
code: @[to_additive (attr := simp)]
theorem div_one (a : G) : a / 1 = a 
goal: a - 0 = a

full_name: div_one
code: @[to_additive (attr := simp)]
theorem div_one (a : G) : a / 1 = a 
goal: a / 1 = a

full_name: one_div_one
code: @[to_additive]
theorem one_div_one : (1 : G) / 1 = 1 
goal: 1 / 1 = 1

full_name: zero_sub_zero
code: @[to_additive]
theorem one_div_one : (1 : G) / 1 = 1 
goal: 0 - 0 = 0

full_name: eq_inv_of_mul_eq_one_right
code: @[to_additive]
theorem eq_inv_of_mul_eq_one_right (h : a * b = 1) : b = a⁻¹ 
goal: b = a⁻¹

full_name: eq_neg_of_add_eq_zero_right
code: @[to_additive]
theorem eq_inv_of_mul_eq_one_right (h : a * b = 1) : b = a⁻¹ 
goal: b = -a

full_name: eq_one_div_of_mul_eq_one_left
code: @[to_additive]
theorem eq_one_div_of_mul_eq_one_left (h : b * a = 1) : b = 1 / a 
goal: b = 1 / a

full_name: eq_zero_sub_of_add_eq_zero_left
code: @[to_additive]
theorem eq_one_div_of_mul_eq_one_left (h : b * a = 1) : b = 1 / a 
goal: b = 0 - a

full_name: eq_one_div_of_mul_eq_one_right
code: @[to_additive]
theorem eq_one_div_of_mul_eq_one_right (h : a * b = 1) : b = 1 / a 
goal: b = 1 / a

full_name: eq_zero_sub_of_add_eq_zero_right
code: @[to_additive]
theorem eq_one_div_of_mul_eq_one_right (h : a * b = 1) : b = 1 / a 
goal: b = 0 - a

full_name: eq_of_div_eq_one
code: @[to_additive]
theorem eq_of_div_eq_one (h : a / b = 1) : a = b 
goal: a = b

full_name: eq_of_sub_eq_zero
code: @[to_additive]
theorem eq_of_div_eq_one (h : a / b = 1) : a = b 
goal: a = b

full_name: eq_of_inv_mul_eq_one
code: lemma eq_of_inv_mul_eq_one (h : a⁻¹ * b = 1) : a = b 
goal: a = b

full_name: eq_of_mul_inv_eq_one
code: lemma eq_of_mul_inv_eq_one (h : a * b⁻¹ = 1) : a = b 
goal: a = b

full_name: div_ne_one_of_ne
code: @[to_additive]
theorem div_ne_one_of_ne : a ≠ b → a / b ≠ 1 
goal: a ≠ b → a / b ≠ 1

full_name: sub_ne_zero_of_ne
code: @[to_additive]
theorem div_ne_one_of_ne : a ≠ b → a / b ≠ 1 
goal: a ≠ b → a - b ≠ 0

full_name: zero_sub_add_zero_sub_rev
code: @[to_additive]
theorem one_div_mul_one_div_rev : 1 / a * (1 / b) = 1 / (b * a) 
goal: 0 - a + (0 - b) = 0 - (b + a)

full_name: one_div_mul_one_div_rev
code: @[to_additive]
theorem one_div_mul_one_div_rev : 1 / a * (1 / b) = 1 / (b * a) 
goal: 1 / a * (1 / b) = 1 / (b * a)

full_name: neg_sub_left
code: @[to_additive]
theorem inv_div_left : a⁻¹ / b = (b * a)⁻¹ 
goal: -a - b = -(b + a)

full_name: inv_div_left
code: @[to_additive]
theorem inv_div_left : a⁻¹ / b = (b * a)⁻¹ 
goal: a⁻¹ / b = (b * a)⁻¹

full_name: inv_div
code: @[to_additive (attr := simp)]
theorem inv_div : (a / b)⁻¹ = b / a 
goal: (a / b)⁻¹ = b / a

full_name: neg_sub
code: @[to_additive (attr := simp)]
theorem inv_div : (a / b)⁻¹ = b / a 
goal: -(a - b) = b - a

full_name: one_div_div
code: @[to_additive]
theorem one_div_div : 1 / (a / b) = b / a 
goal: 1 / (a / b) = b / a

full_name: zero_sub_sub
code: @[to_additive]
theorem one_div_div : 1 / (a / b) = b / a 
goal: 0 - (a - b) = b - a

full_name: one_div_one_div
code: @[to_additive]
theorem one_div_one_div : 1 / (1 / a) = a 
goal: 1 / (1 / a) = a

full_name: zero_sub_zero_sub
code: @[to_additive]
theorem one_div_one_div : 1 / (1 / a) = a 
goal: 0 - (0 - a) = a

full_name: div_eq_div_iff_comm
code: @[to_additive]
theorem div_eq_div_iff_comm : a / b = c / d ↔ b / a = d / c 
goal: a / b = c / d ↔ b / a = d / c

full_name: sub_eq_sub_iff_comm
code: @[to_additive]
theorem div_eq_div_iff_comm : a / b = c / d ↔ b / a = d / c 
goal: a - b = c - d ↔ b - a = d - c

full_name: SubtractionMonoid.toSubNegZeroMonoid
code: @[to_additive SubtractionMonoid.toSubNegZeroMonoid]
instance (priority := 100) DivisionMonoid.toDivInvOneMonoid : DivInvOneMonoid α 
goal: SubNegZeroMonoid α

full_name: DivisionMonoid.toDivInvOneMonoid
code: @[to_additive SubtractionMonoid.toSubNegZeroMonoid]
instance (priority := 100) DivisionMonoid.toDivInvOneMonoid : DivInvOneMonoid α 
goal: DivInvOneMonoid α

full_name: neg_nsmul
code: @[to_additive (attr := simp)]
lemma inv_pow (a : α) : ∀ n : ℕ, a⁻¹ ^ n = (a ^ n)⁻¹
  
goal: n • -a = -(n • a)

full_name: inv_pow
code: @[to_additive (attr := simp)]
lemma inv_pow (a : α) : ∀ n : ℕ, a⁻¹ ^ n = (a ^ n)⁻¹
  
goal: a⁻¹ ^ n = (a ^ n)⁻¹

full_name: zsmul_zero
code: @[to_additive zsmul_zero, simp]
lemma one_zpow : ∀ n : ℤ, (1 : α) ^ n = 1
  
goal: n • 0 = 0

full_name: one_zpow
code: @[to_additive zsmul_zero, simp]
lemma one_zpow : ∀ n : ℤ, (1 : α) ^ n = 1
  
goal: 1 ^ n = 1

full_name: neg_zsmul
code: @[to_additive (attr := simp) neg_zsmul]
lemma zpow_neg (a : α) : ∀ n : ℤ, a ^ (-n) = (a ^ n)⁻¹
  
goal: -n • a = -(n • a)

full_name: zpow_neg
code: @[to_additive (attr := simp) neg_zsmul]
lemma zpow_neg (a : α) : ∀ n : ℤ, a ^ (-n) = (a ^ n)⁻¹
  
goal: a ^ (-n) = (a ^ n)⁻¹

full_name: neg_one_zsmul_add
code: @[to_additive neg_one_zsmul_add]
lemma mul_zpow_neg_one (a b : α) : (a * b) ^ (-1 : ℤ) = b ^ (-1 : ℤ) * a ^ (-1 : ℤ) 
goal: -1 • (a + b) = -1 • b + -1 • a

full_name: mul_zpow_neg_one
code: @[to_additive neg_one_zsmul_add]
lemma mul_zpow_neg_one (a b : α) : (a * b) ^ (-1 : ℤ) = b ^ (-1 : ℤ) * a ^ (-1 : ℤ) 
goal: (a * b) ^ (-1) = b ^ (-1) * a ^ (-1)

full_name: zsmul_neg
code: @[to_additive zsmul_neg]
lemma inv_zpow (a : α) : ∀ n : ℤ, a⁻¹ ^ n = (a ^ n)⁻¹
  
goal: n • -a = -(n • a)

full_name: inv_zpow
code: @[to_additive zsmul_neg]
lemma inv_zpow (a : α) : ∀ n : ℤ, a⁻¹ ^ n = (a ^ n)⁻¹
  
goal: a⁻¹ ^ n = (a ^ n)⁻¹

full_name: inv_zpow'
code: @[to_additive (attr := simp) zsmul_neg']
lemma inv_zpow' (a : α) (n : ℤ) : a⁻¹ ^ n = a ^ (-n) 
goal: a⁻¹ ^ n = a ^ (-n)

full_name: zsmul_neg'
code: @[to_additive (attr := simp) zsmul_neg']
lemma inv_zpow' (a : α) (n : ℤ) : a⁻¹ ^ n = a ^ (-n) 
goal: n • -a = -n • a

full_name: nsmul_zero_sub
code: @[to_additive nsmul_zero_sub]
lemma one_div_pow (a : α) (n : ℕ) : (1 / a) ^ n = 1 / a ^ n 
goal: n • (0 - a) = 0 - n • a

full_name: one_div_pow
code: @[to_additive nsmul_zero_sub]
lemma one_div_pow (a : α) (n : ℕ) : (1 / a) ^ n = 1 / a ^ n 
goal: (1 / a) ^ n = 1 / a ^ n

full_name: one_div_zpow
code: @[to_additive zsmul_zero_sub]
lemma one_div_zpow (a : α) (n : ℤ) : (1 / a) ^ n = 1 / a ^ n 
goal: (1 / a) ^ n = 1 / a ^ n

full_name: zsmul_zero_sub
code: @[to_additive zsmul_zero_sub]
lemma one_div_zpow (a : α) (n : ℤ) : (1 / a) ^ n = 1 / a ^ n 
goal: n • (0 - a) = 0 - n • a

full_name: inv_eq_one
code: @[to_additive (attr := simp)]
theorem inv_eq_one : a⁻¹ = 1 ↔ a = 1 
goal: a⁻¹ = 1 ↔ a = 1

full_name: neg_eq_zero
code: @[to_additive (attr := simp)]
theorem inv_eq_one : a⁻¹ = 1 ↔ a = 1 
goal: -a = 0 ↔ a = 0

full_name: one_eq_inv
code: @[to_additive (attr := simp)]
theorem one_eq_inv : 1 = a⁻¹ ↔ a = 1 
goal: 1 = a⁻¹ ↔ a = 1

full_name: zero_eq_neg
code: @[to_additive (attr := simp)]
theorem one_eq_inv : 1 = a⁻¹ ↔ a = 1 
goal: 0 = -a ↔ a = 0

full_name: inv_ne_one
code: @[to_additive]
theorem inv_ne_one : a⁻¹ ≠ 1 ↔ a ≠ 1 
goal: a⁻¹ ≠ 1 ↔ a ≠ 1

full_name: neg_ne_zero
code: @[to_additive]
theorem inv_ne_one : a⁻¹ ≠ 1 ↔ a ≠ 1 
goal: -a ≠ 0 ↔ a ≠ 0

full_name: eq_of_zero_sub_eq_zero_sub
code: @[to_additive]
theorem eq_of_one_div_eq_one_div (h : 1 / a = 1 / b) : a = b 
goal: a = b

full_name: eq_of_one_div_eq_one_div
code: @[to_additive]
theorem eq_of_one_div_eq_one_div (h : 1 / a = 1 / b) : a = b 
goal: a = b

full_name: mul_zsmul'
code: @[to_additive mul_zsmul'] lemma zpow_mul (a : α) : ∀ m n : ℤ, a ^ (m * n) = (a ^ m) ^ n
  
goal: (m * n) • a = n • m • a

full_name: zpow_mul
code: @[to_additive mul_zsmul'] lemma zpow_mul (a : α) : ∀ m n : ℤ, a ^ (m * n) = (a ^ m) ^ n
  
goal: a ^ (m * n) = (a ^ m) ^ n

full_name: zpow_mul'
code: @[to_additive mul_zsmul]
lemma zpow_mul' (a : α) (m n : ℤ) : a ^ (m * n) = (a ^ n) ^ m 
goal: a ^ (m * n) = (a ^ n) ^ m

full_name: mul_zsmul
code: @[to_additive mul_zsmul]
lemma zpow_mul' (a : α) (m n : ℤ) : a ^ (m * n) = (a ^ n) ^ m 
goal: (m * n) • a = m • n • a

full_name: sub_sub_eq_add_sub
code: @[to_additive, field_simps] -- The attributes are out of order on purpose
theorem div_div_eq_mul_div : a / (b / c) = a * c / b 
goal: a - (b - c) = a + c - b

full_name: div_div_eq_mul_div
code: @[to_additive, field_simps] -- The attributes are out of order on purpose
theorem div_div_eq_mul_div : a / (b / c) = a * c / b 
goal: a / (b / c) = a * c / b

full_name: sub_neg_eq_add
code: @[to_additive (attr := simp)]
theorem div_inv_eq_mul : a / b⁻¹ = a * b 
goal: a - -b = a + b

full_name: div_inv_eq_mul
code: @[to_additive (attr := simp)]
theorem div_inv_eq_mul : a / b⁻¹ = a * b 
goal: a / b⁻¹ = a * b

full_name: sub_add_eq_sub_sub_swap
code: @[to_additive]
theorem div_mul_eq_div_div_swap : a / (b * c) = a / c / b 
goal: a - (b + c) = a - c - b

full_name: div_mul_eq_div_div_swap
code: @[to_additive]
theorem div_mul_eq_div_div_swap : a / (b * c) = a / c / b 
goal: a / (b * c) = a / c / b

full_name: neg_add
code: @[to_additive neg_add]
theorem mul_inv : (a * b)⁻¹ = a⁻¹ * b⁻¹ 
goal: -(a + b) = -a + -b

full_name: mul_inv
code: @[to_additive neg_add]
theorem mul_inv : (a * b)⁻¹ = a⁻¹ * b⁻¹ 
goal: (a * b)⁻¹ = a⁻¹ * b⁻¹

full_name: neg_sub'
code: @[to_additive]
theorem inv_div' : (a / b)⁻¹ = a⁻¹ / b⁻¹ 
goal: -(a - b) = -a - -b

full_name: inv_div'
code: @[to_additive]
theorem inv_div' : (a / b)⁻¹ = a⁻¹ / b⁻¹ 
goal: (a / b)⁻¹ = a⁻¹ / b⁻¹

full_name: sub_eq_neg_add
code: @[to_additive]
theorem div_eq_inv_mul : a / b = b⁻¹ * a 
goal: a - b = -b + a

full_name: div_eq_inv_mul
code: @[to_additive]
theorem div_eq_inv_mul : a / b = b⁻¹ * a 
goal: a / b = b⁻¹ * a

full_name: neg_add_eq_sub
code: @[to_additive]
theorem inv_mul_eq_div : a⁻¹ * b = b / a 
goal: -a + b = b - a

full_name: inv_mul_eq_div
code: @[to_additive]
theorem inv_mul_eq_div : a⁻¹ * b = b / a 
goal: a⁻¹ * b = b / a

full_name: inv_mul'
code: @[to_additive]
theorem inv_mul' : (a * b)⁻¹ = a⁻¹ / b 
goal: (a * b)⁻¹ = a⁻¹ / b

full_name: neg_add'
code: @[to_additive]
theorem inv_mul' : (a * b)⁻¹ = a⁻¹ / b 
goal: -(a + b) = -a - b

full_name: neg_sub_neg
code: @[to_additive]
theorem inv_div_inv : a⁻¹ / b⁻¹ = b / a 
goal: -a - -b = b - a

full_name: inv_div_inv
code: @[to_additive]
theorem inv_div_inv : a⁻¹ / b⁻¹ = b / a 
goal: a⁻¹ / b⁻¹ = b / a

full_name: neg_neg_sub_neg
code: @[to_additive]
theorem inv_inv_div_inv : (a⁻¹ / b⁻¹)⁻¹ = a / b 
goal: -(-a - -b) = a - b

full_name: inv_inv_div_inv
code: @[to_additive]
theorem inv_inv_div_inv : (a⁻¹ / b⁻¹)⁻¹ = a / b 
goal: (a⁻¹ / b⁻¹)⁻¹ = a / b

full_name: zero_sub_add_zero_sub
code: @[to_additive]
theorem one_div_mul_one_div : 1 / a * (1 / b) = 1 / (a * b) 
goal: 0 - a + (0 - b) = 0 - (a + b)

full_name: one_div_mul_one_div
code: @[to_additive]
theorem one_div_mul_one_div : 1 / a * (1 / b) = 1 / (a * b) 
goal: 1 / a * (1 / b) = 1 / (a * b)

full_name: sub_right_comm
code: @[to_additive]
theorem div_right_comm : a / b / c = a / c / b 
goal: a - b - c = a - c - b

full_name: div_right_comm
code: @[to_additive]
theorem div_right_comm : a / b / c = a / c / b 
goal: a / b / c = a / c / b

full_name: div_div
code: @[to_additive, field_simps]
theorem div_div : a / b / c = a / (b * c) 
goal: a / b / c = a / (b * c)

full_name: sub_sub
code: @[to_additive, field_simps]
theorem div_div : a / b / c = a / (b * c) 
goal: a - b - c = a - (b + c)

full_name: div_mul
code: @[to_additive]
theorem div_mul : a / b * c = a / (b / c) 
goal: a / b * c = a / (b / c)

full_name: sub_add
code: @[to_additive]
theorem div_mul : a / b * c = a / (b / c) 
goal: a - b + c = a - (b - c)

full_name: mul_div_left_comm
code: @[to_additive]
theorem mul_div_left_comm : a * (b / c) = b * (a / c) 
goal: a * (b / c) = b * (a / c)

full_name: add_sub_left_comm
code: @[to_additive]
theorem mul_div_left_comm : a * (b / c) = b * (a / c) 
goal: a + (b - c) = b + (a - c)

full_name: mul_div_right_comm
code: @[to_additive]
theorem mul_div_right_comm : a * b / c = a / c * b 
goal: a * b / c = a / c * b

full_name: add_sub_right_comm
code: @[to_additive]
theorem mul_div_right_comm : a * b / c = a / c * b 
goal: a + b - c = a - c + b

full_name: div_mul_eq_div_div
code: @[to_additive]
theorem div_mul_eq_div_div : a / (b * c) = a / b / c 
goal: a / (b * c) = a / b / c

full_name: sub_add_eq_sub_sub
code: @[to_additive]
theorem div_mul_eq_div_div : a / (b * c) = a / b / c 
goal: a - (b + c) = a - b - c

full_name: div_mul_eq_mul_div
code: @[to_additive, field_simps]
theorem div_mul_eq_mul_div : a / b * c = a * c / b 
goal: a / b * c = a * c / b

full_name: sub_add_eq_add_sub
code: @[to_additive, field_simps]
theorem div_mul_eq_mul_div : a / b * c = a * c / b 
goal: a - b + c = a + c - b

full_name: zero_sub_add_eq_sub
code: @[to_additive]
theorem one_div_mul_eq_div : 1 / a * b = b / a 
goal: 0 - a + b = b - a

full_name: one_div_mul_eq_div
code: @[to_additive]
theorem one_div_mul_eq_div : 1 / a * b = b / a 
goal: 1 / a * b = b / a

full_name: mul_comm_div
code: @[to_additive]
theorem mul_comm_div : a / b * c = a * (c / b) 
goal: a / b * c = a * (c / b)

full_name: add_comm_sub
code: @[to_additive]
theorem mul_comm_div : a / b * c = a * (c / b) 
goal: a - b + c = a + (c - b)

full_name: div_mul_comm
code: @[to_additive]
theorem div_mul_comm : a / b * c = c / b * a 
goal: a / b * c = c / b * a

full_name: sub_add_comm
code: @[to_additive]
theorem div_mul_comm : a / b * c = c / b * a 
goal: a - b + c = c - b + a

full_name: sub_add_eq_sub_add_zero_sub
code: @[to_additive]
theorem div_mul_eq_div_mul_one_div : a / (b * c) = a / b * (1 / c) 
goal: a - (b + c) = a - b + (0 - c)

full_name: div_mul_eq_div_mul_one_div
code: @[to_additive]
theorem div_mul_eq_div_mul_one_div : a / (b * c) = a / b * (1 / c) 
goal: a / (b * c) = a / b * (1 / c)

full_name: sub_sub_sub_eq
code: @[to_additive]
theorem div_div_div_eq : a / b / (c / d) = a * d / (b * c) 
goal: a - b - (c - d) = a + d - (b + c)

full_name: div_div_div_eq
code: @[to_additive]
theorem div_div_div_eq : a / b / (c / d) = a * d / (b * c) 
goal: a / b / (c / d) = a * d / (b * c)

full_name: sub_sub_sub_comm
code: @[to_additive]
theorem div_div_div_comm : a / b / (c / d) = a / c / (b / d) 
goal: a - b - (c - d) = a - c - (b - d)

full_name: div_div_div_comm
code: @[to_additive]
theorem div_div_div_comm : a / b / (c / d) = a / c / (b / d) 
goal: a / b / (c / d) = a / c / (b / d)

full_name: div_mul_div_comm
code: @[to_additive]
theorem div_mul_div_comm : a / b * (c / d) = a * c / (b * d) 
goal: a / b * (c / d) = a * c / (b * d)

full_name: sub_add_sub_comm
code: @[to_additive]
theorem div_mul_div_comm : a / b * (c / d) = a * c / (b * d) 
goal: a - b + (c - d) = a + c - (b + d)

full_name: mul_div_mul_comm
code: @[to_additive]
theorem mul_div_mul_comm : a * b / (c * d) = a / c * (b / d) 
goal: a * b / (c * d) = a / c * (b / d)

full_name: add_sub_add_comm
code: @[to_additive]
theorem mul_div_mul_comm : a * b / (c * d) = a / c * (b / d) 
goal: a + b - (c + d) = a - c + (b - d)

full_name: mul_zpow
code: @[to_additive zsmul_add] lemma mul_zpow : ∀ n : ℤ, (a * b) ^ n = a ^ n * b ^ n
  
goal: (a * b) ^ n = a ^ n * b ^ n

full_name: zsmul_add
code: @[to_additive zsmul_add] lemma mul_zpow : ∀ n : ℤ, (a * b) ^ n = a ^ n * b ^ n
  
goal: n • (a + b) = n • a + n • b

full_name: nsmul_sub
code: @[to_additive (attr := simp) nsmul_sub]
lemma div_pow (a b : α) (n : ℕ) : (a / b) ^ n = a ^ n / b ^ n 
goal: n • (a - b) = n • a - n • b

full_name: div_pow
code: @[to_additive (attr := simp) nsmul_sub]
lemma div_pow (a b : α) (n : ℕ) : (a / b) ^ n = a ^ n / b ^ n 
goal: (a / b) ^ n = a ^ n / b ^ n

full_name: zsmul_sub
code: @[to_additive (attr := simp) zsmul_sub]
lemma div_zpow (a b : α) (n : ℤ) : (a / b) ^ n = a ^ n / b ^ n 
goal: n • (a - b) = n • a - n • b

full_name: div_zpow
code: @[to_additive (attr := simp) zsmul_sub]
lemma div_zpow (a b : α) (n : ℤ) : (a / b) ^ n = a ^ n / b ^ n 
goal: (a / b) ^ n = a ^ n / b ^ n

full_name: sub_eq_neg_self
code: @[to_additive (attr := simp)]
theorem div_eq_inv_self : a / b = b⁻¹ ↔ a = 1 
goal: a - b = -b ↔ a = 0

full_name: div_eq_inv_self
code: @[to_additive (attr := simp)]
theorem div_eq_inv_self : a / b = b⁻¹ ↔ a = 1 
goal: a / b = b⁻¹ ↔ a = 1

full_name: add_left_surjective
code: @[to_additive]
theorem mul_left_surjective (a : G) : Surjective (a * ·) 
goal: Function.Surjective fun x => a + x

full_name: mul_left_surjective
code: @[to_additive]
theorem mul_left_surjective (a : G) : Surjective (a * ·) 
goal: Function.Surjective fun x => a * x

full_name: mul_right_surjective
code: @[to_additive]
theorem mul_right_surjective (a : G) : Function.Surjective fun x ↦ x * a 
goal: Function.Surjective fun x => x * a

full_name: add_right_surjective
code: @[to_additive]
theorem mul_right_surjective (a : G) : Function.Surjective fun x ↦ x * a 
goal: Function.Surjective fun x => x + a

full_name: eq_mul_inv_of_mul_eq
code: @[to_additive]
theorem eq_mul_inv_of_mul_eq (h : a * c = b) : a = b * c⁻¹ 
goal: a = b * c⁻¹

full_name: eq_add_neg_of_add_eq
code: @[to_additive]
theorem eq_mul_inv_of_mul_eq (h : a * c = b) : a = b * c⁻¹ 
goal: a = b + -c

full_name: eq_inv_mul_of_mul_eq
code: @[to_additive]
theorem eq_inv_mul_of_mul_eq (h : b * a = c) : a = b⁻¹ * c 
goal: a = b⁻¹ * c

full_name: eq_neg_add_of_add_eq
code: @[to_additive]
theorem eq_inv_mul_of_mul_eq (h : b * a = c) : a = b⁻¹ * c 
goal: a = -b + c

full_name: inv_mul_eq_of_eq_mul
code: @[to_additive]
theorem inv_mul_eq_of_eq_mul (h : b = a * c) : a⁻¹ * b = c 
goal: a⁻¹ * b = c

full_name: neg_add_eq_of_eq_add
code: @[to_additive]
theorem inv_mul_eq_of_eq_mul (h : b = a * c) : a⁻¹ * b = c 
goal: -a + b = c

full_name: mul_inv_eq_of_eq_mul
code: @[to_additive]
theorem mul_inv_eq_of_eq_mul (h : a = c * b) : a * b⁻¹ = c 
goal: a * b⁻¹ = c

full_name: add_neg_eq_of_eq_add
code: @[to_additive]
theorem mul_inv_eq_of_eq_mul (h : a = c * b) : a * b⁻¹ = c 
goal: a + -b = c

full_name: eq_add_of_add_neg_eq
code: @[to_additive]
theorem eq_mul_of_mul_inv_eq (h : a * c⁻¹ = b) : a = b * c 
goal: a = b + c

full_name: eq_mul_of_mul_inv_eq
code: @[to_additive]
theorem eq_mul_of_mul_inv_eq (h : a * c⁻¹ = b) : a = b * c 
goal: a = b * c

full_name: eq_mul_of_inv_mul_eq
code: @[to_additive]
theorem eq_mul_of_inv_mul_eq (h : b⁻¹ * a = c) : a = b * c 
goal: a = b * c

full_name: eq_add_of_neg_add_eq
code: @[to_additive]
theorem eq_mul_of_inv_mul_eq (h : b⁻¹ * a = c) : a = b * c 
goal: a = b + c

full_name: add_eq_of_eq_neg_add
code: @[to_additive]
theorem mul_eq_of_eq_inv_mul (h : b = a⁻¹ * c) : a * b = c 
goal: a + b = c

full_name: mul_eq_of_eq_inv_mul
code: @[to_additive]
theorem mul_eq_of_eq_inv_mul (h : b = a⁻¹ * c) : a * b = c 
goal: a * b = c

full_name: add_eq_of_eq_add_neg
code: @[to_additive]
theorem mul_eq_of_eq_mul_inv (h : a = c * b⁻¹) : a * b = c 
goal: a + b = c

full_name: mul_eq_of_eq_mul_inv
code: @[to_additive]
theorem mul_eq_of_eq_mul_inv (h : a = c * b⁻¹) : a * b = c 
goal: a * b = c

full_name: add_eq_zero_iff_eq_neg
code: @[to_additive]
theorem mul_eq_one_iff_eq_inv : a * b = 1 ↔ a = b⁻¹ 
goal: a + b = 0 ↔ a = -b

full_name: mul_eq_one_iff_eq_inv
code: @[to_additive]
theorem mul_eq_one_iff_eq_inv : a * b = 1 ↔ a = b⁻¹ 
goal: a * b = 1 ↔ a = b⁻¹

full_name: mul_eq_one_iff_inv_eq
code: @[to_additive]
theorem mul_eq_one_iff_inv_eq : a * b = 1 ↔ a⁻¹ = b 
goal: a * b = 1 ↔ a⁻¹ = b

full_name: add_eq_zero_iff_neg_eq
code: @[to_additive]
theorem mul_eq_one_iff_inv_eq : a * b = 1 ↔ a⁻¹ = b 
goal: a + b = 0 ↔ -a = b

full_name: eq_inv_iff_mul_eq_one
code: @[to_additive]
theorem eq_inv_iff_mul_eq_one : a = b⁻¹ ↔ a * b = 1 
goal: a = b⁻¹ ↔ a * b = 1

full_name: eq_neg_iff_add_eq_zero
code: @[to_additive]
theorem eq_inv_iff_mul_eq_one : a = b⁻¹ ↔ a * b = 1 
goal: a = -b ↔ a + b = 0

full_name: inv_eq_iff_mul_eq_one
code: @[to_additive]
theorem inv_eq_iff_mul_eq_one : a⁻¹ = b ↔ a * b = 1 
goal: a⁻¹ = b ↔ a * b = 1

full_name: neg_eq_iff_add_eq_zero
code: @[to_additive]
theorem inv_eq_iff_mul_eq_one : a⁻¹ = b ↔ a * b = 1 
goal: -a = b ↔ a + b = 0

full_name: eq_add_neg_iff_add_eq
code: @[to_additive]
theorem eq_mul_inv_iff_mul_eq : a = b * c⁻¹ ↔ a * c = b 
goal: a = b + -c ↔ a + c = b

full_name: eq_mul_inv_iff_mul_eq
code: @[to_additive]
theorem eq_mul_inv_iff_mul_eq : a = b * c⁻¹ ↔ a * c = b 
goal: a = b * c⁻¹ ↔ a * c = b

full_name: eq_inv_mul_iff_mul_eq
code: @[to_additive]
theorem eq_inv_mul_iff_mul_eq : a = b⁻¹ * c ↔ b * a = c 
goal: a = b⁻¹ * c ↔ b * a = c

full_name: eq_neg_add_iff_add_eq
code: @[to_additive]
theorem eq_inv_mul_iff_mul_eq : a = b⁻¹ * c ↔ b * a = c 
goal: a = -b + c ↔ b + a = c

full_name: neg_add_eq_iff_eq_add
code: @[to_additive]
theorem inv_mul_eq_iff_eq_mul : a⁻¹ * b = c ↔ b = a * c 
goal: -a + b = c ↔ b = a + c

full_name: inv_mul_eq_iff_eq_mul
code: @[to_additive]
theorem inv_mul_eq_iff_eq_mul : a⁻¹ * b = c ↔ b = a * c 
goal: a⁻¹ * b = c ↔ b = a * c

full_name: mul_inv_eq_iff_eq_mul
code: @[to_additive]
theorem mul_inv_eq_iff_eq_mul : a * b⁻¹ = c ↔ a = c * b 
goal: a * b⁻¹ = c ↔ a = c * b

full_name: add_neg_eq_iff_eq_add
code: @[to_additive]
theorem mul_inv_eq_iff_eq_mul : a * b⁻¹ = c ↔ a = c * b 
goal: a + -b = c ↔ a = c + b

full_name: mul_inv_eq_one
code: @[to_additive]
theorem mul_inv_eq_one : a * b⁻¹ = 1 ↔ a = b 
goal: a * b⁻¹ = 1 ↔ a = b

full_name: add_neg_eq_zero
code: @[to_additive]
theorem mul_inv_eq_one : a * b⁻¹ = 1 ↔ a = b 
goal: a + -b = 0 ↔ a = b

full_name: neg_add_eq_zero
code: @[to_additive]
theorem inv_mul_eq_one : a⁻¹ * b = 1 ↔ a = b 
goal: -a + b = 0 ↔ a = b

full_name: inv_mul_eq_one
code: @[to_additive]
theorem inv_mul_eq_one : a⁻¹ * b = 1 ↔ a = b 
goal: a⁻¹ * b = 1 ↔ a = b

full_name: conj_eq_one_iff
code: @[to_additive (attr := simp)]
theorem conj_eq_one_iff : a * b * a⁻¹ = 1 ↔ b = 1 
goal: a * b * a⁻¹ = 1 ↔ b = 1

full_name: conj_eq_zero_iff
code: @[to_additive (attr := simp)]
theorem conj_eq_one_iff : a * b * a⁻¹ = 1 ↔ b = 1 
goal: a + b + -a = 0 ↔ b = 0

full_name: sub_left_injective
code: @[to_additive]
theorem div_left_injective : Function.Injective fun a ↦ a / b 
goal: Function.Injective fun a => a - b

full_name: div_left_injective
code: @[to_additive]
theorem div_left_injective : Function.Injective fun a ↦ a / b 
goal: Function.Injective fun a => a / b

full_name: div_right_injective
code: @[to_additive]
theorem div_right_injective : Function.Injective fun a ↦ b / a 
goal: Function.Injective fun a => b / a

full_name: sub_right_injective
code: @[to_additive]
theorem div_right_injective : Function.Injective fun a ↦ b / a 
goal: Function.Injective fun a => b - a

full_name: div_mul_cancel
code: @[to_additive (attr := simp)]
theorem div_mul_cancel (a b : G) : a / b * b = a 
goal: a / b * b = a

full_name: sub_add_cancel
code: @[to_additive (attr := simp)]
theorem div_mul_cancel (a b : G) : a / b * b = a 
goal: a - b + b = a

full_name: div_self'
code: @[to_additive (attr := simp) sub_self]
theorem div_self' (a : G) : a / a = 1 
goal: a / a = 1

full_name: sub_self
code: @[to_additive (attr := simp) sub_self]
theorem div_self' (a : G) : a / a = 1 
goal: a - a = 0

full_name: mul_div_cancel_right
code: @[to_additive (attr := simp)]
theorem mul_div_cancel_right (a b : G) : a * b / b = a 
goal: a * b / b = a

full_name: add_sub_cancel_right
code: @[to_additive (attr := simp)]
theorem mul_div_cancel_right (a b : G) : a * b / b = a 
goal: a + b - b = a

full_name: div_mul_cancel_right
code: @[to_additive (attr := simp)]
lemma div_mul_cancel_right (a b : G) : a / (b * a) = b⁻¹ 
goal: a / (b * a) = b⁻¹

full_name: sub_add_cancel_right
code: @[to_additive (attr := simp)]
lemma div_mul_cancel_right (a b : G) : a / (b * a) = b⁻¹ 
goal: a - (b + a) = -b

full_name: add_sub_add_right_eq_sub
code: @[to_additive (attr := simp)]
theorem mul_div_mul_right_eq_div (a b c : G) : a * c / (b * c) = a / b 
goal: a + c - (b + c) = a - b

full_name: mul_div_mul_right_eq_div
code: @[to_additive (attr := simp)]
theorem mul_div_mul_right_eq_div (a b c : G) : a * c / (b * c) = a / b 
goal: a * c / (b * c) = a / b

full_name: eq_div_of_mul_eq'
code: @[to_additive eq_sub_of_add_eq]
theorem eq_div_of_mul_eq' (h : a * c = b) : a = b / c 
goal: a = b / c

full_name: eq_sub_of_add_eq
code: @[to_additive eq_sub_of_add_eq]
theorem eq_div_of_mul_eq' (h : a * c = b) : a = b / c 
goal: a = b - c

full_name: sub_eq_of_eq_add
code: @[to_additive sub_eq_of_eq_add]
theorem div_eq_of_eq_mul'' (h : a = c * b) : a / b = c 
goal: a - b = c

full_name: div_eq_of_eq_mul''
code: @[to_additive sub_eq_of_eq_add]
theorem div_eq_of_eq_mul'' (h : a = c * b) : a / b = c 
goal: a / b = c

full_name: eq_mul_of_div_eq
code: @[to_additive]
theorem eq_mul_of_div_eq (h : a / c = b) : a = b * c 
goal: a = b * c

full_name: eq_add_of_sub_eq
code: @[to_additive]
theorem eq_mul_of_div_eq (h : a / c = b) : a = b * c 
goal: a = b + c

full_name: mul_eq_of_eq_div
code: @[to_additive]
theorem mul_eq_of_eq_div (h : a = c / b) : a * b = c 
goal: a * b = c

full_name: add_eq_of_eq_sub
code: @[to_additive]
theorem mul_eq_of_eq_div (h : a = c / b) : a * b = c 
goal: a + b = c

full_name: div_right_inj
code: @[to_additive (attr := simp)]
theorem div_right_inj : a / b = a / c ↔ b = c 
goal: a / b = a / c ↔ b = c

full_name: sub_right_inj
code: @[to_additive (attr := simp)]
theorem div_right_inj : a / b = a / c ↔ b = c 
goal: a - b = a - c ↔ b = c

full_name: sub_left_inj
code: @[to_additive (attr := simp)]
theorem div_left_inj : b / a = c / a ↔ b = c 
goal: b - a = c - a ↔ b = c

full_name: div_left_inj
code: @[to_additive (attr := simp)]
theorem div_left_inj : b / a = c / a ↔ b = c 
goal: b / a = c / a ↔ b = c

full_name: sub_add_sub_cancel
code: @[to_additive (attr := simp) sub_add_sub_cancel]
theorem div_mul_div_cancel' (a b c : G) : a / b * (b / c) = a / c 
goal: a - b + (b - c) = a - c

full_name: div_mul_div_cancel'
code: @[to_additive (attr := simp) sub_add_sub_cancel]
theorem div_mul_div_cancel' (a b c : G) : a / b * (b / c) = a / c 
goal: a / b * (b / c) = a / c

full_name: sub_sub_sub_cancel_right
code: @[to_additive (attr := simp) sub_sub_sub_cancel_right]
theorem div_div_div_cancel_right' (a b c : G) : a / c / (b / c) = a / b 
goal: a - c - (b - c) = a - b

full_name: div_div_div_cancel_right'
code: @[to_additive (attr := simp) sub_sub_sub_cancel_right]
theorem div_div_div_cancel_right' (a b c : G) : a / c / (b / c) = a / b 
goal: a / c / (b / c) = a / b

full_name: sub_eq_zero
code: @[to_additive]
theorem div_eq_one : a / b = 1 ↔ a = b 
goal: a - b = 0 ↔ a = b

full_name: div_eq_one
code: @[to_additive]
theorem div_eq_one : a / b = 1 ↔ a = b 
goal: a / b = 1 ↔ a = b

full_name: div_ne_one
code: @[to_additive]
theorem div_ne_one : a / b ≠ 1 ↔ a ≠ b 
goal: a / b ≠ 1 ↔ a ≠ b

full_name: sub_ne_zero
code: @[to_additive]
theorem div_ne_one : a / b ≠ 1 ↔ a ≠ b 
goal: a - b ≠ 0 ↔ a ≠ b

full_name: sub_eq_self
code: @[to_additive (attr := simp)]
theorem div_eq_self : a / b = a ↔ b = 1 
goal: a - b = a ↔ b = 0

full_name: div_eq_self
code: @[to_additive (attr := simp)]
theorem div_eq_self : a / b = a ↔ b = 1 
goal: a / b = a ↔ b = 1

full_name: eq_sub_iff_add_eq
code: @[to_additive eq_sub_iff_add_eq]
theorem eq_div_iff_mul_eq' : a = b / c ↔ a * c = b 
goal: a = b - c ↔ a + c = b

full_name: eq_div_iff_mul_eq'
code: @[to_additive eq_sub_iff_add_eq]
theorem eq_div_iff_mul_eq' : a = b / c ↔ a * c = b 
goal: a = b / c ↔ a * c = b

full_name: div_eq_iff_eq_mul
code: @[to_additive]
theorem div_eq_iff_eq_mul : a / b = c ↔ a = c * b 
goal: a / b = c ↔ a = c * b

full_name: sub_eq_iff_eq_add
code: @[to_additive]
theorem div_eq_iff_eq_mul : a / b = c ↔ a = c * b 
goal: a - b = c ↔ a = c + b

full_name: eq_iff_eq_of_sub_eq_sub
code: @[to_additive]
theorem eq_iff_eq_of_div_eq_div (H : a / b = c / d) : a = b ↔ c = d 
goal: a = b ↔ c = d

full_name: eq_iff_eq_of_div_eq_div
code: @[to_additive]
theorem eq_iff_eq_of_div_eq_div (H : a / b = c / d) : a = b ↔ c = d 
goal: a = b ↔ c = d

full_name: leftInverse_sub_add_left
code: @[to_additive]
theorem leftInverse_div_mul_left (c : G) : Function.LeftInverse (fun x ↦ x / c) fun x ↦ x * c 
goal: Function.LeftInverse (fun x => x - c) fun x => x + c

full_name: leftInverse_div_mul_left
code: @[to_additive]
theorem leftInverse_div_mul_left (c : G) : Function.LeftInverse (fun x ↦ x / c) fun x ↦ x * c 
goal: Function.LeftInverse (fun x => x / c) fun x => x * c

full_name: leftInverse_mul_left_div
code: @[to_additive]
theorem leftInverse_mul_left_div (c : G) : Function.LeftInverse (fun x ↦ x * c) fun x ↦ x / c 
goal: Function.LeftInverse (fun x => x * c) fun x => x / c

full_name: leftInverse_add_left_sub
code: @[to_additive]
theorem leftInverse_mul_left_div (c : G) : Function.LeftInverse (fun x ↦ x * c) fun x ↦ x / c 
goal: Function.LeftInverse (fun x => x + c) fun x => x - c

full_name: leftInverse_add_right_neg_add
code: @[to_additive]
theorem leftInverse_mul_right_inv_mul (c : G) :
    Function.LeftInverse (fun x ↦ c * x) fun x ↦ c⁻¹ * x 
goal: Function.LeftInverse (fun x => c + x) fun x => -c + x

full_name: leftInverse_mul_right_inv_mul
code: @[to_additive]
theorem leftInverse_mul_right_inv_mul (c : G) :
    Function.LeftInverse (fun x ↦ c * x) fun x ↦ c⁻¹ * x 
goal: Function.LeftInverse (fun x => c * x) fun x => c⁻¹ * x

full_name: leftInverse_inv_mul_mul_right
code: @[to_additive]
theorem leftInverse_inv_mul_mul_right (c : G) :
    Function.LeftInverse (fun x ↦ c⁻¹ * x) fun x ↦ c * x 
goal: Function.LeftInverse (fun x => c⁻¹ * x) fun x => c * x

full_name: leftInverse_neg_add_add_right
code: @[to_additive]
theorem leftInverse_inv_mul_mul_right (c : G) :
    Function.LeftInverse (fun x ↦ c⁻¹ * x) fun x ↦ c * x 
goal: Function.LeftInverse (fun x => -c + x) fun x => c + x

full_name: pow_natAbs_eq_one
code: @[to_additive (attr := simp) natAbs_nsmul_eq_zero]
lemma pow_natAbs_eq_one : a ^ n.natAbs = 1 ↔ a ^ n = 1 
goal: a ^ n.natAbs = 1 ↔ a ^ n = 1

full_name: natAbs_nsmul_eq_zero
code: @[to_additive (attr := simp) natAbs_nsmul_eq_zero]
lemma pow_natAbs_eq_one : a ^ n.natAbs = 1 ↔ a ^ n = 1 
goal: n.natAbs • a = 0 ↔ n • a = 0

full_name: exists_nsmul_eq_zero_of_zsmul_eq_zero
code: @[to_additive, deprecated pow_natAbs_eq_one (since := "2024-02-14")]
lemma exists_pow_eq_one_of_zpow_eq_one (hn : n ≠ 0) (h : a ^ n = 1) :
    ∃ n : ℕ, 0 < n ∧ a ^ n = 1 
goal: ∃ n, 0 < n ∧ n • a = 0

full_name: exists_pow_eq_one_of_zpow_eq_one
code: @[to_additive, deprecated pow_natAbs_eq_one (since := "2024-02-14")]
lemma exists_pow_eq_one_of_zpow_eq_one (hn : n ≠ 0) (h : a ^ n = 1) :
    ∃ n : ℕ, 0 < n ∧ a ^ n = 1 
goal: ∃ n, 0 < n ∧ a ^ n = 1

full_name: sub_nsmul
code: @[to_additive sub_nsmul]
lemma pow_sub (a : G) {m n : ℕ} (h : n ≤ m) : a ^ (m - n) = a ^ m * (a ^ n)⁻¹ 
goal: (m - n) • a = m • a + -(n • a)

full_name: pow_sub
code: @[to_additive sub_nsmul]
lemma pow_sub (a : G) {m n : ℕ} (h : n ≤ m) : a ^ (m - n) = a ^ m * (a ^ n)⁻¹ 
goal: a ^ (m - n) = a ^ m * (a ^ n)⁻¹

full_name: inv_pow_sub
code: @[to_additive sub_nsmul_neg]
theorem inv_pow_sub (a : G) {m n : ℕ} (h : n ≤ m) : a⁻¹ ^ (m - n) = (a ^ m)⁻¹ * a ^ n 
goal: a⁻¹ ^ (m - n) = (a ^ m)⁻¹ * a ^ n

full_name: sub_nsmul_neg
code: @[to_additive sub_nsmul_neg]
theorem inv_pow_sub (a : G) {m n : ℕ} (h : n ≤ m) : a⁻¹ ^ (m - n) = (a ^ m)⁻¹ * a ^ n 
goal: (m - n) • -a = -(m • a) + n • a

full_name: add_one_zsmul
code: @[to_additive add_one_zsmul]
lemma zpow_add_one (a : G) : ∀ n : ℤ, a ^ (n + 1) = a ^ n * a
  
goal: (n + 1) • a = n • a + a

full_name: zpow_add_one
code: @[to_additive add_one_zsmul]
lemma zpow_add_one (a : G) : ∀ n : ℤ, a ^ (n + 1) = a ^ n * a
  
goal: a ^ (n + 1) = a ^ n * a

full_name: sub_one_zsmul
code: @[to_additive sub_one_zsmul]
lemma zpow_sub_one (a : G) (n : ℤ) : a ^ (n - 1) = a ^ n * a⁻¹ 
goal: (n - 1) • a = n • a + -a

full_name: zpow_sub_one
code: @[to_additive sub_one_zsmul]
lemma zpow_sub_one (a : G) (n : ℤ) : a ^ (n - 1) = a ^ n * a⁻¹ 
goal: a ^ (n - 1) = a ^ n * a⁻¹

full_name: zpow_add
code: @[to_additive add_zsmul]
lemma zpow_add (a : G) (m n : ℤ) : a ^ (m + n) = a ^ m * a ^ n 
goal: a ^ (m + n) = a ^ m * a ^ n

full_name: add_zsmul
code: @[to_additive add_zsmul]
lemma zpow_add (a : G) (m n : ℤ) : a ^ (m + n) = a ^ m * a ^ n 
goal: (m + n) • a = m • a + n • a

full_name: zpow_one_add
code: @[to_additive one_add_zsmul]
lemma zpow_one_add (a : G) (n : ℤ) : a ^ (1 + n) = a * a ^ n 
goal: a ^ (1 + n) = a * a ^ n

full_name: one_add_zsmul
code: @[to_additive one_add_zsmul]
lemma zpow_one_add (a : G) (n : ℤ) : a ^ (1 + n) = a * a ^ n 
goal: (1 + n) • a = a + n • a

full_name: mul_self_zpow
code: @[to_additive add_zsmul_self]
lemma mul_self_zpow (a : G) (n : ℤ) : a * a ^ n = a ^ (n + 1) 
goal: a * a ^ n = a ^ (n + 1)

full_name: add_zsmul_self
code: @[to_additive add_zsmul_self]
lemma mul_self_zpow (a : G) (n : ℤ) : a * a ^ n = a ^ (n + 1) 
goal: a + n • a = (n + 1) • a

full_name: add_self_zsmul
code: @[to_additive add_self_zsmul]
lemma mul_zpow_self (a : G) (n : ℤ) : a ^ n * a = a ^ (n + 1) 
goal: n • a + a = (n + 1) • a

full_name: mul_zpow_self
code: @[to_additive add_self_zsmul]
lemma mul_zpow_self (a : G) (n : ℤ) : a ^ n * a = a ^ (n + 1) 
goal: a ^ n * a = a ^ (n + 1)

full_name: sub_zsmul
code: @[to_additive sub_zsmul] lemma zpow_sub (a : G) (m n : ℤ) : a ^ (m - n) = a ^ m * (a ^ n)⁻¹ 
goal: (m - n) • a = m • a + -(n • a)

full_name: zpow_sub
code: @[to_additive sub_zsmul] lemma zpow_sub (a : G) (m n : ℤ) : a ^ (m - n) = a ^ m * (a ^ n)⁻¹ 
goal: a ^ (m - n) = a ^ m * (a ^ n)⁻¹

full_name: zsmul_add_comm
code: @[to_additive] lemma zpow_mul_comm (a : G) (m n : ℤ) : a ^ m * a ^ n = a ^ n * a ^ m 
goal: m • a + n • a = n • a + m • a

full_name: zpow_mul_comm
code: @[to_additive] lemma zpow_mul_comm (a : G) (m n : ℤ) : a ^ m * a ^ n = a ^ n * a ^ m 
goal: a ^ m * a ^ n = a ^ n * a ^ m

full_name: zpow_eq_zpow_emod
code: theorem zpow_eq_zpow_emod {x : G} (m : ℤ) {n : ℤ} (h : x ^ n = 1) :
    x ^ m = x ^ (m % n) 
goal: x ^ m = x ^ (m % n)

full_name: zpow_eq_zpow_emod'
code: theorem zpow_eq_zpow_emod' {x : G} (m : ℤ) {n : ℕ} (h : x ^ n = 1) :
    x ^ m = x ^ (m % (n : ℤ)) 
goal: x ^ m = x ^ (m % ↑n)

full_name: zsmul_induction_left
code: /-- To show a property of all powers of `g` it suffices to show it is closed under multiplication
by `g` and `g⁻¹` on the left. For subgroups generated by more than one element, see
`Subgroup.closure_induction_left`. -/
@[to_additive "To show a property of all multiples of `g` it suffices to show it is closed under
addition by `g` and `-g` on the left. For additive subgroups generated by more than one element, see
`AddSubgroup.closure_induction_left`."]
lemma zpow_induction_left {g : G} {P : G → Prop} (h_one : P (1 : G))
    (h_mul : ∀ a, P a → P (g * a)) (h_inv : ∀ a, P a → P (g⁻¹ * a)) (n : ℤ) : P (g ^ n) 
goal: P (n • g)

full_name: zpow_induction_left
code: /-- To show a property of all powers of `g` it suffices to show it is closed under multiplication
by `g` and `g⁻¹` on the left. For subgroups generated by more than one element, see
`Subgroup.closure_induction_left`. -/
@[to_additive "To show a property of all multiples of `g` it suffices to show it is closed under
addition by `g` and `-g` on the left. For additive subgroups generated by more than one element, see
`AddSubgroup.closure_induction_left`."]
lemma zpow_induction_left {g : G} {P : G → Prop} (h_one : P (1 : G))
    (h_mul : ∀ a, P a → P (g * a)) (h_inv : ∀ a, P a → P (g⁻¹ * a)) (n : ℤ) : P (g ^ n) 
goal: P (g ^ n)

full_name: zsmul_induction_right
code: /-- To show a property of all powers of `g` it suffices to show it is closed under multiplication
by `g` and `g⁻¹` on the right. For subgroups generated by more than one element, see
`Subgroup.closure_induction_right`. -/
@[to_additive "To show a property of all multiples of `g` it suffices to show it is closed under
addition by `g` and `-g` on the right. For additive subgroups generated by more than one element,
see `AddSubgroup.closure_induction_right`."]
lemma zpow_induction_right {g : G} {P : G → Prop} (h_one : P (1 : G))
    (h_mul : ∀ a, P a → P (a * g)) (h_inv : ∀ a, P a → P (a * g⁻¹)) (n : ℤ) : P (g ^ n) 
goal: P (n • g)

full_name: zpow_induction_right
code: /-- To show a property of all powers of `g` it suffices to show it is closed under multiplication
by `g` and `g⁻¹` on the right. For subgroups generated by more than one element, see
`Subgroup.closure_induction_right`. -/
@[to_additive "To show a property of all multiples of `g` it suffices to show it is closed under
addition by `g` and `-g` on the right. For additive subgroups generated by more than one element,
see `AddSubgroup.closure_induction_right`."]
lemma zpow_induction_right {g : G} {P : G → Prop} (h_one : P (1 : G))
    (h_mul : ∀ a, P a → P (a * g)) (h_inv : ∀ a, P a → P (a * g⁻¹)) (n : ℤ) : P (g ^ n) 
goal: P (g ^ n)

full_name: div_eq_of_eq_mul'
code: @[to_additive]
theorem div_eq_of_eq_mul' {a b c : G} (h : a = b * c) : a / b = c 
goal: a / b = c

full_name: sub_eq_of_eq_add'
code: @[to_additive]
theorem div_eq_of_eq_mul' {a b c : G} (h : a = b * c) : a / b = c 
goal: a - b = c

full_name: add_sub_add_left_eq_sub
code: @[to_additive (attr := simp)]
theorem mul_div_mul_left_eq_div (a b c : G) : c * a / (c * b) = a / b 
goal: c + a - (c + b) = a - b

full_name: mul_div_mul_left_eq_div
code: @[to_additive (attr := simp)]
theorem mul_div_mul_left_eq_div (a b c : G) : c * a / (c * b) = a / b 
goal: c * a / (c * b) = a / b

full_name: eq_div_of_mul_eq''
code: @[to_additive eq_sub_of_add_eq']
theorem eq_div_of_mul_eq'' (h : c * a = b) : a = b / c 
goal: a = b / c

full_name: eq_sub_of_add_eq'
code: @[to_additive eq_sub_of_add_eq']
theorem eq_div_of_mul_eq'' (h : c * a = b) : a = b / c 
goal: a = b - c

full_name: eq_add_of_sub_eq'
code: @[to_additive]
theorem eq_mul_of_div_eq' (h : a / b = c) : a = b * c 
goal: a = b + c

full_name: eq_mul_of_div_eq'
code: @[to_additive]
theorem eq_mul_of_div_eq' (h : a / b = c) : a = b * c 
goal: a = b * c

full_name: mul_eq_of_eq_div'
code: @[to_additive]
theorem mul_eq_of_eq_div' (h : b = c / a) : a * b = c 
goal: a * b = c

full_name: add_eq_of_eq_sub'
code: @[to_additive]
theorem mul_eq_of_eq_div' (h : b = c / a) : a * b = c 
goal: a + b = c

full_name: sub_sub_self
code: @[to_additive sub_sub_self]
theorem div_div_self' (a b : G) : a / (a / b) = b 
goal: a - (a - b) = b

full_name: div_div_self'
code: @[to_additive sub_sub_self]
theorem div_div_self' (a b : G) : a / (a / b) = b 
goal: a / (a / b) = b

full_name: sub_eq_sub_add_sub
code: @[to_additive]
theorem div_eq_div_mul_div (a b c : G) : a / b = c / b * (a / c) 
goal: a - b = c - b + (a - c)

full_name: div_eq_div_mul_div
code: @[to_additive]
theorem div_eq_div_mul_div (a b c : G) : a / b = c / b * (a / c) 
goal: a / b = c / b * (a / c)

full_name: sub_sub_cancel
code: @[to_additive (attr := simp)]
theorem div_div_cancel (a b : G) : a / (a / b) = b 
goal: a - (a - b) = b

full_name: div_div_cancel
code: @[to_additive (attr := simp)]
theorem div_div_cancel (a b : G) : a / (a / b) = b 
goal: a / (a / b) = b

full_name: div_div_cancel_left
code: @[to_additive (attr := simp)]
theorem div_div_cancel_left (a b : G) : a / b / a = b⁻¹ 
goal: a / b / a = b⁻¹

full_name: sub_sub_cancel_left
code: @[to_additive (attr := simp)]
theorem div_div_cancel_left (a b : G) : a / b / a = b⁻¹ 
goal: a - b - a = -b

full_name: eq_div_iff_mul_eq''
code: @[to_additive eq_sub_iff_add_eq']
theorem eq_div_iff_mul_eq'' : a = b / c ↔ c * a = b 
goal: a = b / c ↔ c * a = b

full_name: eq_sub_iff_add_eq'
code: @[to_additive eq_sub_iff_add_eq']
theorem eq_div_iff_mul_eq'' : a = b / c ↔ c * a = b 
goal: a = b - c ↔ c + a = b

full_name: sub_eq_iff_eq_add'
code: @[to_additive]
theorem div_eq_iff_eq_mul' : a / b = c ↔ a = b * c 
goal: a - b = c ↔ a = b + c

full_name: div_eq_iff_eq_mul'
code: @[to_additive]
theorem div_eq_iff_eq_mul' : a / b = c ↔ a = b * c 
goal: a / b = c ↔ a = b * c

full_name: add_sub_cancel_left
code: @[to_additive (attr := simp)]
theorem mul_div_cancel_left (a b : G) : a * b / a = b 
goal: a + b - a = b

full_name: mul_div_cancel_left
code: @[to_additive (attr := simp)]
theorem mul_div_cancel_left (a b : G) : a * b / a = b 
goal: a * b / a = b

full_name: mul_div_cancel
code: @[to_additive (attr := simp)]
theorem mul_div_cancel (a b : G) : a * (b / a) = b 
goal: a * (b / a) = b

full_name: add_sub_cancel
code: @[to_additive (attr := simp)]
theorem mul_div_cancel (a b : G) : a * (b / a) = b 
goal: a + (b - a) = b

full_name: div_mul_cancel_left
code: @[to_additive (attr := simp)]
theorem div_mul_cancel_left (a b : G) : a / (a * b) = b⁻¹ 
goal: a / (a * b) = b⁻¹

full_name: sub_add_cancel_left
code: @[to_additive (attr := simp)]
theorem div_mul_cancel_left (a b : G) : a / (a * b) = b⁻¹ 
goal: a - (a + b) = -b

full_name: add_add_neg_cancel'_right
code: @[to_additive]
theorem mul_mul_inv_cancel'_right (a b : G) : a * (b * a⁻¹) = b 
goal: a + (b + -a) = b

full_name: mul_mul_inv_cancel'_right
code: @[to_additive]
theorem mul_mul_inv_cancel'_right (a b : G) : a * (b * a⁻¹) = b 
goal: a * (b * a⁻¹) = b

full_name: add_add_sub_cancel
code: @[to_additive (attr := simp)]
theorem mul_mul_div_cancel (a b c : G) : a * c * (b / c) = a * b 
goal: a + c + (b - c) = a + b

full_name: mul_mul_div_cancel
code: @[to_additive (attr := simp)]
theorem mul_mul_div_cancel (a b c : G) : a * c * (b / c) = a * b 
goal: a * c * (b / c) = a * b

full_name: div_mul_mul_cancel
code: @[to_additive (attr := simp)]
theorem div_mul_mul_cancel (a b c : G) : a / c * (b * c) = a * b 
goal: a / c * (b * c) = a * b

full_name: sub_add_add_cancel
code: @[to_additive (attr := simp)]
theorem div_mul_mul_cancel (a b c : G) : a / c * (b * c) = a * b 
goal: a - c + (b + c) = a + b

full_name: sub_add_sub_cancel'
code: @[to_additive (attr := simp) sub_add_sub_cancel']
theorem div_mul_div_cancel'' (a b c : G) : a / b * (c / a) = c / b 
goal: a - b + (c - a) = c - b

full_name: div_mul_div_cancel''
code: @[to_additive (attr := simp) sub_add_sub_cancel']
theorem div_mul_div_cancel'' (a b c : G) : a / b * (c / a) = c / b 
goal: a / b * (c / a) = c / b

full_name: mul_div_div_cancel
code: @[to_additive (attr := simp)]
theorem mul_div_div_cancel (a b c : G) : a * b / (a / c) = b * c 
goal: a * b / (a / c) = b * c

full_name: add_sub_sub_cancel
code: @[to_additive (attr := simp)]
theorem mul_div_div_cancel (a b c : G) : a * b / (a / c) = b * c 
goal: a + b - (a - c) = b + c

full_name: div_div_div_cancel_left
code: @[to_additive (attr := simp)]
theorem div_div_div_cancel_left (a b c : G) : c / a / (c / b) = b / a 
goal: c / a / (c / b) = b / a

full_name: sub_sub_sub_cancel_left
code: @[to_additive (attr := simp)]
theorem div_div_div_cancel_left (a b c : G) : c / a / (c / b) = b / a 
goal: c - a - (c - b) = b - a

full_name: div_eq_div_iff_mul_eq_mul
code: @[to_additive]
theorem div_eq_div_iff_mul_eq_mul : a / b = c / d ↔ a * d = c * b 
goal: a / b = c / d ↔ a * d = c * b

full_name: sub_eq_sub_iff_add_eq_add
code: @[to_additive]
theorem div_eq_div_iff_mul_eq_mul : a / b = c / d ↔ a * d = c * b 
goal: a - b = c - d ↔ a + d = c + b

full_name: sub_eq_sub_iff_sub_eq_sub
code: @[to_additive]
theorem div_eq_div_iff_div_eq_div : a / b = c / d ↔ a / c = b / d 
goal: a - b = c - d ↔ a - c = b - d

full_name: div_eq_div_iff_div_eq_div
code: @[to_additive]
theorem div_eq_div_iff_div_eq_div : a / b = c / d ↔ a / c = b / d 
goal: a / b = c / d ↔ a / c = b / d

full_name: multiplicative_of_symmetric_of_isTotal
code: @[to_additive additive_of_symmetric_of_isTotal]
lemma multiplicative_of_symmetric_of_isTotal
    (hsymm : Symmetric p) (hf_swap : ∀ {a b}, p a b → f a b * f b a = 1)
    (hmul : ∀ {a b c}, r a b → r b c → p a b → p b c → p a c → f a c = f a b * f b c)
    {a b c : α} (pab : p a b) (pbc : p b c) (pac : p a c) : f a c = f a b * f b c 
goal: f a c = f a b * f b c

full_name: additive_of_symmetric_of_isTotal
code: @[to_additive additive_of_symmetric_of_isTotal]
lemma multiplicative_of_symmetric_of_isTotal
    (hsymm : Symmetric p) (hf_swap : ∀ {a b}, p a b → f a b * f b a = 1)
    (hmul : ∀ {a b c}, r a b → r b c → p a b → p b c → p a c → f a c = f a b * f b c)
    {a b c : α} (pab : p a b) (pbc : p b c) (pac : p a c) : f a c = f a b * f b c 
goal: f a c = f a b + f b c

full_name: additive_of_isTotal
code: /-- If a binary function from a type equipped with a total relation `r` to a monoid is
  anti-symmetric (i.e. satisfies `f a b * f b a = 1`), in order to show it is multiplicative
  (i.e. satisfies `f a c = f a b * f b c`), we may assume `r a b` and `r b c` are satisfied.
  We allow restricting to a subset specified by a predicate `p`. -/
@[to_additive additive_of_isTotal "If a binary function from a type equipped with a total relation
`r` to an additive monoid is anti-symmetric (i.e. satisfies `f a b + f b a = 0`), in order to show
it is additive (i.e. satisfies `f a c = f a b + f b c`), we may assume `r a b` and `r b c` are
satisfied. We allow restricting to a subset specified by a predicate `p`."]
theorem multiplicative_of_isTotal (p : α → Prop) (hswap : ∀ {a b}, p a → p b → f a b * f b a = 1)
    (hmul : ∀ {a b c}, r a b → r b c → p a → p b → p c → f a c = f a b * f b c) {a b c : α}
    (pa : p a) (pb : p b) (pc : p c) : f a c = f a b * f b c 
goal: f a c = f a b + f b c

full_name: multiplicative_of_isTotal
code: /-- If a binary function from a type equipped with a total relation `r` to a monoid is
  anti-symmetric (i.e. satisfies `f a b * f b a = 1`), in order to show it is multiplicative
  (i.e. satisfies `f a c = f a b * f b c`), we may assume `r a b` and `r b c` are satisfied.
  We allow restricting to a subset specified by a predicate `p`. -/
@[to_additive additive_of_isTotal "If a binary function from a type equipped with a total relation
`r` to an additive monoid is anti-symmetric (i.e. satisfies `f a b + f b a = 0`), in order to show
it is additive (i.e. satisfies `f a c = f a b + f b c`), we may assume `r a b` and `r b c` are
satisfied. We allow restricting to a subset specified by a predicate `p`."]
theorem multiplicative_of_isTotal (p : α → Prop) (hswap : ∀ {a b}, p a → p b → f a b * f b a = 1)
    (hmul : ∀ {a b c}, r a b → r b c → p a → p b → p c → f a c = f a b * f b c) {a b c : α}
    (pa : p a) (pb : p b) (pc : p c) : f a c = f a b * f b c 
goal: f a c = f a b * f b c