ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- LieAlgebra.le_solvable_ideal_solvable
theorem le_solvable_ideal_solvable {I J : LieIdeal R L} (h₁ : I ≤ J) (_ : IsSolvable R J) :
    IsSolvable R I 
Arguments: {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] {I J : LieIdeal R L} (h₁ : I ≤ J)
Goal: LieAlgebra.IsSolvable R ↥↑J → LieAlgebra.IsSolvable R ↥↑I
-- LieAlgebra.LieIdeal.solvable_iff_le_radical
theorem LieIdeal.solvable_iff_le_radical [IsNoetherian R L] (I : LieIdeal R L) :
    IsSolvable R I ↔ I ≤ radical R L 
Arguments: (R : Type u) (L : Type v) [CommRing R] [LieRing L] [LieAlgebra R L] [IsNoetherian R L] (I : LieIdeal R L)
Goal: LieAlgebra.IsSolvable R ↥↑I ↔ I ≤ LieAlgebra.radical R L
-- LieAlgebra.center_le_radical
theorem center_le_radical : center R L ≤ radical R L 
Arguments: (R : Type u) (L : Type v) [CommRing R] [LieRing L] [LieAlgebra R L]
Goal: LieAlgebra.center R L ≤ LieAlgebra.radical R L
-- LieAlgebra.radical_eq_top_of_isSolvable
@[simp] lemma radical_eq_top_of_isSolvable [IsSolvable R L] :
    radical R L = ⊤ 
Arguments: (R : Type u) (L : Type v) [CommRing R] [LieRing L] [LieAlgebra R L] [LieAlgebra.IsSolvable R L]
Goal: LieAlgebra.radical R L = ⊤
-- LieAlgebra.derivedSeries_of_derivedLength_succ
theorem derivedSeries_of_derivedLength_succ (I : LieIdeal R L) (k : ℕ) :
    derivedLengthOfIdeal R L I = k + 1 ↔
      IsLieAbelian (derivedSeriesOfIdeal R L k I) ∧ derivedSeriesOfIdeal R L k I ≠ ⊥ 
Arguments: (R : Type u) (L : Type v) [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) (k : ℕ)
Goal: LieAlgebra.derivedLengthOfIdeal R L I = k + 1 ↔
  IsLieAbelian ↥↑(LieAlgebra.derivedSeriesOfIdeal R L k I) ∧ LieAlgebra.derivedSeriesOfIdeal R L k I ≠ ⊥
-- LieAlgebra.derivedLength_eq_derivedLengthOfIdeal
theorem derivedLength_eq_derivedLengthOfIdeal (I : LieIdeal R L) :
    derivedLength R I = derivedLengthOfIdeal R L I 
Arguments: (R : Type u) (L : Type v) [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L)
Goal: LieAlgebra.derivedLength R ↥↑I = LieAlgebra.derivedLengthOfIdeal R L I
-- LieAlgebra.abelian_derivedAbelianOfIdeal
theorem abelian_derivedAbelianOfIdeal (I : LieIdeal R L) :
    IsLieAbelian (derivedAbelianOfIdeal I) 
Arguments: {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L)
Goal: IsLieAbelian ↥↑(LieAlgebra.derivedAbelianOfIdeal I)
-- LieAlgebra.derivedLength_zero
theorem derivedLength_zero (I : LieIdeal R L) [hI : IsSolvable R I] :
    derivedLengthOfIdeal R L I = 0 ↔ I = ⊥ 
Arguments: {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) [hI : LieAlgebra.IsSolvable R ↥↑I]
Goal: LieAlgebra.derivedLengthOfIdeal R L I = 0 ↔ I = ⊥
-- LieAlgebra.abelian_of_solvable_ideal_eq_bot_iff
theorem abelian_of_solvable_ideal_eq_bot_iff (I : LieIdeal R L) [h : IsSolvable R I] :
    derivedAbelianOfIdeal I = ⊥ ↔ I = ⊥ 
