ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Matrix.neg_cons
@[simp] lemma neg_cons (x : α) (v : Fin n → α) : -vecCons x v = vecCons (-x) (-v) 
Arguments: {α : Type u_1} {n : ℕ} [Neg α] (x : α) (v : Fin n → α)
Goal: -Matrix.vecCons x v = Matrix.vecCons (-x) (-v)
-- Matrix.head_neg
@[simp] lemma head_neg (a : Fin n.succ → α) : vecHead (-a) = -vecHead a 
Arguments: {α : Type u_1} {n : ℕ} [Neg α] (a : Fin n.succ → α)
Goal: Matrix.vecHead (-a) = -Matrix.vecHead a
-- Matrix.tail_neg
@[simp] lemma tail_neg (a : Fin n.succ → α) : vecTail (-a) = -vecTail a 
Arguments: {α : Type u_1} {n : ℕ} [Neg α] (a : Fin n.succ → α)
Goal: Matrix.vecTail (-a) = -Matrix.vecTail a
-- Additive.ofMul_symm_eq
@[simp]
theorem ofMul_symm_eq : (@ofMul α).symm = toMul 
Arguments: {α : Type u}
Goal: Additive.ofMul.symm = Additive.toMul
-- Additive.toMul_symm_eq
@[simp]
theorem toMul_symm_eq : (@toMul α).symm = ofMul 
Arguments: {α : Type u}
Goal: Additive.toMul.symm = Additive.ofMul
-- Additive.forall
@[simp]
protected lemma «forall» {p : Additive α → Prop} : (∀ a, p a) ↔ ∀ a, p (ofMul a) 
Arguments: {α : Type u} {p : Additive α → Prop}
Goal: (∀ (a : Additive α), p a) ↔ ∀ (a : α), p (Additive.ofMul a)
-- Additive.exists
@[simp]
protected lemma «exists» {p : Additive α → Prop} : (∃ a, p a) ↔ ∃ a, p (ofMul a) 
Arguments: {α : Type u} {p : Additive α → Prop}
Goal: (∃ a, p a) ↔ ∃ a, p (Additive.ofMul a)
-- Multiplicative.ofAdd_symm_eq
@[simp]
theorem ofAdd_symm_eq : (@ofAdd α).symm = toAdd 
Arguments: {α : Type u}
Goal: Multiplicative.ofAdd.symm = Multiplicative.toAdd
-- Multiplicative.toAdd_symm_eq
@[simp]
theorem toAdd_symm_eq : (@toAdd α).symm = ofAdd 
Arguments: {α : Type u}
Goal: Multiplicative.toAdd.symm = Multiplicative.ofAdd
-- Multiplicative.forall
@[simp]
protected lemma «forall» {p : Multiplicative α → Prop} : (∀ a, p a) ↔ ∀ a, p (ofAdd a) 
Arguments: {α : Type u} {p : Multiplicative α → Prop}
Goal: (∀ (a : Multiplicative α), p a) ↔ ∀ (a : α), p (Multiplicative.ofAdd a)
-- Multiplicative.exists
@[simp]
protected lemma «exists» {p : Multiplicative α → Prop} : (∃ a, p a) ↔ ∃ a, p (ofAdd a) 
Arguments: {α : Type u} {p : Multiplicative α → Prop}
Goal: (∃ a, p a) ↔ ∃ a, p (Multiplicative.ofAdd a)
-- toAdd_ofAdd
@[simp]
theorem toAdd_ofAdd (x : α) : toAdd (ofAdd x) = x 
Arguments: {α : Type u} (x : α)
Goal: Multiplicative.toAdd (Multiplicative.ofAdd x) = x
-- ofAdd_toAdd
@[simp]
theorem ofAdd_toAdd (x : Multiplicative α) : ofAdd (toAdd x) = x 
Arguments: {α : Type u} (x : Multiplicative α)
Goal: Multiplicative.ofAdd (Multiplicative.toAdd x) = x
-- toMul_ofMul
@[simp]
theorem toMul_ofMul (x : α) : toMul (ofMul x) = x 
Arguments: {α : Type u} (x : α)
Goal: Additive.toMul (Additive.ofMul x) = x
-- ofMul_toMul
@[simp]
theorem ofMul_toMul (x : Additive α) : ofMul (toMul x) = x 
Arguments: {α : Type u} (x : Additive α)
Goal: Additive.ofMul (Additive.toMul x) = x
-- ofAdd_add
@[simp]
theorem ofAdd_add [Add α] (x y : α) : ofAdd (x + y) = ofAdd x * ofAdd y 
Arguments: {α : Type u} [Add α] (x y : α)
Goal: Multiplicative.ofAdd (x + y) = Multiplicative.ofAdd x * Multiplicative.ofAdd y
-- toAdd_mul
@[simp]
theorem toAdd_mul [Add α] (x y : Multiplicative α) : toAdd (x * y) = toAdd x + toAdd y 
Arguments: {α : Type u} [Add α] (x y : Multiplicative α)
Goal: Multiplicative.toAdd (x * y) = Multiplicative.toAdd x + Multiplicative.toAdd y
-- ofMul_mul
@[simp]
theorem ofMul_mul [Mul α] (x y : α) : ofMul (x * y) = ofMul x + ofMul y 
Arguments: {α : Type u} [Mul α] (x y : α)
Goal: Additive.ofMul (x * y) = Additive.ofMul x + Additive.ofMul y
-- toMul_add
@[simp]
theorem toMul_add [Mul α] (x y : Additive α) : toMul (x + y) = toMul x * toMul y 
Arguments: {α : Type u} [Mul α] (x y : Additive α)
Goal: Additive.toMul (x + y) = Additive.toMul x * Additive.toMul y
-- ofMul_one
@[simp]
theorem ofMul_one [One α] : @Additive.ofMul α 1 = 0 
Arguments: {α : Type u} [One α]
Goal: Additive.ofMul 1 = 0
-- ofMul_eq_zero
@[simp]
theorem ofMul_eq_zero {A : Type*} [One A] {x : A} : Additive.ofMul x = 0 ↔ x = 1 
Arguments: {A : Type u_1} [One A] {x : A}
Goal: Additive.ofMul x = 0 ↔ x = 1
-- toMul_zero
@[simp]
theorem toMul_zero [One α] : toMul (0 : Additive α) = 1 
Arguments: {α : Type u} [One α]
Goal: Additive.toMul 0 = 1
-- toMul_eq_one
@[simp]
lemma toMul_eq_one {α : Type*} [One α] {x : Additive α} :
    Additive.toMul x = 1 ↔ x = 0 
