ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- MulAut.one_def
theorem one_def : (1 : MulAut M) = MulEquiv.refl _ 
Arguments: (M : Type u_2) [Mul M]
Goal: 1 = MulEquiv.refl M
-- MulAut.inv_def
theorem inv_def (e₁ : MulAut M) : e₁⁻¹ = e₁.symm 
Arguments: (M : Type u_2) [Mul M] (e₁ : MulAut M)
Goal: e₁⁻¹ = MulEquiv.symm e₁
-- MulAut.mul_apply
@[simp]
theorem mul_apply (e₁ e₂ : MulAut M) (m : M) : (e₁ * e₂) m = e₁ (e₂ m) 
Arguments: (M : Type u_2) [Mul M] (e₁ e₂ : MulAut M) (m : M)
Goal: (e₁ * e₂) m = e₁ (e₂ m)
-- MulAut.one_apply
@[simp]
theorem one_apply (m : M) : (1 : MulAut M) m = m 
Arguments: (M : Type u_2) [Mul M] (m : M)
Goal: 1 m = m
-- MulAut.apply_inv_self
@[simp]
theorem apply_inv_self (e : MulAut M) (m : M) : e (e⁻¹ m) = m 
Arguments: (M : Type u_2) [Mul M] (e : MulAut M) (m : M)
Goal: e (e⁻¹ m) = m
-- MulAut.inv_apply_self
@[simp]
theorem inv_apply_self (e : MulAut M) (m : M) : e⁻¹ (e m) = m 
Arguments: (M : Type u_2) [Mul M] (e : MulAut M) (m : M)
Goal: e⁻¹ (e m) = m
-- MulAut.smul_def
@[simp]
protected theorem smul_def {M} [Monoid M] (f : MulAut M) (a : M) : f • a = f a 
Arguments: {M : Type u_4} [Monoid M] (f : MulAut M) (a : M)
Goal: f • a = f a
-- MulAut.conj_apply
@[simp]
theorem conj_apply [Group G] (g h : G) : conj g h = g * h * g⁻¹ 
Arguments: {G : Type u_3} [Group G] (g h : G)
Goal: (MulAut.conj g) h = g * h * g⁻¹
-- MulAut.conj_symm_apply
@[simp]
theorem conj_symm_apply [Group G] (g h : G) : (conj g).symm h = g⁻¹ * h * g 
Arguments: {G : Type u_3} [Group G] (g h : G)
Goal: (MulEquiv.symm (MulAut.conj g)) h = g⁻¹ * h * g
-- MulAut.conj_inv_apply
@[simp]
theorem conj_inv_apply [Group G] (g h : G) : (conj g)⁻¹ h = g⁻¹ * h * g 
Arguments: {G : Type u_3} [Group G] (g h : G)
Goal: (MulAut.conj g)⁻¹ h = g⁻¹ * h * g
-- AddAut.coe_mul
@[simp]
theorem coe_mul (e₁ e₂ : AddAut A) : ⇑(e₁ * e₂) = e₁ ∘ e₂ 
Arguments: (A : Type u_1) [Add A] (e₁ e₂ : AddAut A)
Goal: ⇑(e₁ * e₂) = ⇑e₁ ∘ ⇑e₂
-- AddAut.coe_one
@[simp]
theorem coe_one : ⇑(1 : AddAut A) = id 
Arguments: (A : Type u_1) [Add A]
Goal: ⇑1 = id
-- AddAut.mul_def
theorem mul_def (e₁ e₂ : AddAut A) : e₁ * e₂ = e₂.trans e₁ 
Arguments: (A : Type u_1) [Add A] (e₁ e₂ : AddAut A)
Goal: e₁ * e₂ = AddEquiv.trans e₂ e₁
-- AddAut.one_def
theorem one_def : (1 : AddAut A) = AddEquiv.refl _ 
Arguments: (A : Type u_1) [Add A]
Goal: 1 = AddEquiv.refl A
-- AddAut.inv_def
theorem inv_def (e₁ : AddAut A) : e₁⁻¹ = e₁.symm 
Arguments: (A : Type u_1) [Add A] (e₁ : AddAut A)
Goal: e₁⁻¹ = AddEquiv.symm e₁
-- AddAut.mul_apply
@[simp]
theorem mul_apply (e₁ e₂ : AddAut A) (a : A) : (e₁ * e₂) a = e₁ (e₂ a) 
Arguments: (A : Type u_1) [Add A] (e₁ e₂ : AddAut A) (a : A)
Goal: (e₁ * e₂) a = e₁ (e₂ a)
-- AddAut.one_apply
@[simp]
theorem one_apply (a : A) : (1 : AddAut A) a = a 
Arguments: (A : Type u_1) [Add A] (a : A)
Goal: 1 a = a
-- AddAut.apply_inv_self
@[simp]
theorem apply_inv_self (e : AddAut A) (a : A) : e⁻¹ (e a) = a 
Arguments: (A : Type u_1) [Add A] (e : AddAut A) (a : A)
Goal: e⁻¹ (e a) = a
-- AddAut.inv_apply_self
@[simp]
theorem inv_apply_self (e : AddAut A) (a : A) : e (e⁻¹ a) = a 
Arguments: (A : Type u_1) [Add A] (e : AddAut A) (a : A)
Goal: e (e⁻¹ a) = a
-- AddAut.smul_def
@[simp]
protected theorem smul_def {A} [AddMonoid A] (f : AddAut A) (a : A) : f • a = f a 
Arguments: {A : Type u_4} [AddMonoid A] (f : AddAut A) (a : A)
Goal: f • a = f a
-- AddAut.conj_apply
@[simp]
theorem conj_apply [AddGroup G] (g h : G) : conj g h = g + h + -g 
Arguments: {G : Type u_3} [AddGroup G] (g h : G)
Goal: (Additive.toMul (AddAut.conj g)) h = g + h + -g
-- AddAut.conj_symm_apply
@[simp]
theorem conj_symm_apply [AddGroup G] (g h : G) : (conj g).symm h = -g + h + g 
Arguments: {G : Type u_3} [AddGroup G] (g h : G)
Goal: (AddEquiv.symm (AddAut.conj g)) h = -g + h + g
-- AddAut.conj_inv_apply
@[simp]
theorem conj_inv_apply [AddGroup G] (g h : G) : (Additive.toMul (conj g))⁻¹ h = -g + h + g 
Arguments: {G : Type u_3} [AddGroup G] (g h : G)
Goal: (Additive.toMul (AddAut.conj g))⁻¹ h = -g + h + g
-- AddSemiconjBy.addUnits_neg_right
@[to_additive "If `a` semiconjugates an additive unit `x` to an additive unit `y`, then it
semiconjugates `-x` to `-y`."]
theorem units_inv_right {a : M} {x y : Mˣ} (h : SemiconjBy a x y) : SemiconjBy a ↑x⁻¹ ↑y⁻¹ 
Arguments: {M : Type u_1} [AddMonoid M] {a : M} {x y : AddUnits M} (h : AddSemiconjBy a ↑x ↑y)
Goal: AddSemiconjBy a ↑(-x) ↑(-y)
-- SemiconjBy.units_inv_right
@[to_additive "If `a` semiconjugates an additive unit `x` to an additive unit `y`, then it
semiconjugates `-x` to `-y`."]
theorem units_inv_right {a : M} {x y : Mˣ} (h : SemiconjBy a x y) : SemiconjBy a ↑x⁻¹ ↑y⁻¹ 
Arguments: {M : Type u_1} [Monoid M] {a : M} {x y : Mˣ} (h : SemiconjBy a ↑x ↑y)
Goal: SemiconjBy a ↑x⁻¹ ↑y⁻¹
-- SemiconjBy.units_inv_right_iff
@[to_additive (attr := simp)]
theorem units_inv_right_iff {a : M} {x y : Mˣ} : SemiconjBy a ↑x⁻¹ ↑y⁻¹ ↔ SemiconjBy a x y 
Arguments: {M : Type u_1} [Monoid M] {a : M} {x y : Mˣ}
Goal: SemiconjBy a ↑x⁻¹ ↑y⁻¹ ↔ SemiconjBy a ↑x ↑y
-- AddSemiconjBy.addUnits_neg_right_iff
@[to_additive (attr := simp)]
theorem units_inv_right_iff {a : M} {x y : Mˣ} : SemiconjBy a ↑x⁻¹ ↑y⁻¹ ↔ SemiconjBy a x y 
Arguments: {M : Type u_1} [AddMonoid M] {a : M} {x y : AddUnits M}
Goal: AddSemiconjBy a ↑(-x) ↑(-y) ↔ AddSemiconjBy a ↑x ↑y
-- AddSemiconjBy.addUnits_neg_symm_left
@[to_additive "If an additive unit `a` semiconjugates `x` to `y`, then `-a` semiconjugates `y` to
`x`."]
theorem units_inv_symm_left {a : Mˣ} {x y : M} (h : SemiconjBy (↑a) x y) : SemiconjBy (↑a⁻¹) y x 
Arguments: {M : Type u_1} [AddMonoid M] {a : AddUnits M} {x y : M} (h : AddSemiconjBy (↑a) x y)
Goal: AddSemiconjBy (↑(-a)) y x
-- SemiconjBy.units_inv_symm_left
@[to_additive "If an additive unit `a` semiconjugates `x` to `y`, then `-a` semiconjugates `y` to
`x`."]
theorem units_inv_symm_left {a : Mˣ} {x y : M} (h : SemiconjBy (↑a) x y) : SemiconjBy (↑a⁻¹) y x 
Arguments: {M : Type u_1} [Monoid M] {a : Mˣ} {x y : M} (h : SemiconjBy (↑a) x y)
Goal: SemiconjBy (↑a⁻¹) y x
-- AddSemiconjBy.addUnits_neg_symm_left_iff
@[to_additive (attr := simp)]
theorem units_inv_symm_left_iff {a : Mˣ} {x y : M} : SemiconjBy (↑a⁻¹) y x ↔ SemiconjBy (↑a) x y 
Arguments: {M : Type u_1} [AddMonoid M] {a : AddUnits M} {x y : M}
Goal: AddSemiconjBy (↑(-a)) y x ↔ AddSemiconjBy (↑a) x y
-- SemiconjBy.units_inv_symm_left_iff
@[to_additive (attr := simp)]
theorem units_inv_symm_left_iff {a : Mˣ} {x y : M} : SemiconjBy (↑a⁻¹) y x ↔ SemiconjBy (↑a) x y 
Arguments: {M : Type u_1} [Monoid M] {a : Mˣ} {x y : M}
Goal: SemiconjBy (↑a⁻¹) y x ↔ SemiconjBy (↑a) x y
-- AddSemiconjBy.addUnits_val
@[to_additive]
theorem units_val {a x y : Mˣ} (h : SemiconjBy a x y) : SemiconjBy (a : M) x y 
Arguments: {M : Type u_1} [AddMonoid M] {a x y : AddUnits M} (h : AddSemiconjBy a x y)
Goal: AddSemiconjBy ↑a ↑x ↑y
-- SemiconjBy.units_val
@[to_additive]
theorem units_val {a x y : Mˣ} (h : SemiconjBy a x y) : SemiconjBy (a : M) x y 
Arguments: {M : Type u_1} [Monoid M] {a x y : Mˣ} (h : SemiconjBy a x y)
Goal: SemiconjBy ↑a ↑x ↑y
-- SemiconjBy.units_of_val
@[to_additive]
theorem units_of_val {a x y : Mˣ} (h : SemiconjBy (a : M) x y) : SemiconjBy a x y 
Arguments: {M : Type u_1} [Monoid M] {a x y : Mˣ} (h : SemiconjBy ↑a ↑x ↑y)
Goal: SemiconjBy a x y
-- AddSemiconjBy.addUnits_of_val
@[to_additive]
theorem units_of_val {a x y : Mˣ} (h : SemiconjBy (a : M) x y) : SemiconjBy a x y 
Arguments: {M : Type u_1} [AddMonoid M] {a x y : AddUnits M} (h : AddSemiconjBy ↑a ↑x ↑y)
Goal: AddSemiconjBy a x y
-- AddSemiconjBy.addUnits_val_iff
@[to_additive (attr := simp)]
theorem units_val_iff {a x y : Mˣ} : SemiconjBy (a : M) x y ↔ SemiconjBy a x y 
Arguments: {M : Type u_1} [AddMonoid M] {a x y : AddUnits M}
Goal: AddSemiconjBy ↑a ↑x ↑y ↔ AddSemiconjBy a x y
-- SemiconjBy.units_val_iff
@[to_additive (attr := simp)]
theorem units_val_iff {a x y : Mˣ} : SemiconjBy (a : M) x y ↔ SemiconjBy a x y 
Arguments: {M : Type u_1} [Monoid M] {a x y : Mˣ}
Goal: SemiconjBy ↑a ↑x ↑y ↔ SemiconjBy a x y
-- SemiconjBy.units_zpow_right
@[to_additive (attr := simp)]
lemma units_zpow_right {a : M} {x y : Mˣ} (h : SemiconjBy a x y) :
    ∀ m : ℤ, SemiconjBy a ↑(x ^ m) ↑(y ^ m)
  
Arguments: {M : Type u_1} [Monoid M] {a : M} {x y : Mˣ} (h : SemiconjBy a ↑x ↑y) (m : ℤ)
Goal: SemiconjBy a ↑(x ^ m) ↑(y ^ m)
-- AddSemiconjBy.addUnits_zsmul_right
@[to_additive (attr := simp)]
lemma units_zpow_right {a : M} {x y : Mˣ} (h : SemiconjBy a x y) :
    ∀ m : ℤ, SemiconjBy a ↑(x ^ m) ↑(y ^ m)
  
Arguments: {M : Type u_1} [AddMonoid M] {a : M} {x y : AddUnits M} (h : AddSemiconjBy a ↑x ↑y) (m : ℤ)
Goal: AddSemiconjBy a ↑(m • x) ↑(m • y)
-- Units.mk_semiconjBy
@[to_additive "`a` semiconjugates `x` to `a + x + -a`."]
lemma mk_semiconjBy (u : Mˣ) (x : M) : SemiconjBy (↑u) x (u * x * ↑u⁻¹) 
Arguments: {M : Type u_1} [Monoid M] (u : Mˣ) (x : M)
Goal: SemiconjBy (↑u) x (↑u * x * ↑u⁻¹)
-- AddUnits.mk_addSemiconjBy
@[to_additive "`a` semiconjugates `x` to `a + x + -a`."]
lemma mk_semiconjBy (u : Mˣ) (x : M) : SemiconjBy (↑u) x (u * x * ↑u⁻¹) 
Arguments: {M : Type u_1} [AddMonoid M] (u : AddUnits M) (x : M)
Goal: AddSemiconjBy (↑u) x (↑u + x + ↑(-u))
-- Units.conj_pow
lemma conj_pow (u : Mˣ) (x : M) (n : ℕ) :
    ((↑u : M) * x * (↑u⁻¹ : M)) ^ n = (u : M) * x ^ n * (↑u⁻¹ : M) 
Arguments: {M : Type u_1} [Monoid M] (u : Mˣ) (x : M) (n : ℕ)
Goal: (↑u * x * ↑u⁻¹) ^ n = ↑u * x ^ n * ↑u⁻¹
-- Units.conj_pow'
lemma conj_pow' (u : Mˣ) (x : M) (n : ℕ) :
    ((↑u⁻¹ : M) * x * (u : M)) ^ n = (↑u⁻¹ : M) * x ^ n * (u : M) 
Arguments: {M : Type u_1} [Monoid M] (u : Mˣ) (x : M) (n : ℕ)
Goal: (↑u⁻¹ * x * ↑u) ^ n = ↑u⁻¹ * x ^ n * ↑u
-- Prod.fst_add
@[to_additive (attr := simp)]
theorem fst_mul [Mul M] [Mul N] (p q : M × N) : (p * q).1 = p.1 * q.1 
Arguments: {M : Type u_5} {N : Type u_6} [Add M] [Add N] (p q : M × N)
Goal: (p + q).1 = p.1 + q.1
-- Prod.fst_mul
@[to_additive (attr := simp)]
theorem fst_mul [Mul M] [Mul N] (p q : M × N) : (p * q).1 = p.1 * q.1 
Arguments: {M : Type u_5} {N : Type u_6} [Mul M] [Mul N] (p q : M × N)
Goal: (p * q).1 = p.1 * q.1
-- Prod.snd_mul
@[to_additive (attr := simp)]
theorem snd_mul [Mul M] [Mul N] (p q : M × N) : (p * q).2 = p.2 * q.2 
Arguments: {M : Type u_5} {N : Type u_6} [Mul M] [Mul N] (p q : M × N)
Goal: (p * q).2 = p.2 * q.2
-- Prod.snd_add
@[to_additive (attr := simp)]
theorem snd_mul [Mul M] [Mul N] (p q : M × N) : (p * q).2 = p.2 * q.2 
Arguments: {M : Type u_5} {N : Type u_6} [Add M] [Add N] (p q : M × N)
Goal: (p + q).2 = p.2 + q.2
-- Prod.mk_mul_mk
@[to_additive (attr := simp)]
theorem mk_mul_mk [Mul M] [Mul N] (a₁ a₂ : M) (b₁ b₂ : N) :
    (a₁, b₁) * (a₂, b₂) = (a₁ * a₂, b₁ * b₂) 
Arguments: {M : Type u_5} {N : Type u_6} [Mul M] [Mul N] (a₁ a₂ : M) (b₁ b₂ : N)
Goal: (a₁, b₁) * (a₂, b₂) = (a₁ * a₂, b₁ * b₂)
-- Prod.mk_add_mk
@[to_additive (attr := simp)]
theorem mk_mul_mk [Mul M] [Mul N] (a₁ a₂ : M) (b₁ b₂ : N) :
    (a₁, b₁) * (a₂, b₂) = (a₁ * a₂, b₁ * b₂) 
Arguments: {M : Type u_5} {N : Type u_6} [Add M] [Add N] (a₁ a₂ : M) (b₁ b₂ : N)
Goal: (a₁, b₁) + (a₂, b₂) = (a₁ + a₂, b₁ + b₂)
-- Prod.swap_mul
@[to_additive (attr := simp)]
theorem swap_mul [Mul M] [Mul N] (p q : M × N) : (p * q).swap = p.swap * q.swap 
Arguments: {M : Type u_5} {N : Type u_6} [Mul M] [Mul N] (p q : M × N)
Goal: (p * q).swap = p.swap * q.swap
-- Prod.swap_add
@[to_additive (attr := simp)]
theorem swap_mul [Mul M] [Mul N] (p q : M × N) : (p * q).swap = p.swap * q.swap 
Arguments: {M : Type u_5} {N : Type u_6} [Add M] [Add N] (p q : M × N)
Goal: (p + q).swap = p.swap + q.swap
-- Prod.add_def
@[to_additive]
theorem mul_def [Mul M] [Mul N] (p q : M × N) : p * q = (p.1 * q.1, p.2 * q.2) 
Arguments: {M : Type u_5} {N : Type u_6} [Add M] [Add N] (p q : M × N)
Goal: p + q = (p.1 + q.1, p.2 + q.2)
-- Prod.mul_def
@[to_additive]
theorem mul_def [Mul M] [Mul N] (p q : M × N) : p * q = (p.1 * q.1, p.2 * q.2) 
Arguments: {M : Type u_5} {N : Type u_6} [Mul M] [Mul N] (p q : M × N)
Goal: p * q = (p.1 * q.1, p.2 * q.2)
-- Prod.zero_mk_add_zero_mk
@[to_additive]
theorem one_mk_mul_one_mk [Monoid M] [Mul N] (b₁ b₂ : N) :
    ((1 : M), b₁) * (1, b₂) = (1, b₁ * b₂) 
Arguments: {M : Type u_5} {N : Type u_6} [AddMonoid M] [Add N] (b₁ b₂ : N)
Goal: (0, b₁) + (0, b₂) = (0, b₁ + b₂)
-- Prod.one_mk_mul_one_mk
@[to_additive]
theorem one_mk_mul_one_mk [Monoid M] [Mul N] (b₁ b₂ : N) :
    ((1 : M), b₁) * (1, b₂) = (1, b₁ * b₂) 
Arguments: {M : Type u_5} {N : Type u_6} [Monoid M] [Mul N] (b₁ b₂ : N)
Goal: (1, b₁) * (1, b₂) = (1, b₁ * b₂)
-- Prod.mk_zero_add_mk_zero
@[to_additive]
theorem mk_one_mul_mk_one [Mul M] [Monoid N] (a₁ a₂ : M) :
    (a₁, (1 : N)) * (a₂, 1) = (a₁ * a₂, 1) 
Arguments: {M : Type u_5} {N : Type u_6} [Add M] [AddMonoid N] (a₁ a₂ : M)
Goal: (a₁, 0) + (a₂, 0) = (a₁ + a₂, 0)
-- Prod.mk_one_mul_mk_one
@[to_additive]
theorem mk_one_mul_mk_one [Mul M] [Monoid N] (a₁ a₂ : M) :
    (a₁, (1 : N)) * (a₂, 1) = (a₁ * a₂, 1) 
Arguments: {M : Type u_5} {N : Type u_6} [Mul M] [Monoid N] (a₁ a₂ : M)
Goal: (a₁, 1) * (a₂, 1) = (a₁ * a₂, 1)
-- Prod.fst_one
@[to_additive (attr := simp)]
theorem fst_one [One M] [One N] : (1 : M × N).1 = 1 
Arguments: {M : Type u_5} {N : Type u_6} [One M] [One N]
Goal: 1.1 = 1
-- Prod.fst_zero
@[to_additive (attr := simp)]
theorem fst_one [One M] [One N] : (1 : M × N).1 = 1 
Arguments: {M : Type u_5} {N : Type u_6} [Zero M] [Zero N]
Goal: 0.1 = 0
-- Prod.snd_one
@[to_additive (attr := simp)]
theorem snd_one [One M] [One N] : (1 : M × N).2 = 1 
Arguments: {M : Type u_5} {N : Type u_6} [One M] [One N]
Goal: 1.2 = 1
-- Prod.snd_zero
@[to_additive (attr := simp)]
theorem snd_one [One M] [One N] : (1 : M × N).2 = 1 
Arguments: {M : Type u_5} {N : Type u_6} [Zero M] [Zero N]
Goal: 0.2 = 0
-- Prod.zero_eq_mk
@[to_additive]
theorem one_eq_mk [One M] [One N] : (1 : M × N) = (1, 1) 
Arguments: {M : Type u_5} {N : Type u_6} [Zero M] [Zero N]
Goal: 0 = (0, 0)
-- Prod.one_eq_mk
@[to_additive]
theorem one_eq_mk [One M] [One N] : (1 : M × N) = (1, 1) 
Arguments: {M : Type u_5} {N : Type u_6} [One M] [One N]
Goal: 1 = (1, 1)
-- Prod.mk_eq_one
@[to_additive (attr := simp)]
theorem mk_eq_one [One M] [One N] {x : M} {y : N} : (x, y) = 1 ↔ x = 1 ∧ y = 1 
Arguments: {M : Type u_5} {N : Type u_6} [One M] [One N] {x : M} {y : N}
Goal: (x, y) = 1 ↔ x = 1 ∧ y = 1
-- Prod.mk_eq_zero
@[to_additive (attr := simp)]
theorem mk_eq_one [One M] [One N] {x : M} {y : N} : (x, y) = 1 ↔ x = 1 ∧ y = 1 
Arguments: {M : Type u_5} {N : Type u_6} [Zero M] [Zero N] {x : M} {y : N}
Goal: (x, y) = 0 ↔ x = 0 ∧ y = 0
-- Prod.swap_one
@[to_additive (attr := simp)]
theorem swap_one [One M] [One N] : (1 : M × N).swap = 1 
Arguments: {M : Type u_5} {N : Type u_6} [One M] [One N]
Goal: Prod.swap 1 = 1
-- Prod.swap_zero
@[to_additive (attr := simp)]
theorem swap_one [One M] [One N] : (1 : M × N).swap = 1 
Arguments: {M : Type u_5} {N : Type u_6} [Zero M] [Zero N]
Goal: Prod.swap 0 = 0
-- Prod.fst_mul_snd
@[to_additive]
theorem fst_mul_snd [MulOneClass M] [MulOneClass N] (p : M × N) : (p.fst, 1) * (1, p.snd) = p 
Arguments: {M : Type u_5} {N : Type u_6} [MulOneClass M] [MulOneClass N] (p : M × N)
Goal: (p.1, 1) * (1, p.2) = p
-- Prod.fst_add_snd
@[to_additive]
theorem fst_mul_snd [MulOneClass M] [MulOneClass N] (p : M × N) : (p.fst, 1) * (1, p.snd) = p 
Arguments: {M : Type u_5} {N : Type u_6} [AddZeroClass M] [AddZeroClass N] (p : M × N)
Goal: (p.1, 0) + (0, p.2) = p
-- Prod.fst_inv
@[to_additive (attr := simp)]
theorem fst_inv [Inv G] [Inv H] (p : G × H) : p⁻¹.1 = p.1⁻¹ 
Arguments: {G : Type u_3} {H : Type u_4} [Inv G] [Inv H] (p : G × H)
Goal: p⁻¹.1 = p.1⁻¹
-- Prod.fst_neg
@[to_additive (attr := simp)]
theorem fst_inv [Inv G] [Inv H] (p : G × H) : p⁻¹.1 = p.1⁻¹ 
Arguments: {G : Type u_3} {H : Type u_4} [Neg G] [Neg H] (p : G × H)
Goal: (-p).1 = -p.1
-- Prod.snd_neg
@[to_additive (attr := simp)]
theorem snd_inv [Inv G] [Inv H] (p : G × H) : p⁻¹.2 = p.2⁻¹ 
Arguments: {G : Type u_3} {H : Type u_4} [Neg G] [Neg H] (p : G × H)
Goal: (-p).2 = -p.2
-- Prod.snd_inv
@[to_additive (attr := simp)]
theorem snd_inv [Inv G] [Inv H] (p : G × H) : p⁻¹.2 = p.2⁻¹ 
Arguments: {G : Type u_3} {H : Type u_4} [Inv G] [Inv H] (p : G × H)
Goal: p⁻¹.2 = p.2⁻¹
-- Prod.neg_mk
@[to_additive (attr := simp)]
theorem inv_mk [Inv G] [Inv H] (a : G) (b : H) : (a, b)⁻¹ = (a⁻¹, b⁻¹) 
Arguments: {G : Type u_3} {H : Type u_4} [Neg G] [Neg H] (a : G) (b : H)
Goal: -(a, b) = (-a, -b)
-- Prod.inv_mk
@[to_additive (attr := simp)]
theorem inv_mk [Inv G] [Inv H] (a : G) (b : H) : (a, b)⁻¹ = (a⁻¹, b⁻¹) 
Arguments: {G : Type u_3} {H : Type u_4} [Inv G] [Inv H] (a : G) (b : H)
Goal: (a, b)⁻¹ = (a⁻¹, b⁻¹)
-- Prod.swap_neg
@[to_additive (attr := simp)]
theorem swap_inv [Inv G] [Inv H] (p : G × H) : p⁻¹.swap = p.swap⁻¹ 
Arguments: {G : Type u_3} {H : Type u_4} [Neg G] [Neg H] (p : G × H)
Goal: (-p).swap = -p.swap
-- Prod.swap_inv
@[to_additive (attr := simp)]
theorem swap_inv [Inv G] [Inv H] (p : G × H) : p⁻¹.swap = p.swap⁻¹ 
Arguments: {G : Type u_3} {H : Type u_4} [Inv G] [Inv H] (p : G × H)
Goal: p⁻¹.swap = p.swap⁻¹
-- Prod.fst_div
@[to_additive (attr := simp)]
theorem fst_div [Div G] [Div H] (a b : G × H) : (a / b).1 = a.1 / b.1 
Arguments: {G : Type u_3} {H : Type u_4} [Div G] [Div H] (a b : G × H)
Goal: (a / b).1 = a.1 / b.1
-- Prod.fst_sub
@[to_additive (attr := simp)]
theorem fst_div [Div G] [Div H] (a b : G × H) : (a / b).1 = a.1 / b.1 
Arguments: {G : Type u_3} {H : Type u_4} [Sub G] [Sub H] (a b : G × H)
Goal: (a - b).1 = a.1 - b.1
-- Prod.snd_div
@[to_additive (attr := simp)]
theorem snd_div [Div G] [Div H] (a b : G × H) : (a / b).2 = a.2 / b.2 
Arguments: {G : Type u_3} {H : Type u_4} [Div G] [Div H] (a b : G × H)
Goal: (a / b).2 = a.2 / b.2
-- Prod.snd_sub
@[to_additive (attr := simp)]
theorem snd_div [Div G] [Div H] (a b : G × H) : (a / b).2 = a.2 / b.2 
Arguments: {G : Type u_3} {H : Type u_4} [Sub G] [Sub H] (a b : G × H)
Goal: (a - b).2 = a.2 - b.2
-- Prod.mk_sub_mk
@[to_additive (attr := simp)]
theorem mk_div_mk [Div G] [Div H] (x₁ x₂ : G) (y₁ y₂ : H) :
    (x₁, y₁) / (x₂, y₂) = (x₁ / x₂, y₁ / y₂) 
Arguments: {G : Type u_3} {H : Type u_4} [Sub G] [Sub H] (x₁ x₂ : G) (y₁ y₂ : H)
Goal: (x₁, y₁) - (x₂, y₂) = (x₁ - x₂, y₁ - y₂)
-- Prod.mk_div_mk
@[to_additive (attr := simp)]
theorem mk_div_mk [Div G] [Div H] (x₁ x₂ : G) (y₁ y₂ : H) :
    (x₁, y₁) / (x₂, y₂) = (x₁ / x₂, y₁ / y₂) 
Arguments: {G : Type u_3} {H : Type u_4} [Div G] [Div H] (x₁ x₂ : G) (y₁ y₂ : H)
Goal: (x₁, y₁) / (x₂, y₂) = (x₁ / x₂, y₁ / y₂)
-- Prod.swap_sub
@[to_additive (attr := simp)]
theorem swap_div [Div G] [Div H] (a b : G × H) : (a / b).swap = a.swap / b.swap 
Arguments: {G : Type u_3} {H : Type u_4} [Sub G] [Sub H] (a b : G × H)
Goal: (a - b).swap = a.swap - b.swap
-- Prod.swap_div
@[to_additive (attr := simp)]
theorem swap_div [Div G] [Div H] (a b : G × H) : (a / b).swap = a.swap / b.swap 
Arguments: {G : Type u_3} {H : Type u_4} [Div G] [Div H] (a b : G × H)
Goal: (a / b).swap = a.swap / b.swap
-- SemiconjBy.prod
@[to_additive AddSemiconjBy.prod]
theorem SemiconjBy.prod {x y z : M × N}
    (hm : SemiconjBy x.1 y.1 z.1) (hn : SemiconjBy x.2 y.2 z.2) : SemiconjBy x y z 
Arguments: {M : Type u_5} {N : Type u_6} [Mul M] [Mul N] {x y z : M × N} (hm : SemiconjBy x.1 y.1 z.1) (hn : SemiconjBy x.2 y.2 z.2)
Goal: SemiconjBy x y z
-- AddSemiconjBy.prod
@[to_additive AddSemiconjBy.prod]
theorem SemiconjBy.prod {x y z : M × N}
    (hm : SemiconjBy x.1 y.1 z.1) (hn : SemiconjBy x.2 y.2 z.2) : SemiconjBy x y z 
Arguments: {M : Type u_5} {N : Type u_6} [Add M] [Add N] {x y z : M × N} (hm : AddSemiconjBy x.1 y.1 z.1) (hn : AddSemiconjBy x.2 y.2 z.2)
Goal: AddSemiconjBy x y z
-- Prod.addSemiconjBy_iff
@[to_additive]
theorem Prod.semiconjBy_iff {x y z : M × N} :
    SemiconjBy x y z ↔ SemiconjBy x.1 y.1 z.1 ∧ SemiconjBy x.2 y.2 z.2 
Arguments: {M : Type u_5} {N : Type u_6} [Add M] [Add N] {x y z : M × N}
Goal: AddSemiconjBy x y z ↔ AddSemiconjBy x.1 y.1 z.1 ∧ AddSemiconjBy x.2 y.2 z.2
-- Prod.semiconjBy_iff
@[to_additive]
theorem Prod.semiconjBy_iff {x y z : M × N} :
    SemiconjBy x y z ↔ SemiconjBy x.1 y.1 z.1 ∧ SemiconjBy x.2 y.2 z.2 
Arguments: {M : Type u_5} {N : Type u_6} [Mul M] [Mul N] {x y z : M × N}
Goal: SemiconjBy x y z ↔ SemiconjBy x.1 y.1 z.1 ∧ SemiconjBy x.2 y.2 z.2
-- AddCommute.prod
@[to_additive AddCommute.prod]
theorem Commute.prod {x y : M × N} (hm : Commute x.1 y.1) (hn : Commute x.2 y.2) : Commute x y 
Arguments: {M : Type u_5} {N : Type u_6} [Add M] [Add N] {x y : M × N} (hm : AddCommute x.1 y.1) (hn : AddCommute x.2 y.2)
Goal: AddCommute x y
-- Commute.prod
@[to_additive AddCommute.prod]
theorem Commute.prod {x y : M × N} (hm : Commute x.1 y.1) (hn : Commute x.2 y.2) : Commute x y 
Arguments: {M : Type u_5} {N : Type u_6} [Mul M] [Mul N] {x y : M × N} (hm : Commute x.1 y.1) (hn : Commute x.2 y.2)
Goal: Commute x y
-- Prod.addCommute_iff
@[to_additive]
theorem Prod.commute_iff {x y : M × N} :
    Commute x y ↔ Commute x.1 y.1 ∧ Commute x.2 y.2 
Arguments: {M : Type u_5} {N : Type u_6} [Add M] [Add N] {x y : M × N}
Goal: AddCommute x y ↔ AddCommute x.1 y.1 ∧ AddCommute x.2 y.2
-- Prod.commute_iff
@[to_additive]
theorem Prod.commute_iff {x y : M × N} :
    Commute x y ↔ Commute x.1 y.1 ∧ Commute x.2 y.2 
Arguments: {M : Type u_5} {N : Type u_6} [Mul M] [Mul N] {x y : M × N}
Goal: Commute x y ↔ Commute x.1 y.1 ∧ Commute x.2 y.2
-- AddHom.coe_fst
@[to_additive (attr := simp)]
theorem coe_fst : ⇑(fst M N) = Prod.fst 
Arguments: {M : Type u_5} {N : Type u_6} [Add M] [Add N]
Goal: ⇑(AddHom.fst M N) = Prod.fst
-- MulHom.coe_fst
@[to_additive (attr := simp)]
theorem coe_fst : ⇑(fst M N) = Prod.fst 
Arguments: {M : Type u_5} {N : Type u_6} [Mul M] [Mul N]
Goal: ⇑(MulHom.fst M N) = Prod.fst
-- MulHom.coe_snd
@[to_additive (attr := simp)]
theorem coe_snd : ⇑(snd M N) = Prod.snd 
Arguments: {M : Type u_5} {N : Type u_6} [Mul M] [Mul N]
Goal: ⇑(MulHom.snd M N) = Prod.snd
-- AddHom.coe_snd
@[to_additive (attr := simp)]
theorem coe_snd : ⇑(snd M N) = Prod.snd 
Arguments: {M : Type u_5} {N : Type u_6} [Add M] [Add N]
Goal: ⇑(AddHom.snd M N) = Prod.snd
-- AddHom.coe_prod
@[to_additive coe_prod]
theorem coe_prod (f : M →ₙ* N) (g : M →ₙ* P) : ⇑(f.prod g) = Pi.prod f g 
Arguments: {M : Type u_5} {N : Type u_6} {P : Type u_7} [Add M] [Add N] [Add P] (f : AddHom M N) (g : AddHom M P)
Goal: ⇑(f.prod g) = Pi.prod ⇑f ⇑g
-- MulHom.coe_prod
@[to_additive coe_prod]
theorem coe_prod (f : M →ₙ* N) (g : M →ₙ* P) : ⇑(f.prod g) = Pi.prod f g 
Arguments: {M : Type u_5} {N : Type u_6} {P : Type u_7} [Mul M] [Mul N] [Mul P] (f : M →ₙ* N) (g : M →ₙ* P)
Goal: ⇑(f.prod g) = Pi.prod ⇑f ⇑g
-- AddHom.prod_apply
@[to_additive (attr := simp) prod_apply]
theorem prod_apply (f : M →ₙ* N) (g : M →ₙ* P) (x) : f.prod g x = (f x, g x) 
Arguments: {M : Type u_5} {N : Type u_6} {P : Type u_7} [Add M] [Add N] [Add P] (f : AddHom M N) (g : AddHom M P) (x : M)
Goal: (f.prod g) x = (f x, g x)
-- MulHom.prod_apply
@[to_additive (attr := simp) prod_apply]
theorem prod_apply (f : M →ₙ* N) (g : M →ₙ* P) (x) : f.prod g x = (f x, g x) 
Arguments: {M : Type u_5} {N : Type u_6} {P : Type u_7} [Mul M] [Mul N] [Mul P] (f : M →ₙ* N) (g : M →ₙ* P) (x : M)
Goal: (f.prod g) x = (f x, g x)
-- AddHom.fst_comp_prod
@[to_additive (attr := simp) fst_comp_prod]
theorem fst_comp_prod (f : M →ₙ* N) (g : M →ₙ* P) : (fst N P).comp (f.prod g) = f 
Arguments: {M : Type u_5} {N : Type u_6} {P : Type u_7} [Add M] [Add N] [Add P] (f : AddHom M N) (g : AddHom M P)
Goal: (AddHom.fst N P).comp (f.prod g) = f
-- MulHom.fst_comp_prod
@[to_additive (attr := simp) fst_comp_prod]
theorem fst_comp_prod (f : M →ₙ* N) (g : M →ₙ* P) : (fst N P).comp (f.prod g) = f 
Arguments: {M : Type u_5} {N : Type u_6} {P : Type u_7} [Mul M] [Mul N] [Mul P] (f : M →ₙ* N) (g : M →ₙ* P)
Goal: (MulHom.fst N P).comp (f.prod g) = f
-- AddHom.snd_comp_prod
@[to_additive (attr := simp) snd_comp_prod]
theorem snd_comp_prod (f : M →ₙ* N) (g : M →ₙ* P) : (snd N P).comp (f.prod g) = g 
Arguments: {M : Type u_5} {N : Type u_6} {P : Type u_7} [Add M] [Add N] [Add P] (f : AddHom M N) (g : AddHom M P)
Goal: (AddHom.snd N P).comp (f.prod g) = g
-- MulHom.snd_comp_prod
@[to_additive (attr := simp) snd_comp_prod]
theorem snd_comp_prod (f : M →ₙ* N) (g : M →ₙ* P) : (snd N P).comp (f.prod g) = g 
Arguments: {M : Type u_5} {N : Type u_6} {P : Type u_7} [Mul M] [Mul N] [Mul P] (f : M →ₙ* N) (g : M →ₙ* P)
Goal: (MulHom.snd N P).comp (f.prod g) = g