Arguments: {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) [h : LieAlgebra.IsSolvable R ↥↑I]
Goal: LieAlgebra.derivedAbelianOfIdeal I = ⊥ ↔ I = ⊥
-- SemiconjBy.zero_right
@[simp]
theorem zero_right [MulZeroClass G₀] (a : G₀) : SemiconjBy a 0 0 
Arguments: {G₀ : Type u_3} [MulZeroClass G₀] (a : G₀)
Goal: SemiconjBy a 0 0
-- SemiconjBy.zero_left
@[simp]
theorem zero_left [MulZeroClass G₀] (x y : G₀) : SemiconjBy 0 x y 
Arguments: {G₀ : Type u_3} [MulZeroClass G₀] (x y : G₀)
Goal: SemiconjBy 0 x y
-- SemiconjBy.inv_symm_left_iff₀
@[simp]
theorem inv_symm_left_iff₀ : SemiconjBy a⁻¹ x y ↔ SemiconjBy a y x 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a x y : G₀}
Goal: SemiconjBy a⁻¹ x y ↔ SemiconjBy a y x
-- SemiconjBy.inv_symm_left₀
theorem inv_symm_left₀ (h : SemiconjBy a x y) : SemiconjBy a⁻¹ y x 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a x y : G₀} (h : SemiconjBy a x y)
Goal: SemiconjBy a⁻¹ y x
-- SemiconjBy.inv_right₀
theorem inv_right₀ (h : SemiconjBy a x y) : SemiconjBy a x⁻¹ y⁻¹ 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a x y : G₀} (h : SemiconjBy a x y)
Goal: SemiconjBy a x⁻¹ y⁻¹
-- SemiconjBy.inv_right_iff₀
@[simp]
theorem inv_right_iff₀ : SemiconjBy a x⁻¹ y⁻¹ ↔ SemiconjBy a x y 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a x y : G₀}
Goal: SemiconjBy a x⁻¹ y⁻¹ ↔ SemiconjBy a x y
-- SemiconjBy.div_right
theorem div_right (h : SemiconjBy a x y) (h' : SemiconjBy a x' y') :
    SemiconjBy a (x / x') (y / y') 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a x y x' y' : G₀} (h : SemiconjBy a x y) (h' : SemiconjBy a x' y')
Goal: SemiconjBy a (x / x') (y / y')
-- SemiconjBy.zpow_right₀
lemma zpow_right₀ {a x y : G₀} (h : SemiconjBy a x y) : ∀ m : ℤ, SemiconjBy a (x ^ m) (y ^ m)
  
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a x y : G₀} (h : SemiconjBy a x y) (m : ℤ)
Goal: SemiconjBy a (x ^ m) (y ^ m)
-- Commute.zpow_right₀
lemma zpow_right₀ (h : Commute a b) : ∀ m : ℤ, Commute a (b ^ m) 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b : G₀} (h : Commute a b) (m : ℤ)
Goal: Commute a (b ^ m)
-- Commute.zpow_left₀
lemma zpow_left₀ (h : Commute a b) (m : ℤ) : Commute (a ^ m) b 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b : G₀} (h : Commute a b) (m : ℤ)
Goal: Commute (a ^ m) b
-- Commute.zpow_zpow₀
lemma zpow_zpow₀ (h : Commute a b) (m n : ℤ) : Commute (a ^ m) (b ^ n) 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b : G₀} (h : Commute a b) (m n : ℤ)
Goal: Commute (a ^ m) (b ^ n)
-- Commute.zpow_self₀
lemma zpow_self₀ (a : G₀) (n : ℤ) : Commute (a ^ n) a 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] (a : G₀) (n : ℤ)
Goal: Commute (a ^ n) a
-- Commute.self_zpow₀
lemma self_zpow₀ (a : G₀) (n : ℤ) : Commute a (a ^ n) 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] (a : G₀) (n : ℤ)
Goal: Commute a (a ^ n)
-- Commute.zpow_zpow_self₀
lemma zpow_zpow_self₀ (a : G₀) (m n : ℤ) : Commute (a ^ m) (a ^ n) 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] (a : G₀) (m n : ℤ)
Goal: Commute (a ^ m) (a ^ n)
-- left_ne_zero_of_mul
theorem left_ne_zero_of_mul : a * b ≠ 0 → a ≠ 0 
Arguments: {M₀ : Type u_2} [MulZeroClass M₀] {a b : M₀}
Goal: a * b ≠ 0 → a ≠ 0
-- right_ne_zero_of_mul
theorem right_ne_zero_of_mul : a * b ≠ 0 → b ≠ 0 
Arguments: {M₀ : Type u_2} [MulZeroClass M₀] {a b : M₀}
Goal: a * b ≠ 0 → b ≠ 0
-- ne_zero_and_ne_zero_of_mul
theorem ne_zero_and_ne_zero_of_mul (h : a * b ≠ 0) : a ≠ 0 ∧ b ≠ 0 
Arguments: {M₀ : Type u_2} [MulZeroClass M₀] {a b : M₀} (h : a * b ≠ 0)
Goal: a ≠ 0 ∧ b ≠ 0
-- mul_eq_zero_of_ne_zero_imp_eq_zero
theorem mul_eq_zero_of_ne_zero_imp_eq_zero {a b : M₀} (h : a ≠ 0 → b = 0) : a * b = 0 
Arguments: {M₀ : Type u_2} [MulZeroClass M₀] {a b : M₀} (h : a ≠ 0 → b = 0)
Goal: a * b = 0
-- zero_mul_eq_const
theorem zero_mul_eq_const : ((0 : M₀) * ·) = Function.const _ 0 
Arguments: {M₀ : Type u_2} [MulZeroClass M₀]
Goal: (fun x => 0 * x) = Function.const M₀ 0
-- mul_zero_eq_const
theorem mul_zero_eq_const : (· * (0 : M₀)) = Function.const _ 0 
Arguments: {M₀ : Type u_2} [MulZeroClass M₀]
Goal: (fun x => x * 0) = Function.const M₀ 0
-- eq_zero_of_mul_self_eq_zero
theorem eq_zero_of_mul_self_eq_zero (h : a * a = 0) : a = 0 
Arguments: {M₀ : Type u_2} [Mul M₀] [Zero M₀] [NoZeroDivisors M₀] {a : M₀} (h : a * a = 0)
Goal: a = 0
-- mul_ne_zero
@[field_simps]
theorem mul_ne_zero (ha : a ≠ 0) (hb : b ≠ 0) : a * b ≠ 0 
Arguments: {M₀ : Type u_2} [Mul M₀] [Zero M₀] [NoZeroDivisors M₀] {a b : M₀} (ha : a ≠ 0) (hb : b ≠ 0)
Goal: a * b ≠ 0
-- eq_zero_of_zero_eq_one
theorem eq_zero_of_zero_eq_one (h : (0 : M₀) = 1) (a : M₀) : a = 0 
Arguments: {M₀ : Type u_2} [MulZeroOneClass M₀] (h : 0 = 1) (a : M₀)
Goal: a = 0
-- subsingleton_iff_zero_eq_one
theorem subsingleton_iff_zero_eq_one : (0 : M₀) = 1 ↔ Subsingleton M₀ 
Arguments: {M₀ : Type u_2} [MulZeroOneClass M₀]
Goal: 0 = 1 ↔ Subsingleton M₀
-- eq_of_zero_eq_one
theorem eq_of_zero_eq_one (h : (0 : M₀) = 1) (a b : M₀) : a = b 
Arguments: {M₀ : Type u_2} [MulZeroOneClass M₀] (h : 0 = 1) (a b : M₀)
Goal: a = b
-- zero_ne_one_or_forall_eq_0
theorem zero_ne_one_or_forall_eq_0 : (0 : M₀) ≠ 1 ∨ ∀ a : M₀, a = 0 
Arguments: {M₀ : Type u_2} [MulZeroOneClass M₀]
Goal: 0 ≠ 1 ∨ ∀ (a : M₀), a = 0
-- left_ne_zero_of_mul_eq_one
theorem left_ne_zero_of_mul_eq_one (h : a * b = 1) : a ≠ 0 
Arguments: {M₀ : Type u_2} [MulZeroOneClass M₀] [Nontrivial M₀] {a b : M₀} (h : a * b = 1)
Goal: a ≠ 0
-- right_ne_zero_of_mul_eq_one
theorem right_ne_zero_of_mul_eq_one (h : a * b = 1) : b ≠ 0 
Arguments: {M₀ : Type u_2} [MulZeroOneClass M₀] [Nontrivial M₀] {a b : M₀} (h : a * b = 1)
Goal: b ≠ 0
-- zero_pow
@[simp] lemma zero_pow : ∀ {n : ℕ}, n ≠ 0 → (0 : M₀) ^ n = 0
  
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] {n : ℕ}
Goal: n ≠ 0 → 0 ^ n = 0
-- zero_pow_eq
lemma zero_pow_eq (n : ℕ) : (0 : M₀) ^ n = if n = 0 then 1 else 0 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] (n : ℕ)
Goal: 0 ^ n = if n = 0 then 1 else 0
-- pow_eq_zero_of_le
lemma pow_eq_zero_of_le : ∀ {m n} (hmn : m ≤ n) (ha : a ^ m = 0), a ^ n = 0
  
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] {a : M₀} {m n : ℕ} (hmn : m ≤ n) (ha : a ^ m = 0)
Goal: a ^ n = 0
-- ne_zero_pow
lemma ne_zero_pow (hn : n ≠ 0) (ha : a ^ n ≠ 0) : a ≠ 0 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] {a : M₀} {n : ℕ} (hn : n ≠ 0) (ha : a ^ n ≠ 0)
Goal: a ≠ 0
-- zero_pow_eq_zero
@[simp]
lemma zero_pow_eq_zero [Nontrivial M₀] : (0 : M₀) ^ n = 0 ↔ n ≠ 0 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] {n : ℕ} [Nontrivial M₀]
Goal: 0 ^ n = 0 ↔ n ≠ 0
-- pow_eq_zero
lemma pow_eq_zero : ∀ {n}, a ^ n = 0 → a = 0
  
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] {a : M₀} [NoZeroDivisors M₀] {n : ℕ}
Goal: a ^ n = 0 → a = 0
-- pow_eq_zero_iff
@[simp] lemma pow_eq_zero_iff (hn : n ≠ 0) : a ^ n = 0 ↔ a = 0 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] {a : M₀} {n : ℕ} [NoZeroDivisors M₀] (hn : n ≠ 0)
Goal: a ^ n = 0 ↔ a = 0
-- pow_ne_zero_iff
lemma pow_ne_zero_iff (hn : n ≠ 0) : a ^ n ≠ 0 ↔ a ≠ 0 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] {a : M₀} {n : ℕ} [NoZeroDivisors M₀] (hn : n ≠ 0)
Goal: a ^ n ≠ 0 ↔ a ≠ 0
-- pow_ne_zero
@[field_simps]
lemma pow_ne_zero (n : ℕ) (h : a ≠ 0) : a ^ n ≠ 0 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] {a : M₀} [NoZeroDivisors M₀] (n : ℕ) (h : a ≠ 0)
Goal: a ^ n ≠ 0
-- sq_eq_zero_iff
lemma sq_eq_zero_iff : a ^ 2 = 0 ↔ a = 0 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] {a : M₀} [NoZeroDivisors M₀]
Goal: a ^ 2 = 0 ↔ a = 0
-- pow_eq_zero_iff'
@[simp] lemma pow_eq_zero_iff' [Nontrivial M₀] : a ^ n = 0 ↔ a = 0 ∧ n ≠ 0 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] {a : M₀} {n : ℕ} [NoZeroDivisors M₀] [Nontrivial M₀]
Goal: a ^ n = 0 ↔ a = 0 ∧ n ≠ 0
-- mul_eq_mul_right_iff
@[simp]
theorem mul_eq_mul_right_iff : a * c = b * c ↔ a = b ∨ c = 0 
Arguments: {M₀ : Type u_2} [CancelMonoidWithZero M₀] {a b c : M₀}
Goal: a * c = b * c ↔ a = b ∨ c = 0
-- mul_eq_mul_left_iff
@[simp]
theorem mul_eq_mul_left_iff : a * b = a * c ↔ b = c ∨ a = 0 
Arguments: {M₀ : Type u_2} [CancelMonoidWithZero M₀] {a b c : M₀}
Goal: a * b = a * c ↔ b = c ∨ a = 0
-- mul_right_eq_self₀
theorem mul_right_eq_self₀ : a * b = a ↔ b = 1 ∨ a = 0 
Arguments: {M₀ : Type u_2} [CancelMonoidWithZero M₀] {a b : M₀}
Goal: a * b = a ↔ b = 1 ∨ a = 0
-- mul_left_eq_self₀
theorem mul_left_eq_self₀ : a * b = b ↔ a = 1 ∨ b = 0 
Arguments: {M₀ : Type u_2} [CancelMonoidWithZero M₀] {a b : M₀}
Goal: a * b = b ↔ a = 1 ∨ b = 0
-- mul_eq_left₀
@[simp]
theorem mul_eq_left₀ (ha : a ≠ 0) : a * b = a ↔ b = 1 
Arguments: {M₀ : Type u_2} [CancelMonoidWithZero M₀] {a b : M₀} (ha : a ≠ 0)
Goal: a * b = a ↔ b = 1
-- mul_eq_right₀
@[simp]
theorem mul_eq_right₀ (hb : b ≠ 0) : a * b = b ↔ a = 1 
Arguments: {M₀ : Type u_2} [CancelMonoidWithZero M₀] {a b : M₀} (hb : b ≠ 0)
Goal: a * b = b ↔ a = 1
-- left_eq_mul₀
@[simp]
theorem left_eq_mul₀ (ha : a ≠ 0) : a = a * b ↔ b = 1 
Arguments: {M₀ : Type u_2} [CancelMonoidWithZero M₀] {a b : M₀} (ha : a ≠ 0)
Goal: a = a * b ↔ b = 1
-- right_eq_mul₀
@[simp]
theorem right_eq_mul₀ (hb : b ≠ 0) : b = a * b ↔ a = 1 
Arguments: {M₀ : Type u_2} [CancelMonoidWithZero M₀] {a b : M₀} (hb : b ≠ 0)
Goal: b = a * b ↔ a = 1
-- eq_zero_of_mul_eq_self_right
theorem eq_zero_of_mul_eq_self_right (h₁ : b ≠ 1) (h₂ : a * b = a) : a = 0 
Arguments: {M₀ : Type u_2} [CancelMonoidWithZero M₀] {a b : M₀} (h₁ : b ≠ 1) (h₂ : a * b = a)
Goal: a = 0
-- eq_zero_of_mul_eq_self_left
theorem eq_zero_of_mul_eq_self_left (h₁ : b ≠ 1) (h₂ : b * a = a) : a = 0 
Arguments: {M₀ : Type u_2} [CancelMonoidWithZero M₀] {a b : M₀} (h₁ : b ≠ 1) (h₂ : b * a = a)
Goal: a = 0
-- GroupWithZero.mul_left_injective
theorem GroupWithZero.mul_left_injective (h : x ≠ 0) :
    Function.Injective fun y => x * y 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {x : G₀} (h : x ≠ 0)
