ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- SubNegMonoid.zsmul_succ'
class SubNegMonoid (G : Type u) extends AddMonoid G, Neg G, Sub G where
  protected sub := SubNegMonoid.sub'
  protected sub_eq_add_neg : ∀ a b : G, a - b = a + -b := by intros; rfl
    protected zsmul : ℤ → G → G
  protected zsmul_zero' : ∀ a : G, zsmul 0 a = 0 := by intros; rfl
  protected zsmul_succ' (n : ℕ) (a : G) :
      zsmul (Int.ofNat n.succ) a = zsmul (Int.ofNat n) a + a := by
    intros; rfl
  protected zsmul_neg' (n : ℕ) (a : G) : zsmul (Int.negSucc n) a = -zsmul n.succ a := by
    intros; rfl
Arguments: {G : Type u} [self : SubNegMonoid G] (n : ℕ) (a : G)
Goal: SubNegMonoid.zsmul (Int.ofNat n.succ) a = SubNegMonoid.zsmul (Int.ofNat n) a + a
-- zpow_eq_pow
@[to_additive (attr := simp) zsmul_eq_smul] theorem zpow_eq_pow (n : ℤ) (x : G) :
    DivInvMonoid.zpow n x = x ^ n 
Arguments: {G : Type u_1} [DivInvMonoid G] (n : ℤ) (x : G)
Goal: DivInvMonoid.zpow n x = x ^ n
-- zsmul_eq_smul
@[to_additive (attr := simp) zsmul_eq_smul] theorem zpow_eq_pow (n : ℤ) (x : G) :
    DivInvMonoid.zpow n x = x ^ n 
Arguments: {G : Type u_1} [SubNegMonoid G] (n : ℤ) (x : G)
Goal: SubNegMonoid.zsmul n x = n • x
-- zero_zsmul
@[to_additive (attr := simp) zero_zsmul] theorem zpow_zero (a : G) : a ^ (0 : ℤ) = 1 
Arguments: {G : Type u_1} [SubNegMonoid G] (a : G)
Goal: 0 • a = 0
-- zpow_zero
@[to_additive (attr := simp) zero_zsmul] theorem zpow_zero (a : G) : a ^ (0 : ℤ) = 1 
Arguments: {G : Type u_1} [DivInvMonoid G] (a : G)
Goal: a ^ 0 = 1
-- natCast_zsmul
@[to_additive (attr := simp, norm_cast) natCast_zsmul]
theorem zpow_natCast (a : G) : ∀ n : ℕ, a ^ (n : ℤ) = a ^ n
  
Arguments: {G : Type u_1} [SubNegMonoid G] (a : G) (n : ℕ)
Goal: ↑n • a = n • a
-- zpow_natCast
@[to_additive (attr := simp, norm_cast) natCast_zsmul]
theorem zpow_natCast (a : G) : ∀ n : ℕ, a ^ (n : ℤ) = a ^ n
  
Arguments: {G : Type u_1} [DivInvMonoid G] (a : G) (n : ℕ)
Goal: a ^ ↑n = a ^ n
-- zpow_ofNat
@[to_additive ofNat_zsmul]
lemma zpow_ofNat (a : G) (n : ℕ) : a ^ (no_index (OfNat.ofNat n) : ℤ) = a ^ OfNat.ofNat n 
Arguments: {G : Type u_1} [DivInvMonoid G] (a : G) (n : ℕ)
Goal: a ^ OfNat.ofNat n = a ^ OfNat.ofNat n
-- ofNat_zsmul
@[to_additive ofNat_zsmul]
lemma zpow_ofNat (a : G) (n : ℕ) : a ^ (no_index (OfNat.ofNat n) : ℤ) = a ^ OfNat.ofNat n 
Arguments: {G : Type u_1} [SubNegMonoid G] (a : G) (n : ℕ)
Goal: OfNat.ofNat n • a = OfNat.ofNat n • a
-- zpow_negSucc
theorem zpow_negSucc (a : G) (n : ℕ) : a ^ (Int.negSucc n) = (a ^ (n + 1))⁻¹ 
Arguments: {G : Type u_1} [DivInvMonoid G] (a : G) (n : ℕ)
Goal: a ^ Int.negSucc n = (a ^ (n + 1))⁻¹
-- negSucc_zsmul
theorem negSucc_zsmul {G} [SubNegMonoid G] (a : G) (n : ℕ) :
    Int.negSucc n • a = -((n + 1) • a) 
