ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Commute.units_inv_right
@[to_additive]
theorem units_inv_right : Commute a u → Commute a ↑u⁻¹ 
Arguments: {M : Type u_1} [Monoid M] {a : M} {u : Mˣ}
Goal: Commute a ↑u → Commute a ↑u⁻¹
-- Commute.units_inv_right_iff
@[to_additive (attr := simp)]
theorem units_inv_right_iff : Commute a ↑u⁻¹ ↔ Commute a u 
Arguments: {M : Type u_1} [Monoid M] {a : M} {u : Mˣ}
Goal: Commute a ↑u⁻¹ ↔ Commute a ↑u
-- AddCommute.addUnits_neg_right_iff
@[to_additive (attr := simp)]
theorem units_inv_right_iff : Commute a ↑u⁻¹ ↔ Commute a u 
Arguments: {M : Type u_1} [AddMonoid M] {a : M} {u : AddUnits M}
Goal: AddCommute a ↑(-u) ↔ AddCommute a ↑u
-- Commute.units_inv_left
@[to_additive]
theorem units_inv_left : Commute (↑u) a → Commute (↑u⁻¹) a 
Arguments: {M : Type u_1} [Monoid M] {a : M} {u : Mˣ}
Goal: Commute (↑u) a → Commute (↑u⁻¹) a
-- AddCommute.addUnits_neg_left
@[to_additive]
theorem units_inv_left : Commute (↑u) a → Commute (↑u⁻¹) a 
Arguments: {M : Type u_1} [AddMonoid M] {a : M} {u : AddUnits M}
Goal: AddCommute (↑u) a → AddCommute (↑(-u)) a
-- AddCommute.addUnits_neg_left_iff
@[to_additive (attr := simp)]
theorem units_inv_left_iff : Commute (↑u⁻¹) a ↔ Commute (↑u) a 
Arguments: {M : Type u_1} [AddMonoid M] {a : M} {u : AddUnits M}
Goal: AddCommute (↑(-u)) a ↔ AddCommute (↑u) a
-- Commute.units_inv_left_iff
@[to_additive (attr := simp)]
theorem units_inv_left_iff : Commute (↑u⁻¹) a ↔ Commute (↑u) a 
Arguments: {M : Type u_1} [Monoid M] {a : M} {u : Mˣ}
Goal: Commute (↑u⁻¹) a ↔ Commute (↑u) a
-- Commute.units_val
@[to_additive]
theorem units_val : Commute u₁ u₂ → Commute (u₁ : M) u₂ 
Arguments: {M : Type u_1} [Monoid M] {u₁ u₂ : Mˣ}
Goal: Commute u₁ u₂ → Commute ↑u₁ ↑u₂
-- AddCommute.addUnits_val
@[to_additive]
theorem units_val : Commute u₁ u₂ → Commute (u₁ : M) u₂ 
Arguments: {M : Type u_1} [AddMonoid M] {u₁ u₂ : AddUnits M}
Goal: AddCommute u₁ u₂ → AddCommute ↑u₁ ↑u₂
-- Commute.units_of_val
@[to_additive]
theorem units_of_val : Commute (u₁ : M) u₂ → Commute u₁ u₂ 
Arguments: {M : Type u_1} [Monoid M] {u₁ u₂ : Mˣ}
Goal: Commute ↑u₁ ↑u₂ → Commute u₁ u₂
-- AddCommute.addUnits_of_val
@[to_additive]
theorem units_of_val : Commute (u₁ : M) u₂ → Commute u₁ u₂ 
Arguments: {M : Type u_1} [AddMonoid M] {u₁ u₂ : AddUnits M}
Goal: AddCommute ↑u₁ ↑u₂ → AddCommute u₁ u₂
-- Commute.units_val_iff
@[to_additive (attr := simp)]
theorem units_val_iff : Commute (u₁ : M) u₂ ↔ Commute u₁ u₂ 
Arguments: {M : Type u_1} [Monoid M] {u₁ u₂ : Mˣ}
Goal: Commute ↑u₁ ↑u₂ ↔ Commute u₁ u₂
-- AddCommute.addUnits_val_iff
@[to_additive (attr := simp)]
theorem units_val_iff : Commute (u₁ : M) u₂ ↔ Commute u₁ u₂ 
Arguments: {M : Type u_1} [AddMonoid M] {u₁ u₂ : AddUnits M}
Goal: AddCommute ↑u₁ ↑u₂ ↔ AddCommute u₁ u₂
-- AddCommute.isAddUnit_add_iff
@[to_additive]
theorem Commute.isUnit_mul_iff (h : Commute a b) : IsUnit (a * b) ↔ IsUnit a ∧ IsUnit b 
Arguments: {M : Type u_1} [AddMonoid M] {a b : M} (h : AddCommute a b)
Goal: IsAddUnit (a + b) ↔ IsAddUnit a ∧ IsAddUnit b
-- Commute.isUnit_mul_iff
@[to_additive]
theorem Commute.isUnit_mul_iff (h : Commute a b) : IsUnit (a * b) ↔ IsUnit a ∧ IsUnit b 
Arguments: {M : Type u_1} [Monoid M] {a b : M} (h : Commute a b)
Goal: IsUnit (a * b) ↔ IsUnit a ∧ IsUnit b
-- isUnit_mul_self_iff
@[to_additive (attr := simp)]
theorem isUnit_mul_self_iff : IsUnit (a * a) ↔ IsUnit a 
Arguments: {M : Type u_1} [Monoid M] {a : M}
Goal: IsUnit (a * a) ↔ IsUnit a
-- isAddUnit_add_self_iff
@[to_additive (attr := simp)]
theorem isUnit_mul_self_iff : IsUnit (a * a) ↔ IsUnit a 
Arguments: {M : Type u_1} [AddMonoid M] {a : M}
Goal: IsAddUnit (a + a) ↔ IsAddUnit a
-- Commute.units_zpow_right
@[to_additive (attr := simp)]
lemma Commute.units_zpow_right (h : Commute a u) (m : ℤ) : Commute a ↑(u ^ m) 
Arguments: {M : Type u_1} [Monoid M] {a : M} {u : Mˣ} (h : Commute a ↑u) (m : ℤ)
Goal: Commute a ↑(u ^ m)
-- AddCommute.addUnits_zsmul_right
@[to_additive (attr := simp)]
lemma Commute.units_zpow_right (h : Commute a u) (m : ℤ) : Commute a ↑(u ^ m) 
Arguments: {M : Type u_1} [AddMonoid M] {a : M} {u : AddUnits M} (h : AddCommute a ↑u) (m : ℤ)
Goal: AddCommute a ↑(m • u)
-- AddCommute.addUnits_zsmul_left
@[to_additive (attr := simp)]
lemma Commute.units_zpow_left (h : Commute ↑u a) (m : ℤ) : Commute ↑(u ^ m) a 
Arguments: {M : Type u_1} [AddMonoid M] {a : M} {u : AddUnits M} (h : AddCommute (↑u) a) (m : ℤ)
Goal: AddCommute (↑(m • u)) a
-- Commute.units_zpow_left
@[to_additive (attr := simp)]
lemma Commute.units_zpow_left (h : Commute ↑u a) (m : ℤ) : Commute ↑(u ^ m) a 
Arguments: {M : Type u_1} [Monoid M] {a : M} {u : Mˣ} (h : Commute (↑u) a) (m : ℤ)
Goal: Commute (↑(u ^ m)) a
-- isAddUnit_nsmul_iff
@[to_additive (attr := simp)] lemma isUnit_pow_iff (hn : n ≠ 0) : IsUnit (a ^ n) ↔ IsUnit a 
Arguments: {M : Type u_1} [AddMonoid M] {n : ℕ} {a : M} (hn : n ≠ 0)
Goal: IsAddUnit (n • a) ↔ IsAddUnit a
-- isUnit_pow_iff
@[to_additive (attr := simp)] lemma isUnit_pow_iff (hn : n ≠ 0) : IsUnit (a ^ n) ↔ IsUnit a 
Arguments: {M : Type u_1} [Monoid M] {n : ℕ} {a : M} (hn : n ≠ 0)
Goal: IsUnit (a ^ n) ↔ IsUnit a
-- isUnit_pow_succ_iff
@[to_additive]
lemma isUnit_pow_succ_iff : IsUnit (a ^ (n + 1)) ↔ IsUnit a 
Arguments: {M : Type u_1} [Monoid M] {n : ℕ} {a : M}
Goal: IsUnit (a ^ (n + 1)) ↔ IsUnit a
-- isAddUnit_nsmul_succ_iff
@[to_additive]
lemma isUnit_pow_succ_iff : IsUnit (a ^ (n + 1)) ↔ IsUnit a 
Arguments: {M : Type u_1} [AddMonoid M] {n : ℕ} {a : M}
Goal: IsAddUnit ((n + 1) • a) ↔ IsAddUnit a
-- Units.val_ofPowEqOne
@[to_additive (attr := simps!) "If `n • x = 0`, `n ≠ 0`, then `x` is an additive unit."]
def Units.ofPowEqOne (a : M) (n : ℕ) (ha : a ^ n = 1) (hn : n ≠ 0) : Mˣ 
Arguments: {M : Type u_1} [Monoid M] (a : M) (n : ℕ) (ha : a ^ n = 1) (hn : n ≠ 0)
Goal: ↑(Units.ofPowEqOne a n ha hn) = a
-- Units.val_inv_ofPowEqOne
@[to_additive (attr := simps!) "If `n • x = 0`, `n ≠ 0`, then `x` is an additive unit."]
def Units.ofPowEqOne (a : M) (n : ℕ) (ha : a ^ n = 1) (hn : n ≠ 0) : Mˣ 
Arguments: {M : Type u_1} [Monoid M] (a : M) (n : ℕ) (ha : a ^ n = 1) (hn : n ≠ 0)
Goal: ↑(Units.ofPowEqOne a n ha hn)⁻¹ = a ^ (n - 1)
-- AddUnits.val_ofNSMulEqZero
@[to_additive (attr := simps!) "If `n • x = 0`, `n ≠ 0`, then `x` is an additive unit."]
def Units.ofPowEqOne (a : M) (n : ℕ) (ha : a ^ n = 1) (hn : n ≠ 0) : Mˣ 
Arguments: {M : Type u_1} [AddMonoid M] (a : M) (n : ℕ) (ha : n • a = 0) (hn : n ≠ 0)
Goal: ↑(AddUnits.ofNSMulEqZero a n ha hn) = a
-- AddUnits.val_neg_ofNSMulEqZero
@[to_additive (attr := simps!) "If `n • x = 0`, `n ≠ 0`, then `x` is an additive unit."]
def Units.ofPowEqOne (a : M) (n : ℕ) (ha : a ^ n = 1) (hn : n ≠ 0) : Mˣ 
Arguments: {M : Type u_1} [AddMonoid M] (a : M) (n : ℕ) (ha : n • a = 0) (hn : n ≠ 0)
Goal: ↑(-AddUnits.ofNSMulEqZero a n ha hn) = (n - 1) • a
-- AddUnits.nsmul_ofNSMulEqZero
@[to_additive (attr := simp)]
lemma Units.pow_ofPowEqOne (ha : a ^ n = 1) (hn : n ≠ 0) :
    Units.ofPowEqOne _ n ha hn ^ n = 1 