Goal: Function.Injective fun y => x * y
-- GroupWithZero.mul_right_injective
theorem GroupWithZero.mul_right_injective (h : x ≠ 0) :
    Function.Injective fun y => y * x 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {x : G₀} (h : x ≠ 0)
Goal: Function.Injective fun y => y * x
-- inv_mul_cancel_right₀
@[simp]
theorem inv_mul_cancel_right₀ (h : b ≠ 0) (a : G₀) : a * b⁻¹ * b = a 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {b : G₀} (h : b ≠ 0) (a : G₀)
Goal: a * b⁻¹ * b = a
-- inv_mul_cancel_left₀
@[simp]
theorem inv_mul_cancel_left₀ (h : a ≠ 0) (b : G₀) : a⁻¹ * (a * b) = b 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀} (h : a ≠ 0) (b : G₀)
Goal: a⁻¹ * (a * b) = b
-- _private.Mathlib.Algebra.GroupWithZero.Basic.0.inv_eq_of_mul
private theorem inv_eq_of_mul (h : a * b = 1) : a⁻¹ = b 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b : G₀} (h : a * b = 1)
Goal: a⁻¹ = b
-- zero_div
@[simp]
theorem zero_div (a : G₀) : 0 / a = 0 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] (a : G₀)
Goal: 0 / a = 0
-- div_zero
@[simp]
theorem div_zero (a : G₀) : a / 0 = 0 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] (a : G₀)
Goal: a / 0 = 0
-- mul_self_mul_inv
@[simp]
theorem mul_self_mul_inv (a : G₀) : a * a * a⁻¹ = a 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] (a : G₀)
Goal: a * a * a⁻¹ = a
-- mul_inv_mul_self
@[simp]
theorem mul_inv_mul_self (a : G₀) : a * a⁻¹ * a = a 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] (a : G₀)
Goal: a * a⁻¹ * a = a
-- inv_mul_mul_self
@[simp]
theorem inv_mul_mul_self (a : G₀) : a⁻¹ * a * a = a 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] (a : G₀)
Goal: a⁻¹ * a * a = a
-- mul_self_div_self
@[simp]
theorem mul_self_div_self (a : G₀) : a * a / a = a 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] (a : G₀)
Goal: a * a / a = a
-- div_self_mul_self
@[simp]
theorem div_self_mul_self (a : G₀) : a / a * a = a 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] (a : G₀)
Goal: a / a * a = a
-- div_self_mul_self'
@[simp]
theorem div_self_mul_self' (a : G₀) : a / (a * a) = a⁻¹ 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] (a : G₀)
Goal: a / (a * a) = a⁻¹
-- one_div_ne_zero
theorem one_div_ne_zero {a : G₀} (h : a ≠ 0) : 1 / a ≠ 0 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀} (h : a ≠ 0)
Goal: 1 / a ≠ 0
-- inv_eq_zero
@[simp]
theorem inv_eq_zero {a : G₀} : a⁻¹ = 0 ↔ a = 0 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀}
Goal: a⁻¹ = 0 ↔ a = 0
-- zero_eq_inv
@[simp]
theorem zero_eq_inv {a : G₀} : 0 = a⁻¹ ↔ 0 = a 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀}
Goal: 0 = a⁻¹ ↔ 0 = a
-- div_div_self
@[simp]
theorem div_div_self (a : G₀) : a / (a / a) = a 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] (a : G₀)
Goal: a / (a / a) = a
-- ne_zero_of_one_div_ne_zero
theorem ne_zero_of_one_div_ne_zero {a : G₀} (h : 1 / a ≠ 0) : a ≠ 0 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀} (h : 1 / a ≠ 0)
Goal: a ≠ 0
-- eq_zero_of_one_div_eq_zero
theorem eq_zero_of_one_div_eq_zero {a : G₀} (h : 1 / a = 0) : a = 0 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀} (h : 1 / a = 0)
Goal: a = 0
-- mul_left_surjective₀
theorem mul_left_surjective₀ {a : G₀} (h : a ≠ 0) : Surjective fun g => a * g 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀} (h : a ≠ 0)
Goal: Function.Surjective fun g => a * g
-- mul_right_surjective₀
theorem mul_right_surjective₀ {a : G₀} (h : a ≠ 0) : Surjective fun g => g * a 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀} (h : a ≠ 0)
Goal: Function.Surjective fun g => g * a
-- zero_zpow
lemma zero_zpow : ∀ n : ℤ, n ≠ 0 → (0 : G₀) ^ n = 0
  
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] (n : ℤ)
Goal: n ≠ 0 → 0 ^ n = 0
-- zero_zpow_eq
lemma zero_zpow_eq (n : ℤ) : (0 : G₀) ^ n = if n = 0 then 1 else 0 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] (n : ℤ)
Goal: 0 ^ n = if n = 0 then 1 else 0
-- zpow_add_one₀
lemma zpow_add_one₀ (ha : a ≠ 0) : ∀ n : ℤ, a ^ (n + 1) = a ^ n * a
  
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀} (ha : a ≠ 0) (n : ℤ)
Goal: a ^ (n + 1) = a ^ n * a
-- zpow_sub_one₀
lemma zpow_sub_one₀ (ha : a ≠ 0) (n : ℤ) : a ^ (n - 1) = a ^ n * a⁻¹ 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀} (ha : a ≠ 0) (n : ℤ)
Goal: a ^ (n - 1) = a ^ n * a⁻¹
-- zpow_add₀
lemma zpow_add₀ (ha : a ≠ 0) (m n : ℤ) : a ^ (m + n) = a ^ m * a ^ n 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀} (ha : a ≠ 0) (m n : ℤ)
Goal: a ^ (m + n) = a ^ m * a ^ n
-- zpow_add'
lemma zpow_add' {m n : ℤ} (h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0) :
    a ^ (m + n) = a ^ m * a ^ n 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀} {m n : ℤ} (h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0)