Arguments: {G : Type u_2} [SubNegMonoid G] (a : G) (n : ℕ)
Goal: Int.negSucc n • a = -((n + 1) • a)
-- sub_eq_add_neg
@[to_additive "Subtracting an element is the same as adding by its negative.
This is a duplicate of `SubNegMonoid.sub_eq_mul_neg` ensuring that the types unfold better."]
theorem div_eq_mul_inv (a b : G) : a / b = a * b⁻¹ 
Arguments: {G : Type u_1} [SubNegMonoid G] (a b : G)
Goal: a - b = a + -b
-- div_eq_mul_inv
@[to_additive "Subtracting an element is the same as adding by its negative.
This is a duplicate of `SubNegMonoid.sub_eq_mul_neg` ensuring that the types unfold better."]
theorem div_eq_mul_inv (a b : G) : a / b = a * b⁻¹ 
Arguments: {G : Type u_1} [DivInvMonoid G] (a b : G)
Goal: a / b = a * b⁻¹
-- one_zsmul
@[to_additive (attr := simp) one_zsmul]
lemma zpow_one (a : G) : a ^ (1 : ℤ) = a 
Arguments: {G : Type u_1} [SubNegMonoid G] (a : G)
Goal: 1 • a = a
-- zpow_one
@[to_additive (attr := simp) one_zsmul]
lemma zpow_one (a : G) : a ^ (1 : ℤ) = a 
Arguments: {G : Type u_1} [DivInvMonoid G] (a : G)
Goal: a ^ 1 = a
-- two_zsmul
@[to_additive two_zsmul] lemma zpow_two (a : G) : a ^ (2 : ℤ) = a * a 
Arguments: {G : Type u_1} [SubNegMonoid G] (a : G)
Goal: 2 • a = a + a
-- zpow_two
@[to_additive two_zsmul] lemma zpow_two (a : G) : a ^ (2 : ℤ) = a * a 
Arguments: {G : Type u_1} [DivInvMonoid G] (a : G)
Goal: a ^ 2 = a * a
-- zpow_neg_one
@[to_additive neg_one_zsmul]
lemma zpow_neg_one (x : G) : x ^ (-1 : ℤ) = x⁻¹ 
Arguments: {G : Type u_1} [DivInvMonoid G] (x : G)
Goal: x ^ (-1) = x⁻¹
-- neg_one_zsmul
@[to_additive neg_one_zsmul]
lemma zpow_neg_one (x : G) : x ^ (-1 : ℤ) = x⁻¹ 
Arguments: {G : Type u_1} [SubNegMonoid G] (x : G)
Goal: -1 • x = -x
-- zsmul_neg_coe_of_pos
@[to_additive]
lemma zpow_neg_coe_of_pos (a : G) : ∀ {n : ℕ}, 0 < n → a ^ (-(n : ℤ)) = (a ^ n)⁻¹
  
Arguments: {G : Type u_1} [SubNegMonoid G] (a : G) {n : ℕ}
Goal: 0 < n → -↑n • a = -(n • a)
-- zpow_neg_coe_of_pos
@[to_additive]
lemma zpow_neg_coe_of_pos (a : G) : ∀ {n : ℕ}, 0 < n → a ^ (-(n : ℤ)) = (a ^ n)⁻¹
  
Arguments: {G : Type u_1} [DivInvMonoid G] (a : G) {n : ℕ}
Goal: 0 < n → a ^ (-↑n) = (a ^ n)⁻¹
-- NegZeroClass.neg_zero
class NegZeroClass (G : Type*) extends Zero G, Neg G where
  protected neg_zero : -(0 : G) = 0
Arguments: {G : Type u_2} [self : NegZeroClass G]
Goal: -0 = 0
-- InvOneClass.inv_one
@[to_additive]
class InvOneClass (G : Type*) extends One G, Inv G where
  protected inv_one : (1 : G)⁻¹ = 1
Arguments: {G : Type u_2} [self : InvOneClass G]
Goal: 1⁻¹ = 1
-- inv_one
@[to_additive (attr := simp)]
theorem inv_one : (1 : G)⁻¹ = 1 
Arguments: {G : Type u_1} [InvOneClass G]
Goal: 1⁻¹ = 1
-- neg_zero
@[to_additive (attr := simp)]
theorem inv_one : (1 : G)⁻¹ = 1 
Arguments: {G : Type u_1} [NegZeroClass G]
Goal: -0 = 0
-- SubtractionMonoid.neg_eq_of_add
class SubtractionMonoid (G : Type u) extends SubNegMonoid G, InvolutiveNeg G where
  protected neg_add_rev (a b : G) : -(a + b) = -b + -a
    protected neg_eq_of_add (a b : G) : a + b = 0 → -a = b
Arguments: {G : Type u} [self : SubtractionMonoid G] (a b : G)
Goal: a + b = 0 → -a = b
-- SubtractionMonoid.neg_add_rev
class SubtractionMonoid (G : Type u) extends SubNegMonoid G, InvolutiveNeg G where
  protected neg_add_rev (a b : G) : -(a + b) = -b + -a
    protected neg_eq_of_add (a b : G) : a + b = 0 → -a = b
Arguments: {G : Type u} [self : SubtractionMonoid G] (a b : G)
Goal: -(a + b) = -b + -a
-- DivisionMonoid.inv_eq_of_mul
@[to_additive SubtractionMonoid]
class DivisionMonoid (G : Type u) extends DivInvMonoid G, InvolutiveInv G where
  protected mul_inv_rev (a b : G) : (a * b)⁻¹ = b⁻¹ * a⁻¹
    protected inv_eq_of_mul (a b : G) : a * b = 1 → a⁻¹ = b
Arguments: {G : Type u} [self : DivisionMonoid G] (a b : G)
Goal: a * b = 1 → a⁻¹ = b
-- DivisionMonoid.mul_inv_rev
@[to_additive SubtractionMonoid]
class DivisionMonoid (G : Type u) extends DivInvMonoid G, InvolutiveInv G where
  protected mul_inv_rev (a b : G) : (a * b)⁻¹ = b⁻¹ * a⁻¹
    protected inv_eq_of_mul (a b : G) : a * b = 1 → a⁻¹ = b
Arguments: {G : Type u} [self : DivisionMonoid G] (a b : G)
Goal: (a * b)⁻¹ = b⁻¹ * a⁻¹
-- neg_add_rev
@[to_additive (attr := simp) neg_add_rev]
theorem mul_inv_rev (a b : G) : (a * b)⁻¹ = b⁻¹ * a⁻¹ 
Arguments: {G : Type u_1} [SubtractionMonoid G] (a b : G)
Goal: -(a + b) = -b + -a
-- mul_inv_rev
@[to_additive (attr := simp) neg_add_rev]
theorem mul_inv_rev (a b : G) : (a * b)⁻¹ = b⁻¹ * a⁻¹ 
Arguments: {G : Type u_1} [DivisionMonoid G] (a b : G)
Goal: (a * b)⁻¹ = b⁻¹ * a⁻¹
-- inv_eq_of_mul_eq_one_right
@[to_additive]
theorem inv_eq_of_mul_eq_one_right : a * b = 1 → a⁻¹ = b 
Arguments: {G : Type u_1} [DivisionMonoid G] {a b : G}
Goal: a * b = 1 → a⁻¹ = b
-- neg_eq_of_add_eq_zero_right
@[to_additive]
theorem inv_eq_of_mul_eq_one_right : a * b = 1 → a⁻¹ = b 
Arguments: {G : Type u_1} [SubtractionMonoid G] {a b : G}
Goal: a + b = 0 → -a = b
-- inv_eq_of_mul_eq_one_left
@[to_additive]
theorem inv_eq_of_mul_eq_one_left (h : a * b = 1) : b⁻¹ = a 
Arguments: {G : Type u_1} [DivisionMonoid G] {a b : G} (h : a * b = 1)
Goal: b⁻¹ = a
-- neg_eq_of_add_eq_zero_left
@[to_additive]
theorem inv_eq_of_mul_eq_one_left (h : a * b = 1) : b⁻¹ = a 
Arguments: {G : Type u_1} [SubtractionMonoid G] {a b : G} (h : a + b = 0)
Goal: -b = a
-- eq_neg_of_add_eq_zero_left
@[to_additive]
theorem eq_inv_of_mul_eq_one_left (h : a * b = 1) : a = b⁻¹ 
Arguments: {G : Type u_1} [SubtractionMonoid G] {a b : G} (h : a + b = 0)
Goal: a = -b
-- eq_inv_of_mul_eq_one_left
@[to_additive]
theorem eq_inv_of_mul_eq_one_left (h : a * b = 1) : a = b⁻¹ 
Arguments: {G : Type u_1} [DivisionMonoid G] {a b : G} (h : a * b = 1)
Goal: a = b⁻¹
-- Group.mul_left_inv
class Group (G : Type u) extends DivInvMonoid G where
  protected mul_left_inv : ∀ a : G, a⁻¹ * a = 1
Arguments: {G : Type u} [self : Group G] (a : G)
Goal: a⁻¹ * a = 1
-- AddGroup.add_left_neg
class AddGroup (A : Type u) extends SubNegMonoid A where
  protected add_left_neg : ∀ a : A, -a + a = 0
Arguments: {A : Type u} [self : AddGroup A] (a : A)
Goal: -a + a = 0
-- add_left_neg
@[to_additive (attr := simp)]
theorem mul_left_inv : ∀ a : G, a⁻¹ * a = 1 
Arguments: {G : Type u_1} [AddGroup G] (a : G)
Goal: -a + a = 0
-- mul_left_inv
@[to_additive (attr := simp)]
theorem mul_left_inv : ∀ a : G, a⁻¹ * a = 1 
Arguments: {G : Type u_1} [Group G] (a : G)
Goal: a⁻¹ * a = 1
-- neg_add_self
@[to_additive]
theorem inv_mul_self (a : G) : a⁻¹ * a = 1 
Arguments: {G : Type u_1} [AddGroup G] (a : G)
Goal: -a + a = 0
-- inv_mul_self
@[to_additive]
theorem inv_mul_self (a : G) : a⁻¹ * a = 1 
Arguments: {G : Type u_1} [Group G] (a : G)
Goal: a⁻¹ * a = 1
-- _private.Mathlib.Algebra.Group.Defs.0.neg_eq_of_add
@[to_additive]
private theorem inv_eq_of_mul (h : a * b = 1) : a⁻¹ = b 
Arguments: {G : Type u_1} [AddGroup G] {a b : G} (h : a + b = 0)
Goal: -a = b
-- _private.Mathlib.Algebra.Group.Defs.0.inv_eq_of_mul
@[to_additive]
private theorem inv_eq_of_mul (h : a * b = 1) : a⁻¹ = b 
Arguments: {G : Type u_1} [Group G] {a b : G} (h : a * b = 1)
Goal: a⁻¹ = b
-- mul_right_inv
@[to_additive (attr := simp)]
theorem mul_right_inv (a : G) : a * a⁻¹ = 1 
Arguments: {G : Type u_1} [Group G] (a : G)
Goal: a * a⁻¹ = 1
-- add_right_neg
@[to_additive (attr := simp)]
theorem mul_right_inv (a : G) : a * a⁻¹ = 1 
Arguments: {G : Type u_1} [AddGroup G] (a : G)
Goal: a + -a = 0
-- mul_inv_self
@[to_additive]
theorem mul_inv_self (a : G) : a * a⁻¹ = 1 
Arguments: {G : Type u_1} [Group G] (a : G)
Goal: a * a⁻¹ = 1
-- add_neg_self
@[to_additive]
theorem mul_inv_self (a : G) : a * a⁻¹ = 1 
Arguments: {G : Type u_1} [AddGroup G] (a : G)
Goal: a + -a = 0
-- neg_add_cancel_left
@[to_additive (attr := simp)]
theorem inv_mul_cancel_left (a b : G) : a⁻¹ * (a * b) = b 
Arguments: {G : Type u_1} [AddGroup G] (a b : G)
Goal: -a + (a + b) = b
-- inv_mul_cancel_left
@[to_additive (attr := simp)]
theorem inv_mul_cancel_left (a b : G) : a⁻¹ * (a * b) = b 
Arguments: {G : Type u_1} [Group G] (a b : G)
Goal: a⁻¹ * (a * b) = b
-- mul_inv_cancel_left
@[to_additive (attr := simp)]
theorem mul_inv_cancel_left (a b : G) : a * (a⁻¹ * b) = b 
Arguments: {G : Type u_1} [Group G] (a b : G)
Goal: a * (a⁻¹ * b) = b
-- add_neg_cancel_left
@[to_additive (attr := simp)]
theorem mul_inv_cancel_left (a b : G) : a * (a⁻¹ * b) = b 
Arguments: {G : Type u_1} [AddGroup G] (a b : G)
Goal: a + (-a + b) = b
-- add_neg_cancel_right
@[to_additive (attr := simp)]
theorem mul_inv_cancel_right (a b : G) : a * b * b⁻¹ = a 
Arguments: {G : Type u_1} [AddGroup G] (a b : G)
Goal: a + b + -b = a
-- mul_inv_cancel_right
@[to_additive (attr := simp)]
theorem mul_inv_cancel_right (a b : G) : a * b * b⁻¹ = a 
Arguments: {G : Type u_1} [Group G] (a b : G)
Goal: a * b * b⁻¹ = a
-- inv_mul_cancel_right
@[to_additive (attr := simp)]
theorem inv_mul_cancel_right (a b : G) : a * b⁻¹ * b = a 
Arguments: {G : Type u_1} [Group G] (a b : G)
Goal: a * b⁻¹ * b = a
-- neg_add_cancel_right
@[to_additive (attr := simp)]
theorem inv_mul_cancel_right (a b : G) : a * b⁻¹ * b = a 
Arguments: {G : Type u_1} [AddGroup G] (a b : G)
Goal: a + -b + b = a
-- neg_add_cancel_comm
@[to_additive (attr := simp)] lemma inv_mul_cancel_comm (a b : G) : a⁻¹ * b * a = b 
Arguments: {G : Type u_1} [AddCommGroup G] (a b : G)
Goal: -a + b + a = b
-- inv_mul_cancel_comm
@[to_additive (attr := simp)] lemma inv_mul_cancel_comm (a b : G) : a⁻¹ * b * a = b 
Arguments: {G : Type u_1} [CommGroup G] (a b : G)
Goal: a⁻¹ * b * a = b
-- mul_inv_cancel_comm
@[to_additive (attr := simp)]
lemma mul_inv_cancel_comm (a b : G) : a * b * a⁻¹ = b 
Arguments: {G : Type u_1} [CommGroup G] (a b : G)
Goal: a * b * a⁻¹ = b
-- add_neg_cancel_comm
@[to_additive (attr := simp)]
lemma mul_inv_cancel_comm (a b : G) : a * b * a⁻¹ = b 
Arguments: {G : Type u_1} [AddCommGroup G] (a b : G)
Goal: a + b + -a = b
-- inv_mul_cancel_comm_assoc
@[to_additive (attr := simp)] lemma inv_mul_cancel_comm_assoc (a b : G) : a⁻¹ * (b * a) = b 
Arguments: {G : Type u_1} [CommGroup G] (a b : G)
Goal: a⁻¹ * (b * a) = b
-- neg_add_cancel_comm_assoc
@[to_additive (attr := simp)] lemma inv_mul_cancel_comm_assoc (a b : G) : a⁻¹ * (b * a) = b 
Arguments: {G : Type u_1} [AddCommGroup G] (a b : G)
Goal: -a + (b + a) = b
-- add_neg_cancel_comm_assoc
@[to_additive (attr := simp)] lemma mul_inv_cancel_comm_assoc (a b : G) : a * (b * a⁻¹) = b 
Arguments: {G : Type u_1} [AddCommGroup G] (a b : G)
Goal: a + (b + -a) = b
-- mul_inv_cancel_comm_assoc
@[to_additive (attr := simp)] lemma mul_inv_cancel_comm_assoc (a b : G) : a * (b * a⁻¹) = b 
Arguments: {G : Type u_1} [CommGroup G] (a b : G)
Goal: a * (b * a⁻¹) = b
-- ZeroHom.inverse_apply
@[to_additive (attr := simps)
  "Make a `ZeroHom` inverse from the bijective inverse of a `ZeroHom`"]
def OneHom.inverse [One M] [One N]
    (f : OneHom M N) (g : N → M)
    (h₁ : Function.LeftInverse g f) :
  OneHom N M 
Arguments: {M : Type u_6} {N : Type u_7} [Zero M] [Zero N] (f : ZeroHom M N) (g : N → M) (h₁ : Function.LeftInverse g ⇑f)
Goal: ∀ (a : N), (f.inverse g h₁) a = g a
-- OneHom.inverse_apply
@[to_additive (attr := simps)
  "Make a `ZeroHom` inverse from the bijective inverse of a `ZeroHom`"]
def OneHom.inverse [One M] [One N]
    (f : OneHom M N) (g : N → M)
    (h₁ : Function.LeftInverse g f) :
  OneHom N M 
Arguments: {M : Type u_6} {N : Type u_7} [One M] [One N] (f : OneHom M N) (g : N → M) (h₁ : Function.LeftInverse g ⇑f)
Goal: ∀ (a : N), (f.inverse g h₁) a = g a
-- MulHom.inverse_apply
@[to_additive (attr := simps)
  "Makes an additive inverse from a bijection which preserves addition."]
def MulHom.inverse [Mul M] [Mul N] (f : M →ₙ* N) (g : N → M)
    (h₁ : Function.LeftInverse g f)
    (h₂ : Function.RightInverse g f) : N →ₙ* M 
Arguments: {M : Type u_6} {N : Type u_7} [Mul M] [Mul N] (f : M →ₙ* N) (g : N → M) (h₁ : Function.LeftInverse g ⇑f) (h₂ : Function.RightInverse g ⇑f)
Goal: ∀ (a : N), (f.inverse g h₁ h₂) a = g a
-- AddHom.inverse_apply
@[to_additive (attr := simps)
  "Makes an additive inverse from a bijection which preserves addition."]
def MulHom.inverse [Mul M] [Mul N] (f : M →ₙ* N) (g : N → M)
    (h₁ : Function.LeftInverse g f)
    (h₂ : Function.RightInverse g f) : N →ₙ* M 
Arguments: {M : Type u_6} {N : Type u_7} [Add M] [Add N] (f : AddHom M N) (g : N → M) (h₁ : Function.LeftInverse g ⇑f) (h₂ : Function.RightInverse g ⇑f)
Goal: ∀ (a : N), (f.inverse g h₁ h₂) a = g a
-- AddMonoidHom.inverse_apply
@[to_additive (attr := simps)
  "The inverse of a bijective `AddMonoidHom` is an `AddMonoidHom`."]
def MonoidHom.inverse {A B : Type*} [Monoid A] [Monoid B] (f : A →* B) (g : B → A)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) : B →* A 
Arguments: {A : Type u_12} {B : Type u_13} [AddMonoid A] [AddMonoid B] (f : A →+ B) (g : B → A) (h₁ : Function.LeftInverse g ⇑f) (h₂ : Function.RightInverse g ⇑f)
Goal: ∀ (a : B), (f.inverse g h₁ h₂) a = g a
-- MonoidHom.inverse_apply
@[to_additive (attr := simps)
  "The inverse of a bijective `AddMonoidHom` is an `AddMonoidHom`."]
def MonoidHom.inverse {A B : Type*} [Monoid A] [Monoid B] (f : A →* B) (g : B → A)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) : B →* A 
Arguments: {A : Type u_12} {B : Type u_13} [Monoid A] [Monoid B] (f : A →* B) (g : B → A) (h₁ : Function.LeftInverse g ⇑f) (h₂ : Function.RightInverse g ⇑f)
Goal: ∀ (a : B), (f.inverse g h₁ h₂) a = g a
-- AddEquivClass.map_add
class AddEquivClass (F : Type*) (A B : outParam Type*) [Add A] [Add B] [EquivLike F A B] :
    Prop where
    map_add : ∀ (f : F) (a b), f (a + b) = f a + f b