Arguments: {M : Type u_1} [AddMonoid M] {n : ℕ} {a : M} (ha : n • a = 0) (hn : n ≠ 0)
Goal: n • AddUnits.ofNSMulEqZero a n ha hn = 0
-- Units.pow_ofPowEqOne
@[to_additive (attr := simp)]
lemma Units.pow_ofPowEqOne (ha : a ^ n = 1) (hn : n ≠ 0) :
    Units.ofPowEqOne _ n ha hn ^ n = 1 
Arguments: {M : Type u_1} [Monoid M] {n : ℕ} {a : M} (ha : a ^ n = 1) (hn : n ≠ 0)
Goal: Units.ofPowEqOne a n ha hn ^ n = 1
-- isAddUnit_ofNSMulEqZero
@[to_additive]
lemma isUnit_ofPowEqOne (ha : a ^ n = 1) (hn : n ≠ 0) : IsUnit a 
Arguments: {M : Type u_1} [AddMonoid M] {n : ℕ} {a : M} (ha : n • a = 0) (hn : n ≠ 0)
Goal: IsAddUnit a
-- isUnit_ofPowEqOne
@[to_additive]
lemma isUnit_ofPowEqOne (ha : a ^ n = 1) (hn : n ≠ 0) : IsUnit a 
Arguments: {M : Type u_1} [Monoid M] {n : ℕ} {a : M} (ha : a ^ n = 1) (hn : n ≠ 0)
Goal: IsUnit a
-- Commute.div_eq_div_iff_of_isUnit
@[to_additive]
lemma Commute.div_eq_div_iff_of_isUnit (hbd : Commute b d) (hb : IsUnit b) (hd : IsUnit d) :
    a / b = c / d ↔ a * d = c * b 
