ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Pi.single_smul
theorem single_smul {α} [Monoid α] [∀ i, AddMonoid <| f i] [∀ i, DistribMulAction α <| f i]
    [DecidableEq I] (i : I) (r : α) (x : f i) : single i (r • x) = r • single i x 
Arguments: {I : Type u} {f : I → Type v} {α : Type u_1} [Monoid α] [(i : I) → AddMonoid (f i)] [(i : I) → DistribMulAction α (f i)] [DecidableEq I] (i : I) (r : α) (x : f i)
Goal: Pi.single i (r • x) = r • Pi.single i x
-- Pi.single_smul'
theorem single_smul' {α β} [Monoid α] [AddMonoid β] [DistribMulAction α β] [DecidableEq I] (i : I)
    (r : α) (x : β) : single (f := fun _ => β) i (r • x) = r • single (f := fun _ => β) i x 
Arguments: {I : Type u} {α : Type u_1} {β : Type u_2} [Monoid α] [AddMonoid β] [DistribMulAction α β] [DecidableEq I] (i : I) (r : α) (x : β)
Goal: Pi.single i (r • x) = r • Pi.single i x
-- Pi.single_smul₀
theorem single_smul₀ {g : I → Type*} [∀ i, MonoidWithZero (f i)] [∀ i, AddMonoid (g i)]
    [∀ i, DistribMulAction (f i) (g i)] [DecidableEq I] (i : I) (r : f i) (x : g i) :
    single i (r • x) = single i r • single i x 
Arguments: {I : Type u} {f : I → Type v} {g : I → Type u_1} [(i : I) → MonoidWithZero (f i)] [(i : I) → AddMonoid (g i)] [(i : I) → DistribMulAction (f i) (g i)] [DecidableEq I] (i : I) (r : f i) (x : g i)
Goal: Pi.single i (r • x) = Pi.single i r • Pi.single i x
-- LieModule.LinearWeights.map_lie
class LinearWeights [LieAlgebra.IsNilpotent R L] : Prop :=
  map_add : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ x y, χ (x + y) = χ x + χ y
  map_smul : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ (t : R) x, χ (t • x) = t • χ x
  map_lie : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ x y : L, χ ⁅x, y⁆ = 0
