ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Units.inv_mul_cancel_left
@[to_additive (attr := simp)]
theorem inv_mul_cancel_left (a : αˣ) (b : α) : (↑a⁻¹ : α) * (a * b) = b 
Arguments: {α : Type u} [Monoid α] (a : αˣ) (b : α)
Goal: ↑a⁻¹ * (↑a * b) = b
-- Units.mul_inv_cancel_right
@[to_additive (attr := simp)]
theorem mul_inv_cancel_right (a : α) (b : αˣ) : a * b * ↑b⁻¹ = a 
Arguments: {α : Type u} [Monoid α] (a : α) (b : αˣ)
Goal: a * ↑b * ↑b⁻¹ = a
-- AddUnits.add_neg_cancel_right
@[to_additive (attr := simp)]
theorem mul_inv_cancel_right (a : α) (b : αˣ) : a * b * ↑b⁻¹ = a 
Arguments: {α : Type u} [AddMonoid α] (a : α) (b : AddUnits α)
Goal: a + ↑b + ↑(-b) = a
-- Units.inv_mul_cancel_right
@[to_additive (attr := simp)]
theorem inv_mul_cancel_right (a : α) (b : αˣ) : a * ↑b⁻¹ * b = a 
Arguments: {α : Type u} [Monoid α] (a : α) (b : αˣ)
Goal: a * ↑b⁻¹ * ↑b = a
-- AddUnits.neg_add_cancel_right
@[to_additive (attr := simp)]
theorem inv_mul_cancel_right (a : α) (b : αˣ) : a * ↑b⁻¹ * b = a 
Arguments: {α : Type u} [AddMonoid α] (a : α) (b : AddUnits α)
Goal: a + ↑(-b) + ↑b = a
-- Units.mul_right_inj
@[to_additive (attr := simp)]
theorem mul_right_inj (a : αˣ) {b c : α} : (a : α) * b = a * c ↔ b = c 
Arguments: {α : Type u} [Monoid α] (a : αˣ) {b c : α}
Goal: ↑a * b = ↑a * c ↔ b = c
-- AddUnits.add_right_inj
@[to_additive (attr := simp)]
theorem mul_right_inj (a : αˣ) {b c : α} : (a : α) * b = a * c ↔ b = c 
Arguments: {α : Type u} [AddMonoid α] (a : AddUnits α) {b c : α}
Goal: ↑a + b = ↑a + c ↔ b = c
-- Units.mul_left_inj
@[to_additive (attr := simp)]
theorem mul_left_inj (a : αˣ) {b c : α} : b * a = c * a ↔ b = c 
Arguments: {α : Type u} [Monoid α] (a : αˣ) {b c : α}
Goal: b * ↑a = c * ↑a ↔ b = c
-- AddUnits.add_left_inj
@[to_additive (attr := simp)]
theorem mul_left_inj (a : αˣ) {b c : α} : b * a = c * a ↔ b = c 
Arguments: {α : Type u} [AddMonoid α] (a : AddUnits α) {b c : α}
Goal: b + ↑a = c + ↑a ↔ b = c
-- Units.eq_mul_inv_iff_mul_eq
@[to_additive]
theorem eq_mul_inv_iff_mul_eq {a b : α} : a = b * ↑c⁻¹ ↔ a * c = b 
Arguments: {α : Type u} [Monoid α] (c : αˣ) {a b : α}
Goal: a = b * ↑c⁻¹ ↔ a * ↑c = b
-- AddUnits.eq_add_neg_iff_add_eq
@[to_additive]
theorem eq_mul_inv_iff_mul_eq {a b : α} : a = b * ↑c⁻¹ ↔ a * c = b 
Arguments: {α : Type u} [AddMonoid α] (c : AddUnits α) {a b : α}
Goal: a = b + ↑(-c) ↔ a + ↑c = b
-- Units.eq_inv_mul_iff_mul_eq
@[to_additive]
theorem eq_inv_mul_iff_mul_eq {a c : α} : a = ↑b⁻¹ * c ↔ ↑b * a = c 
Arguments: {α : Type u} [Monoid α] (b : αˣ) {a c : α}
Goal: a = ↑b⁻¹ * c ↔ ↑b * a = c
-- AddUnits.eq_neg_add_iff_add_eq
@[to_additive]
theorem eq_inv_mul_iff_mul_eq {a c : α} : a = ↑b⁻¹ * c ↔ ↑b * a = c 
Arguments: {α : Type u} [AddMonoid α] (b : AddUnits α) {a c : α}
Goal: a = ↑(-b) + c ↔ ↑b + a = c
-- Units.inv_mul_eq_iff_eq_mul
@[to_additive]
theorem inv_mul_eq_iff_eq_mul {b c : α} : ↑a⁻¹ * b = c ↔ b = a * c 
Arguments: {α : Type u} [Monoid α] (a : αˣ) {b c : α}
Goal: ↑a⁻¹ * b = c ↔ b = ↑a * c
-- AddUnits.neg_add_eq_iff_eq_add
@[to_additive]
theorem inv_mul_eq_iff_eq_mul {b c : α} : ↑a⁻¹ * b = c ↔ b = a * c 
Arguments: {α : Type u} [AddMonoid α] (a : AddUnits α) {b c : α}
Goal: ↑(-a) + b = c ↔ b = ↑a + c
-- Units.mul_inv_eq_iff_eq_mul
@[to_additive]
theorem mul_inv_eq_iff_eq_mul {a c : α} : a * ↑b⁻¹ = c ↔ a = c * b 
Arguments: {α : Type u} [Monoid α] (b : αˣ) {a c : α}
Goal: a * ↑b⁻¹ = c ↔ a = c * ↑b
-- AddUnits.add_neg_eq_iff_eq_add
@[to_additive]
theorem mul_inv_eq_iff_eq_mul {a c : α} : a * ↑b⁻¹ = c ↔ a = c * b 
Arguments: {α : Type u} [AddMonoid α] (b : AddUnits α) {a c : α}
Goal: a + ↑(-b) = c ↔ a = c + ↑b
-- AddUnits.neg_eq_of_add_eq_zero_left
@[to_additive]
protected theorem inv_eq_of_mul_eq_one_left {a : α} (h : a * u = 1) : ↑u⁻¹ = a 
Arguments: {α : Type u} [AddMonoid α] {u : AddUnits α} {a : α} (h : a + ↑u = 0)
Goal: ↑(-u) = a
-- Units.inv_eq_of_mul_eq_one_left
@[to_additive]
protected theorem inv_eq_of_mul_eq_one_left {a : α} (h : a * u = 1) : ↑u⁻¹ = a 
Arguments: {α : Type u} [Monoid α] {u : αˣ} {a : α} (h : a * ↑u = 1)
Goal: ↑u⁻¹ = a
-- AddUnits.neg_eq_of_add_eq_zero_right
@[to_additive]
protected theorem inv_eq_of_mul_eq_one_right {a : α} (h : ↑u * a = 1) : ↑u⁻¹ = a 
Arguments: {α : Type u} [AddMonoid α] {u : AddUnits α} {a : α} (h : ↑u + a = 0)
Goal: ↑(-u) = a
-- Units.inv_eq_of_mul_eq_one_right
@[to_additive]
protected theorem inv_eq_of_mul_eq_one_right {a : α} (h : ↑u * a = 1) : ↑u⁻¹ = a 
Arguments: {α : Type u} [Monoid α] {u : αˣ} {a : α} (h : ↑u * a = 1)
Goal: ↑u⁻¹ = a
-- Units.eq_inv_of_mul_eq_one_left
@[to_additive]
protected theorem eq_inv_of_mul_eq_one_left {a : α} (h : ↑u * a = 1) : a = ↑u⁻¹ 
Arguments: {α : Type u} [Monoid α] {u : αˣ} {a : α} (h : ↑u * a = 1)
Goal: a = ↑u⁻¹
-- AddUnits.eq_neg_of_add_eq_zero_left
@[to_additive]
protected theorem eq_inv_of_mul_eq_one_left {a : α} (h : ↑u * a = 1) : a = ↑u⁻¹ 
Arguments: {α : Type u} [AddMonoid α] {u : AddUnits α} {a : α} (h : ↑u + a = 0)
Goal: a = ↑(-u)
-- Units.eq_inv_of_mul_eq_one_right
@[to_additive]
protected theorem eq_inv_of_mul_eq_one_right {a : α} (h : a * u = 1) : a = ↑u⁻¹ 
Arguments: {α : Type u} [Monoid α] {u : αˣ} {a : α} (h : a * ↑u = 1)
Goal: a = ↑u⁻¹
-- AddUnits.eq_neg_of_add_eq_zero_right
@[to_additive]
protected theorem eq_inv_of_mul_eq_one_right {a : α} (h : a * u = 1) : a = ↑u⁻¹ 
Arguments: {α : Type u} [AddMonoid α] {u : AddUnits α} {a : α} (h : a + ↑u = 0)
Goal: a = ↑(-u)
-- Units.val_pow_eq_pow_val
@[to_additive (attr := simp, norm_cast)]
lemma val_pow_eq_pow_val (n : ℕ) : ↑(a ^ n) = (a ^ n : α) 
Arguments: {α : Type u} [Monoid α] (a : αˣ) (n : ℕ)
Goal: ↑(a ^ n) = ↑a ^ n
-- AddUnits.val_nsmul_eq_nsmul_val
@[to_additive (attr := simp, norm_cast)]
lemma val_pow_eq_pow_val (n : ℕ) : ↑(a ^ n) = (a ^ n : α) 
Arguments: {α : Type u} [AddMonoid α] (a : AddUnits α) (n : ℕ)
Goal: ↑(n • a) = n • ↑a
-- AddUnits.add_neg_eq_zero
@[to_additive (attr := simp)]
theorem mul_inv_eq_one {a : α} : a * ↑u⁻¹ = 1 ↔ a = u 
Arguments: {α : Type u} [AddMonoid α] {u : AddUnits α} {a : α}
Goal: a + ↑(-u) = 0 ↔ a = ↑u
-- Units.mul_inv_eq_one
@[to_additive (attr := simp)]
theorem mul_inv_eq_one {a : α} : a * ↑u⁻¹ = 1 ↔ a = u 
Arguments: {α : Type u} [Monoid α] {u : αˣ} {a : α}
Goal: a * ↑u⁻¹ = 1 ↔ a = ↑u
-- AddUnits.neg_add_eq_zero
@[to_additive (attr := simp)]
theorem inv_mul_eq_one {a : α} : ↑u⁻¹ * a = 1 ↔ ↑u = a 
Arguments: {α : Type u} [AddMonoid α] {u : AddUnits α} {a : α}
Goal: ↑(-u) + a = 0 ↔ ↑u = a
-- Units.inv_mul_eq_one
@[to_additive (attr := simp)]
theorem inv_mul_eq_one {a : α} : ↑u⁻¹ * a = 1 ↔ ↑u = a 
Arguments: {α : Type u} [Monoid α] {u : αˣ} {a : α}
Goal: ↑u⁻¹ * a = 1 ↔ ↑u = a
-- AddUnits.add_eq_zero_iff_eq_neg
@[to_additive]
theorem mul_eq_one_iff_eq_inv {a : α} : a * u = 1 ↔ a = ↑u⁻¹ 
Arguments: {α : Type u} [AddMonoid α] {u : AddUnits α} {a : α}
Goal: a + ↑u = 0 ↔ a = ↑(-u)
-- Units.mul_eq_one_iff_eq_inv
@[to_additive]
theorem mul_eq_one_iff_eq_inv {a : α} : a * u = 1 ↔ a = ↑u⁻¹ 
Arguments: {α : Type u} [Monoid α] {u : αˣ} {a : α}
Goal: a * ↑u = 1 ↔ a = ↑u⁻¹
-- Units.mul_eq_one_iff_inv_eq
@[to_additive]
theorem mul_eq_one_iff_inv_eq {a : α} : ↑u * a = 1 ↔ ↑u⁻¹ = a 
Arguments: {α : Type u} [Monoid α] {u : αˣ} {a : α}
Goal: ↑u * a = 1 ↔ ↑u⁻¹ = a
-- AddUnits.add_eq_zero_iff_neg_eq
@[to_additive]
theorem mul_eq_one_iff_inv_eq {a : α} : ↑u * a = 1 ↔ ↑u⁻¹ = a 
Arguments: {α : Type u} [AddMonoid α] {u : AddUnits α} {a : α}
Goal: ↑u + a = 0 ↔ ↑(-u) = a
-- AddUnits.neg_unique
@[to_additive]
theorem inv_unique {u₁ u₂ : αˣ} (h : (↑u₁ : α) = ↑u₂) : (↑u₁⁻¹ : α) = ↑u₂⁻¹ 
Arguments: {α : Type u} [AddMonoid α] {u₁ u₂ : AddUnits α} (h : ↑u₁ = ↑u₂)
Goal: ↑(-u₁) = ↑(-u₂)
-- Units.inv_unique
@[to_additive]
theorem inv_unique {u₁ u₂ : αˣ} (h : (↑u₁ : α) = ↑u₂) : (↑u₁⁻¹ : α) = ↑u₂⁻¹ 
Arguments: {α : Type u} [Monoid α] {u₁ u₂ : αˣ} (h : ↑u₁ = ↑u₂)
Goal: ↑u₁⁻¹ = ↑u₂⁻¹
-- Units.val_inv_eq_inv_val
@[to_additive (attr := simp, norm_cast)] lemma val_inv_eq_inv_val (u : αˣ) : ↑u⁻¹ = (u⁻¹ : α) 
Arguments: {α : Type u} [DivisionMonoid α] (u : αˣ)
Goal: ↑u⁻¹ = (↑u)⁻¹
-- AddUnits.val_neg_eq_neg_val
@[to_additive (attr := simp, norm_cast)] lemma val_inv_eq_inv_val (u : αˣ) : ↑u⁻¹ = (u⁻¹ : α) 
Arguments: {α : Type u} [SubtractionMonoid α] (u : AddUnits α)
Goal: ↑(-u) = -↑u
-- AddUnits.val_sub_eq_sub_val
@[to_additive (attr := simp, norm_cast)]
lemma val_div_eq_div_val : ∀ u₁ u₂ : αˣ, ↑(u₁ / u₂) = (u₁ / u₂ : α) 
Arguments: {α : Type u} [SubtractionMonoid α] (u₁ u₂ : AddUnits α)
Goal: ↑(u₁ - u₂) = ↑u₁ - ↑u₂
-- Units.val_div_eq_div_val
@[to_additive (attr := simp, norm_cast)]
lemma val_div_eq_div_val : ∀ u₁ u₂ : αˣ, ↑(u₁ / u₂) = (u₁ / u₂ : α) 
Arguments: {α : Type u} [DivisionMonoid α] (u₁ u₂ : αˣ)
Goal: ↑(u₁ / u₂) = ↑u₁ / ↑u₂
-- AddUnits.val_mkOfAddEqZero
@[to_additive (attr := simp)]
theorem Units.val_mkOfMulEqOne [CommMonoid α] {a b : α} (h : a * b = 1) :
    (Units.mkOfMulEqOne a b h : α) = a 