Arguments: {M : Type u_1} [DivisionMonoid M] {a b c d : M} (hbd : Commute b d) (hb : IsUnit b) (hd : IsUnit d)
Goal: a / b = c / d ↔ a * d = c * b
-- AddCommute.sub_eq_sub_iff_of_isAddUnit
@[to_additive]
lemma Commute.div_eq_div_iff_of_isUnit (hbd : Commute b d) (hb : IsUnit b) (hd : IsUnit d) :
    a / b = c / d ↔ a * d = c * b 
Arguments: {M : Type u_1} [SubtractionMonoid M] {a b c d : M} (hbd : AddCommute b d) (hb : IsAddUnit b) (hd : IsAddUnit d)
Goal: a - b = c - d ↔ a + d = c + b
-- Sum.vadd_def
@[to_additive]
theorem smul_def : a • x = x.map (a • ·) (a • ·) 
Arguments: {M : Type u_1} {α : Type u_4} {β : Type u_5} [VAdd M α] [VAdd M β] (a : M) (x : α ⊕ β)
Goal: a +ᵥ x = Sum.map (fun x => a +ᵥ x) (fun x => a +ᵥ x) x
-- Sum.smul_def
@[to_additive]
theorem smul_def : a • x = x.map (a • ·) (a • ·) 
Arguments: {M : Type u_1} {α : Type u_4} {β : Type u_5} [SMul M α] [SMul M β] (a : M) (x : α ⊕ β)
Goal: a • x = Sum.map (fun x => a • x) (fun x => a • x) x
-- Sum.vadd_inl
@[to_additive (attr := simp)]
theorem smul_inl : a • (inl b : α ⊕ β) = inl (a • b) 
Arguments: {M : Type u_1} {α : Type u_4} {β : Type u_5} [VAdd M α] [VAdd M β] (a : M) (b : α)
Goal: a +ᵥ Sum.inl b = Sum.inl (a +ᵥ b)
-- Sum.smul_inl
@[to_additive (attr := simp)]
theorem smul_inl : a • (inl b : α ⊕ β) = inl (a • b) 
Arguments: {M : Type u_1} {α : Type u_4} {β : Type u_5} [SMul M α] [SMul M β] (a : M) (b : α)
Goal: a • Sum.inl b = Sum.inl (a • b)
-- Sum.vadd_inr
@[to_additive (attr := simp)]
theorem smul_inr : a • (inr c : α ⊕ β) = inr (a • c) 
Arguments: {M : Type u_1} {α : Type u_4} {β : Type u_5} [VAdd M α] [VAdd M β] (a : M) (c : β)
Goal: a +ᵥ Sum.inr c = Sum.inr (a +ᵥ c)
-- Sum.smul_inr
@[to_additive (attr := simp)]
theorem smul_inr : a • (inr c : α ⊕ β) = inr (a • c) 
Arguments: {M : Type u_1} {α : Type u_4} {β : Type u_5} [SMul M α] [SMul M β] (a : M) (c : β)
Goal: a • Sum.inr c = Sum.inr (a • c)
-- Sum.smul_swap
@[to_additive (attr := simp)]
theorem smul_swap : (a • x).swap = a • x.swap 
Arguments: {M : Type u_1} {α : Type u_4} {β : Type u_5} [SMul M α] [SMul M β] (a : M) (x : α ⊕ β)
Goal: (a • x).swap = a • x.swap
-- Sum.vadd_swap
@[to_additive (attr := simp)]
theorem smul_swap : (a • x).swap = a • x.swap 
Arguments: {M : Type u_1} {α : Type u_4} {β : Type u_5} [VAdd M α] [VAdd M β] (a : M) (x : α ⊕ β)
Goal: (a +ᵥ x).swap = a +ᵥ x.swap
-- AddUnits.vadd_def
@[to_additive] lemma smul_def [Monoid M] [SMul M α] (m : Mˣ) (a : α) : m • a = (m : M) • a 
Arguments: {M : Type u_3} {α : Type u_5} [AddMonoid M] [VAdd M α] (m : AddUnits M) (a : α)
Goal: m +ᵥ a = ↑m +ᵥ a
-- Units.smul_def
@[to_additive] lemma smul_def [Monoid M] [SMul M α] (m : Mˣ) (a : α) : m • a = (m : M) • a 
Arguments: {M : Type u_3} {α : Type u_5} [Monoid M] [SMul M α] (m : Mˣ) (a : α)
Goal: m • a = ↑m • a
-- AddUnits.vadd_mk_apply
@[to_additive, simp]
lemma smul_mk_apply {M α : Type*} [Monoid M] [SMul M α] (m n : M) (h₁) (h₂) (a : α) :
    (⟨m, n, h₁, h₂⟩ : Mˣ) • a = m • a 