Goal: a ^ (m + n) = a ^ m * a ^ n
-- zpow_one_add₀
lemma zpow_one_add₀ (h : a ≠ 0) (i : ℤ) : a ^ (1 + i) = a * a ^ i 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀} (h : a ≠ 0) (i : ℤ)
Goal: a ^ (1 + i) = a * a ^ i
-- div_mul_eq_mul_div₀
theorem div_mul_eq_mul_div₀ (a b c : G₀) : a / c * b = a * b / c 
Arguments: {G₀ : Type u_3} [CommGroupWithZero G₀] (a b c : G₀)
Goal: a / c * b = a * b / c
-- div_sq_cancel
lemma div_sq_cancel (a b : G₀) : a ^ 2 * b / a = a * b 
Arguments: {G₀ : Type u_3} [CommGroupWithZero G₀] (a b : G₀)
Goal: a ^ 2 * b / a = a * b
-- SMulZeroClass.smul_zero
class SMulZeroClass (M A : Type*) [Zero A] extends SMul M A where
    smul_zero : ∀ a : M, a • (0 : A) = 0
Arguments: {M : Type u_10} {A : Type u_11} [Zero A] [self : SMulZeroClass M A] (a : M)
Goal: a • 0 = 0
-- smul_zero
@[simp]
theorem smul_zero (a : M) : a • (0 : A) = 0 
Arguments: {M : Type u_1} {A : Type u_4} [Zero A] [SMulZeroClass M A] (a : M)
Goal: a • 0 = 0
-- smul_ite_zero
lemma smul_ite_zero (p : Prop) [Decidable p] (a : M) (b : A) :
    (a • if p then b else 0) = if p then a • b else 0 
