ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- MonoidWithZeroHom.coe_copy
@[simp]
lemma coe_copy {_ : MulZeroOneClass α} {_ : MulZeroOneClass β} (f : α →*₀ β) (f' : α → β) (h) :
    (f.copy f' h) = f' 
Arguments: {α : Type u_2} {β : Type u_3}
Goal: ∀ {x : MulZeroOneClass α} {x_1 : MulZeroOneClass β} (f : α →*₀ β) (f' : α → β) (h : f' = ⇑f), ⇑(f.copy f' h) = f'
-- MonoidWithZeroHom.copy_eq
lemma copy_eq {_ : MulZeroOneClass α} {_ : MulZeroOneClass β} (f : α →*₀ β) (f' : α → β) (h) :
    f.copy f' h = f 
Arguments: {α : Type u_2} {β : Type u_3}
Goal: ∀ {x : MulZeroOneClass α} {x_1 : MulZeroOneClass β} (f : α →*₀ β) (f' : α → β) (h : f' = ⇑f), f.copy f' h = ↑f
-- MonoidWithZeroHom.map_one
protected lemma map_one (f : α →*₀ β) : f 1 = 1 
Arguments: {α : Type u_2} {β : Type u_3} [MulZeroOneClass α] [MulZeroOneClass β] (f : α →*₀ β)
Goal: f 1 = 1
-- MonoidWithZeroHom.map_zero
protected lemma map_zero (f : α →*₀ β) : f 0 = 0 
Arguments: {α : Type u_2} {β : Type u_3} [MulZeroOneClass α] [MulZeroOneClass β] (f : α →*₀ β)
Goal: f 0 = 0
-- MonoidWithZeroHom.map_mul
protected lemma map_mul (f : α →*₀ β) (a b : α) : f (a * b) = f a * f b 
Arguments: {α : Type u_2} {β : Type u_3} [MulZeroOneClass α] [MulZeroOneClass β] (f : α →*₀ β) (a b : α)
Goal: f (a * b) = f a * f b
-- MonoidWithZeroHom.id_apply
@[simps]
def id (α : Type*) [MulZeroOneClass α] : α →*₀ α 
Arguments: (α : Type u_7) [MulZeroOneClass α] (x : α)
Goal: (MonoidWithZeroHom.id α) x = x
-- MonoidWithZeroHom.coe_comp
@[simp] lemma coe_comp (g : β →*₀ γ) (f : α →*₀ β) : ↑(g.comp f) = g ∘ f 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [MulZeroOneClass α] [MulZeroOneClass β] [MulZeroOneClass γ] (g : β →*₀ γ) (f : α →*₀ β)
Goal: ⇑(g.comp f) = ⇑g ∘ ⇑f
-- MonoidWithZeroHom.comp_apply
lemma comp_apply (g : β →*₀ γ) (f : α →*₀ β) (x : α) : g.comp f x = g (f x) 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [MulZeroOneClass α] [MulZeroOneClass β] [MulZeroOneClass γ] (g : β →*₀ γ) (f : α →*₀ β) (x : α)
Goal: (g.comp f) x = g (f x)
-- MonoidWithZeroHom.comp_assoc
lemma comp_assoc (f : α →*₀ β) (g : β →*₀ γ) (h : γ →*₀ δ) :
    (h.comp g).comp f = h.comp (g.comp f) 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} {δ : Type u_5} [MulZeroOneClass α] [MulZeroOneClass β] [MulZeroOneClass γ] [MulZeroOneClass δ] (f : α →*₀ β) (g : β →*₀ γ) (h : γ →*₀ δ)
Goal: (h.comp g).comp f = h.comp (g.comp f)
-- MonoidWithZeroHom.cancel_right
lemma cancel_right {g₁ g₂ : β →*₀ γ} {f : α →*₀ β} (hf : Surjective f) :
    g₁.comp f = g₂.comp f ↔ g₁ = g₂ 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [MulZeroOneClass α] [MulZeroOneClass β] [MulZeroOneClass γ] {g₁ g₂ : β →*₀ γ} {f : α →*₀ β} (hf : Function.Surjective ⇑f)
Goal: g₁.comp f = g₂.comp f ↔ g₁ = g₂
-- MonoidWithZeroHom.cancel_left
lemma cancel_left {g : β →*₀ γ} {f₁ f₂ : α →*₀ β} (hg : Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂ 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [MulZeroOneClass α] [MulZeroOneClass β] [MulZeroOneClass γ] {g : β →*₀ γ} {f₁ f₂ : α →*₀ β} (hg : Function.Injective ⇑g)
Goal: g.comp f₁ = g.comp f₂ ↔ f₁ = f₂
-- MonoidWithZeroHom.toMonoidHom_injective
lemma toMonoidHom_injective : Injective (toMonoidHom : (α →*₀ β) → α →* β) 
Arguments: {α : Type u_2} {β : Type u_3} [MulZeroOneClass α] [MulZeroOneClass β]
Goal: Function.Injective MonoidWithZeroHom.toMonoidHom
-- MonoidWithZeroHom.toZeroHom_injective
lemma toZeroHom_injective : Injective (toZeroHom : (α →*₀ β) → ZeroHom α β) 
Arguments: {α : Type u_2} {β : Type u_3} [MulZeroOneClass α] [MulZeroOneClass β]
Goal: Function.Injective MonoidWithZeroHom.toZeroHom
-- MonoidWithZeroHom.comp_id
@[simp] lemma comp_id (f : α →*₀ β) : f.comp (id α) = f 
Arguments: {α : Type u_2} {β : Type u_3} [MulZeroOneClass α] [MulZeroOneClass β] (f : α →*₀ β)
Goal: f.comp (MonoidWithZeroHom.id α) = f
-- MonoidWithZeroHom.id_comp
@[simp] lemma id_comp (f : α →*₀ β) : (id β).comp f = f 
Arguments: {α : Type u_2} {β : Type u_3} [MulZeroOneClass α] [MulZeroOneClass β] (f : α →*₀ β)
Goal: (MonoidWithZeroHom.id β).comp f = f
-- coe_powMonoidWithZeroHom
@[simp] lemma coe_powMonoidWithZeroHom : (powMonoidWithZeroHom hn : M₀ → M₀) = fun x ↦ x ^ n 
Arguments: {M₀ : Type u_6} [CommMonoidWithZero M₀] {n : ℕ} (hn : n ≠ 0)
Goal: ⇑(powMonoidWithZeroHom hn) = fun x => x ^ n
-- powMonoidWithZeroHom_apply
@[simp] lemma powMonoidWithZeroHom_apply (a : M₀) : powMonoidWithZeroHom hn a = a ^ n 
Arguments: {M₀ : Type u_6} [CommMonoidWithZero M₀] {n : ℕ} (hn : n ≠ 0) (a : M₀)
Goal: (powMonoidWithZeroHom hn) a = a ^ n
-- Set.zero_mem_center
@[simp] lemma zero_mem_center : (0 : M₀) ∈ center M₀ 
Arguments: {M₀ : Type u_1} [MulZeroClass M₀]
Goal: 0 ∈ Set.center M₀
-- Set.zero_mem_centralizer
@[simp] lemma zero_mem_centralizer : (0 : M₀) ∈ centralizer s 
Arguments: {M₀ : Type u_1} [MulZeroClass M₀] {s : Set M₀}
Goal: 0 ∈ s.centralizer
-- Set.center_units_subset
lemma center_units_subset : center G₀ˣ ⊆ ((↑) : G₀ˣ → G₀) ⁻¹' center G₀ 
Arguments: {G₀ : Type u_2} [GroupWithZero G₀]
Goal: Set.center G₀ˣ ⊆ Units.val ⁻¹' Set.center G₀
-- Set.center_units_eq
lemma center_units_eq : center G₀ˣ = ((↑) : G₀ˣ → G₀) ⁻¹' center G₀ 
Arguments: {G₀ : Type u_2} [GroupWithZero G₀]
Goal: Set.center G₀ˣ = Units.val ⁻¹' Set.center G₀
-- Set.inv_mem_centralizer₀
@[simp] lemma inv_mem_centralizer₀ (ha : a ∈ centralizer s) : a⁻¹ ∈ centralizer s 
Arguments: {G₀ : Type u_2} [GroupWithZero G₀] {s : Set G₀} {a : G₀} (ha : a ∈ s.centralizer)
Goal: a⁻¹ ∈ s.centralizer
-- Set.div_mem_centralizer₀
@[simp] lemma div_mem_centralizer₀ (ha : a ∈ centralizer s) (hb : b ∈ centralizer s) :
    a / b ∈ centralizer s 
Arguments: {G₀ : Type u_2} [GroupWithZero G₀] {s : Set G₀} {a b : G₀} (ha : a ∈ s.centralizer) (hb : b ∈ s.centralizer)
Goal: a / b ∈ s.centralizer
-- Set.inv_mem_center₀
@[deprecated inv_mem_center (since := "2024-06-17")]
theorem inv_mem_center₀ (ha : a ∈ Set.center G₀) : a⁻¹ ∈ Set.center G₀ 
Arguments: {G₀ : Type u_2} [GroupWithZero G₀] {a : G₀} (ha : a ∈ Set.center G₀)
Goal: a⁻¹ ∈ Set.center G₀
-- Set.div_mem_center₀
@[deprecated div_mem_center (since := "2024-06-17")]
theorem div_mem_center₀ (ha : a ∈ Set.center G₀) (hb : b ∈ Set.center G₀) : a / b ∈ Set.center G₀ 
Arguments: {G₀ : Type u_2} [GroupWithZero G₀] {a b : G₀} (ha : a ∈ Set.center G₀) (hb : b ∈ Set.center G₀)
Goal: a / b ∈ Set.center G₀
-- mulMonoidWithZeroHom_apply
@[simps]
def mulMonoidWithZeroHom [CommMonoidWithZero M₀] : M₀ × M₀ →*₀ M₀ 
Arguments: {M₀ : Type u_1} [CommMonoidWithZero M₀]
Goal: ∀ (a : M₀ × M₀), mulMonoidWithZeroHom a = (↑mulMonoidHom).toFun a
-- divMonoidWithZeroHom_apply
@[simps]
def divMonoidWithZeroHom [CommGroupWithZero M₀] : M₀ × M₀ →*₀ M₀ 
Arguments: {M₀ : Type u_1} [CommGroupWithZero M₀]
Goal: ∀ (a : M₀ × M₀), divMonoidWithZeroHom a = (↑divMonoidHom).toFun a
-- pullback_nonzero
theorem pullback_nonzero [Zero M₀'] [One M₀'] (f : M₀' → M₀) (zero : f 0 = 0) (one : f 1 = 1) :
    Nontrivial M₀' 
Arguments: {M₀ : Type u_1} {M₀' : Type u_2} [MulZeroOneClass M₀] [Nontrivial M₀] [Zero M₀'] [One M₀'] (f : M₀' → M₀) (zero : f 0 = 0) (one : f 1 = 1)
Goal: Nontrivial M₀'
-- inv_ne_zero
theorem inv_ne_zero (h : a ≠ 0) : a⁻¹ ≠ 0 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀} (h : a ≠ 0)
Goal: a⁻¹ ≠ 0
-- inv_mul_cancel
@[simp]
theorem inv_mul_cancel (h : a ≠ 0) : a⁻¹ * a = 1 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀} (h : a ≠ 0)
Goal: a⁻¹ * a = 1
-- MulZeroClass.zero_mul
class MulZeroClass (M₀ : Type u) extends Mul M₀, Zero M₀ where
    zero_mul : ∀ a : M₀, 0 * a = 0
    mul_zero : ∀ a : M₀, a * 0 = 0
Arguments: {M₀ : Type u} [self : MulZeroClass M₀] (a : M₀)
Goal: 0 * a = 0
-- MulZeroClass.mul_zero
class MulZeroClass (M₀ : Type u) extends Mul M₀, Zero M₀ where
    zero_mul : ∀ a : M₀, 0 * a = 0
    mul_zero : ∀ a : M₀, a * 0 = 0
Arguments: {M₀ : Type u} [self : MulZeroClass M₀] (a : M₀)
Goal: a * 0 = 0
-- IsLeftCancelMulZero.mul_left_cancel_of_ne_zero
class IsLeftCancelMulZero (M₀ : Type u) [Mul M₀] [Zero M₀] : Prop where
    protected mul_left_cancel_of_ne_zero : ∀ {a b c : M₀}, a ≠ 0 → a * b = a * c → b = c
Arguments: {M₀ : Type u} [Mul M₀] [Zero M₀] [self : IsLeftCancelMulZero M₀] {a b c : M₀}
Goal: a ≠ 0 → a * b = a * c → b = c
-- mul_left_cancel₀
theorem mul_left_cancel₀ (ha : a ≠ 0) (h : a * b = a * c) : b = c 
Arguments: {M₀ : Type u_1} [Mul M₀] [Zero M₀] [IsLeftCancelMulZero M₀] {a b c : M₀} (ha : a ≠ 0) (h : a * b = a * c)
Goal: b = c
-- mul_right_injective₀
theorem mul_right_injective₀ (ha : a ≠ 0) : Function.Injective (a * ·) 
Arguments: {M₀ : Type u_1} [Mul M₀] [Zero M₀] [IsLeftCancelMulZero M₀] {a : M₀} (ha : a ≠ 0)
Goal: Function.Injective fun x => a * x
-- IsRightCancelMulZero.mul_right_cancel_of_ne_zero
class IsRightCancelMulZero (M₀ : Type u) [Mul M₀] [Zero M₀] : Prop where
    protected mul_right_cancel_of_ne_zero : ∀ {a b c : M₀}, b ≠ 0 → a * b = c * b → a = c
Arguments: {M₀ : Type u} [Mul M₀] [Zero M₀] [self : IsRightCancelMulZero M₀] {a b c : M₀}
Goal: b ≠ 0 → a * b = c * b → a = c
-- mul_right_cancel₀
theorem mul_right_cancel₀ (hb : b ≠ 0) (h : a * b = c * b) : a = c 
Arguments: {M₀ : Type u_1} [Mul M₀] [Zero M₀] [IsRightCancelMulZero M₀] {a b c : M₀} (hb : b ≠ 0) (h : a * b = c * b)
Goal: a = c
-- mul_left_injective₀
theorem mul_left_injective₀ (hb : b ≠ 0) : Function.Injective fun a => a * b 
Arguments: {M₀ : Type u_1} [Mul M₀] [Zero M₀] [IsRightCancelMulZero M₀] {b : M₀} (hb : b ≠ 0)
Goal: Function.Injective fun a => a * b
-- NoZeroDivisors.eq_zero_or_eq_zero_of_mul_eq_zero
class NoZeroDivisors (M₀ : Type*) [Mul M₀] [Zero M₀] : Prop where
    eq_zero_or_eq_zero_of_mul_eq_zero : ∀ {a b : M₀}, a * b = 0 → a = 0 ∨ b = 0
Arguments: {M₀ : Type u_4} [Mul M₀] [Zero M₀] [self : NoZeroDivisors M₀] {a b : M₀}
Goal: a * b = 0 → a = 0 ∨ b = 0
-- mul_left_inj'
theorem mul_left_inj' (hc : c ≠ 0) : a * c = b * c ↔ a = b 
Arguments: {M₀ : Type u_1} [CancelMonoidWithZero M₀] {a b c : M₀} (hc : c ≠ 0)
Goal: a * c = b * c ↔ a = b
-- mul_right_inj'
theorem mul_right_inj' (ha : a ≠ 0) : a * b = a * c ↔ b = c 
Arguments: {M₀ : Type u_1} [CancelMonoidWithZero M₀] {a b c : M₀} (ha : a ≠ 0)
Goal: a * b = a * c ↔ b = c
-- IsLeftCancelMulZero.to_isRightCancelMulZero
lemma IsLeftCancelMulZero.to_isRightCancelMulZero [IsLeftCancelMulZero M₀] :
    IsRightCancelMulZero M₀ 
Arguments: {M₀ : Type u_1} [CommSemigroup M₀] [Zero M₀] [IsLeftCancelMulZero M₀]
Goal: IsRightCancelMulZero M₀
-- IsRightCancelMulZero.to_isLeftCancelMulZero
lemma IsRightCancelMulZero.to_isLeftCancelMulZero [IsRightCancelMulZero M₀] :
    IsLeftCancelMulZero M₀ 
Arguments: {M₀ : Type u_1} [CommSemigroup M₀] [Zero M₀] [IsRightCancelMulZero M₀]
Goal: IsLeftCancelMulZero M₀
-- IsLeftCancelMulZero.to_isCancelMulZero
lemma IsLeftCancelMulZero.to_isCancelMulZero [IsLeftCancelMulZero M₀] :
    IsCancelMulZero M₀ 
Arguments: {M₀ : Type u_1} [CommSemigroup M₀] [Zero M₀] [IsLeftCancelMulZero M₀]
Goal: IsCancelMulZero M₀
-- IsRightCancelMulZero.to_isCancelMulZero
lemma IsRightCancelMulZero.to_isCancelMulZero [IsRightCancelMulZero M₀] :
    IsCancelMulZero M₀ 
Arguments: {M₀ : Type u_1} [CommSemigroup M₀] [Zero M₀] [IsRightCancelMulZero M₀]
Goal: IsCancelMulZero M₀
-- MulDivCancelClass.mul_div_cancel
class MulDivCancelClass (M₀ : Type*) [MonoidWithZero M₀] [Div M₀] : Prop where
  protected mul_div_cancel (a b : M₀) : b ≠ 0 → a * b / b = a
Arguments: {M₀ : Type u_4} [MonoidWithZero M₀] [Div M₀] [self : MulDivCancelClass M₀] (a b : M₀)
Goal: b ≠ 0 → a * b / b = a
-- mul_div_cancel_right₀
@[simp] lemma mul_div_cancel_right₀ (a : M₀) (hb : b ≠ 0) : a * b / b = a 
Arguments: {M₀ : Type u_1} [MonoidWithZero M₀] [Div M₀] [MulDivCancelClass M₀] {b : M₀} (a : M₀) (hb : b ≠ 0)
Goal: a * b / b = a
-- mul_div_cancel_left₀
@[simp] lemma mul_div_cancel_left₀ (b : M₀) (ha : a ≠ 0) : a * b / a = b 
Arguments: {M₀ : Type u_1} [CommMonoidWithZero M₀] [Div M₀] [MulDivCancelClass M₀] {a : M₀} (b : M₀) (ha : a ≠ 0)
Goal: a * b / a = b
-- GroupWithZero.mul_inv_cancel
class GroupWithZero (G₀ : Type u) extends MonoidWithZero G₀, DivInvMonoid G₀, Nontrivial G₀ where
    inv_zero : (0 : G₀)⁻¹ = 0
    protected mul_inv_cancel (a : G₀) : a ≠ 0 → a * a⁻¹ = 1
Arguments: {G₀ : Type u} [self : GroupWithZero G₀] (a : G₀)
Goal: a ≠ 0 → a * a⁻¹ = 1
-- GroupWithZero.inv_zero
class GroupWithZero (G₀ : Type u) extends MonoidWithZero G₀, DivInvMonoid G₀, Nontrivial G₀ where
    inv_zero : (0 : G₀)⁻¹ = 0
    protected mul_inv_cancel (a : G₀) : a ≠ 0 → a * a⁻¹ = 1
Arguments: {G₀ : Type u} [self : GroupWithZero G₀]
Goal: 0⁻¹ = 0
-- mul_inv_cancel
@[simp] lemma mul_inv_cancel (h : a ≠ 0) : a * a⁻¹ = 1 
Arguments: {G₀ : Type u} [GroupWithZero G₀] {a : G₀} (h : a ≠ 0)
Goal: a * a⁻¹ = 1
-- eq_zero_or_one_of_sq_eq_self
lemma eq_zero_or_one_of_sq_eq_self (hx : x ^ 2 = x) : x = 0 ∨ x = 1 
Arguments: {M₀ : Type u_1} [CancelMonoidWithZero M₀] {x : M₀} (hx : x ^ 2 = x)
Goal: x = 0 ∨ x = 1
-- mul_inv_cancel_right₀
@[simp]
theorem mul_inv_cancel_right₀ (h : b ≠ 0) (a : G₀) : a * b * b⁻¹ = a 
Arguments: {G₀ : Type u} [GroupWithZero G₀] {b : G₀} (h : b ≠ 0) (a : G₀)
Goal: a * b * b⁻¹ = a
-- mul_inv_cancel_left₀
@[simp]
theorem mul_inv_cancel_left₀ (h : a ≠ 0) (b : G₀) : a * (a⁻¹ * b) = b 
Arguments: {G₀ : Type u} [GroupWithZero G₀] {a : G₀} (h : a ≠ 0) (b : G₀)
Goal: a * (a⁻¹ * b) = b
-- mul_eq_zero_of_left
theorem mul_eq_zero_of_left {a : M₀} (h : a = 0) (b : M₀) : a * b = 0 
Arguments: {M₀ : Type u_1} [MulZeroClass M₀] {a : M₀} (h : a = 0) (b : M₀)
Goal: a * b = 0
-- mul_eq_zero_of_right
theorem mul_eq_zero_of_right (a : M₀) {b : M₀} (h : b = 0) : a * b = 0 
Arguments: {M₀ : Type u_1} [MulZeroClass M₀] (a : M₀) {b : M₀} (h : b = 0)
Goal: a * b = 0
-- mul_eq_zero
@[simp]
theorem mul_eq_zero : a * b = 0 ↔ a = 0 ∨ b = 0 
Arguments: {M₀ : Type u_1} [MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}
Goal: a * b = 0 ↔ a = 0 ∨ b = 0
-- zero_eq_mul
@[simp]
theorem zero_eq_mul : 0 = a * b ↔ a = 0 ∨ b = 0 
Arguments: {M₀ : Type u_1} [MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}
Goal: 0 = a * b ↔ a = 0 ∨ b = 0
-- mul_ne_zero_iff
theorem mul_ne_zero_iff : a * b ≠ 0 ↔ a ≠ 0 ∧ b ≠ 0 
Arguments: {M₀ : Type u_1} [MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}
Goal: a * b ≠ 0 ↔ a ≠ 0 ∧ b ≠ 0
-- mul_eq_zero_comm
theorem mul_eq_zero_comm : a * b = 0 ↔ b * a = 0 
Arguments: {M₀ : Type u_1} [MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}
Goal: a * b = 0 ↔ b * a = 0
-- mul_ne_zero_comm
theorem mul_ne_zero_comm : a * b ≠ 0 ↔ b * a ≠ 0 
Arguments: {M₀ : Type u_1} [MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}
Goal: a * b ≠ 0 ↔ b * a ≠ 0
-- mul_self_eq_zero
theorem mul_self_eq_zero : a * a = 0 ↔ a = 0 
Arguments: {M₀ : Type u_1} [MulZeroClass M₀] [NoZeroDivisors M₀] {a : M₀}
Goal: a * a = 0 ↔ a = 0
-- zero_eq_mul_self
theorem zero_eq_mul_self : 0 = a * a ↔ a = 0 
Arguments: {M₀ : Type u_1} [MulZeroClass M₀] [NoZeroDivisors M₀] {a : M₀}
Goal: 0 = a * a ↔ a = 0
-- mul_self_ne_zero
theorem mul_self_ne_zero : a * a ≠ 0 ↔ a ≠ 0 
Arguments: {M₀ : Type u_1} [MulZeroClass M₀] [NoZeroDivisors M₀] {a : M₀}
Goal: a * a ≠ 0 ↔ a ≠ 0
-- zero_ne_mul_self
theorem zero_ne_mul_self : 0 ≠ a * a ↔ a ≠ 0 
Arguments: {M₀ : Type u_1} [MulZeroClass M₀] [NoZeroDivisors M₀] {a : M₀}
Goal: 0 ≠ a * a ↔ a ≠ 0
-- Function.Injective.noZeroDivisors
protected theorem Function.Injective.noZeroDivisors [NoZeroDivisors M₀'] : NoZeroDivisors M₀ 
Arguments: {M₀ : Type u_1} {M₀' : Type u_3} [Mul M₀] [Zero M₀] [Mul M₀'] [Zero M₀'] (f : M₀ → M₀') (hf : Function.Injective f) (zero : f 0 = 0) (mul : ∀ (x y : M₀), f (x * y) = f x * f y) [NoZeroDivisors M₀']
Goal: NoZeroDivisors M₀
-- Function.Injective.isLeftCancelMulZero
protected theorem Function.Injective.isLeftCancelMulZero
    [IsLeftCancelMulZero M₀'] : IsLeftCancelMulZero M₀ 
Arguments: {M₀ : Type u_1} {M₀' : Type u_3} [Mul M₀] [Zero M₀] [Mul M₀'] [Zero M₀'] (f : M₀ → M₀') (hf : Function.Injective f) (zero : f 0 = 0) (mul : ∀ (x y : M₀), f (x * y) = f x * f y) [IsLeftCancelMulZero M₀']
Goal: IsLeftCancelMulZero M₀
-- Function.Injective.isRightCancelMulZero
protected theorem Function.Injective.isRightCancelMulZero
    [IsRightCancelMulZero M₀'] : IsRightCancelMulZero M₀ 
Arguments: {M₀ : Type u_1} {M₀' : Type u_3} [Mul M₀] [Zero M₀] [Mul M₀'] [Zero M₀'] (f : M₀ → M₀') (hf : Function.Injective f) (zero : f 0 = 0) (mul : ∀ (x y : M₀), f (x * y) = f x * f y) [IsRightCancelMulZero M₀']
Goal: IsRightCancelMulZero M₀
-- Ring.mul_inverse_rev'
theorem mul_inverse_rev' {a b : M₀} (h : Commute a b) :
    inverse (a * b) = inverse b * inverse a 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] {a b : M₀} (h : Commute a b)
Goal: Ring.inverse (a * b) = Ring.inverse b * Ring.inverse a
-- Ring.mul_inverse_rev
theorem mul_inverse_rev {M₀} [CommMonoidWithZero M₀] (a b : M₀) :
    Ring.inverse (a * b) = inverse b * inverse a 
Arguments: {M₀ : Type u_8} [CommMonoidWithZero M₀] (a b : M₀)
Goal: Ring.inverse (a * b) = Ring.inverse b * Ring.inverse a
-- Ring.inverse_pow
lemma inverse_pow (r : M₀) : ∀ n : ℕ, Ring.inverse r ^ n = Ring.inverse (r ^ n)
  
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] (r : M₀) (n : ℕ)
Goal: Ring.inverse r ^ n = Ring.inverse (r ^ n)
-- Commute.ring_inverse_ring_inverse
theorem Commute.ring_inverse_ring_inverse {a b : M₀} (h : Commute a b) :
    Commute (Ring.inverse a) (Ring.inverse b) 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] {a b : M₀} (h : Commute a b)
Goal: Commute (Ring.inverse a) (Ring.inverse b)
-- Commute.zero_right
@[simp]
theorem zero_right [MulZeroClass G₀] (a : G₀) : Commute a 0 
Arguments: {G₀ : Type u_3} [MulZeroClass G₀] (a : G₀)
Goal: Commute a 0
-- Commute.zero_left
@[simp]
theorem zero_left [MulZeroClass G₀] (a : G₀) : Commute 0 a 
Arguments: {G₀ : Type u_3} [MulZeroClass G₀] (a : G₀)
Goal: Commute 0 a
-- Commute.inv_left_iff₀
@[simp]
theorem inv_left_iff₀ : Commute a⁻¹ b ↔ Commute a b 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b : G₀}
Goal: Commute a⁻¹ b ↔ Commute a b
-- Commute.inv_left₀
theorem inv_left₀ (h : Commute a b) : Commute a⁻¹ b 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b : G₀} (h : Commute a b)
Goal: Commute a⁻¹ b
-- Commute.inv_right_iff₀
@[simp]
theorem inv_right_iff₀ : Commute a b⁻¹ ↔ Commute a b 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b : G₀}
Goal: Commute a b⁻¹ ↔ Commute a b
-- Commute.inv_right₀
theorem inv_right₀ (h : Commute a b) : Commute a b⁻¹ 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b : G₀} (h : Commute a b)
Goal: Commute a b⁻¹
-- Commute.div_right
@[simp]
theorem div_right (hab : Commute a b) (hac : Commute a c) : Commute a (b / c) 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b c : G₀} (hab : Commute a b) (hac : Commute a c)
Goal: Commute a (b / c)
-- Commute.div_left
@[simp]
theorem div_left (hac : Commute a c) (hbc : Commute b c) : Commute (a / b) c 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b c : G₀} (hac : Commute a c) (hbc : Commute b c)
Goal: Commute (a / b) c
-- pow_inv_comm₀
theorem pow_inv_comm₀ (a : G₀) (m n : ℕ) : a⁻¹ ^ m * a ^ n = a ^ n * a⁻¹ ^ m 
Arguments: {G₀ : Type u_8} [GroupWithZero G₀] (a : G₀) (m n : ℕ)
Goal: a⁻¹ ^ m * a ^ n = a ^ n * a⁻¹ ^ m
-- WithZero.coe_one
@[simp, norm_cast] lemma coe_one : ((1 : α) : WithZero α) = 1 
Arguments: {α : Type u_1} [One α]
Goal: ↑1 = 1
-- WithZero.coe_mul
@[simp, norm_cast] lemma coe_mul (a b : α) : (↑(a * b) : WithZero α) = a * b 
Arguments: {α : Type u_1} [Mul α] (a b : α)
Goal: ↑(a * b) = ↑a * ↑b
-- WithZero.unzero_mul
lemma unzero_mul {x y : WithZero α} (hxy : x * y ≠ 0) :
    unzero hxy = unzero (left_ne_zero_of_mul hxy) * unzero (right_ne_zero_of_mul hxy) 