Arguments: {M : Type u_6} {α : Type u_7} [AddMonoid M] [VAdd M α] (m n : M) (h₁ : m + n = 0) (h₂ : n + m = 0) (a : α)
Goal: { val := m, neg := n, val_neg := h₁, neg_val := h₂ } +ᵥ a = m +ᵥ a
-- Units.smul_mk_apply
@[to_additive, simp]
lemma smul_mk_apply {M α : Type*} [Monoid M] [SMul M α] (m n : M) (h₁) (h₂) (a : α) :
    (⟨m, n, h₁, h₂⟩ : Mˣ) • a = m • a 
Arguments: {M : Type u_6} {α : Type u_7} [Monoid M] [SMul M α] (m n : M) (h₁ : m * n = 1) (h₂ : n * m = 1) (a : α)
Goal: { val := m, inv := n, val_inv := h₁, inv_val := h₂ } • a = m • a
-- Units.smul_isUnit
@[simp]
lemma smul_isUnit [Monoid M] [SMul M α] {m : M} (hm : IsUnit m) (a : α) : hm.unit • a = m • a 
Arguments: {M : Type u_3} {α : Type u_5} [Monoid M] [SMul M α] {m : M} (hm : IsUnit m) (a : α)
Goal: hm.unit • a = m • a
-- IsAddUnit.neg_vadd
@[to_additive]
lemma _root_.IsUnit.inv_smul [Monoid α] {a : α} (h : IsUnit a) : h.unit⁻¹ • a = 1 
Arguments: {α : Type u_5} [AddMonoid α] {a : α} (h : IsAddUnit a)
Goal: -h.addUnit +ᵥ a = 0
-- IsUnit.inv_smul
@[to_additive]
lemma _root_.IsUnit.inv_smul [Monoid α] {a : α} (h : IsUnit a) : h.unit⁻¹ • a = 1 
Arguments: {α : Type u_5} [Monoid α] {a : α} (h : IsUnit a)
Goal: h.unit⁻¹ • a = 1
-- Units.val_smul
@[to_additive (attr := simp)]
lemma val_smul [Group G] [Monoid M] [MulAction G M] [SMulCommClass G M M] [IsScalarTower G M M]
    (g : G) (m : Mˣ) : ↑(g • m) = g • (m : M) 