Arguments: {α : Type u_1} [One α] {x : Additive α}
Goal: Additive.toMul x = 1 ↔ x = 0
-- ofAdd_zero
@[simp]
theorem ofAdd_zero [Zero α] : @Multiplicative.ofAdd α 0 = 1 
Arguments: {α : Type u} [Zero α]
Goal: Multiplicative.ofAdd 0 = 1
-- ofAdd_eq_one
@[simp]
theorem ofAdd_eq_one {A : Type*} [Zero A] {x : A} : Multiplicative.ofAdd x = 1 ↔ x = 0 
Arguments: {A : Type u_1} [Zero A] {x : A}
Goal: Multiplicative.ofAdd x = 1 ↔ x = 0
-- toAdd_one
@[simp]
theorem toAdd_one [Zero α] : toAdd (1 : Multiplicative α) = 0 
Arguments: {α : Type u} [Zero α]
Goal: Multiplicative.toAdd 1 = 0
-- toAdd_eq_zero
@[simp]
lemma toAdd_eq_zero {α : Type*} [Zero α] {x : Multiplicative α} :
    Multiplicative.toAdd x = 0 ↔ x = 1 
Arguments: {α : Type u_1} [Zero α] {x : Multiplicative α}
Goal: Multiplicative.toAdd x = 0 ↔ x = 1
-- ofMul_pow
@[simp]
theorem ofMul_pow [Monoid α] (n : ℕ) (a : α) : ofMul (a ^ n) = n • ofMul a 
Arguments: {α : Type u} [Monoid α] (n : ℕ) (a : α)
Goal: Additive.ofMul (a ^ n) = n • Additive.ofMul a
-- toMul_nsmul
@[simp]
theorem toMul_nsmul [Monoid α] (n : ℕ) (a : Additive α) : toMul (n • a) = toMul a ^ n 
Arguments: {α : Type u} [Monoid α] (n : ℕ) (a : Additive α)
Goal: Additive.toMul (n • a) = Additive.toMul a ^ n
-- ofAdd_nsmul
@[simp]
theorem ofAdd_nsmul [AddMonoid α] (n : ℕ) (a : α) : ofAdd (n • a) = ofAdd a ^ n 
Arguments: {α : Type u} [AddMonoid α] (n : ℕ) (a : α)
Goal: Multiplicative.ofAdd (n • a) = Multiplicative.ofAdd a ^ n
-- toAdd_pow
@[simp]
theorem toAdd_pow [AddMonoid α] (a : Multiplicative α) (n : ℕ) : toAdd (a ^ n) = n • toAdd a 
Arguments: {α : Type u} [AddMonoid α] (a : Multiplicative α) (n : ℕ)
Goal: Multiplicative.toAdd (a ^ n) = n • Multiplicative.toAdd a
-- ofMul_inv
@[simp]
theorem ofMul_inv [Inv α] (x : α) : ofMul x⁻¹ = -ofMul x 
Arguments: {α : Type u} [Inv α] (x : α)
Goal: Additive.ofMul x⁻¹ = -Additive.ofMul x
-- toMul_neg
@[simp]
theorem toMul_neg [Inv α] (x : Additive α) : toMul (-x) = (toMul x)⁻¹ 
Arguments: {α : Type u} [Inv α] (x : Additive α)
Goal: Additive.toMul (-x) = (Additive.toMul x)⁻¹
-- ofAdd_neg
@[simp]
theorem ofAdd_neg [Neg α] (x : α) : ofAdd (-x) = (ofAdd x)⁻¹ 
Arguments: {α : Type u} [Neg α] (x : α)
Goal: Multiplicative.ofAdd (-x) = (Multiplicative.ofAdd x)⁻¹
-- toAdd_inv
@[simp]
theorem toAdd_inv [Neg α] (x : Multiplicative α) : toAdd x⁻¹ = -(toAdd x) 
Arguments: {α : Type u} [Neg α] (x : Multiplicative α)
Goal: Multiplicative.toAdd x⁻¹ = -Multiplicative.toAdd x
-- ofAdd_sub
@[simp]
theorem ofAdd_sub [Sub α] (x y : α) : ofAdd (x - y) = ofAdd x / ofAdd y 
Arguments: {α : Type u} [Sub α] (x y : α)
Goal: Multiplicative.ofAdd (x - y) = Multiplicative.ofAdd x / Multiplicative.ofAdd y
-- toAdd_div
@[simp]
theorem toAdd_div [Sub α] (x y : Multiplicative α) : toAdd (x / y) = toAdd x - toAdd y 
Arguments: {α : Type u} [Sub α] (x y : Multiplicative α)
Goal: Multiplicative.toAdd (x / y) = Multiplicative.toAdd x - Multiplicative.toAdd y
-- ofMul_div
@[simp]
theorem ofMul_div [Div α] (x y : α) : ofMul (x / y) = ofMul x - ofMul y 
Arguments: {α : Type u} [Div α] (x y : α)
Goal: Additive.ofMul (x / y) = Additive.ofMul x - Additive.ofMul y
-- toMul_sub
@[simp]
theorem toMul_sub [Div α] (x y : Additive α) : toMul (x - y) = toMul x / toMul y 
Arguments: {α : Type u} [Div α] (x y : Additive α)
Goal: Additive.toMul (x - y) = Additive.toMul x / Additive.toMul y
-- ofMul_zpow
@[simp]
theorem ofMul_zpow [DivInvMonoid α] (z : ℤ) (a : α) : ofMul (a ^ z) = z • ofMul a 
Arguments: {α : Type u} [DivInvMonoid α] (z : ℤ) (a : α)
Goal: Additive.ofMul (a ^ z) = z • Additive.ofMul a
-- toMul_zsmul
@[simp]
theorem toMul_zsmul [DivInvMonoid α] (z : ℤ) (a : Additive α) : toMul (z • a) = toMul a ^ z 
Arguments: {α : Type u} [DivInvMonoid α] (z : ℤ) (a : Additive α)
Goal: Additive.toMul (z • a) = Additive.toMul a ^ z
-- ofAdd_zsmul
@[simp]
theorem ofAdd_zsmul [SubNegMonoid α] (z : ℤ) (a : α) : ofAdd (z • a) = ofAdd a ^ z 
Arguments: {α : Type u} [SubNegMonoid α] (z : ℤ) (a : α)
Goal: Multiplicative.ofAdd (z • a) = Multiplicative.ofAdd a ^ z
-- toAdd_zpow
@[simp]
theorem toAdd_zpow [SubNegMonoid α] (a : Multiplicative α) (z : ℤ) : toAdd (a ^ z) = z • toAdd a 
Arguments: {α : Type u} [SubNegMonoid α] (a : Multiplicative α) (z : ℤ)
Goal: Multiplicative.toAdd (a ^ z) = z • Multiplicative.toAdd a
-- AddMonoidHom.toMultiplicative_apply_apply
@[simps]
def AddMonoidHom.toMultiplicative [AddZeroClass α] [AddZeroClass β] :
    (α →+ β) ≃ (Multiplicative α →* Multiplicative β) 