Arguments: {F : Type u_12} {A : outParam (Type u_13)} {B : outParam (Type u_14)} [Add A] [Add B] [EquivLike F A B] [self : AddEquivClass F A B] (f : F) (a b : A)
Goal: f (a + b) = f a + f b
-- MulEquivClass.map_mul
-- TODO: make this a synonym for MulHomClass?
@[to_additive]
class MulEquivClass (F : Type*) (A B : outParam Type*) [Mul A] [Mul B] [EquivLike F A B] :
    Prop where
    map_mul : ∀ (f : F) (a b), f (a * b) = f a * f b
Arguments: {F : Type u_12} {A : outParam (Type u_13)} {B : outParam (Type u_14)} [Mul A] [Mul B] [EquivLike F A B] [self : MulEquivClass F A B] (f : F) (a b : A)
Goal: f (a * b) = f a * f b
-- MulEquivClass.map_eq_one_iff
@[to_additive (attr := simp)]
theorem map_eq_one_iff {M N} [MulOneClass M] [MulOneClass N] [EquivLike F M N] [MulEquivClass F M N]
    (h : F) {x : M} :
    h x = 1 ↔ x = 1 
Arguments: {F : Type u_1} {M : Type u_12} {N : Type u_13} [MulOneClass M] [MulOneClass N] [EquivLike F M N] [MulEquivClass F M N] (h : F) {x : M}
Goal: h x = 1 ↔ x = 1
-- AddEquivClass.map_eq_zero_iff
@[to_additive (attr := simp)]
theorem map_eq_one_iff {M N} [MulOneClass M] [MulOneClass N] [EquivLike F M N] [MulEquivClass F M N]
    (h : F) {x : M} :
    h x = 1 ↔ x = 1 