Arguments: {G : Type u_1} {M : Type u_3} [Group G] [Monoid M] [MulAction G M] [SMulCommClass G M M] [IsScalarTower G M M] (g : G) (m : Mˣ)
Goal: ↑(g • m) = g • ↑m
-- AddUnits.val_vadd
@[to_additive (attr := simp)]
lemma val_smul [Group G] [Monoid M] [MulAction G M] [SMulCommClass G M M] [IsScalarTower G M M]
    (g : G) (m : Mˣ) : ↑(g • m) = g • (m : M) 
Arguments: {G : Type u_1} {M : Type u_3} [AddGroup G] [AddMonoid M] [AddAction G M] [VAddCommClass G M M] [VAddAssocClass G M M] (g : G) (m : AddUnits M)
Goal: ↑(g +ᵥ m) = g +ᵥ ↑m
-- Units.smul_inv
@[to_additive (attr := simp)]
lemma smul_inv [Group G] [Monoid M] [MulAction G M] [SMulCommClass G M M] [IsScalarTower G M M]
    (g : G) (m : Mˣ) : (g • m)⁻¹ = g⁻¹ • m⁻¹ 
Arguments: {G : Type u_1} {M : Type u_3} [Group G] [Monoid M] [MulAction G M] [SMulCommClass G M M] [IsScalarTower G M M] (g : G) (m : Mˣ)
Goal: (g • m)⁻¹ = g⁻¹ • m⁻¹
-- AddUnits.vadd_neg
@[to_additive (attr := simp)]
lemma smul_inv [Group G] [Monoid M] [MulAction G M] [SMulCommClass G M M] [IsScalarTower G M M]
    (g : G) (m : Mˣ) : (g • m)⁻¹ = g⁻¹ • m⁻¹ 
Arguments: {G : Type u_1} {M : Type u_3} [AddGroup G] [AddMonoid M] [AddAction G M] [VAddCommClass G M M] [VAddAssocClass G M M] (g : G) (m : AddUnits M)
Goal: -(g +ᵥ m) = -g +ᵥ -m
-- IsUnit.smul
@[to_additive]
lemma IsUnit.smul [Group G] [Monoid M] [MulAction G M] [SMulCommClass G M M] [IsScalarTower G M M]
    {m : M} (g : G) (h : IsUnit m) : IsUnit (g • m) 
Arguments: {G : Type u_1} {M : Type u_3} [Group G] [Monoid M] [MulAction G M] [SMulCommClass G M M] [IsScalarTower G M M] {m : M} (g : G) (h : IsUnit m)
Goal: IsUnit (g • m)
-- IsAddUnit.vadd
@[to_additive]
lemma IsUnit.smul [Group G] [Monoid M] [MulAction G M] [SMulCommClass G M M] [IsScalarTower G M M]
    {m : M} (g : G) (h : IsUnit m) : IsUnit (g • m) 
Arguments: {G : Type u_1} {M : Type u_3} [AddGroup G] [AddMonoid M] [AddAction G M] [VAddCommClass G M M] [VAddAssocClass G M M] {m : M} (g : G) (h : IsAddUnit m)
Goal: IsAddUnit (g +ᵥ m)
-- Monoid.ext
@[to_additive (attr := ext)]
theorem Monoid.ext {M : Type u} ⦃m₁ m₂ : Monoid M⦄
    (h_mul : (letI := m₁; HMul.hMul : M → M → M) = (letI := m₂; HMul.hMul : M → M → M)) :
    m₁ = m₂ 
Arguments: {M : Type u} ⦃m₁ m₂ : Monoid M⦄ (h_mul : HMul.hMul = HMul.hMul)
Goal: m₁ = m₂
-- AddMonoid.ext
@[to_additive (attr := ext)]
theorem Monoid.ext {M : Type u} ⦃m₁ m₂ : Monoid M⦄
    (h_mul : (letI := m₁; HMul.hMul : M → M → M) = (letI := m₂; HMul.hMul : M → M → M)) :
    m₁ = m₂ 