Arguments: {R : Type u_1} {L : Type u_2} {M : Type u_3} [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [LieAlgebra.IsNilpotent R L] [self : LieModule.LinearWeights R L M] (χ : L → R)
Goal: LieModule.weightSpace M χ ≠ ⊥ → ∀ (x y : L), χ ⁅x, y⁆ = 0
-- LieModule.LinearWeights.map_add
class LinearWeights [LieAlgebra.IsNilpotent R L] : Prop :=
  map_add : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ x y, χ (x + y) = χ x + χ y
  map_smul : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ (t : R) x, χ (t • x) = t • χ x
  map_lie : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ x y : L, χ ⁅x, y⁆ = 0
Arguments: {R : Type u_1} {L : Type u_2} {M : Type u_3} [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [LieAlgebra.IsNilpotent R L] [self : LieModule.LinearWeights R L M] (χ : L → R)
Goal: LieModule.weightSpace M χ ≠ ⊥ → ∀ (x y : L), χ (x + y) = χ x + χ y
-- LieModule.LinearWeights.map_smul
class LinearWeights [LieAlgebra.IsNilpotent R L] : Prop :=
  map_add : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ x y, χ (x + y) = χ x + χ y
  map_smul : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ (t : R) x, χ (t • x) = t • χ x
  map_lie : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ x y : L, χ ⁅x, y⁆ = 0
Arguments: {R : Type u_1} {L : Type u_2} {M : Type u_3} [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [LieAlgebra.IsNilpotent R L] [self : LieModule.LinearWeights R L M] (χ : L → R)
Goal: LieModule.weightSpace M χ ≠ ⊥ → ∀ (t : R) (x : L), χ (t • x) = t • χ x
-- LieModule.Weight.toLinear_apply
@[simps]
def toLinear : L →ₗ[R] R 
Arguments: (R : Type u_1) (L : Type u_2) (M : Type u_3) [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [LieAlgebra.IsNilpotent R L] [LieModule.LinearWeights R L M] (χ : LieModule.Weight R L M) (a : L)
Goal: (LieModule.Weight.toLinear R L M χ) a = χ a
-- LieModule.Weight.apply_lie
@[simp]
lemma apply_lie (x y : L) :
    χ ⁅x, y⁆ = 0 
Arguments: {R : Type u_1} {L : Type u_2} {M : Type u_3} [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [LieAlgebra.IsNilpotent R L] [LieModule.LinearWeights R L M] {χ : LieModule.Weight R L M} (x y : L)
Goal: χ ⁅x, y⁆ = 0
-- LieModule.Weight.coe_coe
@[simp] lemma coe_coe : (↑(χ : L →ₗ[R] R) : L → R) = (χ : L → R) 
Arguments: {R : Type u_1} {L : Type u_2} {M : Type u_3} [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [LieAlgebra.IsNilpotent R L] [LieModule.LinearWeights R L M] {χ : LieModule.Weight R L M}
Goal: ⇑(LieModule.Weight.toLinear R L M χ) = ⇑χ
-- LieModule.Weight.coe_toLinear_eq_zero_iff
@[simp] lemma coe_toLinear_eq_zero_iff : (χ : L →ₗ[R] R) = 0 ↔ χ.IsZero 
Arguments: {R : Type u_1} {L : Type u_2} {M : Type u_3} [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [LieAlgebra.IsNilpotent R L] [LieModule.LinearWeights R L M] {χ : LieModule.Weight R L M}
Goal: LieModule.Weight.toLinear R L M χ = 0 ↔ χ.IsZero
-- LieModule.Weight.coe_toLinear_ne_zero_iff
lemma coe_toLinear_ne_zero_iff : (χ : L →ₗ[R] R) ≠ 0 ↔ χ.IsNonZero 
Arguments: {R : Type u_1} {L : Type u_2} {M : Type u_3} [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [LieAlgebra.IsNilpotent R L] [LieModule.LinearWeights R L M] {χ : LieModule.Weight R L M}
Goal: LieModule.Weight.toLinear R L M χ ≠ 0 ↔ χ.IsNonZero
-- LieModule.trace_comp_toEnd_weightSpace_eq
lemma trace_comp_toEnd_weightSpace_eq (χ : L → R) :
    LinearMap.trace R _ ∘ₗ (toEnd R L (weightSpace M χ)).toLinearMap =
    finrank R (weightSpace M χ) • χ 
Arguments: (R : Type u_1) (L : Type u_2) (M : Type u_3) [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [IsDomain R] [IsPrincipalIdealRing R] [Module.Free R M] [Module.Finite R M] [LieAlgebra.IsNilpotent R L] (χ : L → R)
Goal: ⇑(LinearMap.trace R ↥↑(LieModule.weightSpace M χ) ∘ₗ ↑(LieModule.toEnd R L ↥↑(LieModule.weightSpace M χ))) =
  FiniteDimensional.finrank R ↥↑(LieModule.weightSpace M χ) • χ
-- LieModule.zero_lt_finrank_weightSpace
lemma zero_lt_finrank_weightSpace {χ : L → R} (hχ : weightSpace M χ ≠ ⊥) :
    0 < finrank R (weightSpace M χ) 
Arguments: {R : Type u_1} {L : Type u_2} {M : Type u_3} [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [IsDomain R] [IsPrincipalIdealRing R] [Module.Free R M] [Module.Finite R M] [LieAlgebra.IsNilpotent R L] {χ : L → R} (hχ : LieModule.weightSpace M χ ≠ ⊥)
Goal: 0 < FiniteDimensional.finrank R ↥↑(LieModule.weightSpace M χ)
-- _private.Mathlib.Algebra.Lie.Weights.Linear.0.LieModule.shiftedWeightSpace.aux
private lemma aux [h : Nontrivial (shiftedWeightSpace R L M χ)] : weightSpace M χ ≠ ⊥ 
Arguments: (R : Type u_1) (L : Type u_2) (M : Type u_3) [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [LieAlgebra.IsNilpotent R L] (χ : L → R) [h : Nontrivial ↥↑(LieModule.shiftedWeightSpace R L M χ)]
Goal: LieModule.weightSpace M χ ≠ ⊥
-- LieModule.shiftedWeightSpace.coe_lie_shiftedWeightSpace_apply
@[simp] lemma coe_lie_shiftedWeightSpace_apply (x : L) (m : shiftedWeightSpace R L M χ) :
    ⁅x, m⁆ = ⁅x, (m : M)⁆ - χ x • m 
Arguments: (R : Type u_1) (L : Type u_2) (M : Type u_3) [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [LieAlgebra.IsNilpotent R L] [LieModule.LinearWeights R L M] (χ : L → R) (x : L) (m : ↥(LieModule.shiftedWeightSpace R L M χ))
Goal: ↑⁅x, m⁆ = ⁅x, ↑m⁆ - χ x • ↑m
-- LieModule.shiftedWeightSpace.shift_apply
@[simps!] def shift : weightSpace M χ ≃ₗ[R] shiftedWeightSpace R L M χ 
Arguments: (R : Type u_1) (L : Type u_2) (M : Type u_3) [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [LieAlgebra.IsNilpotent R L] (χ : L → R) (a : ↥↑(LieModule.weightSpace M χ))
Goal: (LieModule.shiftedWeightSpace.shift R L M χ) a = a
-- LieModule.shiftedWeightSpace.shift_symm_apply
@[simps!] def shift : weightSpace M χ ≃ₗ[R] shiftedWeightSpace R L M χ 
Arguments: (R : Type u_1) (L : Type u_2) (M : Type u_3) [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [LieAlgebra.IsNilpotent R L] (χ : L → R)
Goal: ∀ (a : ↥↑(LieModule.weightSpace M χ)), (LieModule.shiftedWeightSpace.shift R L M χ).symm a = a
-- LieModule.shiftedWeightSpace.toEnd_eq
lemma toEnd_eq (x : L) :
    toEnd R L (shiftedWeightSpace R L M χ) x =
    (shift R L M χ).conj (toEnd R L (weightSpace M χ) x - χ x • LinearMap.id) 
Arguments: (R : Type u_1) (L : Type u_2) (M : Type u_3) [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [LieAlgebra.IsNilpotent R L] [LieModule.LinearWeights R L M] (χ : L → R) (x : L)
Goal: (LieModule.toEnd R L ↥↑(LieModule.shiftedWeightSpace R L M χ)) x =
  (LieModule.shiftedWeightSpace.shift R L M χ).conj
    ((LieModule.toEnd R L ↥↑(LieModule.weightSpace M χ)) x - χ x • LinearMap.id)
-- LieModule.exists_forall_lie_eq_smul
lemma exists_forall_lie_eq_smul [IsNoetherian R M] (χ : Weight R L M) :
    ∃ m : M, m ≠ 0 ∧ ∀ x : L, ⁅x, m⁆ = χ x • m 
Arguments: (R : Type u_1) (L : Type u_2) (M : Type u_3) [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [LieAlgebra.IsNilpotent R L] [LieModule.LinearWeights R L M] [IsNoetherian R M] (χ : LieModule.Weight R L M)
Goal: ∃ m, m ≠ 0 ∧ ∀ (x : L), ⁅x, m⁆ = χ x • m
-- Units.ne_zero
@[simp]
theorem ne_zero [Nontrivial M₀] (u : M₀ˣ) : (u : M₀) ≠ 0 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] [Nontrivial M₀] (u : M₀ˣ)
Goal: ↑u ≠ 0
-- Units.mul_left_eq_zero
@[simp]
theorem mul_left_eq_zero (u : M₀ˣ) {a : M₀} : a * u = 0 ↔ a = 0 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] (u : M₀ˣ) {a : M₀}
Goal: a * ↑u = 0 ↔ a = 0
-- Units.mul_right_eq_zero
@[simp]
theorem mul_right_eq_zero (u : M₀ˣ) {a : M₀} : ↑u * a = 0 ↔ a = 0 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] (u : M₀ˣ) {a : M₀}
Goal: ↑u * a = 0 ↔ a = 0
-- IsUnit.ne_zero
theorem ne_zero [Nontrivial M₀] {a : M₀} (ha : IsUnit a) : a ≠ 0 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] [Nontrivial M₀] {a : M₀} (ha : IsUnit a)
Goal: a ≠ 0
-- IsUnit.mul_right_eq_zero
theorem mul_right_eq_zero {a b : M₀} (ha : IsUnit a) : a * b = 0 ↔ b = 0 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] {a b : M₀} (ha : IsUnit a)
Goal: a * b = 0 ↔ b = 0
-- IsUnit.mul_left_eq_zero
theorem mul_left_eq_zero {a b : M₀} (hb : IsUnit b) : a * b = 0 ↔ a = 0 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] {a b : M₀} (hb : IsUnit b)
Goal: a * b = 0 ↔ a = 0
-- isUnit_zero_iff
@[simp]
theorem isUnit_zero_iff : IsUnit (0 : M₀) ↔ (0 : M₀) = 1 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀]
Goal: IsUnit 0 ↔ 0 = 1
-- not_isUnit_zero
theorem not_isUnit_zero [Nontrivial M₀] : ¬IsUnit (0 : M₀) 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] [Nontrivial M₀]
Goal: ¬IsUnit 0
-- Ring.inverse_unit
@[simp]
theorem inverse_unit (u : M₀ˣ) : inverse (u : M₀) = (u⁻¹ : M₀ˣ) 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] (u : M₀ˣ)
Goal: Ring.inverse ↑u = ↑u⁻¹
-- Ring.inverse_non_unit
@[simp]
theorem inverse_non_unit (x : M₀) (h : ¬IsUnit x) : inverse x = 0 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] (x : M₀) (h : ¬IsUnit x)
Goal: Ring.inverse x = 0
-- Ring.mul_inverse_cancel
theorem mul_inverse_cancel (x : M₀) (h : IsUnit x) : x * inverse x = 1 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] (x : M₀) (h : IsUnit x)
Goal: x * Ring.inverse x = 1
-- Ring.inverse_mul_cancel
theorem inverse_mul_cancel (x : M₀) (h : IsUnit x) : inverse x * x = 1 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] (x : M₀) (h : IsUnit x)
Goal: Ring.inverse x * x = 1
-- Ring.mul_inverse_cancel_right
theorem mul_inverse_cancel_right (x y : M₀) (h : IsUnit x) : y * x * inverse x = y 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] (x y : M₀) (h : IsUnit x)
Goal: y * x * Ring.inverse x = y
-- Ring.inverse_mul_cancel_right
theorem inverse_mul_cancel_right (x y : M₀) (h : IsUnit x) : y * inverse x * x = y 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] (x y : M₀) (h : IsUnit x)
Goal: y * Ring.inverse x * x = y
-- Ring.mul_inverse_cancel_left
theorem mul_inverse_cancel_left (x y : M₀) (h : IsUnit x) : x * (inverse x * y) = y 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] (x y : M₀) (h : IsUnit x)
Goal: x * (Ring.inverse x * y) = y
-- Ring.inverse_mul_cancel_left
theorem inverse_mul_cancel_left (x y : M₀) (h : IsUnit x) : inverse x * (x * y) = y 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] (x y : M₀) (h : IsUnit x)
Goal: Ring.inverse x * (x * y) = y
-- Ring.inverse_mul_eq_iff_eq_mul
theorem inverse_mul_eq_iff_eq_mul (x y z : M₀) (h : IsUnit x) : inverse x * y = z ↔ y = x * z 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] (x y z : M₀) (h : IsUnit x)
Goal: Ring.inverse x * y = z ↔ y = x * z
-- Ring.eq_mul_inverse_iff_mul_eq
theorem eq_mul_inverse_iff_mul_eq (x y z : M₀) (h : IsUnit z) : x = y * inverse z ↔ x * z = y 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] (x y z : M₀) (h : IsUnit z)
Goal: x = y * Ring.inverse z ↔ x * z = y
-- Ring.inverse_one
@[simp]
theorem inverse_one : inverse (1 : M₀) = 1 
Arguments: (M₀ : Type u_2) [MonoidWithZero M₀]
Goal: Ring.inverse 1 = 1
-- Ring.inverse_zero
@[simp]
theorem inverse_zero : inverse (0 : M₀) = 0 
Arguments: (M₀ : Type u_2) [MonoidWithZero M₀]
Goal: Ring.inverse 0 = 0
-- IsUnit.ring_inverse
theorem IsUnit.ring_inverse {a : M₀} : IsUnit a → IsUnit (Ring.inverse a)
  
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] {a : M₀}
Goal: IsUnit a → IsUnit (Ring.inverse a)
-- isUnit_ring_inverse
@[simp]
theorem isUnit_ring_inverse {a : M₀} : IsUnit (Ring.inverse a) ↔ IsUnit a 
Arguments: {M₀ : Type u_2} [MonoidWithZero M₀] {a : M₀}
Goal: IsUnit (Ring.inverse a) ↔ IsUnit a
-- Units.mk0_one
@[simp]
theorem mk0_one (h := one_ne_zero) : mk0 (1 : G₀) h = 1 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] (h : 1 ≠ 0 := ⋯)
Goal: Units.mk0 1 h = 1
-- Units.val_mk0
@[simp]
theorem val_mk0 {a : G₀} (h : a ≠ 0) : (mk0 a h : G₀) = a 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀} (h : a ≠ 0)
Goal: ↑(Units.mk0 a h) = a
-- Units.mk0_val
@[simp]
theorem mk0_val (u : G₀ˣ) (h : (u : G₀) ≠ 0) : mk0 (u : G₀) h = u 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] (u : G₀ˣ) (h : ↑u ≠ 0)
Goal: Units.mk0 (↑u) h = u
-- Units.mul_inv'
theorem mul_inv' (u : G₀ˣ) : u * (u : G₀)⁻¹ = 1 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] (u : G₀ˣ)
Goal: ↑u * (↑u)⁻¹ = 1
-- Units.inv_mul'
theorem inv_mul' (u : G₀ˣ) : (u⁻¹ : G₀) * u = 1 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] (u : G₀ˣ)
Goal: (↑u)⁻¹ * ↑u = 1
-- Units.mk0_inj
@[simp]
theorem mk0_inj {a b : G₀} (ha : a ≠ 0) (hb : b ≠ 0) : Units.mk0 a ha = Units.mk0 b hb ↔ a = b 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b : G₀} (ha : a ≠ 0) (hb : b ≠ 0)
Goal: Units.mk0 a ha = Units.mk0 b hb ↔ a = b
-- Units.exists0
theorem exists0 {p : G₀ˣ → Prop} : (∃ g : G₀ˣ, p g) ↔ ∃ (g : G₀) (hg : g ≠ 0), p (Units.mk0 g hg) 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {p : G₀ˣ → Prop}
Goal: (∃ g, p g) ↔ ∃ g hg, p (Units.mk0 g hg)
-- Units.exists0'
theorem exists0' {p : ∀ g : G₀, g ≠ 0 → Prop} :
    (∃ (g : G₀) (hg : g ≠ 0), p g hg) ↔ ∃ g : G₀ˣ, p g g.ne_zero 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {p : (g : G₀) → g ≠ 0 → Prop}
