Module docstring
{"# Lemmas about commuting elements in a MonoidWithZero or a GroupWithZero.
"}
{"# Lemmas about commuting elements in a MonoidWithZero or a GroupWithZero.
"}
Ring.mul_inverse_rev'
theorem
{a b : M₀} (h : Commute a b) : inverse (a * b) = inverse b * inverse a
theorem mul_inverse_rev' {a b : M₀} (h : Commute a b) :
inverse (a * b) = inverse b * inverse a := by
by_cases hab : IsUnit (a * b)
· obtain ⟨⟨a, rfl⟩, b, rfl⟩ := h.isUnit_mul_iff.mp hab
rw [← Units.val_mul, inverse_unit, inverse_unit, inverse_unit, ← Units.val_mul, mul_inv_rev]
obtain ha | hb := not_and_or.mp (mt h.isUnit_mul_iff.mpr hab)
· rw [inverse_non_unit _ hab, inverse_non_unit _ ha, mul_zero]
· rw [inverse_non_unit _ hab, inverse_non_unit _ hb, zero_mul]
Ring.mul_inverse_rev
theorem
{M₀} [CommMonoidWithZero M₀] (a b : M₀) : Ring.inverse (a * b) = inverse b * inverse a
theorem mul_inverse_rev {M₀} [CommMonoidWithZero M₀] (a b : M₀) :
Ring.inverse (a * b) = inverse b * inverse a :=
mul_inverse_rev' (Commute.all _ _)
Ring.inverse_pow
theorem
(r : M₀) : ∀ n : ℕ, Ring.inverse r ^ n = Ring.inverse (r ^ n)
lemma inverse_pow (r : M₀) : ∀ n : ℕ, Ring.inverse r ^ n = Ring.inverse (r ^ n)
| 0 => by rw [pow_zero, pow_zero, Ring.inverse_one]
| n + 1 => by
rw [pow_succ', pow_succ, Ring.mul_inverse_rev' ((Commute.refl r).pow_left n),
Ring.inverse_pow r n]
Ring.inverse_pow_mul_eq_iff_eq_mul
theorem
{a : M₀} (b c : M₀) (ha : IsUnit a) {k : ℕ} : Ring.inverse a ^ k * b = c ↔ b = a ^ k * c
lemma inverse_pow_mul_eq_iff_eq_mul {a : M₀} (b c : M₀) (ha : IsUnit a) {k : ℕ} :
Ring.inverseRing.inverse a ^ k * b = c ↔ b = a ^ k * c := by
rw [Ring.inverse_pow, Ring.inverse_mul_eq_iff_eq_mul _ _ _ (IsUnit.pow _ ha)]
Commute.ringInverse_ringInverse
theorem
{a b : M₀} (h : Commute a b) : Commute (Ring.inverse a) (Ring.inverse b)
theorem Commute.ringInverse_ringInverse {a b : M₀} (h : Commute a b) :
Commute (Ring.inverse a) (Ring.inverse b) :=
(Ring.mul_inverse_rev' h.symm).symm.trans <| (congr_arg _ h.symm.eq).trans <|
Ring.mul_inverse_rev' h
Commute.zero_right
theorem
[MulZeroClass G₀] (a : G₀) : Commute a 0
@[simp]
theorem zero_right [MulZeroClass G₀] (a : G₀) : Commute a 0 :=
SemiconjBy.zero_right a
Commute.zero_left
theorem
[MulZeroClass G₀] (a : G₀) : Commute 0 a
@[simp]
theorem zero_left [MulZeroClass G₀] (a : G₀) : Commute 0 a :=
SemiconjBy.zero_left a a
Commute.inv_left_iff₀
theorem
: Commute a⁻¹ b ↔ Commute a b
@[simp]
theorem inv_left_iff₀ : CommuteCommute a⁻¹ b ↔ Commute a b :=
SemiconjBy.inv_symm_left_iff₀
Commute.inv_left₀
theorem
(h : Commute a b) : Commute a⁻¹ b
Commute.inv_right_iff₀
theorem
: Commute a b⁻¹ ↔ Commute a b
@[simp]
theorem inv_right_iff₀ : CommuteCommute a b⁻¹ ↔ Commute a b :=
SemiconjBy.inv_right_iff₀
Commute.inv_right₀
theorem
(h : Commute a b) : Commute a b⁻¹
theorem inv_right₀ (h : Commute a b) : Commute a b⁻¹ :=
inv_right_iff₀.2 h
Commute.div_right
theorem
(hab : Commute a b) (hac : Commute a c) : Commute a (b / c)
@[simp]
theorem div_right (hab : Commute a b) (hac : Commute a c) : Commute a (b / c) :=
SemiconjBy.div_right hab hac
Commute.div_left
theorem
(hac : Commute a c) (hbc : Commute b c) : Commute (a / b) c
pow_inv_comm₀
theorem
(a : G₀) (m n : ℕ) : a⁻¹ ^ m * a ^ n = a ^ n * a⁻¹ ^ m
theorem pow_inv_comm₀ (a : G₀) (m n : ℕ) : a⁻¹ ^ m * a ^ n = a ^ n * a⁻¹ ^ m :=
(Commute.refl a).inv_left₀.pow_pow m n