Arguments: {M : Type u_1} {A : Type u_4} [Zero A] [SMulZeroClass M A] (p : Prop) [Decidable p] (a : M) (b : A)
Goal: (a • if p then b else 0) = if p then a • b else 0
-- smul_eq_zero_of_right
lemma smul_eq_zero_of_right (a : M) {b : A} (h : b = 0) : a • b = 0 
Arguments: {M : Type u_1} {A : Type u_4} [Zero A] [SMulZeroClass M A] (a : M) {b : A} (h : b = 0)
Goal: a • b = 0
-- right_ne_zero_of_smul
lemma right_ne_zero_of_smul {a : M} {b : A} : a • b ≠ 0 → b ≠ 0 
Arguments: {M : Type u_1} {A : Type u_4} [Zero A] [SMulZeroClass M A] {a : M} {b : A}
Goal: a • b ≠ 0 → b ≠ 0
-- SMulZeroClass.toZeroHom_apply
@[simps]
def SMulZeroClass.toZeroHom (x : M) :
    ZeroHom A A 
Arguments: {M : Type u_1} (A : Type u_4) [Zero A] [SMulZeroClass M A] (x : M)
Goal: ∀ (x_1 : A), (SMulZeroClass.toZeroHom A x) x_1 = x • x_1
-- DistribSMul.smul_add
@[ext]
class DistribSMul (M A : Type*) [AddZeroClass A] extends SMulZeroClass M A where
    smul_add : ∀ (a : M) (x y : A), a • (x + y) = a • x + a • y