Arguments: {M : Type u} ⦃m₁ m₂ : AddMonoid M⦄ (h_mul : HAdd.hAdd = HAdd.hAdd)
Goal: m₁ = m₂
-- AddCommMonoid.toAddMonoid_injective
@[to_additive]
theorem CommMonoid.toMonoid_injective {M : Type u} :
    Function.Injective (@CommMonoid.toMonoid M) 
Arguments: {M : Type u}
Goal: Function.Injective (@AddCommMonoid.toAddMonoid M)
-- CommMonoid.toMonoid_injective
@[to_additive]
theorem CommMonoid.toMonoid_injective {M : Type u} :
    Function.Injective (@CommMonoid.toMonoid M) 
Arguments: {M : Type u}
Goal: Function.Injective (@CommMonoid.toMonoid M)
-- CommMonoid.ext
@[to_additive (attr := ext)]
theorem CommMonoid.ext {M : Type*} ⦃m₁ m₂ : CommMonoid M⦄
    (h_mul : (letI := m₁; HMul.hMul : M → M → M) = (letI := m₂; HMul.hMul : M → M → M)) : m₁ = m₂ 
Arguments: {M : Type u_1} ⦃m₁ m₂ : CommMonoid M⦄ (h_mul : HMul.hMul = HMul.hMul)
Goal: m₁ = m₂
-- AddCommMonoid.ext
@[to_additive (attr := ext)]
theorem CommMonoid.ext {M : Type*} ⦃m₁ m₂ : CommMonoid M⦄
    (h_mul : (letI := m₁; HMul.hMul : M → M → M) = (letI := m₂; HMul.hMul : M → M → M)) : m₁ = m₂ 
Arguments: {M : Type u_1} ⦃m₁ m₂ : AddCommMonoid M⦄ (h_mul : HAdd.hAdd = HAdd.hAdd)
Goal: m₁ = m₂
-- AddLeftCancelMonoid.toAddMonoid_injective
@[to_additive]
theorem LeftCancelMonoid.toMonoid_injective {M : Type u} :
    Function.Injective (@LeftCancelMonoid.toMonoid M) 
Arguments: {M : Type u}
Goal: Function.Injective (@AddLeftCancelMonoid.toAddMonoid M)
-- LeftCancelMonoid.toMonoid_injective
@[to_additive]
theorem LeftCancelMonoid.toMonoid_injective {M : Type u} :
    Function.Injective (@LeftCancelMonoid.toMonoid M) 
Arguments: {M : Type u}
Goal: Function.Injective (@LeftCancelMonoid.toMonoid M)
-- LeftCancelMonoid.ext
@[to_additive (attr := ext)]
theorem LeftCancelMonoid.ext {M : Type u} ⦃m₁ m₂ : LeftCancelMonoid M⦄
    (h_mul : (letI := m₁; HMul.hMul : M → M → M) = (letI := m₂; HMul.hMul : M → M → M)) :
    m₁ = m₂ 
Arguments: {M : Type u} ⦃m₁ m₂ : LeftCancelMonoid M⦄ (h_mul : HMul.hMul = HMul.hMul)
Goal: m₁ = m₂
-- AddLeftCancelMonoid.ext
@[to_additive (attr := ext)]
theorem LeftCancelMonoid.ext {M : Type u} ⦃m₁ m₂ : LeftCancelMonoid M⦄
    (h_mul : (letI := m₁; HMul.hMul : M → M → M) = (letI := m₂; HMul.hMul : M → M → M)) :
    m₁ = m₂ 
Arguments: {M : Type u} ⦃m₁ m₂ : AddLeftCancelMonoid M⦄ (h_mul : HAdd.hAdd = HAdd.hAdd)
Goal: m₁ = m₂
-- AddRightCancelMonoid.toAddMonoid_injective
@[to_additive]
theorem RightCancelMonoid.toMonoid_injective {M : Type u} :
    Function.Injective (@RightCancelMonoid.toMonoid M) 
Arguments: {M : Type u}
Goal: Function.Injective (@AddRightCancelMonoid.toAddMonoid M)
-- RightCancelMonoid.toMonoid_injective
@[to_additive]
theorem RightCancelMonoid.toMonoid_injective {M : Type u} :
    Function.Injective (@RightCancelMonoid.toMonoid M) 
Arguments: {M : Type u}
Goal: Function.Injective (@RightCancelMonoid.toMonoid M)
-- RightCancelMonoid.ext
@[to_additive (attr := ext)]
theorem RightCancelMonoid.ext {M : Type u} ⦃m₁ m₂ : RightCancelMonoid M⦄
    (h_mul : (letI := m₁; HMul.hMul : M → M → M) = (letI := m₂; HMul.hMul : M → M → M))  :
    m₁ = m₂ 
Arguments: {M : Type u} ⦃m₁ m₂ : RightCancelMonoid M⦄ (h_mul : HMul.hMul = HMul.hMul)
Goal: m₁ = m₂
-- AddRightCancelMonoid.ext
@[to_additive (attr := ext)]
theorem RightCancelMonoid.ext {M : Type u} ⦃m₁ m₂ : RightCancelMonoid M⦄
    (h_mul : (letI := m₁; HMul.hMul : M → M → M) = (letI := m₂; HMul.hMul : M → M → M))  :
    m₁ = m₂ 