Arguments: {α : Type u} [AddCommMonoid α] {a b : α} (h : a + b = 0)
Goal: ↑(AddUnits.mkOfAddEqZero a b h) = a
-- Units.val_mkOfMulEqOne
@[to_additive (attr := simp)]
theorem Units.val_mkOfMulEqOne [CommMonoid α] {a b : α} (h : a * b = 1) :
    (Units.mkOfMulEqOne a b h : α) = a 
Arguments: {α : Type u} [CommMonoid α] {a b : α} (h : a * b = 1)
Goal: ↑(Units.mkOfMulEqOne a b h) = a
-- divp_self
@[simp]
theorem divp_self (u : αˣ) : (u : α) /ₚ u = 1 
Arguments: {α : Type u} [Monoid α] (u : αˣ)
Goal: ↑u /ₚ u = 1
-- divp_one
@[simp]
theorem divp_one (a : α) : a /ₚ 1 = a 
Arguments: {α : Type u} [Monoid α] (a : α)
Goal: a /ₚ 1 = a
-- divp_assoc
theorem divp_assoc (a b : α) (u : αˣ) : a * b /ₚ u = a * (b /ₚ u) 
Arguments: {α : Type u} [Monoid α] (a b : α) (u : αˣ)
Goal: a * b /ₚ u = a * (b /ₚ u)
-- divp_assoc'
@[field_simps]
theorem divp_assoc' (x y : α) (u : αˣ) : x * (y /ₚ u) = x * y /ₚ u 
Arguments: {α : Type u} [Monoid α] (x y : α) (u : αˣ)
Goal: x * (y /ₚ u) = x * y /ₚ u
-- divp_inv
@[simp]
theorem divp_inv (u : αˣ) : a /ₚ u⁻¹ = a * u 
Arguments: {α : Type u} [Monoid α] {a : α} (u : αˣ)
Goal: a /ₚ u⁻¹ = a * ↑u
-- divp_mul_cancel
@[simp]
theorem divp_mul_cancel (a : α) (u : αˣ) : a /ₚ u * u = a 
Arguments: {α : Type u} [Monoid α] (a : α) (u : αˣ)
Goal: a /ₚ u * ↑u = a
-- mul_divp_cancel
@[simp]
theorem mul_divp_cancel (a : α) (u : αˣ) : a * u /ₚ u = a 
Arguments: {α : Type u} [Monoid α] (a : α) (u : αˣ)
Goal: a * ↑u /ₚ u = a
-- divp_left_inj
@[simp]
theorem divp_left_inj (u : αˣ) {a b : α} : a /ₚ u = b /ₚ u ↔ a = b 
Arguments: {α : Type u} [Monoid α] (u : αˣ) {a b : α}
Goal: a /ₚ u = b /ₚ u ↔ a = b
-- divp_divp_eq_divp_mul
@[field_simps]
theorem divp_divp_eq_divp_mul (x : α) (u₁ u₂ : αˣ) : x /ₚ u₁ /ₚ u₂ = x /ₚ (u₂ * u₁) 
Arguments: {α : Type u} [Monoid α] (x : α) (u₁ u₂ : αˣ)
Goal: x /ₚ u₁ /ₚ u₂ = x /ₚ (u₂ * u₁)
-- divp_eq_iff_mul_eq
@[field_simps 1010]
theorem divp_eq_iff_mul_eq {x : α} {u : αˣ} {y : α} : x /ₚ u = y ↔ y * u = x 
Arguments: {α : Type u} [Monoid α] {x : α} {u : αˣ} {y : α}
Goal: x /ₚ u = y ↔ y * ↑u = x
-- eq_divp_iff_mul_eq
@[field_simps]
theorem eq_divp_iff_mul_eq {x : α} {u : αˣ} {y : α} : x = y /ₚ u ↔ x * u = y 
Arguments: {α : Type u} [Monoid α] {x : α} {u : αˣ} {y : α}
Goal: x = y /ₚ u ↔ x * ↑u = y
-- divp_eq_one_iff_eq
theorem divp_eq_one_iff_eq {a : α} {u : αˣ} : a /ₚ u = 1 ↔ a = u 
Arguments: {α : Type u} [Monoid α] {a : α} {u : αˣ}
Goal: a /ₚ u = 1 ↔ a = ↑u
-- one_divp
@[simp]
theorem one_divp (u : αˣ) : 1 /ₚ u = ↑u⁻¹ 
Arguments: {α : Type u} [Monoid α] (u : αˣ)
Goal: 1 /ₚ u = ↑u⁻¹
-- inv_eq_one_divp
@[field_simps]
theorem inv_eq_one_divp (u : αˣ) : ↑u⁻¹ = 1 /ₚ u 
Arguments: {α : Type u} [Monoid α] (u : αˣ)
Goal: ↑u⁻¹ = 1 /ₚ u
-- inv_eq_one_divp'
@[field_simps]
theorem inv_eq_one_divp' (u : αˣ) : ((1 / u : αˣ) : α) = 1 /ₚ u 
Arguments: {α : Type u} [Monoid α] (u : αˣ)
Goal: ↑(1 / u) = 1 /ₚ u
-- val_div_eq_divp
@[field_simps]
theorem val_div_eq_divp (u₁ u₂ : αˣ) : ↑(u₁ / u₂) = ↑u₁ /ₚ u₂ 
Arguments: {α : Type u} [Monoid α] (u₁ u₂ : αˣ)
Goal: ↑(u₁ / u₂) = ↑u₁ /ₚ u₂
-- divp_mul_eq_mul_divp
@[field_simps]
theorem divp_mul_eq_mul_divp (x y : α) (u : αˣ) : x /ₚ u * y = x * y /ₚ u 
Arguments: {α : Type u} [CommMonoid α] (x y : α) (u : αˣ)
Goal: x /ₚ u * y = x * y /ₚ u
-- divp_eq_divp_iff
@[field_simps]
theorem divp_eq_divp_iff {x y : α} {ux uy : αˣ} : x /ₚ ux = y /ₚ uy ↔ x * uy = y * ux 
Arguments: {α : Type u} [CommMonoid α] {x y : α} {ux uy : αˣ}
Goal: x /ₚ ux = y /ₚ uy ↔ x * ↑uy = y * ↑ux
-- divp_mul_divp
@[field_simps]
theorem divp_mul_divp (x y : α) (ux uy : αˣ) : x /ₚ ux * (y /ₚ uy) = x * y /ₚ (ux * uy) 
Arguments: {α : Type u} [CommMonoid α] (x y : α) (ux uy : αˣ)
Goal: x /ₚ ux * (y /ₚ uy) = x * y /ₚ (ux * uy)
-- eq_zero_of_add_right
@[to_additive]
theorem eq_one_of_mul_right (h : a * b = 1) : a = 1 
Arguments: {α : Type u} [AddCommMonoid α] [Subsingleton (AddUnits α)] {a b : α} (h : a + b = 0)
Goal: a = 0
-- eq_one_of_mul_right
@[to_additive]
theorem eq_one_of_mul_right (h : a * b = 1) : a = 1 
Arguments: {α : Type u} [CommMonoid α] [Subsingleton αˣ] {a b : α} (h : a * b = 1)
Goal: a = 1
-- eq_one_of_mul_left
@[to_additive]
theorem eq_one_of_mul_left (h : a * b = 1) : b = 1 
Arguments: {α : Type u} [CommMonoid α] [Subsingleton αˣ] {a b : α} (h : a * b = 1)
Goal: b = 1
-- eq_zero_of_add_left
@[to_additive]
theorem eq_one_of_mul_left (h : a * b = 1) : b = 1 
Arguments: {α : Type u} [AddCommMonoid α] [Subsingleton (AddUnits α)] {a b : α} (h : a + b = 0)
Goal: b = 0
-- add_eq_zero
@[to_additive (attr := simp)]
theorem mul_eq_one : a * b = 1 ↔ a = 1 ∧ b = 1 
Arguments: {α : Type u} [AddCommMonoid α] [Subsingleton (AddUnits α)] {a b : α}
Goal: a + b = 0 ↔ a = 0 ∧ b = 0
-- mul_eq_one
@[to_additive (attr := simp)]
theorem mul_eq_one : a * b = 1 ↔ a = 1 ∧ b = 1 
Arguments: {α : Type u} [CommMonoid α] [Subsingleton αˣ] {a b : α}
Goal: a * b = 1 ↔ a = 1 ∧ b = 1
-- isAddUnit_iff_exists
@[to_additive "See `isAddUnit_iff_exists_and_exists` for a similar lemma with two existentials."]
lemma isUnit_iff_exists [Monoid M] {x : M} : IsUnit x ↔ ∃ b, x * b = 1 ∧ b * x = 1 
Arguments: {M : Type u_1} [AddMonoid M] {x : M}
Goal: IsAddUnit x ↔ ∃ b, x + b = 0 ∧ b + x = 0
-- isUnit_iff_exists
@[to_additive "See `isAddUnit_iff_exists_and_exists` for a similar lemma with two existentials."]
lemma isUnit_iff_exists [Monoid M] {x : M} : IsUnit x ↔ ∃ b, x * b = 1 ∧ b * x = 1 
Arguments: {M : Type u_1} [Monoid M] {x : M}
Goal: IsUnit x ↔ ∃ b, x * b = 1 ∧ b * x = 1
-- isUnit_iff_exists_and_exists
@[to_additive "See `isAddUnit_iff_exists` for a similar lemma with one existential."]
theorem isUnit_iff_exists_and_exists [Monoid M] {a : M} :
    IsUnit a ↔ (∃ b, a * b = 1) ∧ (∃ c, c * a = 1) 
