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

full_name: AddCommute
code: /-- Two elements commute if `a * b = b * a`. -/
@[to_additive "Two elements additively commute if `a + b = b + a`"]
def Commute [Mul S] (a b : S) : Prop 
goal: Prop

full_name: Commute
code: /-- Two elements commute if `a * b = b * a`. -/
@[to_additive "Two elements additively commute if `a + b = b + a`"]
def Commute [Mul S] (a b : S) : Prop 
goal: Prop

full_name: commute_iff_eq
code: /--
Two elements `a` and `b` commute if `a * b = b * a`.
-/
@[to_additive]
theorem commute_iff_eq [Mul S] (a b : S) : Commute a b ↔ a * b = b * a 
goal: Commute a b ↔ a * b = b * a

full_name: addCommute_iff_eq
code: /--
Two elements `a` and `b` commute if `a * b = b * a`.
-/
@[to_additive]
theorem commute_iff_eq [Mul S] (a b : S) : Commute a b ↔ a * b = b * a 
goal: AddCommute a b ↔ a + b = b + a

full_name: Commute.eq
code: /-- Equality behind `Commute a b`; useful for rewriting. -/
@[to_additive "Equality behind `AddCommute a b`; useful for rewriting."]
protected theorem eq {a b : S} (h : Commute a b) : a * b = b * a 
goal: a * b = b * a

full_name: AddCommute.eq
code: /-- Equality behind `Commute a b`; useful for rewriting. -/
@[to_additive "Equality behind `AddCommute a b`; useful for rewriting."]
protected theorem eq {a b : S} (h : Commute a b) : a * b = b * a 
goal: a + b = b + a

full_name: AddCommute.refl
code: /-- Any element commutes with itself. -/
@[to_additive (attr := refl, simp) "Any element commutes with itself."]
protected theorem refl (a : S) : Commute a a 
goal: AddCommute a a

full_name: Commute.refl
code: /-- Any element commutes with itself. -/
@[to_additive (attr := refl, simp) "Any element commutes with itself."]
protected theorem refl (a : S) : Commute a a 
goal: Commute a a

full_name: Commute.symm
code: /-- If `a` commutes with `b`, then `b` commutes with `a`. -/
@[to_additive (attr := symm) "If `a` commutes with `b`, then `b` commutes with `a`."]
protected theorem symm {a b : S} (h : Commute a b) : Commute b a 
goal: Commute b a

full_name: AddCommute.symm
code: /-- If `a` commutes with `b`, then `b` commutes with `a`. -/
@[to_additive (attr := symm) "If `a` commutes with `b`, then `b` commutes with `a`."]
protected theorem symm {a b : S} (h : Commute a b) : Commute b a 
goal: AddCommute b a

full_name: Commute.semiconjBy
code: @[to_additive]
protected theorem semiconjBy {a b : S} (h : Commute a b) : SemiconjBy a b b 
goal: SemiconjBy a b b

full_name: AddCommute.addSemiconjBy
code: @[to_additive]
protected theorem semiconjBy {a b : S} (h : Commute a b) : SemiconjBy a b b 
goal: AddSemiconjBy a b b

full_name: Commute.symm_iff
code: @[to_additive]
protected theorem symm_iff {a b : S} : Commute a b ↔ Commute b a 
goal: Commute a b ↔ Commute b a

full_name: AddCommute.symm_iff
code: @[to_additive]
protected theorem symm_iff {a b : S} : Commute a b ↔ Commute b a 
goal: AddCommute a b ↔ AddCommute b a

full_name: Commute.instIsRefl
code: @[to_additive]
instance : IsRefl S Commute 
goal: IsRefl S Commute

full_name: AddCommute.instIsRefl
code: @[to_additive]
instance : IsRefl S Commute 
goal: IsRefl S AddCommute

full_name: AddCommute.on_isRefl
code: @[to_additive]
instance on_isRefl {f : G → S} : IsRefl G fun a b => Commute (f a) (f b) 
goal: IsRefl G fun a b => AddCommute (f a) (f b)

full_name: Commute.on_isRefl
code: @[to_additive]
instance on_isRefl {f : G → S} : IsRefl G fun a b => Commute (f a) (f b) 
goal: IsRefl G fun a b => Commute (f a) (f b)

full_name: AddCommute.add_right
code: /-- If `a` commutes with both `b` and `c`, then it commutes with their product. -/
@[to_additive (attr := simp)
"If `a` commutes with both `b` and `c`, then it commutes with their sum."]
theorem mul_right (hab : Commute a b) (hac : Commute a c) : Commute a (b * c) 
goal: AddCommute a (b + c)