Arguments: {α : Type u} {β : Type v} [AddZeroClass α] [AddZeroClass β] (f : α →+ β) (a : Multiplicative α)
Goal: (AddMonoidHom.toMultiplicative f) a = Multiplicative.ofAdd (f (Multiplicative.toAdd a))
-- AddMonoidHom.toMultiplicative_symm_apply_apply
@[simps]
def AddMonoidHom.toMultiplicative [AddZeroClass α] [AddZeroClass β] :
    (α →+ β) ≃ (Multiplicative α →* Multiplicative β) 
Arguments: {α : Type u} {β : Type v} [AddZeroClass α] [AddZeroClass β] (f : Multiplicative α →* Multiplicative β) (a : α)
Goal: (AddMonoidHom.toMultiplicative.symm f) a = Multiplicative.toAdd (f (Multiplicative.ofAdd a))
-- AddMonoidHom.coe_toMultiplicative
@[simp, norm_cast]
lemma AddMonoidHom.coe_toMultiplicative [AddZeroClass α] [AddZeroClass β] (f : α →+ β) :
    ⇑(toMultiplicative f) = ofAdd ∘ f ∘ toAdd 
Arguments: {α : Type u} {β : Type v} [AddZeroClass α] [AddZeroClass β] (f : α →+ β)
Goal: ⇑(AddMonoidHom.toMultiplicative f) = ⇑Multiplicative.ofAdd ∘ ⇑f ∘ ⇑Multiplicative.toAdd
-- MonoidHom.toAdditive_apply_apply
@[simps]
def MonoidHom.toAdditive [MulOneClass α] [MulOneClass β] :
    (α →* β) ≃ (Additive α →+ Additive β) 