Arguments: {M : Type u_10} {A : Type u_11} [AddZeroClass A] [self : DistribSMul M A] (a : M) (x y : A)
Goal: a • (x + y) = a • x + a • y
-- smul_add
theorem smul_add (a : M) (b₁ b₂ : A) : a • (b₁ + b₂) = a • b₁ + a • b₂ 
Arguments: {M : Type u_1} {A : Type u_4} [AddZeroClass A] [DistribSMul M A] (a : M) (b₁ b₂ : A)
Goal: a • (b₁ + b₂) = a • b₁ + a • b₂
-- DistribSMul.toAddMonoidHom_apply
@[simps]
def DistribSMul.toAddMonoidHom (x : M) : A →+ A 
Arguments: {M : Type u_1} (A : Type u_4) [AddZeroClass A] [DistribSMul M A] (x : M)
Goal: ∀ (x_1 : A), (DistribSMul.toAddMonoidHom A x) x_1 = (fun x x_2 => x • x_2) x x_1
-- DistribMulAction.smul_zero
@[ext]
class DistribMulAction (M A : Type*) [Monoid M] [AddMonoid A] extends MulAction M A where
    smul_zero : ∀ a : M, a • (0 : A) = 0
    smul_add : ∀ (a : M) (x y : A), a • (x + y) = a • x + a • y
