Documentation

Mathlib.Algebra.Group.Commute.Units

Lemmas about commuting pairs of elements involving units. #

source
theorem Commute.units_inv_right {M : Type u_1} [Monoid M] {a : M} {u : Mˣ} :
Commute a ↑u → Commute a ↑u⁻¹
source
theorem AddCommute.addUnits_neg_right {M : Type u_1} [AddMonoid M] {a : M} {u : AddUnits M} :
AddCommute a ↑u → AddCommute a ↑(-u)
source
@[simp]
theorem Commute.units_inv_right_iff {M : Type u_1} [Monoid M] {a : M} {u : Mˣ} :
Commute a ↑u⁻¹ ↔ Commute a ↑u
source
@[simp]
theorem AddCommute.addUnits_neg_right_iff {M : Type u_1} [AddMonoid M] {a : M} {u : AddUnits M} :
AddCommute a ↑(-u) ↔ AddCommute a ↑u
source
theorem Commute.units_inv_left {M : Type u_1} [Monoid M] {a : M} {u : Mˣ} :
Commute (↑u) a → Commute (↑u⁻¹) a
source
theorem AddCommute.addUnits_neg_left {M : Type u_1} [AddMonoid M] {a : M} {u : AddUnits M} :
AddCommute (↑u) a → AddCommute (↑(-u)) a
source
@[simp]
theorem Commute.units_inv_left_iff {M : Type u_1} [Monoid M] {a : M} {u : Mˣ} :
Commute (↑u⁻¹) a ↔ Commute (↑u) a
source
@[simp]
theorem AddCommute.addUnits_neg_left_iff {M : Type u_1} [AddMonoid M] {a : M} {u : AddUnits M} :
AddCommute (↑(-u)) a ↔ AddCommute (↑u) a
source
theorem Commute.units_val {M : Type u_1} [Monoid M] {u₁ u₂ : Mˣ} :
Commute u₁ u₂ → Commute ↑u₁ ↑u₂
source
theorem AddCommute.addUnits_val {M : Type u_1} [AddMonoid M] {u₁ u₂ : AddUnits M} :
AddCommute u₁ u₂ → AddCommute ↑u₁ ↑u₂
source
theorem Commute.units_of_val {M : Type u_1} [Monoid M] {u₁ u₂ : Mˣ} :
Commute ↑u₁ ↑u₂ → Commute u₁ u₂
source
theorem AddCommute.addUnits_of_val {M : Type u_1} [AddMonoid M] {u₁ u₂ : AddUnits M} :
AddCommute ↑u₁ ↑u₂ → AddCommute u₁ u₂
source
@[simp]
theorem Commute.units_val_iff {M : Type u_1} [Monoid M] {u₁ u₂ : Mˣ} :
Commute ↑u₁ ↑u₂ ↔ Commute u₁ u₂
source
@[simp]
theorem AddCommute.addUnits_val_iff {M : Type u_1} [AddMonoid M] {u₁ u₂ : AddUnits M} :
AddCommute ↑u₁ ↑u₂ ↔ AddCommute u₁ u₂
source
def Units.leftOfMul {M : Type u_1} [Monoid M] (u : Mˣ) (a b : M) (hu : a * b = ↑u) (hc : Commute a b) :
Mˣ

If the product of two commuting elements is a unit, then the left multiplier is a unit.