Arguments: {α : Type u_1} [Mul α] {x y : WithZero α} (hxy : x * y ≠ 0)
Goal: WithZero.unzero hxy = WithZero.unzero ⋯ * WithZero.unzero ⋯
-- WithZero.coeMonoidHom_apply
@[simps apply]
def coeMonoidHom : α →* WithZero α 
Arguments: {α : Type u_1} [MulOneClass α]
Goal: ∀ (a : α), WithZero.coeMonoidHom a = ↑a
-- WithZero.monoidWithZeroHom_ext
@[ext high]
theorem monoidWithZeroHom_ext ⦃f g : WithZero α →*₀ β⦄
    (h : f.toMonoidHom.comp coeMonoidHom = g.toMonoidHom.comp coeMonoidHom) :
    f = g 
Arguments: {α : Type u_1} {β : Type u_2} [MulOneClass α] [MulZeroOneClass β] ⦃f g : WithZero α →*₀ β⦄ (h : (↑f).comp WithZero.coeMonoidHom = (↑g).comp WithZero.coeMonoidHom)
Goal: f = g
-- WithZero.lift'_symm_apply_apply
@[simps! symm_apply_apply]
noncomputable nonrec def lift' : (α →* β) ≃ (WithZero α →*₀ β) 
Arguments: {α : Type u_1} {β : Type u_2} [MulOneClass α] [MulZeroOneClass β] (F : WithZero α →*₀ β)
Goal: ∀ (a : α), (WithZero.lift'.symm F) a = F ↑a
-- WithZero.lift'_zero
lemma lift'_zero (f : α →* β) : lift' f (0 : WithZero α) = 0 
Arguments: {α : Type u_1} {β : Type u_2} [MulOneClass α] [MulZeroOneClass β] (f : α →* β)
Goal: (WithZero.lift' f) 0 = 0
-- WithZero.lift'_coe
@[simp] lemma lift'_coe (f : α →* β) (x : α) : lift' f (x : WithZero α) = f x 
Arguments: {α : Type u_1} {β : Type u_2} [MulOneClass α] [MulZeroOneClass β] (f : α →* β) (x : α)
Goal: (WithZero.lift' f) ↑x = f x
-- WithZero.lift'_unique
lemma lift'_unique (f : WithZero α →*₀ β) : f = lift' (f.toMonoidHom.comp coeMonoidHom) 
Arguments: {α : Type u_1} {β : Type u_2} [MulOneClass α] [MulZeroOneClass β] (f : WithZero α →*₀ β)
Goal: f = WithZero.lift' ((↑f).comp WithZero.coeMonoidHom)
-- WithZero.map'_zero
lemma map'_zero (f : α →* β) : map' f 0 = 0 
Arguments: {α : Type u_1} {β : Type u_2} [MulOneClass α] [MulOneClass β] (f : α →* β)
Goal: (WithZero.map' f) 0 = 0
-- WithZero.map'_coe
@[simp] lemma map'_coe (f : α →* β) (x : α) : map' f (x : WithZero α) = f x 
Arguments: {α : Type u_1} {β : Type u_2} [MulOneClass α] [MulOneClass β] (f : α →* β) (x : α)
Goal: (WithZero.map' f) ↑x = ↑(f x)
-- WithZero.map'_id
@[simp]
lemma map'_id : map' (MonoidHom.id β) = MonoidHom.id (WithZero β) 
Arguments: {β : Type u_2} [MulOneClass β]
Goal: ↑(WithZero.map' (MonoidHom.id β)) = MonoidHom.id (WithZero β)
-- WithZero.map'_map'
lemma map'_map'  (f : α →* β) (g : β →* γ) (x) : map' g (map' f x) = map' (g.comp f) x 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [MulOneClass α] [MulOneClass β] [MulOneClass γ] (f : α →* β) (g : β →* γ) (x : WithZero α)
Goal: (WithZero.map' g) ((WithZero.map' f) x) = (WithZero.map' (g.comp f)) x
-- WithZero.map'_comp
@[simp]
lemma map'_comp (f : α →* β) (g : β →* γ) : map' (g.comp f) = (map' g).comp (map' f) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [MulOneClass α] [MulOneClass β] [MulOneClass γ] (f : α →* β) (g : β →* γ)
Goal: WithZero.map' (g.comp f) = (WithZero.map' g).comp (WithZero.map' f)
-- WithZero.coe_pow
@[simp, norm_cast] lemma coe_pow (a : α) (n : ℕ) : (↑(a ^ n) : WithZero α) = a ^ n 
Arguments: {α : Type u_1} [One α] [Pow α ℕ] (a : α) (n : ℕ)
Goal: ↑(a ^ n) = ↑a ^ n
-- WithZero.coe_inv
@[simp, norm_cast] lemma coe_inv (a : α) : ((a⁻¹ : α) : WithZero α) = (↑a)⁻¹ 
Arguments: {α : Type u_1} [Inv α] (a : α)
Goal: ↑a⁻¹ = (↑a)⁻¹
-- WithZero.inv_zero
@[simp] protected lemma inv_zero : (0 : WithZero α)⁻¹ = 0 
Arguments: {α : Type u_1} [Inv α]
Goal: 0⁻¹ = 0
-- WithZero.coe_div
@[norm_cast] lemma coe_div (a b : α) : ↑(a / b : α) = (a / b : WithZero α) 
Arguments: {α : Type u_1} [Div α] (a b : α)
Goal: ↑(a / b) = ↑a / ↑b
-- WithZero.coe_zpow
@[simp, norm_cast] lemma coe_zpow (a : α) (n : ℤ) : ↑(a ^ n) = (↑a : WithZero α) ^ n 
Arguments: {α : Type u_1} [One α] [Pow α ℤ] (a : α) (n : ℤ)
Goal: ↑(a ^ n) = ↑a ^ n
-- nonzero_of_invertible
theorem nonzero_of_invertible [MulZeroOneClass α] (a : α) [Nontrivial α] [Invertible a] : a ≠ 0 
Arguments: {α : Type u} [MulZeroOneClass α] (a : α) [Nontrivial α] [Invertible a]
Goal: a ≠ 0
-- Ring.inverse_invertible
@[simp]
theorem Ring.inverse_invertible (x : α) [Invertible x] : Ring.inverse x = ⅟ x 
Arguments: {α : Type u} [MonoidWithZero α] (x : α) [Invertible x]
Goal: Ring.inverse x = ⅟x
-- invOf_eq_inv
@[simp]
theorem invOf_eq_inv (a : α) [Invertible a] : ⅟ a = a⁻¹ 
Arguments: {α : Type u} [GroupWithZero α] (a : α) [Invertible a]
Goal: ⅟a = a⁻¹
-- inv_mul_cancel_of_invertible
@[simp]
theorem inv_mul_cancel_of_invertible (a : α) [Invertible a] : a⁻¹ * a = 1 
Arguments: {α : Type u} [GroupWithZero α] (a : α) [Invertible a]
Goal: a⁻¹ * a = 1
-- mul_inv_cancel_of_invertible
@[simp]
theorem mul_inv_cancel_of_invertible (a : α) [Invertible a] : a * a⁻¹ = 1 
Arguments: {α : Type u} [GroupWithZero α] (a : α) [Invertible a]
Goal: a * a⁻¹ = 1
-- div_mul_cancel_of_invertible
@[simp]
theorem div_mul_cancel_of_invertible (a b : α) [Invertible b] : a / b * b = a 
Arguments: {α : Type u} [GroupWithZero α] (a b : α) [Invertible b]
Goal: a / b * b = a