Arguments: {F : Type u_1} {M : Type u_12} {N : Type u_13} [AddZeroClass M] [AddZeroClass N] [EquivLike F M N] [AddEquivClass F M N] (h : F) {x : M}
Goal: h x = 0 ↔ x = 0
-- MulEquivClass.map_ne_one_iff
@[to_additive]
theorem map_ne_one_iff {M N} [MulOneClass M] [MulOneClass N] [EquivLike F M N] [MulEquivClass F M N]
    (h : F) {x : M} :
    h x ≠ 1 ↔ x ≠ 1 
Arguments: {F : Type u_1} {M : Type u_12} {N : Type u_13} [MulOneClass M] [MulOneClass N] [EquivLike F M N] [MulEquivClass F M N] (h : F) {x : M}
Goal: h x ≠ 1 ↔ x ≠ 1
-- AddEquivClass.map_ne_zero_iff
@[to_additive]
theorem map_ne_one_iff {M N} [MulOneClass M] [MulOneClass N] [EquivLike F M N] [MulEquivClass F M N]
    (h : F) {x : M} :
    h x ≠ 1 ↔ x ≠ 1 
Arguments: {F : Type u_1} {M : Type u_12} {N : Type u_13} [AddZeroClass M] [AddZeroClass N] [EquivLike F M N] [AddEquivClass F M N] (h : F) {x : M}
Goal: h x ≠ 0 ↔ x ≠ 0
-- MulEquivClass.toMulEquiv_injective
@[to_additive]
theorem MulEquivClass.toMulEquiv_injective [Mul α] [Mul β] [MulEquivClass F α β] :
    Function.Injective ((↑) : F → α ≃* β) 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [EquivLike F α β] [Mul α] [Mul β] [MulEquivClass F α β]