full_name: Commute.mul_right
code: /-- If `a` commutes with both `b` and `c`, then it commutes with their product. -/
@[to_additive (attr := simp)
"If `a` commutes with both `b` and `c`, then it commutes with their sum."]
theorem mul_right (hab : Commute a b) (hac : Commute a c) : Commute a (b * c) 
goal: Commute a (b * c)

full_name: AddCommute.add_left
code: /-- If both `a` and `b` commute with `c`, then their product commutes with `c`. -/
@[to_additive (attr := simp)
"If both `a` and `b` commute with `c`, then their product commutes with `c`."]
theorem mul_left (hac : Commute a c) (hbc : Commute b c) : Commute (a * b) c 
goal: AddCommute (a + b) c

full_name: Commute.mul_left
code: /-- If both `a` and `b` commute with `c`, then their product commutes with `c`. -/
@[to_additive (attr := simp)
"If both `a` and `b` commute with `c`, then their product commutes with `c`."]
theorem mul_left (hac : Commute a c) (hbc : Commute b c) : Commute (a * b) c 
goal: Commute (a * b) c

full_name: AddCommute.right_comm
code: @[to_additive]
protected theorem right_comm (h : Commute b c) (a : S) : a * b * c = a * c * b 
goal: a + b + c = a + c + b

full_name: Commute.right_comm
code: @[to_additive]
protected theorem right_comm (h : Commute b c) (a : S) : a * b * c = a * c * b 
goal: a * b * c = a * c * b

full_name: Commute.left_comm
code: @[to_additive]
protected theorem left_comm (h : Commute a b) (c) : a * (b * c) = b * (a * c) 
goal: a * (b * c) = b * (a * c)

full_name: AddCommute.left_comm
code: @[to_additive]
protected theorem left_comm (h : Commute a b) (c) : a * (b * c) = b * (a * c) 
goal: a + (b + c) = b + (a + c)

full_name: Commute.mul_mul_mul_comm
code: @[to_additive]
protected theorem mul_mul_mul_comm (hbc : Commute b c) (a d : S) :
    a * b * (c * d) = a * c * (b * d) 
goal: a * b * (c * d) = a * c * (b * d)

full_name: AddCommute.add_add_add_comm
code: @[to_additive]
protected theorem mul_mul_mul_comm (hbc : Commute b c) (a d : S) :
    a * b * (c * d) = a * c * (b * d) 
goal: a + b + (c + d) = a + c + (b + d)

full_name: AddCommute.all
code: @[to_additive]
protected theorem all [CommMagma S] (a b : S) : Commute a b 
goal: AddCommute a b

full_name: Commute.all
code: @[to_additive]
protected theorem all [CommMagma S] (a b : S) : Commute a b 
goal: Commute a b

full_name: Commute.one_right
code: @[to_additive (attr := simp)]
theorem one_right (a : M) : Commute a 1 
goal: Commute a 1

full_name: AddCommute.zero_right
code: @[to_additive (attr := simp)]
theorem one_right (a : M) : Commute a 1 
goal: AddCommute a 0

full_name: Commute.one_left
code: @[to_additive (attr := simp)]
theorem one_left (a : M) : Commute 1 a 
goal: Commute 1 a

full_name: AddCommute.zero_left
code: @[to_additive (attr := simp)]
theorem one_left (a : M) : Commute 1 a 
goal: AddCommute 0 a

full_name: Commute.pow_right
code: @[to_additive (attr := simp)]
theorem pow_right (h : Commute a b) (n : ℕ) : Commute a (b ^ n) 
goal: Commute a (b ^ n)

full_name: AddCommute.nsmul_right
code: @[to_additive (attr := simp)]
theorem pow_right (h : Commute a b) (n : ℕ) : Commute a (b ^ n) 
goal: AddCommute a (n • b)

full_name: AddCommute.nsmul_left
code: @[to_additive (attr := simp)]
theorem pow_left (h : Commute a b) (n : ℕ) : Commute (a ^ n) b 
goal: AddCommute (n • a) b

full_name: Commute.pow_left
code: @[to_additive (attr := simp)]
theorem pow_left (h : Commute a b) (n : ℕ) : Commute (a ^ n) b 
goal: Commute (a ^ n) b