Arguments: {M : Type u} ⦃m₁ m₂ : AddRightCancelMonoid M⦄ (h_mul : HAdd.hAdd = HAdd.hAdd)
Goal: m₁ = m₂
-- AddCancelMonoid.toAddLeftCancelMonoid_injective
@[to_additive]
theorem CancelMonoid.toLeftCancelMonoid_injective {M : Type u} :
    Function.Injective (@CancelMonoid.toLeftCancelMonoid M) 
Arguments: {M : Type u}
Goal: Function.Injective (@AddCancelMonoid.toAddLeftCancelMonoid M)
-- CancelMonoid.toLeftCancelMonoid_injective
@[to_additive]
theorem CancelMonoid.toLeftCancelMonoid_injective {M : Type u} :
    Function.Injective (@CancelMonoid.toLeftCancelMonoid M) 
Arguments: {M : Type u}
Goal: Function.Injective (@CancelMonoid.toLeftCancelMonoid M)
-- AddCancelMonoid.ext
@[to_additive (attr := ext)]
theorem CancelMonoid.ext {M : Type*} ⦃m₁ m₂ : CancelMonoid M⦄
    (h_mul : (letI := m₁; HMul.hMul : M → M → M) = (letI := m₂; HMul.hMul : M → M → M)) :
    m₁ = m₂ 
Arguments: {M : Type u_1} ⦃m₁ m₂ : AddCancelMonoid M⦄ (h_mul : HAdd.hAdd = HAdd.hAdd)
Goal: m₁ = m₂
-- CancelMonoid.ext
@[to_additive (attr := ext)]
theorem CancelMonoid.ext {M : Type*} ⦃m₁ m₂ : CancelMonoid M⦄
    (h_mul : (letI := m₁; HMul.hMul : M → M → M) = (letI := m₂; HMul.hMul : M → M → M)) :
    m₁ = m₂ 
Arguments: {M : Type u_1} ⦃m₁ m₂ : CancelMonoid M⦄ (h_mul : HMul.hMul = HMul.hMul)
Goal: m₁ = m₂
-- CancelCommMonoid.toCommMonoid_injective
@[to_additive]
theorem CancelCommMonoid.toCommMonoid_injective {M : Type u} :
    Function.Injective (@CancelCommMonoid.toCommMonoid M) 
Arguments: {M : Type u}
Goal: Function.Injective (@CancelCommMonoid.toCommMonoid M)
-- AddCancelCommMonoid.toAddCommMonoid_injective
@[to_additive]
theorem CancelCommMonoid.toCommMonoid_injective {M : Type u} :
    Function.Injective (@CancelCommMonoid.toCommMonoid M) 
Arguments: {M : Type u}
Goal: Function.Injective (@AddCancelCommMonoid.toAddCommMonoid M)
-- CancelCommMonoid.ext
@[to_additive (attr := ext)]
theorem CancelCommMonoid.ext {M : Type*} ⦃m₁ m₂ : CancelCommMonoid M⦄
    (h_mul : (letI := m₁; HMul.hMul : M → M → M) = (letI := m₂; HMul.hMul : M → M → M)) :
    m₁ = m₂ 
Arguments: {M : Type u_1} ⦃m₁ m₂ : CancelCommMonoid M⦄ (h_mul : HMul.hMul = HMul.hMul)
Goal: m₁ = m₂
-- AddCancelCommMonoid.ext
@[to_additive (attr := ext)]
theorem CancelCommMonoid.ext {M : Type*} ⦃m₁ m₂ : CancelCommMonoid M⦄
    (h_mul : (letI := m₁; HMul.hMul : M → M → M) = (letI := m₂; HMul.hMul : M → M → M)) :
    m₁ = m₂ 
Arguments: {M : Type u_1} ⦃m₁ m₂ : AddCancelCommMonoid M⦄ (h_mul : HAdd.hAdd = HAdd.hAdd)
Goal: m₁ = m₂
-- DivInvMonoid.ext
@[to_additive (attr := ext)]
theorem DivInvMonoid.ext {M : Type*} ⦃m₁ m₂ : DivInvMonoid M⦄
    (h_mul : (letI := m₁; HMul.hMul : M → M → M) = (letI := m₂; HMul.hMul : M → M → M))
    (h_inv : (letI := m₁; Inv.inv : M → M) = (letI := m₂; Inv.inv : M → M)) : m₁ = m₂ 