Goal: Function.Injective MulEquivClass.toMulEquiv
-- AddEquivClass.toAddEquiv_injective
@[to_additive]
theorem MulEquivClass.toMulEquiv_injective [Mul α] [Mul β] [MulEquivClass F α β] :
    Function.Injective ((↑) : F → α ≃* β) 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [EquivLike F α β] [Add α] [Add β] [AddEquivClass F α β]
Goal: Function.Injective AddEquivClass.toAddEquiv
-- MulEquiv.toEquiv_eq_coe
@[to_additive (attr := simp)]
theorem toEquiv_eq_coe (f : M ≃* N) : f.toEquiv = f 
Arguments: {M : Type u_6} {N : Type u_7} [Mul M] [Mul N] (f : M ≃* N)
Goal: f.toEquiv = ↑f
-- AddEquiv.toEquiv_eq_coe
@[to_additive (attr := simp)]
theorem toEquiv_eq_coe (f : M ≃* N) : f.toEquiv = f 
Arguments: {M : Type u_6} {N : Type u_7} [Add M] [Add N] (f : M ≃+ N)
Goal: f.toEquiv = ↑f
-- MulEquiv.toMulHom_eq_coe
@[to_additive (attr := simp)]
theorem toMulHom_eq_coe (f : M ≃* N) : f.toMulHom = ↑f 
Arguments: {M : Type u_6} {N : Type u_7} [Mul M] [Mul N] (f : M ≃* N)
Goal: f.toMulHom = ↑f
-- AddEquiv.toAddHom_eq_coe
@[to_additive (attr := simp)]
theorem toMulHom_eq_coe (f : M ≃* N) : f.toMulHom = ↑f 
Arguments: {M : Type u_6} {N : Type u_7} [Add M] [Add N] (f : M ≃+ N)
Goal: f.toAddHom = ↑f
-- MulEquiv.coe_toEquiv
@[to_additive (attr := simp)]
theorem coe_toEquiv (f : M ≃* N) : ⇑(f : M ≃ N) = f 
Arguments: {M : Type u_6} {N : Type u_7} [Mul M] [Mul N] (f : M ≃* N)
Goal: ⇑↑f = ⇑f
-- AddEquiv.coe_toEquiv
@[to_additive (attr := simp)]
theorem coe_toEquiv (f : M ≃* N) : ⇑(f : M ≃ N) = f 
Arguments: {M : Type u_6} {N : Type u_7} [Add M] [Add N] (f : M ≃+ N)
Goal: ⇑↑f = ⇑f
-- MulEquiv.coe_toMulHom
@[to_additive (attr := simp 1100)]
theorem coe_toMulHom {f : M ≃* N} : (f.toMulHom : M → N) = f 
Arguments: {M : Type u_6} {N : Type u_7} [Mul M] [Mul N] {f : M ≃* N}
Goal: ⇑f.toMulHom = ⇑f
-- AddEquiv.coe_toAddHom
@[to_additive (attr := simp 1100)]
theorem coe_toMulHom {f : M ≃* N} : (f.toMulHom : M → N) = f 
Arguments: {M : Type u_6} {N : Type u_7} [Add M] [Add N] {f : M ≃+ N}
Goal: ⇑f.toAddHom = ⇑f
-- AddEquiv.map_add
@[to_additive "An additive isomorphism preserves addition."]
protected theorem map_mul (f : M ≃* N) : ∀ x y, f (x * y) = f x * f y 
Arguments: {M : Type u_6} {N : Type u_7} [Add M] [Add N] (f : M ≃+ N) (x y : M)
Goal: f (x + y) = f x + f y
-- MulEquiv.map_mul
@[to_additive "An additive isomorphism preserves addition."]
protected theorem map_mul (f : M ≃* N) : ∀ x y, f (x * y) = f x * f y 
Arguments: {M : Type u_6} {N : Type u_7} [Mul M] [Mul N] (f : M ≃* N) (x y : M)
Goal: f (x * y) = f x * f y
-- MulEquiv.bijective
@[to_additive]
protected theorem bijective (e : M ≃* N) : Function.Bijective e 
Arguments: {M : Type u_6} {N : Type u_7} [Mul M] [Mul N] (e : M ≃* N)
Goal: Function.Bijective ⇑e
-- AddEquiv.bijective
@[to_additive]
protected theorem bijective (e : M ≃* N) : Function.Bijective e 
Arguments: {M : Type u_6} {N : Type u_7} [Add M] [Add N] (e : M ≃+ N)
Goal: Function.Bijective ⇑e
-- AddEquiv.injective
@[to_additive]
protected theorem injective (e : M ≃* N) : Function.Injective e 
Arguments: {M : Type u_6} {N : Type u_7} [Add M] [Add N] (e : M ≃+ N)
Goal: Function.Injective ⇑e
-- MulEquiv.injective
@[to_additive]
protected theorem injective (e : M ≃* N) : Function.Injective e 
Arguments: {M : Type u_6} {N : Type u_7} [Mul M] [Mul N] (e : M ≃* N)
Goal: Function.Injective ⇑e
-- AddEquiv.surjective
@[to_additive]
protected theorem surjective (e : M ≃* N) : Function.Surjective e 
Arguments: {M : Type u_6} {N : Type u_7} [Add M] [Add N] (e : M ≃+ N)
Goal: Function.Surjective ⇑e
-- MulEquiv.surjective
@[to_additive]
protected theorem surjective (e : M ≃* N) : Function.Surjective e 
Arguments: {M : Type u_6} {N : Type u_7} [Mul M] [Mul N] (e : M ≃* N)
Goal: Function.Surjective ⇑e
-- MulEquiv.symm_map_mul
@[to_additive]
lemma symm_map_mul {M N : Type*} [Mul M] [Mul N] (h : M ≃* N) (x y : N) :
    h.symm (x * y) = h.symm x * h.symm y 