full_name: AddCommute.nsmul_nsmul
code: @[to_additive (attr := simp)]
theorem pow_pow (h : Commute a b) (m n : ℕ) : Commute (a ^ m) (b ^ n) 
goal: AddCommute (m • a) (n • b)

full_name: Commute.pow_pow
code: @[to_additive (attr := simp)]
theorem pow_pow (h : Commute a b) (m n : ℕ) : Commute (a ^ m) (b ^ n) 
goal: Commute (a ^ m) (b ^ n)

full_name: Commute.self_pow
code: @[to_additive]
theorem self_pow (a : M) (n : ℕ) : Commute a (a ^ n) 
goal: Commute a (a ^ n)

full_name: AddCommute.self_nsmul
code: @[to_additive]
theorem self_pow (a : M) (n : ℕ) : Commute a (a ^ n) 
goal: AddCommute a (n • a)

full_name: AddCommute.nsmul_self
code: @[to_additive]
theorem pow_self (a : M) (n : ℕ) : Commute (a ^ n) a 
goal: AddCommute (n • a) a

full_name: Commute.pow_self
code: @[to_additive]
theorem pow_self (a : M) (n : ℕ) : Commute (a ^ n) a 
goal: Commute (a ^ n) a

full_name: Commute.pow_pow_self
code: @[to_additive]
theorem pow_pow_self (a : M) (m n : ℕ) : Commute (a ^ m) (a ^ n) 
goal: Commute (a ^ m) (a ^ n)

full_name: AddCommute.nsmul_nsmul_self
code: @[to_additive]
theorem pow_pow_self (a : M) (m n : ℕ) : Commute (a ^ m) (a ^ n) 
goal: AddCommute (m • a) (n • a)

full_name: AddCommute.add_nsmul
code: @[to_additive] lemma mul_pow (h : Commute a b) : ∀ n, (a * b) ^ n = a ^ n * b ^ n
  
goal: n • (a + b) = n • a + n • b

full_name: Commute.mul_pow
code: @[to_additive] lemma mul_pow (h : Commute a b) : ∀ n, (a * b) ^ n = a ^ n * b ^ n
  
goal: (a * b) ^ n = a ^ n * b ^ n

full_name: AddCommute.add_neg
code: @[to_additive]
protected theorem mul_inv (hab : Commute a b) : (a * b)⁻¹ = a⁻¹ * b⁻¹ 
goal: -(a + b) = -a + -b

full_name: Commute.mul_inv
code: @[to_additive]
protected theorem mul_inv (hab : Commute a b) : (a * b)⁻¹ = a⁻¹ * b⁻¹ 
goal: (a * b)⁻¹ = a⁻¹ * b⁻¹

full_name: AddCommute.neg
code: @[to_additive]
protected theorem inv (hab : Commute a b) : (a * b)⁻¹ = a⁻¹ * b⁻¹ 
goal: -(a + b) = -a + -b

full_name: Commute.inv
code: @[to_additive]
protected theorem inv (hab : Commute a b) : (a * b)⁻¹ = a⁻¹ * b⁻¹ 
goal: (a * b)⁻¹ = a⁻¹ * b⁻¹

full_name: AddCommute.zsmul_add
code: @[to_additive AddCommute.zsmul_add]
protected lemma mul_zpow (h : Commute a b) : ∀ n : ℤ, (a * b) ^ n = a ^ n * b ^ n
  
goal: n • (a + b) = n • a + n • b

full_name: Commute.mul_zpow
code: @[to_additive AddCommute.zsmul_add]
protected lemma mul_zpow (h : Commute a b) : ∀ n : ℤ, (a * b) ^ n = a ^ n * b ^ n
  
goal: (a * b) ^ n = a ^ n * b ^ n

full_name: Commute.mul_inv_cancel
code: @[to_additive]
protected theorem mul_inv_cancel (h : Commute a b) : a * b * a⁻¹ = b 
goal: a * b * a⁻¹ = b

full_name: AddCommute.add_neg_cancel
code: @[to_additive]
protected theorem mul_inv_cancel (h : Commute a b) : a * b * a⁻¹ = b 
goal: a + b + -a = b

full_name: Commute.mul_inv_cancel_assoc
code: @[to_additive]
theorem mul_inv_cancel_assoc (h : Commute a b) : a * (b * a⁻¹) = b 
goal: a * (b * a⁻¹) = b

full_name: AddCommute.add_neg_cancel_assoc
code: @[to_additive]
theorem mul_inv_cancel_assoc (h : Commute a b) : a * (b * a⁻¹) = b 
goal: a + (b + -a) = b