Goal: (∃ g hg, p g hg) ↔ ∃ g, p ↑g ⋯
-- Units.exists_iff_ne_zero
@[simp]
theorem exists_iff_ne_zero {p : G₀ → Prop} : (∃ u : G₀ˣ, p u) ↔ ∃ x ≠ 0, p x 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {p : G₀ → Prop}
Goal: (∃ u, p ↑u) ↔ ∃ x, x ≠ 0 ∧ p x
-- GroupWithZero.eq_zero_or_unit
theorem _root_.GroupWithZero.eq_zero_or_unit (a : G₀) : a = 0 ∨ ∃ u : G₀ˣ, a = u 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] (a : G₀)
Goal: a = 0 ∨ ∃ u, a = ↑u
-- IsUnit.mk0
theorem IsUnit.mk0 (x : G₀) (hx : x ≠ 0) : IsUnit x 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] (x : G₀) (hx : x ≠ 0)
Goal: IsUnit x
-- isUnit_iff_ne_zero
@[simp]
theorem isUnit_iff_ne_zero : IsUnit a ↔ a ≠ 0 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀}
Goal: IsUnit a ↔ a ≠ 0
-- Units.mk0_mul
@[simp]
theorem Units.mk0_mul (x y : G₀) (hxy) :
    Units.mk0 (x * y) hxy =
      Units.mk0 x (mul_ne_zero_iff.mp hxy).1 * Units.mk0 y (mul_ne_zero_iff.mp hxy).2 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] (x y : G₀) (hxy : x * y ≠ 0)