Arguments: {M : Type u_10} {A : Type u_11} [Monoid M] [AddMonoid A] [self : DistribMulAction M A] (a : M)
Goal: a • 0 = 0
-- DistribMulAction.smul_add
@[ext]
class DistribMulAction (M A : Type*) [Monoid M] [AddMonoid A] extends MulAction M A where
    smul_zero : ∀ a : M, a • (0 : A) = 0
    smul_add : ∀ (a : M) (x y : A), a • (x + y) = a • x + a • y
Arguments: {M : Type u_10} {A : Type u_11} [Monoid M] [AddMonoid A] [self : DistribMulAction M A] (a : M) (x y : A)
Goal: a • (x + y) = a • x + a • y
-- DistribMulAction.toAddMonoidHom_apply
@[simps!]
def DistribMulAction.toAddMonoidHom (x : M) : A →+ A 
Arguments: {M : Type u_1} (A : Type u_4) [Monoid M] [AddMonoid A] [DistribMulAction M A] (x : M)
Goal: ∀ (x_1 : A), (DistribMulAction.toAddMonoidHom A x) x_1 = x • x_1
-- DistribMulAction.toAddMonoidEnd_apply
@[simps]
def DistribMulAction.toAddMonoidEnd :
    M →* AddMonoid.End A 
