File: Mathlib/Algebra/Ring/Commute.lean

full_name: Commute.add_right
code: @[simp]
theorem add_right [Distrib R] {a b c : R} : Commute a b → Commute a c → Commute a (b + c) 
goal: Commute a b → Commute a c → Commute a (b + c)

full_name: Commute.add_left
code: @[simp]
theorem add_left [Distrib R] {a b c : R} : Commute a c → Commute b c → Commute (a + b) c 
goal: Commute a c → Commute b c → Commute (a + b) c

full_name: Commute.mul_self_sub_mul_self_eq
code: /-- Representation of a difference of two squares of commuting elements as a product. -/
theorem mul_self_sub_mul_self_eq [NonUnitalNonAssocRing R] {a b : R} (h : Commute a b) :
    a * a - b * b = (a + b) * (a - b) 
goal: a * a - b * b = (a + b) * (a - b)

full_name: Commute.mul_self_sub_mul_self_eq'
code: theorem mul_self_sub_mul_self_eq' [NonUnitalNonAssocRing R] {a b : R} (h : Commute a b) :
    a * a - b * b = (a - b) * (a + b) 
goal: a * a - b * b = (a - b) * (a + b)

full_name: Commute.mul_self_eq_mul_self_iff
code: theorem mul_self_eq_mul_self_iff [NonUnitalNonAssocRing R] [NoZeroDivisors R] {a b : R}
    (h : Commute a b) : a * a = b * b ↔ a = b ∨ a = -b 
goal: a * a = b * b ↔ a = b ∨ a = -b

full_name: Commute.neg_right
code: theorem neg_right : Commute a b → Commute a (-b) 
goal: Commute a b → Commute a (-b)

full_name: Commute.neg_right_iff
code: @[simp]
theorem neg_right_iff : Commute a (-b) ↔ Commute a b 
goal: Commute a (-b) ↔ Commute a b

full_name: Commute.neg_left
code: theorem neg_left : Commute a b → Commute (-a) b 
goal: Commute a b → Commute (-a) b

full_name: Commute.neg_left_iff
code: @[simp]
theorem neg_left_iff : Commute (-a) b ↔ Commute a b 
goal: Commute (-a) b ↔ Commute a b

full_name: Commute.neg_one_right
code: theorem neg_one_right (a : R) : Commute a (-1) 
goal: Commute a (-1)

full_name: Commute.neg_one_left
code: theorem neg_one_left (a : R) : Commute (-1) a 
goal: Commute (-1) a

full_name: Commute.sub_right
code: @[simp]
theorem sub_right : Commute a b → Commute a c → Commute a (b - c) 
goal: Commute a b → Commute a c → Commute a (b - c)

full_name: Commute.sub_left
code: @[simp]
theorem sub_left : Commute a c → Commute b c → Commute (a - b) c 
goal: Commute a c → Commute b c → Commute (a - b) c

full_name: Commute.sq_sub_sq
code: protected lemma sq_sub_sq (h : Commute a b) : a ^ 2 - b ^ 2 = (a + b) * (a - b) 
goal: a ^ 2 - b ^ 2 = (a + b) * (a - b)

full_name: Commute.sq_eq_sq_iff_eq_or_eq_neg
code: protected lemma sq_eq_sq_iff_eq_or_eq_neg (h : Commute a b) : a ^ 2 = b ^ 2 ↔ a = b ∨ a = -b 
goal: a ^ 2 = b ^ 2 ↔ a = b ∨ a = -b

full_name: neg_one_pow_eq_or
code: lemma neg_one_pow_eq_or : ∀ n : ℕ, (-1 : R) ^ n = 1 ∨ (-1 : R) ^ n = -1
  
goal: (-1) ^ n = 1 ∨ (-1) ^ n = -1

full_name: neg_pow
code: lemma neg_pow (a : R) (n : ℕ) : (-a) ^ n = (-1) ^ n * a ^ n 
goal: (-a) ^ n = (-1) ^ n * a ^ n

full_name: neg_pow'
code: lemma neg_pow' (a : R) (n : ℕ) : (-a) ^ n = a ^ n * (-1) ^ n 
goal: (-a) ^ n = a ^ n * (-1) ^ n

full_name: neg_sq
code: lemma neg_sq (a : R) : (-a) ^ 2 = a ^ 2 
goal: (-a) ^ 2 = a ^ 2

full_name: neg_one_sq
code: lemma neg_one_sq : (-1 : R) ^ 2 = 1 
goal: (-1) ^ 2 = 1

full_name: neg_one_pow_mul_eq_zero_iff
code: @[simp] lemma neg_one_pow_mul_eq_zero_iff : (-1) ^ n * a = 0 ↔ a = 0 
goal: (-1) ^ n * a = 0 ↔ a = 0

full_name: mul_neg_one_pow_eq_zero_iff
code: @[simp] lemma mul_neg_one_pow_eq_zero_iff : a * (-1) ^ n = 0 ↔ a = 0 
goal: a * (-1) ^ n = 0 ↔ a = 0