Goal: Units.mk0 (x * y) hxy = Units.mk0 x ⋯ * Units.mk0 y ⋯
-- div_ne_zero
theorem div_ne_zero (ha : a ≠ 0) (hb : b ≠ 0) : a / b ≠ 0 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b : G₀} (ha : a ≠ 0) (hb : b ≠ 0)
Goal: a / b ≠ 0
-- div_eq_zero_iff
@[simp]
theorem div_eq_zero_iff : a / b = 0 ↔ a = 0 ∨ b = 0 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b : G₀}
Goal: a / b = 0 ↔ a = 0 ∨ b = 0
-- div_ne_zero_iff
theorem div_ne_zero_iff : a / b ≠ 0 ↔ a ≠ 0 ∧ b ≠ 0 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b : G₀}
Goal: a / b ≠ 0 ↔ a ≠ 0 ∧ b ≠ 0
-- div_self
@[simp] lemma div_self (h : a ≠ 0) : a / a = 1 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀} (h : a ≠ 0)
Goal: a / a = 1
-- eq_mul_inv_iff_mul_eq₀
lemma eq_mul_inv_iff_mul_eq₀ (hc : c ≠ 0) : a = b * c⁻¹ ↔ a * c = b 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b c : G₀} (hc : c ≠ 0)
Goal: a = b * c⁻¹ ↔ a * c = b
-- eq_inv_mul_iff_mul_eq₀
lemma eq_inv_mul_iff_mul_eq₀ (hb : b ≠ 0) : a = b⁻¹ * c ↔ b * a = c 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b c : G₀} (hb : b ≠ 0)
Goal: a = b⁻¹ * c ↔ b * a = c
-- inv_mul_eq_iff_eq_mul₀
lemma inv_mul_eq_iff_eq_mul₀ (ha : a ≠ 0) : a⁻¹ * b = c ↔ b = a * c 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b c : G₀} (ha : a ≠ 0)
Goal: a⁻¹ * b = c ↔ b = a * c
-- mul_inv_eq_iff_eq_mul₀
lemma mul_inv_eq_iff_eq_mul₀ (hb : b ≠ 0) : a * b⁻¹ = c ↔ a = c * b 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b c : G₀} (hb : b ≠ 0)
Goal: a * b⁻¹ = c ↔ a = c * b
-- mul_inv_eq_one₀
lemma mul_inv_eq_one₀ (hb : b ≠ 0) : a * b⁻¹ = 1 ↔ a = b 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b : G₀} (hb : b ≠ 0)
Goal: a * b⁻¹ = 1 ↔ a = b
-- inv_mul_eq_one₀
lemma inv_mul_eq_one₀ (ha : a ≠ 0) : a⁻¹ * b = 1 ↔ a = b 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b : G₀} (ha : a ≠ 0)
Goal: a⁻¹ * b = 1 ↔ a = b
-- mul_eq_one_iff_eq_inv₀
lemma mul_eq_one_iff_eq_inv₀ (hb : b ≠ 0) : a * b = 1 ↔ a = b⁻¹ 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b : G₀} (hb : b ≠ 0)
Goal: a * b = 1 ↔ a = b⁻¹
-- mul_eq_one_iff_inv_eq₀
lemma mul_eq_one_iff_inv_eq₀ (ha : a ≠ 0) : a * b = 1 ↔ a⁻¹ = b 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b : G₀} (ha : a ≠ 0)
Goal: a * b = 1 ↔ a⁻¹ = b
-- mul_eq_of_eq_mul_inv₀
lemma mul_eq_of_eq_mul_inv₀ (ha : a ≠ 0) (h : a = c * b⁻¹) : a * b = c 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b c : G₀} (ha : a ≠ 0) (h : a = c * b⁻¹)
Goal: a * b = c
-- mul_eq_of_eq_inv_mul₀
lemma mul_eq_of_eq_inv_mul₀ (hb : b ≠ 0) (h : b = a⁻¹ * c) : a * b = c 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b c : G₀} (hb : b ≠ 0) (h : b = a⁻¹ * c)
Goal: a * b = c
-- eq_mul_of_inv_mul_eq₀
lemma eq_mul_of_inv_mul_eq₀ (hc : c ≠ 0) (h : b⁻¹ * a = c) : a = b * c 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b c : G₀} (hc : c ≠ 0) (h : b⁻¹ * a = c)
Goal: a = b * c
-- eq_mul_of_mul_inv_eq₀
lemma eq_mul_of_mul_inv_eq₀ (hb : b ≠ 0) (h : a * c⁻¹ = b) : a = b * c 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b c : G₀} (hb : b ≠ 0) (h : a * c⁻¹ = b)
Goal: a = b * c
-- div_mul_cancel₀
@[simp] lemma div_mul_cancel₀ (a : G₀) (h : b ≠ 0) : a / b * b = a 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {b : G₀} (a : G₀) (h : b ≠ 0)
Goal: a / b * b = a
-- mul_one_div_cancel
lemma mul_one_div_cancel (h : a ≠ 0) : a * (1 / a) = 1 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀} (h : a ≠ 0)
Goal: a * (1 / a) = 1
-- one_div_mul_cancel
lemma one_div_mul_cancel (h : a ≠ 0) : 1 / a * a = 1 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀} (h : a ≠ 0)
Goal: 1 / a * a = 1
-- div_left_inj'
lemma div_left_inj' (hc : c ≠ 0) : a / c = b / c ↔ a = b 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b c : G₀} (hc : c ≠ 0)
Goal: a / c = b / c ↔ a = b
-- div_eq_iff
@[field_simps] lemma div_eq_iff (hb : b ≠ 0) : a / b = c ↔ a = c * b 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b c : G₀} (hb : b ≠ 0)
Goal: a / b = c ↔ a = c * b
-- eq_div_iff
@[field_simps] lemma eq_div_iff (hb : b ≠ 0) : c = a / b ↔ c * b = a 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b c : G₀} (hb : b ≠ 0)
Goal: c = a / b ↔ c * b = a
-- div_eq_iff_mul_eq
lemma div_eq_iff_mul_eq (hb : b ≠ 0) : a / b = c ↔ c * b = a 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b c : G₀} (hb : b ≠ 0)
Goal: a / b = c ↔ c * b = a
-- eq_div_iff_mul_eq
lemma eq_div_iff_mul_eq (hc : c ≠ 0) : a = b / c ↔ a * c = b 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b c : G₀} (hc : c ≠ 0)
Goal: a = b / c ↔ a * c = b
-- div_eq_of_eq_mul
lemma div_eq_of_eq_mul (hb : b ≠ 0) : a = c * b → a / b = c 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b c : G₀} (hb : b ≠ 0)
Goal: a = c * b → a / b = c
-- eq_div_of_mul_eq
lemma eq_div_of_mul_eq (hc : c ≠ 0) : a * c = b → a = b / c 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b c : G₀} (hc : c ≠ 0)
Goal: a * c = b → a = b / c
-- div_eq_one_iff_eq
lemma div_eq_one_iff_eq (hb : b ≠ 0) : a / b = 1 ↔ a = b 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b : G₀} (hb : b ≠ 0)
Goal: a / b = 1 ↔ a = b
-- div_mul_cancel_right₀
lemma div_mul_cancel_right₀ (hb : b ≠ 0) (a : G₀) : b / (a * b) = a⁻¹ 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {b : G₀} (hb : b ≠ 0) (a : G₀)
Goal: b / (a * b) = a⁻¹
-- div_mul_left
@[deprecated div_mul_cancel_right₀ (since := "2024-03-20")]
lemma div_mul_left (hb : b ≠ 0) : b / (a * b) = 1 / a 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b : G₀} (hb : b ≠ 0)
Goal: b / (a * b) = 1 / a
-- mul_div_mul_right
lemma mul_div_mul_right (a b : G₀) (hc : c ≠ 0) : a * c / (b * c) = a / b 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {c : G₀} (a b : G₀) (hc : c ≠ 0)
Goal: a * c / (b * c) = a / b
-- mul_mul_div
lemma mul_mul_div (a : G₀) (hb : b ≠ 0) : a = a * b * (1 / b) 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {b : G₀} (a : G₀) (hb : b ≠ 0)
Goal: a = a * b * (1 / b)
-- div_div_div_cancel_right
lemma div_div_div_cancel_right (a : G₀) (hc : c ≠ 0) : a / c / (b / c) = a / b 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {b c : G₀} (a : G₀) (hc : c ≠ 0)
Goal: a / c / (b / c) = a / b
-- div_mul_div_cancel
lemma div_mul_div_cancel (a : G₀) (hc : c ≠ 0) : a / c * (c / b) = a / b 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {b c : G₀} (a : G₀) (hc : c ≠ 0)
Goal: a / c * (c / b) = a / b
-- div_mul_cancel_of_imp
lemma div_mul_cancel_of_imp (h : b = 0 → a = 0) : a / b * b = a 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b : G₀} (h : b = 0 → a = 0)
Goal: a / b * b = a
-- mul_div_cancel_of_imp
lemma mul_div_cancel_of_imp (h : b = 0 → a = 0) : a * b / b = a 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b : G₀} (h : b = 0 → a = 0)
Goal: a * b / b = a
-- divp_mk0
@[simp] lemma divp_mk0 (a : G₀) (hb : b ≠ 0) : a /ₚ Units.mk0 b hb = a / b 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {b : G₀} (a : G₀) (hb : b ≠ 0)
Goal: a /ₚ Units.mk0 b hb = a / b
-- pow_sub₀
lemma pow_sub₀ (a : G₀) (ha : a ≠ 0) (h : n ≤ m) : a ^ (m - n) = a ^ m * (a ^ n)⁻¹ 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {m n : ℕ} (a : G₀) (ha : a ≠ 0) (h : n ≤ m)
Goal: a ^ (m - n) = a ^ m * (a ^ n)⁻¹
-- pow_sub_of_lt
lemma pow_sub_of_lt (a : G₀) (h : n < m) : a ^ (m - n) = a ^ m * (a ^ n)⁻¹ 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {m n : ℕ} (a : G₀) (h : n < m)
Goal: a ^ (m - n) = a ^ m * (a ^ n)⁻¹
-- inv_pow_sub₀
lemma inv_pow_sub₀ (ha : a ≠ 0) (h : n ≤ m) : a⁻¹ ^ (m - n) = (a ^ m)⁻¹ * a ^ n 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀} {m n : ℕ} (ha : a ≠ 0) (h : n ≤ m)
Goal: a⁻¹ ^ (m - n) = (a ^ m)⁻¹ * a ^ n
-- inv_pow_sub_of_lt
lemma inv_pow_sub_of_lt (a : G₀) (h : n < m) : a⁻¹ ^ (m - n) = (a ^ m)⁻¹ * a ^ n 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {m n : ℕ} (a : G₀) (h : n < m)
Goal: a⁻¹ ^ (m - n) = (a ^ m)⁻¹ * a ^ n
-- zpow_sub₀
lemma zpow_sub₀ (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_ne_zero
lemma zpow_ne_zero {a : G₀} : ∀ n : ℤ, a ≠ 0 → a ^ n ≠ 0
  
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀} (n : ℤ)
Goal: a ≠ 0 → a ^ n ≠ 0
-- eq_zero_of_zpow_eq_zero
lemma eq_zero_of_zpow_eq_zero {n : ℤ} : a ^ n = 0 → a = 0 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a : G₀} {n : ℤ}
Goal: a ^ n = 0 → a = 0