Arguments: (M : Type u_1) (A : Type u_4) [Monoid M] [AddMonoid A] [DistribMulAction M A] (x : M)
Goal: (DistribMulAction.toAddMonoidEnd M A) x = DistribMulAction.toAddMonoidHom A x
-- smul_neg
@[simp]
theorem smul_neg (r : M) (x : A) : r • -x = -(r • x) 
Arguments: {M : Type u_1} {A : Type u_4} [Monoid M] [AddGroup A] [DistribMulAction M A] (r : M) (x : A)
Goal: r • -x = -(r • x)
-- smul_sub
theorem smul_sub (r : M) (x y : A) : r • (x - y) = r • x - r • y 
Arguments: {M : Type u_1} {A : Type u_4} [Monoid M] [AddGroup A] [DistribMulAction M A] (r : M) (x y : A)
Goal: r • (x - y) = r • x - r • y
-- MulDistribMulAction.smul_mul
@[ext]
class MulDistribMulAction (M : Type*) (A : Type*) [Monoid M] [Monoid A] extends
  MulAction M A where
    smul_mul : ∀ (r : M) (x y : A), r • (x * y) = r • x * r • y
    smul_one : ∀ r : M, r • (1 : A) = 1
Arguments: {M : Type u_10} {A : Type u_11} [Monoid M] [Monoid A] [self : MulDistribMulAction M A] (r : M) (x y : A)
Goal: r • (x * y) = r • x * r • y
-- MulDistribMulAction.smul_one
@[ext]
class MulDistribMulAction (M : Type*) (A : Type*) [Monoid M] [Monoid A] extends
  MulAction M A where
    smul_mul : ∀ (r : M) (x y : A), r • (x * y) = r • x * r • y
    smul_one : ∀ r : M, r • (1 : A) = 1
Arguments: {M : Type u_10} {A : Type u_11} [Monoid M] [Monoid A] [self : MulDistribMulAction M A] (r : M)
Goal: r • 1 = 1
-- smul_mul'
theorem smul_mul' (a : M) (b₁ b₂ : A) : a • (b₁ * b₂) = a • b₁ * a • b₂ 
Arguments: {M : Type u_1} {A : Type u_4} [Monoid M] [Monoid A] [MulDistribMulAction M A] (a : M) (b₁ b₂ : A)
Goal: a • (b₁ * b₂) = a • b₁ * a • b₂
-- MulDistribMulAction.toMonoidHom_apply
@[simp]
theorem MulDistribMulAction.toMonoidHom_apply (r : M) (x : A) :
    MulDistribMulAction.toMonoidHom A r x = r • x 
Arguments: {M : Type u_1} {A : Type u_4} [Monoid M] [Monoid A] [MulDistribMulAction M A] (r : M) (x : A)
Goal: (MulDistribMulAction.toMonoidHom A r) x = r • x
-- smul_pow'
@[simp] lemma smul_pow' (r : M) (x : A) (n : ℕ) : r • x ^ n = (r • x) ^ n 
Arguments: {M : Type u_1} {A : Type u_4} [Monoid M] [Monoid A] [MulDistribMulAction M A] (r : M) (x : A) (n : ℕ)
Goal: r • x ^ n = (r • x) ^ n
-- MulDistribMulAction.toMonoidEnd_apply
@[simps]
def MulDistribMulAction.toMonoidEnd :
    M →* Monoid.End A 
Arguments: (M : Type u_1) (A : Type u_4) [Monoid M] [Monoid A] [MulDistribMulAction M A] (r : M)
Goal: (MulDistribMulAction.toMonoidEnd M A) r = MulDistribMulAction.toMonoidHom A r
-- smul_inv'
@[simp]
theorem smul_inv' (r : M) (x : A) : r • x⁻¹ = (r • x)⁻¹ 
Arguments: {M : Type u_1} {A : Type u_4} [Monoid M] [Group A] [MulDistribMulAction M A] (r : M) (x : A)
Goal: r • x⁻¹ = (r • x)⁻¹
-- smul_div'
theorem smul_div' (r : M) (x y : A) : r • (x / y) = r • x / r • y 
Arguments: {M : Type u_1} {A : Type u_4} [Monoid M] [Group A] [MulDistribMulAction M A] (r : M) (x y : A)
Goal: r • (x / y) = r • x / r • y
-- AddMonoid.End.smul_def
@[simp]
theorem AddMonoid.End.smul_def [AddMonoid α] (f : AddMonoid.End α) (a : α) : f • a = f a 
Arguments: {α : Type u_6} [AddMonoid α] (f : AddMonoid.End α) (a : α)
Goal: f • a = f a