Arguments: {α : Type u} {β : Type v} [MulOneClass α] [MulOneClass β] (f : α →* β) (a : Additive α)
Goal: (MonoidHom.toAdditive f) a = Additive.ofMul (f (Additive.toMul a))
-- MonoidHom.toAdditive_symm_apply_apply
@[simps]
def MonoidHom.toAdditive [MulOneClass α] [MulOneClass β] :
    (α →* β) ≃ (Additive α →+ Additive β) 
Arguments: {α : Type u} {β : Type v} [MulOneClass α] [MulOneClass β] (f : Additive α →+ Additive β) (a : α)
Goal: (MonoidHom.toAdditive.symm f) a = Additive.toMul (f (Additive.ofMul a))
-- MonoidHom.coe_toMultiplicative
@[simp, norm_cast]
lemma MonoidHom.coe_toMultiplicative [MulOneClass α] [MulOneClass β] (f : α →* β) :
    ⇑(toAdditive f) = ofMul ∘ f ∘ toMul 
Arguments: {α : Type u} {β : Type v} [MulOneClass α] [MulOneClass β] (f : α →* β)
Goal: ⇑(MonoidHom.toAdditive f) = ⇑Additive.ofMul ∘ ⇑f ∘ ⇑Additive.toMul
-- AddMonoidHom.toMultiplicative'_apply_apply
@[simps]
def AddMonoidHom.toMultiplicative' [MulOneClass α] [AddZeroClass β] :
    (Additive α →+ β) ≃ (α →* Multiplicative β) 