Arguments: {M : Type u_12} {N : Type u_13} [Mul M] [Mul N] (h : M ≃* N) (x y : N)
Goal: h.symm (x * y) = h.symm x * h.symm y
-- AddEquiv.symm_map_add
@[to_additive]
lemma symm_map_mul {M N : Type*} [Mul M] [Mul N] (h : M ≃* N) (x y : N) :
    h.symm (x * y) = h.symm x * h.symm y 
Arguments: {M : Type u_12} {N : Type u_13} [Add M] [Add N] (h : M ≃+ N) (x y : N)
Goal: h.symm (x + y) = h.symm x + h.symm y
-- MulEquiv.invFun_eq_symm
@[to_additive] -- Porting note: no longer a `simp`, see below
theorem invFun_eq_symm {f : M ≃* N} : f.invFun = f.symm 
Arguments: {M : Type u_6} {N : Type u_7} [Mul M] [Mul N] {f : M ≃* N}
Goal: f.invFun = ⇑f.symm
-- AddEquiv.invFun_eq_symm
@[to_additive] -- Porting note: no longer a `simp`, see below
theorem invFun_eq_symm {f : M ≃* N} : f.invFun = f.symm 
Arguments: {M : Type u_6} {N : Type u_7} [Add M] [Add N] {f : M ≃+ N}
Goal: f.invFun = ⇑f.symm
-- AddEquiv.coe_toEquiv_symm
@[to_additive (attr := simp)]
theorem coe_toEquiv_symm (f : M ≃* N) : ((f : M ≃ N).symm : N → M) = f.symm 
Arguments: {M : Type u_6} {N : Type u_7} [Add M] [Add N] (f : M ≃+ N)
Goal: ⇑(↑f).symm = ⇑f.symm
-- MulEquiv.coe_toEquiv_symm
@[to_additive (attr := simp)]
theorem coe_toEquiv_symm (f : M ≃* N) : ((f : M ≃ N).symm : N → M) = f.symm 
Arguments: {M : Type u_6} {N : Type u_7} [Mul M] [Mul N] (f : M ≃* N)
Goal: ⇑(↑f).symm = ⇑f.symm
-- MulEquiv.equivLike_inv_eq_symm
@[to_additive (attr := simp)]
theorem equivLike_inv_eq_symm (f : M ≃* N) : EquivLike.inv f = f.symm 
Arguments: {M : Type u_6} {N : Type u_7} [Mul M] [Mul N] (f : M ≃* N)
Goal: EquivLike.inv f = ⇑f.symm
-- AddEquiv.equivLike_neg_eq_symm
@[to_additive (attr := simp)]
theorem equivLike_inv_eq_symm (f : M ≃* N) : EquivLike.inv f = f.symm 
Arguments: {M : Type u_6} {N : Type u_7} [Add M] [Add N] (f : M ≃+ N)
Goal: EquivLike.inv f = ⇑f.symm