Arguments: {M : Type u_1} [Monoid M] {a : M}
Goal: IsUnit a ↔ (∃ b, a * b = 1) ∧ ∃ c, c * a = 1
-- isAddUnit_iff_exists_and_exists
@[to_additive "See `isAddUnit_iff_exists` for a similar lemma with one existential."]
theorem isUnit_iff_exists_and_exists [Monoid M] {a : M} :
    IsUnit a ↔ (∃ b, a * b = 1) ∧ (∃ c, c * a = 1) 
Arguments: {M : Type u_1} [AddMonoid M] {a : M}
Goal: IsAddUnit a ↔ (∃ b, a + b = 0) ∧ ∃ c, c + a = 0
-- isUnit_of_subsingleton
@[to_additive (attr := nontriviality)]
theorem isUnit_of_subsingleton [Monoid M] [Subsingleton M] (a : M) : IsUnit a 
Arguments: {M : Type u_1} [Monoid M] [Subsingleton M] (a : M)
Goal: IsUnit a
-- isAddUnit_of_subsingleton
@[to_additive (attr := nontriviality)]
theorem isUnit_of_subsingleton [Monoid M] [Subsingleton M] (a : M) : IsUnit a 
Arguments: {M : Type u_1} [AddMonoid M] [Subsingleton M] (a : M)
Goal: IsAddUnit a
-- AddUnits.isAddUnit
@[to_additive (attr := simp)]
protected theorem Units.isUnit [Monoid M] (u : Mˣ) : IsUnit (u : M) 
Arguments: {M : Type u_1} [AddMonoid M] (u : AddUnits M)
Goal: IsAddUnit ↑u
-- Units.isUnit
@[to_additive (attr := simp)]
protected theorem Units.isUnit [Monoid M] (u : Mˣ) : IsUnit (u : M) 
Arguments: {M : Type u_1} [Monoid M] (u : Mˣ)
Goal: IsUnit ↑u
-- isAddUnit_zero
@[to_additive (attr := simp)]
theorem isUnit_one [Monoid M] : IsUnit (1 : M) 
Arguments: {M : Type u_1} [AddMonoid M]
Goal: IsAddUnit 0
-- isUnit_one
@[to_additive (attr := simp)]
theorem isUnit_one [Monoid M] : IsUnit (1 : M) 
Arguments: {M : Type u_1} [Monoid M]
Goal: IsUnit 1
-- isUnit_of_mul_eq_one
@[to_additive]
theorem isUnit_of_mul_eq_one [CommMonoid M] (a b : M) (h : a * b = 1) : IsUnit a 
Arguments: {M : Type u_1} [CommMonoid M] (a b : M) (h : a * b = 1)
Goal: IsUnit a
-- isAddUnit_of_add_eq_zero
@[to_additive]
theorem isUnit_of_mul_eq_one [CommMonoid M] (a b : M) (h : a * b = 1) : IsUnit a 
Arguments: {M : Type u_1} [AddCommMonoid M] (a b : M) (h : a + b = 0)
Goal: IsAddUnit a
-- isUnit_of_mul_eq_one_right
@[to_additive]
theorem isUnit_of_mul_eq_one_right [CommMonoid M] (a b : M) (h : a * b = 1) : IsUnit b 
Arguments: {M : Type u_1} [CommMonoid M] (a b : M) (h : a * b = 1)
Goal: IsUnit b
-- isAddUnit_of_add_eq_zero_right
@[to_additive]
theorem isUnit_of_mul_eq_one_right [CommMonoid M] (a b : M) (h : a * b = 1) : IsUnit b 
Arguments: {M : Type u_1} [AddCommMonoid M] (a b : M) (h : a + b = 0)
Goal: IsAddUnit b
-- IsUnit.exists_right_inv
@[to_additive IsAddUnit.exists_neg]
lemma IsUnit.exists_right_inv (h : IsUnit a) : ∃ b, a * b = 1 
Arguments: {M : Type u_1} [Monoid M] {a : M} (h : IsUnit a)
Goal: ∃ b, a * b = 1
-- IsAddUnit.exists_neg
@[to_additive IsAddUnit.exists_neg]
lemma IsUnit.exists_right_inv (h : IsUnit a) : ∃ b, a * b = 1 
Arguments: {M : Type u_1} [AddMonoid M] {a : M} (h : IsAddUnit a)
Goal: ∃ b, a + b = 0
-- IsAddUnit.exists_neg'
@[to_additive IsAddUnit.exists_neg']
lemma IsUnit.exists_left_inv {a : M} (h : IsUnit a) : ∃ b, b * a = 1 
Arguments: {M : Type u_1} [AddMonoid M] {a : M} (h : IsAddUnit a)
Goal: ∃ b, b + a = 0
-- IsUnit.exists_left_inv
@[to_additive IsAddUnit.exists_neg']
lemma IsUnit.exists_left_inv {a : M} (h : IsUnit a) : ∃ b, b * a = 1 
Arguments: {M : Type u_1} [Monoid M] {a : M} (h : IsUnit a)
Goal: ∃ b, b * a = 1
-- IsAddUnit.add
@[to_additive] lemma IsUnit.mul : IsUnit a → IsUnit b → IsUnit (a * b) 
Arguments: {M : Type u_1} [AddMonoid M] {a b : M}
Goal: IsAddUnit a → IsAddUnit b → IsAddUnit (a + b)
-- IsUnit.mul
@[to_additive] lemma IsUnit.mul : IsUnit a → IsUnit b → IsUnit (a * b) 
Arguments: {M : Type u_1} [Monoid M] {a b : M}
Goal: IsUnit a → IsUnit b → IsUnit (a * b)
-- IsUnit.pow
@[to_additive] lemma IsUnit.pow (n : ℕ) : IsUnit a → IsUnit (a ^ n) 
Arguments: {M : Type u_1} [Monoid M] {a : M} (n : ℕ)
Goal: IsUnit a → IsUnit (a ^ n)
-- IsAddUnit.nsmul
@[to_additive] lemma IsUnit.pow (n : ℕ) : IsUnit a → IsUnit (a ^ n) 
Arguments: {M : Type u_1} [AddMonoid M] {a : M} (n : ℕ)
Goal: IsAddUnit a → IsAddUnit (n • a)
-- units_eq_one
theorem units_eq_one [Unique Mˣ] (u : Mˣ) : u = 1 
Arguments: {M : Type u_1} [Monoid M] [Unique Mˣ] (u : Mˣ)
Goal: u = 1
-- isUnit_iff_eq_one
@[to_additive] lemma isUnit_iff_eq_one [Unique Mˣ] {x : M} : IsUnit x ↔ x = 1 
Arguments: {M : Type u_1} [Monoid M] [Unique Mˣ] {x : M}
Goal: IsUnit x ↔ x = 1
-- isAddUnit_iff_eq_zero
@[to_additive] lemma isUnit_iff_eq_one [Unique Mˣ] {x : M} : IsUnit x ↔ x = 1 
Arguments: {M : Type u_1} [AddMonoid M] [Unique (AddUnits M)] {x : M}
Goal: IsAddUnit x ↔ x = 0
-- isUnit_iff_exists_inv
@[to_additive]
theorem isUnit_iff_exists_inv [CommMonoid M] {a : M} : IsUnit a ↔ ∃ b, a * b = 1 
Arguments: {M : Type u_1} [CommMonoid M] {a : M}
Goal: IsUnit a ↔ ∃ b, a * b = 1
-- isAddUnit_iff_exists_neg
@[to_additive]
theorem isUnit_iff_exists_inv [CommMonoid M] {a : M} : IsUnit a ↔ ∃ b, a * b = 1 
Arguments: {M : Type u_1} [AddCommMonoid M] {a : M}
Goal: IsAddUnit a ↔ ∃ b, a + b = 0
-- isAddUnit_iff_exists_neg'
@[to_additive]
theorem isUnit_iff_exists_inv' [CommMonoid M] {a : M} : IsUnit a ↔ ∃ b, b * a = 1 
Arguments: {M : Type u_1} [AddCommMonoid M] {a : M}
Goal: IsAddUnit a ↔ ∃ b, b + a = 0
-- isUnit_iff_exists_inv'
@[to_additive]
theorem isUnit_iff_exists_inv' [CommMonoid M] {a : M} : IsUnit a ↔ ∃ b, b * a = 1 
Arguments: {M : Type u_1} [CommMonoid M] {a : M}
Goal: IsUnit a ↔ ∃ b, b * a = 1
-- Units.isUnit_mul_units
@[to_additive (attr := simp)
"Addition of a `u : AddUnits M` on the right doesn't affect `IsAddUnit`."]
theorem Units.isUnit_mul_units [Monoid M] (a : M) (u : Mˣ) : IsUnit (a * u) ↔ IsUnit a 
Arguments: {M : Type u_1} [Monoid M] (a : M) (u : Mˣ)
Goal: IsUnit (a * ↑u) ↔ IsUnit a
-- AddUnits.isAddUnit_add_addUnits
@[to_additive (attr := simp)
"Addition of a `u : AddUnits M` on the right doesn't affect `IsAddUnit`."]
theorem Units.isUnit_mul_units [Monoid M] (a : M) (u : Mˣ) : IsUnit (a * u) ↔ IsUnit a 
Arguments: {M : Type u_1} [AddMonoid M] (a : M) (u : AddUnits M)
Goal: IsAddUnit (a + ↑u) ↔ IsAddUnit a
-- Units.isUnit_units_mul
@[to_additive (attr := simp)
"Addition of a `u : AddUnits M` on the left doesn't affect `IsAddUnit`."]
theorem Units.isUnit_units_mul {M : Type*} [Monoid M] (u : Mˣ) (a : M) :
    IsUnit (↑u * a) ↔ IsUnit a 
Arguments: {M : Type u_3} [Monoid M] (u : Mˣ) (a : M)
Goal: IsUnit (↑u * a) ↔ IsUnit a
-- AddUnits.isAddUnit_addUnits_add
@[to_additive (attr := simp)
"Addition of a `u : AddUnits M` on the left doesn't affect `IsAddUnit`."]
theorem Units.isUnit_units_mul {M : Type*} [Monoid M] (u : Mˣ) (a : M) :
    IsUnit (↑u * a) ↔ IsUnit a 
Arguments: {M : Type u_3} [AddMonoid M] (u : AddUnits M) (a : M)
Goal: IsAddUnit (↑u + a) ↔ IsAddUnit a
-- isUnit_of_mul_isUnit_left
@[to_additive]
theorem isUnit_of_mul_isUnit_left [CommMonoid M] {x y : M} (hu : IsUnit (x * y)) : IsUnit x 
Arguments: {M : Type u_1} [CommMonoid M] {x y : M} (hu : IsUnit (x * y))
Goal: IsUnit x
-- isAddUnit_of_add_isAddUnit_left
@[to_additive]
theorem isUnit_of_mul_isUnit_left [CommMonoid M] {x y : M} (hu : IsUnit (x * y)) : IsUnit x 
Arguments: {M : Type u_1} [AddCommMonoid M] {x y : M} (hu : IsAddUnit (x + y))
Goal: IsAddUnit x
-- isUnit_of_mul_isUnit_right
@[to_additive]
theorem isUnit_of_mul_isUnit_right [CommMonoid M] {x y : M} (hu : IsUnit (x * y)) : IsUnit y 
Arguments: {M : Type u_1} [CommMonoid M] {x y : M} (hu : IsUnit (x * y))
Goal: IsUnit y
-- isAddUnit_of_add_isAddUnit_right
@[to_additive]
theorem isUnit_of_mul_isUnit_right [CommMonoid M] {x y : M} (hu : IsUnit (x * y)) : IsUnit y 
Arguments: {M : Type u_1} [AddCommMonoid M] {x y : M} (hu : IsAddUnit (x + y))
Goal: IsAddUnit y
-- IsUnit.mul_iff
@[to_additive (attr := simp)]
theorem mul_iff [CommMonoid M] {x y : M} : IsUnit (x * y) ↔ IsUnit x ∧ IsUnit y 
Arguments: {M : Type u_1} [CommMonoid M] {x y : M}
Goal: IsUnit (x * y) ↔ IsUnit x ∧ IsUnit y
-- IsAddUnit.add_iff
@[to_additive (attr := simp)]
theorem mul_iff [CommMonoid M] {x y : M} : IsUnit (x * y) ↔ IsUnit x ∧ IsUnit y 
Arguments: {M : Type u_1} [AddCommMonoid M] {x y : M}
Goal: IsAddUnit (x + y) ↔ IsAddUnit x ∧ IsAddUnit y
-- IsAddUnit.addUnit_of_val_addUnits
@[to_additive (attr := simp)]
theorem unit_of_val_units {a : Mˣ} (h : IsUnit (a : M)) : h.unit = a 
Arguments: {M : Type u_1} [AddMonoid M] {a : AddUnits M} (h : IsAddUnit ↑a)
Goal: h.addUnit = a
-- IsUnit.unit_of_val_units
@[to_additive (attr := simp)]
theorem unit_of_val_units {a : Mˣ} (h : IsUnit (a : M)) : h.unit = a 
Arguments: {M : Type u_1} [Monoid M] {a : Mˣ} (h : IsUnit ↑a)
Goal: h.unit = a
-- IsUnit.unit_spec
@[to_additive (attr := simp)]
theorem unit_spec (h : IsUnit a) : ↑h.unit = a 
Arguments: {M : Type u_1} [Monoid M] {a : M} (h : IsUnit a)
Goal: ↑h.unit = a
-- IsAddUnit.addUnit_spec
@[to_additive (attr := simp)]
theorem unit_spec (h : IsUnit a) : ↑h.unit = a 
Arguments: {M : Type u_1} [AddMonoid M] {a : M} (h : IsAddUnit a)
Goal: ↑h.addUnit = a
-- IsAddUnit.addUnit_zero
@[to_additive (attr := simp)]
theorem unit_one (h : IsUnit (1 : M)) : h.unit = 1 
Arguments: {M : Type u_1} [AddMonoid M] (h : IsAddUnit 0)
Goal: h.addUnit = 0
-- IsUnit.unit_one
@[to_additive (attr := simp)]
theorem unit_one (h : IsUnit (1 : M)) : h.unit = 1 
Arguments: {M : Type u_1} [Monoid M] (h : IsUnit 1)
Goal: h.unit = 1
-- IsAddUnit.val_neg_add
@[to_additive (attr := simp)]
theorem val_inv_mul (h : IsUnit a) : ↑h.unit⁻¹ * a = 1 
Arguments: {M : Type u_1} [AddMonoid M] {a : M} (h : IsAddUnit a)
Goal: ↑(-h.addUnit) + a = 0
-- IsUnit.val_inv_mul
@[to_additive (attr := simp)]
theorem val_inv_mul (h : IsUnit a) : ↑h.unit⁻¹ * a = 1 
Arguments: {M : Type u_1} [Monoid M] {a : M} (h : IsUnit a)
Goal: ↑h.unit⁻¹ * a = 1
-- IsAddUnit.add_val_neg
@[to_additive (attr := simp)]
theorem mul_val_inv (h : IsUnit a) : a * ↑h.unit⁻¹ = 1 
Arguments: {M : Type u_1} [AddMonoid M] {a : M} (h : IsAddUnit a)
Goal: a + ↑(-h.addUnit) = 0
-- IsUnit.mul_val_inv
@[to_additive (attr := simp)]
theorem mul_val_inv (h : IsUnit a) : a * ↑h.unit⁻¹ = 1 
Arguments: {M : Type u_1} [Monoid M] {a : M} (h : IsUnit a)
Goal: a * ↑h.unit⁻¹ = 1