Instances For
    source
    def AddUnits.leftOfAdd {M : Type u_1} [AddMonoid M] (u : AddUnits M) (a b : M) (hu : a + b = ↑u) (hc : AddCommute a b) :
    AddUnits M

    If the sum of two commuting elements is an additive unit, then the left summand is an additive unit.

    Instances For
      source
      def Units.rightOfMul {M : Type u_1} [Monoid M] (u : Mˣ) (a b : M) (hu : a * b = ↑u) (hc : Commute a b) :
      Mˣ

      If the product of two commuting elements is a unit, then the right multiplier is a unit.

      Instances For
        source
        def AddUnits.rightOfAdd {M : Type u_1} [AddMonoid M] (u : AddUnits M) (a b : M) (hu : a + b = ↑u) (hc : AddCommute a b) :
        AddUnits M

        If the sum of two commuting elements is an additive unit, then the right summand is an additive unit.

        Instances For
          source
          theorem Commute.isUnit_mul_iff {M : Type u_1} [Monoid M] {a b : M} (h : Commute a b) :
          IsUnit (a * b) ↔ IsUnit a ∧ IsUnit b
          source
          theorem AddCommute.isAddUnit_add_iff {M : Type u_1} [AddMonoid M] {a b : M} (h : AddCommute a b) :
          IsAddUnit (a + b) ↔ IsAddUnit a ∧ IsAddUnit b
          source
          @[simp]
          theorem isUnit_mul_self_iff {M : Type u_1} [Monoid M] {a : M} :
          IsUnit (a * a) ↔ IsUnit a
          source
          @[simp]
          theorem isAddUnit_add_self_iff {M : Type u_1} [AddMonoid M] {a : M} :
          IsAddUnit (a + a) ↔ IsAddUnit a
          source
          @[simp]
          theorem Commute.units_zpow_right {M : Type u_1} [Monoid M] {a : M} {u : Mˣ} (h : Commute a ↑u) (m : ℤ) :
          Commute a ↑(u ^ m)
          source
          @[simp]
          theorem AddCommute.addUnits_zsmul_right {M : Type u_1} [AddMonoid M] {a : M} {u : AddUnits M} (h : AddCommute a ↑u) (m : ℤ) :
          AddCommute a ↑(m • u)
          source
          @[simp]
          theorem Commute.units_zpow_left {M : Type u_1} [Monoid M] {a : M} {u : Mˣ} (h : Commute (↑u) a) (m : ℤ) :
          Commute (↑(u ^ m)) a
          source
          @[simp]
          theorem AddCommute.addUnits_zsmul_left {M : Type u_1} [AddMonoid M] {a : M} {u : AddUnits M} (h : AddCommute (↑u) a) (m : ℤ) :
          AddCommute (↑(m • u)) a
          source
          def Units.ofPow {M : Type u_1} [Monoid M] (u : Mˣ) (x : M) {n : ℕ} (hn : n ≠ 0) (hu : x ^ n = ↑u) :
          Mˣ

          If a natural power of x is a unit, then x is a unit.

          Instances For
            source
            def AddUnits.ofNSMul {M : Type u_1} [AddMonoid M] (u : AddUnits M) (x : M) {n : ℕ} (hn : n ≠ 0) (hu : n • x = ↑u) :
            AddUnits M

            If a natural multiple of x is an additive unit, then x is an additive unit.

            Instances For
              source
              @[simp]
              theorem isUnit_pow_iff {M : Type u_1} [Monoid M] {n : ℕ} {a : M} (hn : n ≠ 0) :
              IsUnit (a ^ n) ↔ IsUnit a
              source
              @[simp]
              theorem isAddUnit_nsmul_iff {M : Type u_1} [AddMonoid M] {n : ℕ} {a : M} (hn : n ≠ 0) :
              IsAddUnit (n • a) ↔ IsAddUnit a
              source
              theorem isUnit_pow_succ_iff {M : Type u_1} [Monoid M] {n : ℕ} {a : M} :
              IsUnit (a ^ (n + 1)) ↔ IsUnit a
              source
              theorem isAddUnit_nsmul_succ_iff {M : Type u_1} [AddMonoid M] {n : ℕ} {a : M} :
              IsAddUnit ((n + 1) • a) ↔ IsAddUnit a
              source
              theorem isUnit_pow_iff_of_not_isUnit {M : Type u_1} [Monoid M] {a : M} (hx : ¬IsUnit a) {n : ℕ} :
              IsUnit (a ^ n) ↔ n = 0
              source
              def Units.ofPowEqOne {M : Type u_1} [Monoid M] (a : M) (n : ℕ) (ha : a ^ n = 1) (hn : n ≠ 0) :
              Mˣ

              If a ^ n = 1, n ≠ 0, then a is a unit.

              Instances For
                source
                def AddUnits.ofNSMulEqZero {M : Type u_1} [AddMonoid M] (a : M) (n : ℕ) (ha : n • a = 0) (hn : n ≠ 0) :
                AddUnits M

                If n • x = 0, n ≠ 0, then x is an additive unit.

                Instances For
                  source
                  @[simp]
                  theorem Units.val_ofPowEqOne {M : Type u_1} [Monoid M] (a : M) (n : ℕ) (ha : a ^ n = 1) (hn : n ≠ 0) :
                  ↑(ofPowEqOne a n ha hn) = a
                  source
                  @[simp]
                  theorem Units.val_inv_ofPowEqOne {M : Type u_1} [Monoid M] (a : M) (n : ℕ) (ha : a ^ n = 1) (hn : n ≠ 0) :
                  ↑(ofPowEqOne a n ha hn)⁻¹ = a ^ (n - 1)
                  source
                  @[simp]
                  theorem AddUnits.val_ofNSMulEqZero {M : Type u_1} [AddMonoid M] (a : M) (n : ℕ) (ha : n • a = 0) (hn : n ≠ 0) :
                  ↑(ofNSMulEqZero a n ha hn) = a
                  source
                  @[simp]
                  theorem AddUnits.val_neg_ofNSMulEqZero {M : Type u_1} [AddMonoid M] (a : M) (n : ℕ) (ha : n • a = 0) (hn : n ≠ 0) :
                  ↑(-ofNSMulEqZero a n ha hn) = (n - 1) • a
                  source
                  @[simp]
                  theorem Units.pow_ofPowEqOne {M : Type u_1} [Monoid M] {n : ℕ} {a : M} (ha : a ^ n = 1) (hn : n ≠ 0) :
                  ofPowEqOne a n ha hn ^ n = 1
                  source
                  @[simp]
                  theorem AddUnits.nsmul_ofNSMulEqZero {M : Type u_1} [AddMonoid M] {n : ℕ} {a : M} (ha : n • a = 0) (hn : n ≠ 0) :
                  n • ofNSMulEqZero a n ha hn = 0
                  source
                  theorem IsUnit.of_pow_eq_one {M : Type u_1} [Monoid M] {n : ℕ} {a : M} (ha : a ^ n = 1) (hn : n ≠ 0) :
                  IsUnit a
                  source
                  theorem IsAddUnit.of_nsmul_eq_zero {M : Type u_1} [AddMonoid M] {n : ℕ} {a : M} (ha : n • a = 0) (hn : n ≠ 0) :
                  IsAddUnit a
                  source
                  theorem Units.commute_iff_inv_mul_cancel {M : Type u_1} [Monoid M] {u : Mˣ} {a : M} :
                  Commute (↑u) a ↔ ↑u⁻¹ * a * ↑u = a
                  source
                  theorem AddUnits.addCommute_iff_neg_add_cancel {M : Type u_1} [AddMonoid M] {u : AddUnits M} {a : M} :
                  AddCommute (↑u) a ↔ ↑(-u) + a + ↑u = a
                  source
                  theorem Units.commute_iff_inv_mul_cancel_assoc {M : Type u_1} [Monoid M] {u : Mˣ} {a : M} :
                  Commute (↑u) a ↔ ↑u⁻¹ * (a * ↑u) = a
                  source
                  theorem AddUnits.addCommute_iff_neg_add_cancel_assoc {M : Type u_1} [AddMonoid M] {u : AddUnits M} {a : M} :
                  AddCommute (↑u) a ↔ ↑(-u) + (a + ↑u) = a
                  source
                  theorem Units.commute_iff_mul_inv_cancel {M : Type u_1} [Monoid M] {u : Mˣ} {a : M} :
                  Commute (↑u) a ↔ ↑u * a * ↑u⁻¹ = a
                  source
                  theorem AddUnits.addCommute_iff_add_neg_cancel {M : Type u_1} [AddMonoid M] {u : AddUnits M} {a : M} :
                  AddCommute (↑u) a ↔ ↑u + a + ↑(-u) = a
                  source
                  theorem Units.commute_iff_mul_inv_cancel_assoc {M : Type u_1} [Monoid M] {u : Mˣ} {a : M} :
                  Commute (↑u) a ↔ ↑u * (a * ↑u⁻¹) = a
                  source
                  theorem AddUnits.addCommute_iff_add_neg_cancel_assoc {M : Type u_1} [AddMonoid M] {u : AddUnits M} {a : M} :
                  AddCommute (↑u) a ↔ ↑u + (a + ↑(-u)) = a
                  source
                  theorem Commute.div_eq_div_iff_of_isUnit {M : Type u_1} [DivisionMonoid M] {a b c d : M} (hbd : Commute b d) (hb : IsUnit b) (hd : IsUnit d) :
                  a / b = c / d ↔ a * d = c * b
                  source
                  theorem AddCommute.sub_eq_sub_iff_of_isAddUnit {M : Type u_1} [SubtractionMonoid M] {a b c d : M} (hbd : AddCommute b d) (hb : IsAddUnit b) (hd : IsAddUnit d) :
                  a - b = c - d ↔ a + d = c + b
                  source
                  theorem Commute.mul_inv_eq_mul_inv_iff_of_isUnit {M : Type u_1} [DivisionMonoid M] {a b c d : M} (hbd : Commute b d) (hb : IsUnit b) (hd : IsUnit d) :
                  a * b⁻¹ = c * d⁻¹ ↔ a * d = c * b
                  source
                  theorem AddCommute.add_neg_eq_add_neg_iff_of_isAddUnit {M : Type u_1} [SubtractionMonoid M] {a b c d : M} (hbd : AddCommute b d) (hb : IsAddUnit b) (hd : IsAddUnit d) :
                  a + -b = c + -d ↔ a + d = c + b
                  source
                  theorem Commute.inv_mul_eq_inv_mul_iff_of_isUnit {M : Type u_1} [DivisionMonoid M] {a b c d : M} (hbd : Commute b d) (hb : IsUnit b) (hd : IsUnit d) :
                  b⁻¹ * a = d⁻¹ * c ↔ d * a = b * c
                  source
                  theorem AddCommute.neg_add_eq_neg_add_iff_of_isAddUnit {M : Type u_1} [SubtractionMonoid M] {a b c d : M} (hbd : AddCommute b d) (hb : IsAddUnit b) (hd : IsAddUnit d) :
                  -b + a = -d + c ↔ d + a = b + c