Arguments: {α : Type u} {β : Type v} [MulOneClass α] [AddZeroClass β] (f : Additive α →+ β) (a : α)
Goal: (AddMonoidHom.toMultiplicative' f) a = Multiplicative.ofAdd (f (Additive.ofMul a))
-- AddMonoidHom.toMultiplicative'_symm_apply_apply
@[simps]
def AddMonoidHom.toMultiplicative' [MulOneClass α] [AddZeroClass β] :
    (Additive α →+ β) ≃ (α →* Multiplicative β) 
Arguments: {α : Type u} {β : Type v} [MulOneClass α] [AddZeroClass β] (f : α →* Multiplicative β) (a : Additive α)
Goal: (AddMonoidHom.toMultiplicative'.symm f) a = Multiplicative.toAdd (f (Additive.toMul a))
-- AddMonoidHom.coe_toMultiplicative'
@[simp, norm_cast]
lemma AddMonoidHom.coe_toMultiplicative' [MulOneClass α] [AddZeroClass β] (f : Additive α →+ β) :
    ⇑(toMultiplicative' f) = ofAdd ∘ f ∘ ofMul 
Arguments: {α : Type u} {β : Type v} [MulOneClass α] [AddZeroClass β] (f : Additive α →+ β)
Goal: ⇑(AddMonoidHom.toMultiplicative' f) = ⇑Multiplicative.ofAdd ∘ ⇑f ∘ ⇑Additive.ofMul
-- MonoidHom.toAdditive'_apply_apply
@[simps!]
def MonoidHom.toAdditive' [MulOneClass α] [AddZeroClass β] :
    (α →* Multiplicative β) ≃ (Additive α →+ β) 
Arguments: {α : Type u} {β : Type v} [MulOneClass α] [AddZeroClass β]
Goal: ∀ (a : α →* Multiplicative β) (a_1 : Additive α),
  (MonoidHom.toAdditive' a) a_1 = Multiplicative.toAdd (a (Additive.toMul a_1))
-- MonoidHom.toAdditive'_symm_apply_apply
@[simps!]
def MonoidHom.toAdditive' [MulOneClass α] [AddZeroClass β] :
    (α →* Multiplicative β) ≃ (Additive α →+ β) 
Arguments: {α : Type u} {β : Type v} [MulOneClass α] [AddZeroClass β]
Goal: ∀ (a : Additive α →+ β) (a_1 : α), (MonoidHom.toAdditive'.symm a) a_1 = Multiplicative.ofAdd (a (Additive.ofMul a_1))
-- MonoidHom.coe_toAdditive'
@[simp, norm_cast]
lemma MonoidHom.coe_toAdditive' [MulOneClass α] [AddZeroClass β] (f : α →* Multiplicative β) :
    ⇑(toAdditive' f) = toAdd ∘ f ∘ toMul 
Arguments: {α : Type u} {β : Type v} [MulOneClass α] [AddZeroClass β] (f : α →* Multiplicative β)
Goal: ⇑(MonoidHom.toAdditive' f) = ⇑Multiplicative.toAdd ∘ ⇑f ∘ ⇑Additive.toMul
-- AddMonoidHom.toMultiplicative''_symm_apply_apply
@[simps]
def AddMonoidHom.toMultiplicative'' [AddZeroClass α] [MulOneClass β] :
    (α →+ Additive β) ≃ (Multiplicative α →* β) 
Arguments: {α : Type u} {β : Type v} [AddZeroClass α] [MulOneClass β] (f : Multiplicative α →* β) (a : α)
Goal: (AddMonoidHom.toMultiplicative''.symm f) a = Additive.ofMul (f (Multiplicative.ofAdd a))
-- AddMonoidHom.toMultiplicative''_apply_apply
@[simps]
def AddMonoidHom.toMultiplicative'' [AddZeroClass α] [MulOneClass β] :
    (α →+ Additive β) ≃ (Multiplicative α →* β) 
Arguments: {α : Type u} {β : Type v} [AddZeroClass α] [MulOneClass β] (f : α →+ Additive β) (a : Multiplicative α)
Goal: (AddMonoidHom.toMultiplicative'' f) a = Additive.toMul (f (Multiplicative.toAdd a))
-- AddMonoidHom.coe_toMultiplicative''
@[simp, norm_cast]
lemma AddMonoidHom.coe_toMultiplicative'' [AddZeroClass α] [MulOneClass β] (f : α →+ Additive β) :
    ⇑(toMultiplicative'' f) = toMul ∘ f ∘ toAdd 
Arguments: {α : Type u} {β : Type v} [AddZeroClass α] [MulOneClass β] (f : α →+ Additive β)
Goal: ⇑(AddMonoidHom.toMultiplicative'' f) = ⇑Additive.toMul ∘ ⇑f ∘ ⇑Multiplicative.toAdd
-- MonoidHom.toAdditive''_symm_apply_apply
@[simps!]
def MonoidHom.toAdditive'' [AddZeroClass α] [MulOneClass β] :
    (Multiplicative α →* β) ≃ (α →+ Additive β) 
Arguments: {α : Type u} {β : Type v} [AddZeroClass α] [MulOneClass β]
Goal: ∀ (a : α →+ Additive β) (a_1 : Multiplicative α),
  (MonoidHom.toAdditive''.symm a) a_1 = Additive.toMul (a (Multiplicative.toAdd a_1))
-- MonoidHom.toAdditive''_apply_apply
@[simps!]
def MonoidHom.toAdditive'' [AddZeroClass α] [MulOneClass β] :
    (Multiplicative α →* β) ≃ (α →+ Additive β) 
Arguments: {α : Type u} {β : Type v} [AddZeroClass α] [MulOneClass β]
Goal: ∀ (a : Multiplicative α →* β) (a_1 : α), (MonoidHom.toAdditive'' a) a_1 = Additive.ofMul (a (Multiplicative.ofAdd a_1))
-- MonoidHom.coe_toAdditive''
@[simp, norm_cast]
lemma MonoidHom.coe_toAdditive'' [AddZeroClass α] [MulOneClass β] (f : Multiplicative α →* β) :
    ⇑(toAdditive'' f) = ofMul ∘ f ∘ ofAdd 
Arguments: {α : Type u} {β : Type v} [AddZeroClass α] [MulOneClass β] (f : Multiplicative α →* β)
Goal: ⇑(MonoidHom.toAdditive'' f) = ⇑Additive.ofMul ∘ ⇑f ∘ ⇑Multiplicative.ofAdd
-- SemiconjBy.inv_inv_symm_iff
@[to_additive (attr := simp)]
theorem inv_inv_symm_iff : SemiconjBy a⁻¹ x⁻¹ y⁻¹ ↔ SemiconjBy a y x 
Arguments: {G : Type u_1} [DivisionMonoid G] {a x y : G}
Goal: SemiconjBy a⁻¹ x⁻¹ y⁻¹ ↔ SemiconjBy a y x
-- AddSemiconjBy.neg_neg_symm_iff
@[to_additive (attr := simp)]
theorem inv_inv_symm_iff : SemiconjBy a⁻¹ x⁻¹ y⁻¹ ↔ SemiconjBy a y x 
Arguments: {G : Type u_1} [SubtractionMonoid G] {a x y : G}
Goal: AddSemiconjBy (-a) (-x) (-y) ↔ AddSemiconjBy a y x
-- SemiconjBy.inv_symm_left_iff
@[to_additive (attr := simp)] lemma inv_symm_left_iff : SemiconjBy a⁻¹ y x ↔ SemiconjBy a x y 
Arguments: {G : Type u_1} [Group G] {a x y : G}
Goal: SemiconjBy a⁻¹ y x ↔ SemiconjBy a x y
-- AddSemiconjBy.neg_symm_left_iff
@[to_additive (attr := simp)] lemma inv_symm_left_iff : SemiconjBy a⁻¹ y x ↔ SemiconjBy a x y 
Arguments: {G : Type u_1} [AddGroup G] {a x y : G}
Goal: AddSemiconjBy (-a) y x ↔ AddSemiconjBy a x y
-- AddSemiconjBy.neg_right_iff
@[to_additive (attr := simp)] lemma inv_right_iff : SemiconjBy a x⁻¹ y⁻¹ ↔ SemiconjBy a x y 
Arguments: {G : Type u_1} [AddGroup G] {a x y : G}
Goal: AddSemiconjBy a (-x) (-y) ↔ AddSemiconjBy a x y
-- SemiconjBy.inv_right_iff
@[to_additive (attr := simp)] lemma inv_right_iff : SemiconjBy a x⁻¹ y⁻¹ ↔ SemiconjBy a x y 
Arguments: {G : Type u_1} [Group G] {a x y : G}
Goal: SemiconjBy a x⁻¹ y⁻¹ ↔ SemiconjBy a x y
-- SemiconjBy.zpow_right
@[to_additive (attr := simp)] lemma zpow_right (h : SemiconjBy a x y) :
    ∀ m : ℤ, SemiconjBy a (x ^ m) (y ^ m)
  
Arguments: {G : Type u_1} [Group G] {a x y : G} (h : SemiconjBy a x y) (m : ℤ)
Goal: SemiconjBy a (x ^ m) (y ^ m)
-- AddSemiconjBy.zsmul_right
@[to_additive (attr := simp)] lemma zpow_right (h : SemiconjBy a x y) :
    ∀ m : ℤ, SemiconjBy a (x ^ m) (y ^ m)
  
Arguments: {G : Type u_1} [AddGroup G] {a x y : G} (h : AddSemiconjBy a x y) (m : ℤ)
Goal: AddSemiconjBy a (m • x) (m • y)
-- AddSemiconjBy.eq_zero_iff
@[to_additive] lemma eq_one_iff (h : SemiconjBy a x y): x = 1 ↔ y = 1 
Arguments: {G : Type u_1} [AddGroup G] (a : G) {x y : G} (h : AddSemiconjBy a x y)
Goal: x = 0 ↔ y = 0
-- SemiconjBy.eq_one_iff
@[to_additive] lemma eq_one_iff (h : SemiconjBy a x y): x = 1 ↔ y = 1 
Arguments: {G : Type u_1} [Group G] (a : G) {x y : G} (h : SemiconjBy a x y)
Goal: x = 1 ↔ y = 1
-- SemiconjBy.eq
@[to_additive "Equality behind `AddSemiconjBy a x y`; useful for rewriting."]
protected theorem eq [Mul S] {a x y : S} (h : SemiconjBy a x y) : a * x = y * a 
Arguments: {S : Type u_1} [Mul S] {a x y : S} (h : SemiconjBy a x y)
Goal: a * x = y * a
-- AddSemiconjBy.eq
@[to_additive "Equality behind `AddSemiconjBy a x y`; useful for rewriting."]
protected theorem eq [Mul S] {a x y : S} (h : SemiconjBy a x y) : a * x = y * a 
Arguments: {S : Type u_1} [Add S] {a x y : S} (h : AddSemiconjBy a x y)
Goal: a + x = y + a
-- AddSemiconjBy.add_right
@[to_additive (attr := simp) "If `a` semiconjugates `x` to `y` and `x'` to `y'`,
then it semiconjugates `x + x'` to `y + y'`."]
theorem mul_right (h : SemiconjBy a x y) (h' : SemiconjBy a x' y') :
    SemiconjBy a (x * x') (y * y') 
Arguments: {S : Type u_1} [AddSemigroup S] {a x y x' y' : S} (h : AddSemiconjBy a x y) (h' : AddSemiconjBy a x' y')
Goal: AddSemiconjBy a (x + x') (y + y')
-- SemiconjBy.mul_right
@[to_additive (attr := simp) "If `a` semiconjugates `x` to `y` and `x'` to `y'`,
then it semiconjugates `x + x'` to `y + y'`."]
theorem mul_right (h : SemiconjBy a x y) (h' : SemiconjBy a x' y') :
    SemiconjBy a (x * x') (y * y') 
Arguments: {S : Type u_1} [Semigroup S] {a x y x' y' : S} (h : SemiconjBy a x y) (h' : SemiconjBy a x' y')
Goal: SemiconjBy a (x * x') (y * y')
-- AddSemiconjBy.add_left
@[to_additive "If `b` semiconjugates `x` to `y` and `a` semiconjugates `y` to `z`, then `a + b`
semiconjugates `x` to `z`."]
theorem mul_left (ha : SemiconjBy a y z) (hb : SemiconjBy b x y) : SemiconjBy (a * b) x z 
Arguments: {S : Type u_1} [AddSemigroup S] {a b x y z : S} (ha : AddSemiconjBy a y z) (hb : AddSemiconjBy b x y)
Goal: AddSemiconjBy (a + b) x z
-- SemiconjBy.mul_left
@[to_additive "If `b` semiconjugates `x` to `y` and `a` semiconjugates `y` to `z`, then `a + b`
semiconjugates `x` to `z`."]
theorem mul_left (ha : SemiconjBy a y z) (hb : SemiconjBy b x y) : SemiconjBy (a * b) x z 
Arguments: {S : Type u_1} [Semigroup S] {a b x y z : S} (ha : SemiconjBy a y z) (hb : SemiconjBy b x y)
Goal: SemiconjBy (a * b) x z
-- SemiconjBy.transitive
@[to_additive "The relation “there exists an element that semiconjugates `a` to `b`” on an additive
semigroup is transitive."]
protected theorem transitive : Transitive fun a b : S ↦ ∃ c, SemiconjBy c a b
  
Arguments: {S : Type u_1} [Semigroup S]
Goal: Transitive fun a b => ∃ c, SemiconjBy c a b
-- AddSemiconjBy.transitive
@[to_additive "The relation “there exists an element that semiconjugates `a` to `b`” on an additive
semigroup is transitive."]
protected theorem transitive : Transitive fun a b : S ↦ ∃ c, SemiconjBy c a b
  
Arguments: {S : Type u_1} [AddSemigroup S]
Goal: Transitive fun a b => ∃ c, AddSemiconjBy c a b
-- SemiconjBy.one_right
@[to_additive (attr := simp) "Any element semiconjugates `0` to `0`."]
theorem one_right (a : M) : SemiconjBy a 1 1 
Arguments: {M : Type u_2} [MulOneClass M] (a : M)
Goal: SemiconjBy a 1 1
-- AddSemiconjBy.zero_right
@[to_additive (attr := simp) "Any element semiconjugates `0` to `0`."]
theorem one_right (a : M) : SemiconjBy a 1 1 
Arguments: {M : Type u_2} [AddZeroClass M] (a : M)
Goal: AddSemiconjBy a 0 0
-- SemiconjBy.one_left
@[to_additive (attr := simp) "Zero semiconjugates any element to itself."]
theorem one_left (x : M) : SemiconjBy 1 x x 
Arguments: {M : Type u_2} [MulOneClass M] (x : M)
Goal: SemiconjBy 1 x x
-- AddSemiconjBy.zero_left
@[to_additive (attr := simp) "Zero semiconjugates any element to itself."]
theorem one_left (x : M) : SemiconjBy 1 x x 
Arguments: {M : Type u_2} [AddZeroClass M] (x : M)
Goal: AddSemiconjBy 0 x x
-- SemiconjBy.reflexive
@[to_additive "The relation “there exists an element that semiconjugates `a` to `b`” on an additive
monoid (or, more generally, on an `AddZeroClass` type) is reflexive."]
protected theorem reflexive : Reflexive fun a b : M ↦ ∃ c, SemiconjBy c a b
  
Arguments: {M : Type u_2} [MulOneClass M]
Goal: Reflexive fun a b => ∃ c, SemiconjBy c a b
-- AddSemiconjBy.reflexive
@[to_additive "The relation “there exists an element that semiconjugates `a` to `b`” on an additive
monoid (or, more generally, on an `AddZeroClass` type) is reflexive."]
protected theorem reflexive : Reflexive fun a b : M ↦ ∃ c, SemiconjBy c a b
  
Arguments: {M : Type u_2} [AddZeroClass M]
Goal: Reflexive fun a b => ∃ c, AddSemiconjBy c a b
-- SemiconjBy.pow_right
@[to_additive (attr := simp)]
theorem pow_right {a x y : M} (h : SemiconjBy a x y) (n : ℕ) : SemiconjBy a (x ^ n) (y ^ n) 
Arguments: {M : Type u_2} [Monoid M] {a x y : M} (h : SemiconjBy a x y) (n : ℕ)
Goal: SemiconjBy a (x ^ n) (y ^ n)
-- AddSemiconjBy.nsmul_right
@[to_additive (attr := simp)]
theorem pow_right {a x y : M} (h : SemiconjBy a x y) (n : ℕ) : SemiconjBy a (x ^ n) (y ^ n) 
Arguments: {M : Type u_2} [AddMonoid M] {a x y : M} (h : AddSemiconjBy a x y) (n : ℕ)
Goal: AddSemiconjBy a (n • x) (n • y)
-- SemiconjBy.conj_mk
@[to_additive "`a` semiconjugates `x` to `a + x + -a`."]
theorem conj_mk (a x : G) : SemiconjBy a x (a * x * a⁻¹) 
Arguments: {G : Type u_3} [Group G] (a x : G)
Goal: SemiconjBy a x (a * x * a⁻¹)
-- AddSemiconjBy.conj_mk
@[to_additive "`a` semiconjugates `x` to `a + x + -a`."]
theorem conj_mk (a x : G) : SemiconjBy a x (a * x * a⁻¹) 
Arguments: {G : Type u_3} [AddGroup G] (a x : G)
Goal: AddSemiconjBy a x (a + x + -a)
-- SemiconjBy.conj_iff
@[to_additive (attr := simp)]
theorem conj_iff {a x y b : G} :
    SemiconjBy (b * a * b⁻¹) (b * x * b⁻¹) (b * y * b⁻¹) ↔ SemiconjBy a x y 
Arguments: {G : Type u_3} [Group G] {a x y b : G}
Goal: SemiconjBy (b * a * b⁻¹) (b * x * b⁻¹) (b * y * b⁻¹) ↔ SemiconjBy a x y
-- AddSemiconjBy.conj_iff
@[to_additive (attr := simp)]
theorem conj_iff {a x y b : G} :
    SemiconjBy (b * a * b⁻¹) (b * x * b⁻¹) (b * y * b⁻¹) ↔ SemiconjBy a x y 
Arguments: {G : Type u_3} [AddGroup G] {a x y b : G}
Goal: AddSemiconjBy (b + a + -b) (b + x + -b) (b + y + -b) ↔ AddSemiconjBy a x y
-- semiconjBy_iff_eq
@[to_additive (attr := simp)]
theorem semiconjBy_iff_eq [CancelCommMonoid M] {a x y : M} : SemiconjBy a x y ↔ x = y 
Arguments: {M : Type u_2} [CancelCommMonoid M] {a x y : M}
Goal: SemiconjBy a x y ↔ x = y
-- addSemiconjBy_iff_eq
@[to_additive (attr := simp)]
theorem semiconjBy_iff_eq [CancelCommMonoid M] {a x y : M} : SemiconjBy a x y ↔ x = y 
Arguments: {M : Type u_2} [AddCancelCommMonoid M] {a x y : M}
Goal: AddSemiconjBy a x y ↔ x = y
-- MulAut.coe_mul
@[simp]
theorem coe_mul (e₁ e₂ : MulAut M) : ⇑(e₁ * e₂) = e₁ ∘ e₂ 
Arguments: (M : Type u_2) [Mul M] (e₁ e₂ : MulAut M)
Goal: ⇑(e₁ * e₂) = ⇑e₁ ∘ ⇑e₂
-- MulAut.coe_one
@[simp]
theorem coe_one : ⇑(1 : MulAut M) = id 
Arguments: (M : Type u_2) [Mul M]
Goal: ⇑1 = id
-- MulAut.mul_def
theorem mul_def (e₁ e₂ : MulAut M) : e₁ * e₂ = e₂.trans e₁ 
Arguments: (M : Type u_2) [Mul M] (e₁ e₂ : MulAut M)
Goal: e₁ * e₂ = MulEquiv.trans e₂ e₁