Arguments: {M : Type u_1} ⦃m₁ m₂ : DivInvMonoid M⦄ (h_mul : HMul.hMul = HMul.hMul) (h_inv : Inv.inv = Inv.inv)
Goal: m₁ = m₂
-- SubNegMonoid.ext
@[to_additive (attr := ext)]
theorem DivInvMonoid.ext {M : Type*} ⦃m₁ m₂ : DivInvMonoid M⦄
    (h_mul : (letI := m₁; HMul.hMul : M → M → M) = (letI := m₂; HMul.hMul : M → M → M))
    (h_inv : (letI := m₁; Inv.inv : M → M) = (letI := m₂; Inv.inv : M → M)) : m₁ = m₂ 
Arguments: {M : Type u_1} ⦃m₁ m₂ : SubNegMonoid M⦄ (h_mul : HAdd.hAdd = HAdd.hAdd) (h_inv : Neg.neg = Neg.neg)
Goal: m₁ = m₂
-- AddGroup.toSubNegAddMonoid_injective
@[to_additive]
lemma Group.toDivInvMonoid_injective {G : Type*} : Injective (@Group.toDivInvMonoid G) 
Arguments: {G : Type u_1}
Goal: Function.Injective (@AddGroup.toSubNegMonoid G)
-- Group.toDivInvMonoid_injective
@[to_additive]
lemma Group.toDivInvMonoid_injective {G : Type*} : Injective (@Group.toDivInvMonoid G) 
Arguments: {G : Type u_1}
Goal: Function.Injective (@Group.toDivInvMonoid G)
-- Group.ext
@[to_additive (attr := ext)]
theorem Group.ext {G : Type*} ⦃g₁ g₂ : Group G⦄ (h_mul : g₁.mul = g₂.mul) : g₁ = g₂ 
Arguments: {G : Type u_1} ⦃g₁ g₂ : Group G⦄ (h_mul : Mul.mul = Mul.mul)
Goal: g₁ = g₂
-- AddGroup.ext
@[to_additive (attr := ext)]
theorem Group.ext {G : Type*} ⦃g₁ g₂ : Group G⦄ (h_mul : g₁.mul = g₂.mul) : g₁ = g₂ 
Arguments: {G : Type u_1} ⦃g₁ g₂ : AddGroup G⦄ (h_mul : Add.add = Add.add)
Goal: g₁ = g₂
-- AddCommGroup.toAddGroup_injective
@[to_additive]
lemma CommGroup.toGroup_injective {G : Type*} : Injective (@CommGroup.toGroup G) 
Arguments: {G : Type u_1}
Goal: Function.Injective (@AddCommGroup.toAddGroup G)
-- CommGroup.toGroup_injective
@[to_additive]
lemma CommGroup.toGroup_injective {G : Type*} : Injective (@CommGroup.toGroup G) 
Arguments: {G : Type u_1}
Goal: Function.Injective (@CommGroup.toGroup G)
-- AddCommGroup.ext
@[to_additive (attr := ext)]
theorem CommGroup.ext {G : Type*} ⦃g₁ g₂ : CommGroup G⦄ (h_mul : g₁.mul = g₂.mul) : g₁ = g₂ 
Arguments: {G : Type u_1} ⦃g₁ g₂ : AddCommGroup G⦄ (h_mul : Add.add = Add.add)
Goal: g₁ = g₂
-- CommGroup.ext
@[to_additive (attr := ext)]
theorem CommGroup.ext {G : Type*} ⦃g₁ g₂ : CommGroup G⦄ (h_mul : g₁.mul = g₂.mul) : g₁ = g₂ 
Arguments: {G : Type u_1} ⦃g₁ g₂ : CommGroup G⦄ (h_mul : Mul.mul = Mul.mul)
Goal: g₁ = g₂
-- MulAction.toPerm_apply
@[to_additive (attr := simps)]
def MulAction.toPerm (a : α) : Equiv.Perm β 
Arguments: {α : Type u_1} {β : Type u_2} [Group α] [MulAction α β] (a : α) (x : β)
Goal: (MulAction.toPerm a) x = a • x
-- MulAction.toPerm_symm_apply
@[to_additive (attr := simps)]
def MulAction.toPerm (a : α) : Equiv.Perm β 
Arguments: {α : Type u_1} {β : Type u_2} [Group α] [MulAction α β] (a : α) (x : β)
Goal: (Equiv.symm (MulAction.toPerm a)) x = a⁻¹ • x
-- AddAction.toPerm_apply
@[to_additive (attr := simps)]
def MulAction.toPerm (a : α) : Equiv.Perm β 
Arguments: {α : Type u_1} {β : Type u_2} [AddGroup α] [AddAction α β] (a : α) (x : β)
Goal: (AddAction.toPerm a) x = a +ᵥ x
-- AddAction.toPerm_symm_apply
@[to_additive (attr := simps)]
def MulAction.toPerm (a : α) : Equiv.Perm β 
Arguments: {α : Type u_1} {β : Type u_2} [AddGroup α] [AddAction α β] (a : α) (x : β)
Goal: (Equiv.symm (AddAction.toPerm a)) x = -a +ᵥ x