File: Mathlib/Algebra/Group/Commute/Units.lean

full_name: AddCommute.addUnits_neg_right
code: @[to_additive]
theorem units_inv_right : Commute a u → Commute a ↑u⁻¹ 
goal: AddCommute a ↑u → AddCommute a ↑(-u)

full_name: Commute.units_inv_right
code: @[to_additive]
theorem units_inv_right : Commute a u → Commute a ↑u⁻¹ 
goal: Commute a ↑u → Commute a ↑u⁻¹

full_name: Commute.units_inv_right_iff
code: @[to_additive (attr := simp)]
theorem units_inv_right_iff : Commute a ↑u⁻¹ ↔ Commute a u 
goal: Commute a ↑u⁻¹ ↔ Commute a ↑u

full_name: AddCommute.addUnits_neg_right_iff
code: @[to_additive (attr := simp)]
theorem units_inv_right_iff : Commute a ↑u⁻¹ ↔ Commute a u 
goal: AddCommute a ↑(-u) ↔ AddCommute a ↑u

full_name: Commute.units_inv_left
code: @[to_additive]
theorem units_inv_left : Commute (↑u) a → Commute (↑u⁻¹) a 
goal: Commute (↑u) a → Commute (↑u⁻¹) a

full_name: AddCommute.addUnits_neg_left
code: @[to_additive]
theorem units_inv_left : Commute (↑u) a → Commute (↑u⁻¹) a 
goal: AddCommute (↑u) a → AddCommute (↑(-u)) a

full_name: AddCommute.addUnits_neg_left_iff
code: @[to_additive (attr := simp)]
theorem units_inv_left_iff : Commute (↑u⁻¹) a ↔ Commute (↑u) a 
goal: AddCommute (↑(-u)) a ↔ AddCommute (↑u) a

full_name: Commute.units_inv_left_iff
code: @[to_additive (attr := simp)]
theorem units_inv_left_iff : Commute (↑u⁻¹) a ↔ Commute (↑u) a 
goal: Commute (↑u⁻¹) a ↔ Commute (↑u) a

full_name: Commute.units_val
code: @[to_additive]
theorem units_val : Commute u₁ u₂ → Commute (u₁ : M) u₂ 
goal: Commute u₁ u₂ → Commute ↑u₁ ↑u₂

full_name: AddCommute.addUnits_val
code: @[to_additive]
theorem units_val : Commute u₁ u₂ → Commute (u₁ : M) u₂ 
goal: AddCommute u₁ u₂ → AddCommute ↑u₁ ↑u₂

full_name: Commute.units_of_val
code: @[to_additive]
theorem units_of_val : Commute (u₁ : M) u₂ → Commute u₁ u₂ 
goal: Commute ↑u₁ ↑u₂ → Commute u₁ u₂

full_name: AddCommute.addUnits_of_val
code: @[to_additive]
theorem units_of_val : Commute (u₁ : M) u₂ → Commute u₁ u₂ 
goal: AddCommute ↑u₁ ↑u₂ → AddCommute u₁ u₂

full_name: Commute.units_val_iff
code: @[to_additive (attr := simp)]
theorem units_val_iff : Commute (u₁ : M) u₂ ↔ Commute u₁ u₂ 
goal: Commute ↑u₁ ↑u₂ ↔ Commute u₁ u₂

full_name: AddCommute.addUnits_val_iff
code: @[to_additive (attr := simp)]
theorem units_val_iff : Commute (u₁ : M) u₂ ↔ Commute u₁ u₂ 
goal: AddCommute ↑u₁ ↑u₂ ↔ AddCommute u₁ u₂