full_name: neg_one_pow_eq_pow_mod_two
code: lemma neg_one_pow_eq_pow_mod_two (n : ℕ) : (-1 : R) ^ n = (-1) ^ (n % 2) 
goal: (-1) ^ n = (-1) ^ (n % 2)

full_name: sq_eq_one_iff
code: @[simp] lemma sq_eq_one_iff : a ^ 2 = 1 ↔ a = 1 ∨ a = -1 
goal: a ^ 2 = 1 ↔ a = 1 ∨ a = -1

full_name: sq_ne_one_iff
code: lemma sq_ne_one_iff : a ^ 2 ≠ 1 ↔ a ≠ 1 ∧ a ≠ -1 
goal: a ^ 2 ≠ 1 ↔ a ≠ 1 ∧ a ≠ -1

full_name: mul_self_sub_mul_self
code: /-- Representation of a difference of two squares in a commutative ring as a product. -/
theorem mul_self_sub_mul_self [CommRing R] (a b : R) : a * a - b * b = (a + b) * (a - b) 
goal: a * a - b * b = (a + b) * (a - b)

full_name: mul_self_sub_one
code: theorem mul_self_sub_one [NonAssocRing R] (a : R) : a * a - 1 = (a + 1) * (a - 1) 
goal: a * a - 1 = (a + 1) * (a - 1)

full_name: mul_self_eq_mul_self_iff
code: theorem mul_self_eq_mul_self_iff [CommRing R] [NoZeroDivisors R] {a b : R} :
    a * a = b * b ↔ a = b ∨ a = -b 
goal: a * a = b * b ↔ a = b ∨ a = -b

full_name: mul_self_eq_one_iff
code: theorem mul_self_eq_one_iff [NonAssocRing R] [NoZeroDivisors R] {a : R} :
    a * a = 1 ↔ a = 1 ∨ a = -1 
goal: a * a = 1 ↔ a = 1 ∨ a = -1

full_name: sq_sub_sq
code: lemma sq_sub_sq (a b : R) : a ^ 2 - b ^ 2 = (a + b) * (a - b) 
goal: a ^ 2 - b ^ 2 = (a + b) * (a - b)

full_name: sub_sq
code: lemma sub_sq (a b : R) : (a - b) ^ 2 = a ^ 2 - 2 * a * b + b ^ 2 
goal: (a - b) ^ 2 = a ^ 2 - 2 * a * b + b ^ 2

full_name: sub_sq'
code: lemma sub_sq' (a b : R) : (a - b) ^ 2 = a ^ 2 + b ^ 2 - 2 * a * b 
goal: (a - b) ^ 2 = a ^ 2 + b ^ 2 - 2 * a * b

full_name: sq_eq_sq_iff_eq_or_eq_neg
code: lemma sq_eq_sq_iff_eq_or_eq_neg : a ^ 2 = b ^ 2 ↔ a = b ∨ a = -b 
goal: a ^ 2 = b ^ 2 ↔ a = b ∨ a = -b

full_name: eq_or_eq_neg_of_sq_eq_sq
code: lemma eq_or_eq_neg_of_sq_eq_sq (a b : R) : a ^ 2 = b ^ 2 → a = b ∨ a = -b 
goal: a ^ 2 = b ^ 2 → a = b ∨ a = -b

full_name: Units.sq_eq_sq_iff_eq_or_eq_neg
code: protected lemma sq_eq_sq_iff_eq_or_eq_neg {a b : Rˣ} : a ^ 2 = b ^ 2 ↔ a = b ∨ a = -b 
goal: a ^ 2 = b ^ 2 ↔ a = b ∨ a = -b

full_name: Units.eq_or_eq_neg_of_sq_eq_sq
code: protected lemma eq_or_eq_neg_of_sq_eq_sq (a b : Rˣ) (h : a ^ 2 = b ^ 2) : a = b ∨ a = -b 
goal: a = b ∨ a = -b

full_name: Units.inv_eq_self_iff
code: /-- In the unit group of an integral domain, a unit is its own inverse iff the unit is one or
  one's additive inverse. -/
theorem inv_eq_self_iff [Ring R] [NoZeroDivisors R] (u : Rˣ) : u⁻¹ = u ↔ u = 1 ∨ u = -1 
goal: u⁻¹ = u ↔ u = 1 ∨ u = -1

full_name: Ring.instBracket
code: instance (priority := 100) instBracket : Bracket R R 
goal: Bracket R R

full_name: Ring.lie_def
code: theorem lie_def (x y : R) : ⁅x, y⁆ = x * y - y * x 
goal: ⁅x, y⁆ = x * y - y * x

full_name: commute_iff_lie_eq
code: theorem commute_iff_lie_eq {x y : R} : Commute x y ↔ ⁅x, y⁆ = 0 
goal: Commute x y ↔ ⁅x, y⁆ = 0

full_name: Commute.lie_eq
code: theorem Commute.lie_eq {x y : R} (h : Commute x y) : ⁅x, y⁆ = 0 
goal: ⁅x, y⁆ = 0