full_name: AddUnits.leftOfAdd
code: /-- If the product of two commuting elements is a unit, then the left multiplier is a unit. -/
@[to_additive "If the sum of two commuting elements is an additive unit, then the left summand is
an additive unit."]
def Units.leftOfMul (u : Mˣ) (a b : M) (hu : a * b = u) (hc : Commute a b) : Mˣ 
goal: AddUnits M

full_name: Units.leftOfMul
code: /-- If the product of two commuting elements is a unit, then the left multiplier is a unit. -/
@[to_additive "If the sum of two commuting elements is an additive unit, then the left summand is
an additive unit."]
def Units.leftOfMul (u : Mˣ) (a b : M) (hu : a * b = u) (hc : Commute a b) : Mˣ 
goal: Mˣ

full_name: Units.rightOfMul
code: /-- If the product of two commuting elements is a unit, then the right multiplier is a unit. -/
@[to_additive "If the sum of two commuting elements is an additive unit, then the right summand
is an additive unit."]
def Units.rightOfMul (u : Mˣ) (a b : M) (hu : a * b = u) (hc : Commute a b) : Mˣ 
goal: Mˣ

full_name: AddUnits.rightOfAdd
code: /-- If the product of two commuting elements is a unit, then the right multiplier is a unit. -/
@[to_additive "If the sum of two commuting elements is an additive unit, then the right summand
is an additive unit."]
def Units.rightOfMul (u : Mˣ) (a b : M) (hu : a * b = u) (hc : Commute a b) : Mˣ 
goal: AddUnits M

full_name: AddCommute.isAddUnit_add_iff
code: @[to_additive]
theorem Commute.isUnit_mul_iff (h : Commute a b) : IsUnit (a * b) ↔ IsUnit a ∧ IsUnit b 
goal: IsAddUnit (a + b) ↔ IsAddUnit a ∧ IsAddUnit b

full_name: Commute.isUnit_mul_iff
code: @[to_additive]
theorem Commute.isUnit_mul_iff (h : Commute a b) : IsUnit (a * b) ↔ IsUnit a ∧ IsUnit b 
goal: IsUnit (a * b) ↔ IsUnit a ∧ IsUnit b

full_name: isUnit_mul_self_iff
code: @[to_additive (attr := simp)]
theorem isUnit_mul_self_iff : IsUnit (a * a) ↔ IsUnit a 
goal: IsUnit (a * a) ↔ IsUnit a

full_name: isAddUnit_add_self_iff
code: @[to_additive (attr := simp)]
theorem isUnit_mul_self_iff : IsUnit (a * a) ↔ IsUnit a 
goal: IsAddUnit (a + a) ↔ IsAddUnit a

full_name: Commute.units_zpow_right
code: @[to_additive (attr := simp)]
lemma Commute.units_zpow_right (h : Commute a u) (m : ℤ) : Commute a ↑(u ^ m) 
goal: Commute a ↑(u ^ m)

full_name: AddCommute.addUnits_zsmul_right
code: @[to_additive (attr := simp)]
lemma Commute.units_zpow_right (h : Commute a u) (m : ℤ) : Commute a ↑(u ^ m) 
goal: AddCommute a ↑(m • u)

full_name: AddCommute.addUnits_zsmul_left
code: @[to_additive (attr := simp)]
lemma Commute.units_zpow_left (h : Commute ↑u a) (m : ℤ) : Commute ↑(u ^ m) a 
goal: AddCommute (↑(m • u)) a

full_name: Commute.units_zpow_left
code: @[to_additive (attr := simp)]
lemma Commute.units_zpow_left (h : Commute ↑u a) (m : ℤ) : Commute ↑(u ^ m) a 
goal: Commute (↑(u ^ m)) a

full_name: AddUnits.ofNSMul
code: /-- If a natural power of `x` is a unit, then `x` is a unit. -/
@[to_additive "If a natural multiple of `x` is an additive unit, then `x` is an additive unit."]
def Units.ofPow (u : Mˣ) (x : M) {n : ℕ} (hn : n ≠ 0) (hu : x ^ n = u) : Mˣ 
goal: AddUnits M

full_name: Units.ofPow
code: /-- If a natural power of `x` is a unit, then `x` is a unit. -/
@[to_additive "If a natural multiple of `x` is an additive unit, then `x` is an additive unit."]
def Units.ofPow (u : Mˣ) (x : M) {n : ℕ} (hn : n ≠ 0) (hu : x ^ n = u) : Mˣ 
goal: Mˣ

full_name: isAddUnit_nsmul_iff
code: @[to_additive (attr := simp)] lemma isUnit_pow_iff (hn : n ≠ 0) : IsUnit (a ^ n) ↔ IsUnit a 
goal: IsAddUnit (n • a) ↔ IsAddUnit a

full_name: isUnit_pow_iff
code: @[to_additive (attr := simp)] lemma isUnit_pow_iff (hn : n ≠ 0) : IsUnit (a ^ n) ↔ IsUnit a 
goal: IsUnit (a ^ n) ↔ IsUnit a

full_name: isUnit_pow_succ_iff
code: @[to_additive]
lemma isUnit_pow_succ_iff : IsUnit (a ^ (n + 1)) ↔ IsUnit a 
goal: IsUnit (a ^ (n + 1)) ↔ IsUnit a

full_name: isAddUnit_nsmul_succ_iff
code: @[to_additive]
lemma isUnit_pow_succ_iff : IsUnit (a ^ (n + 1)) ↔ IsUnit a 
goal: IsAddUnit ((n + 1) • a) ↔ IsAddUnit a

full_name: AddUnits.ofNSMulEqZero
code: /-- If `a ^ n = 1`, `n ≠ 0`, then `a` is a unit. -/
@[to_additive (attr := simps!) "If `n • x = 0`, `n ≠ 0`, then `x` is an additive unit."]
def Units.ofPowEqOne (a : M) (n : ℕ) (ha : a ^ n = 1) (hn : n ≠ 0) : Mˣ 
goal: AddUnits M

full_name: Units.val_ofPowEqOne
code: /-- If `a ^ n = 1`, `n ≠ 0`, then `a` is a unit. -/
@[to_additive (attr := simps!) "If `n • x = 0`, `n ≠ 0`, then `x` is an additive unit."]
def Units.ofPowEqOne (a : M) (n : ℕ) (ha : a ^ n = 1) (hn : n ≠ 0) : Mˣ 
goal: ↑(Units.ofPowEqOne a n ha hn) = a

full_name: Units.ofPowEqOne
code: /-- If `a ^ n = 1`, `n ≠ 0`, then `a` is a unit. -/
@[to_additive (attr := simps!) "If `n • x = 0`, `n ≠ 0`, then `x` is an additive unit."]
def Units.ofPowEqOne (a : M) (n : ℕ) (ha : a ^ n = 1) (hn : n ≠ 0) : Mˣ 
goal: Mˣ

full_name: Units.val_inv_ofPowEqOne
code: /-- If `a ^ n = 1`, `n ≠ 0`, then `a` is a unit. -/
@[to_additive (attr := simps!) "If `n • x = 0`, `n ≠ 0`, then `x` is an additive unit."]
def Units.ofPowEqOne (a : M) (n : ℕ) (ha : a ^ n = 1) (hn : n ≠ 0) : Mˣ 
goal: ↑(Units.ofPowEqOne a n ha hn)⁻¹ = a ^ (n - 1)

full_name: AddUnits.val_ofNSMulEqZero
code: /-- If `a ^ n = 1`, `n ≠ 0`, then `a` is a unit. -/
@[to_additive (attr := simps!) "If `n • x = 0`, `n ≠ 0`, then `x` is an additive unit."]
def Units.ofPowEqOne (a : M) (n : ℕ) (ha : a ^ n = 1) (hn : n ≠ 0) : Mˣ 
goal: ↑(AddUnits.ofNSMulEqZero a n ha hn) = a

full_name: AddUnits.val_neg_ofNSMulEqZero
code: /-- If `a ^ n = 1`, `n ≠ 0`, then `a` is a unit. -/
@[to_additive (attr := simps!) "If `n • x = 0`, `n ≠ 0`, then `x` is an additive unit."]
def Units.ofPowEqOne (a : M) (n : ℕ) (ha : a ^ n = 1) (hn : n ≠ 0) : Mˣ 
goal: ↑(-AddUnits.ofNSMulEqZero a n ha hn) = (n - 1) • a

full_name: AddUnits.nsmul_ofNSMulEqZero
code: @[to_additive (attr := simp)]
lemma Units.pow_ofPowEqOne (ha : a ^ n = 1) (hn : n ≠ 0) :
    Units.ofPowEqOne _ n ha hn ^ n = 1 
goal: n • AddUnits.ofNSMulEqZero a n ha hn = 0

full_name: Units.pow_ofPowEqOne
code: @[to_additive (attr := simp)]
lemma Units.pow_ofPowEqOne (ha : a ^ n = 1) (hn : n ≠ 0) :
    Units.ofPowEqOne _ n ha hn ^ n = 1 
goal: Units.ofPowEqOne a n ha hn ^ n = 1

full_name: isAddUnit_ofNSMulEqZero
code: @[to_additive]
lemma isUnit_ofPowEqOne (ha : a ^ n = 1) (hn : n ≠ 0) : IsUnit a 
goal: IsAddUnit a

full_name: isUnit_ofPowEqOne
code: @[to_additive]
lemma isUnit_ofPowEqOne (ha : a ^ n = 1) (hn : n ≠ 0) : IsUnit a 
goal: IsUnit a

full_name: Commute.div_eq_div_iff_of_isUnit
code: @[to_additive]
lemma Commute.div_eq_div_iff_of_isUnit (hbd : Commute b d) (hb : IsUnit b) (hd : IsUnit d) :
    a / b = c / d ↔ a * d = c * b 
goal: a / b = c / d ↔ a * d = c * b

full_name: AddCommute.sub_eq_sub_iff_of_isAddUnit
code: @[to_additive]
lemma Commute.div_eq_div_iff_of_isUnit (hbd : Commute b d) (hb : IsUnit b) (hd : IsUnit d) :
    a / b = c / d ↔ a * d = c * b 
goal: a - b = c - d ↔ a + d = c + b