ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AlgEquiv.toLieEquiv_symm_apply
@[simp]
theorem toLieEquiv_symm_apply (x : A₂) : e.toLieEquiv.symm x = e.symm x 
Arguments: {R : Type u} {A₁ : Type v} {A₂ : Type w} [CommRing R] [Ring A₁] [Ring A₂] [Algebra R A₁] [Algebra R A₂] (e : A₁ ≃ₐ[R] A₂) (x : A₂)
Goal: e.toLieEquiv.symm x = e.symm x
-- LieAlgebra.conj_ad_apply
@[simp]
lemma conj_ad_apply (e : L ≃ₗ⁅R⁆ L') (x : L) : LinearEquiv.conj e (ad R L x) = ad R L' (e x) 
Arguments: {R : Type u_1} {L : Type u_2} {L' : Type u_3} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (e : L ≃ₗ⁅R⁆ L') (x : L)
Goal: e.toLinearEquiv.conj ((LieAlgebra.ad R L) x) = (LieAlgebra.ad R L') (e x)
-- IsAddRegular.left
structure IsAddRegular {R : Type*} [Add R] (c : R) : Prop where
    left : IsAddLeftRegular c -- Porting note: It seems like to_additive is misbehaving
    right : IsAddRightRegular c
Arguments: {R : Type u_2} [Add R] {c : R} (self : IsAddRegular c)
Goal: IsAddLeftRegular c
-- IsAddRegular.right
structure IsAddRegular {R : Type*} [Add R] (c : R) : Prop where
    left : IsAddLeftRegular c -- Porting note: It seems like to_additive is misbehaving
    right : IsAddRightRegular c
Arguments: {R : Type u_2} [Add R] {c : R} (self : IsAddRegular c)
Goal: IsAddRightRegular c
-- IsRegular.left
structure IsRegular (c : R) : Prop where
    left : IsLeftRegular c
    right : IsRightRegular c
Arguments: {R : Type u_1} [Mul R] {c : R} (self : IsRegular c)
Goal: IsLeftRegular c
-- IsRegular.right
structure IsRegular (c : R) : Prop where
    left : IsLeftRegular c
    right : IsRightRegular c
Arguments: {R : Type u_1} [Mul R] {c : R} (self : IsRegular c)
Goal: IsRightRegular c
-- isRegular_iff
@[to_additive]
theorem isRegular_iff {c : R} : IsRegular c ↔ IsLeftRegular c ∧ IsRightRegular c 
Arguments: {R : Type u_1} [Mul R] {c : R}
Goal: IsRegular c ↔ IsLeftRegular c ∧ IsRightRegular c
-- isAddRegular_iff
@[to_additive]
theorem isRegular_iff {c : R} : IsRegular c ↔ IsLeftRegular c ∧ IsRightRegular c 
Arguments: {R : Type u_1} [Add R] {c : R}
Goal: IsAddRegular c ↔ IsAddLeftRegular c ∧ IsAddRightRegular c
-- AddLECancellable.isAddLeftRegular
@[to_additive]
protected theorem MulLECancellable.isLeftRegular [PartialOrder R] {a : R}
    (ha : MulLECancellable a) : IsLeftRegular a 
Arguments: {R : Type u_1} [Add R] [PartialOrder R] {a : R} (ha : AddLECancellable a)
Goal: IsAddLeftRegular a
-- MulLECancellable.isLeftRegular
@[to_additive]
protected theorem MulLECancellable.isLeftRegular [PartialOrder R] {a : R}
    (ha : MulLECancellable a) : IsLeftRegular a 
Arguments: {R : Type u_1} [Mul R] [PartialOrder R] {a : R} (ha : MulLECancellable a)
Goal: IsLeftRegular a
-- IsLeftRegular.right_of_commute
theorem IsLeftRegular.right_of_commute {a : R}
    (ca : ∀ b, Commute a b) (h : IsLeftRegular a) : IsRightRegular a 
Arguments: {R : Type u_1} [Mul R] {a : R} (ca : ∀ (b : R), Commute a b) (h : IsLeftRegular a)
Goal: IsRightRegular a
-- IsRightRegular.left_of_commute
theorem IsRightRegular.left_of_commute {a : R}
    (ca : ∀ b, Commute a b) (h : IsRightRegular a) : IsLeftRegular a 
Arguments: {R : Type u_1} [Mul R] {a : R} (ca : ∀ (b : R), Commute a b) (h : IsRightRegular a)
Goal: IsLeftRegular a
-- Commute.isRightRegular_iff
theorem Commute.isRightRegular_iff {a : R} (ca : ∀ b, Commute a b) :
    IsRightRegular a ↔ IsLeftRegular a 
Arguments: {R : Type u_1} [Mul R] {a : R} (ca : ∀ (b : R), Commute a b)
Goal: IsRightRegular a ↔ IsLeftRegular a
-- Commute.isRegular_iff
theorem Commute.isRegular_iff {a : R} (ca : ∀ b, Commute a b) : IsRegular a ↔ IsLeftRegular a 
Arguments: {R : Type u_1} [Mul R] {a : R} (ca : ∀ (b : R), Commute a b)
Goal: IsRegular a ↔ IsLeftRegular a
-- IsAddLeftRegular.add
@[to_additive "In an additive semigroup, the sum of add-left-regular elements is add-left.regular."]
theorem IsLeftRegular.mul (lra : IsLeftRegular a) (lrb : IsLeftRegular b) : IsLeftRegular (a * b) 
Arguments: {R : Type u_1} [AddSemigroup R] {a b : R} (lra : IsAddLeftRegular a) (lrb : IsAddLeftRegular b)
Goal: IsAddLeftRegular (a + b)
-- IsLeftRegular.mul
@[to_additive "In an additive semigroup, the sum of add-left-regular elements is add-left.regular."]
theorem IsLeftRegular.mul (lra : IsLeftRegular a) (lrb : IsLeftRegular b) : IsLeftRegular (a * b) 
Arguments: {R : Type u_1} [Semigroup R] {a b : R} (lra : IsLeftRegular a) (lrb : IsLeftRegular b)
Goal: IsLeftRegular (a * b)
-- IsRightRegular.mul
@[to_additive "In an additive semigroup, the sum of add-right-regular elements is
add-right-regular."]
theorem IsRightRegular.mul (rra : IsRightRegular a) (rrb : IsRightRegular b) :
    IsRightRegular (a * b) 
Arguments: {R : Type u_1} [Semigroup R] {a b : R} (rra : IsRightRegular a) (rrb : IsRightRegular b)
Goal: IsRightRegular (a * b)
-- IsAddRightRegular.add
@[to_additive "In an additive semigroup, the sum of add-right-regular elements is
add-right-regular."]
theorem IsRightRegular.mul (rra : IsRightRegular a) (rrb : IsRightRegular b) :
    IsRightRegular (a * b) 
Arguments: {R : Type u_1} [AddSemigroup R] {a b : R} (rra : IsAddRightRegular a) (rrb : IsAddRightRegular b)
Goal: IsAddRightRegular (a + b)
-- IsRegular.mul
@[to_additive "In an additive semigroup, the sum of add-regular elements is add-regular."]
theorem IsRegular.mul (rra : IsRegular a) (rrb : IsRegular b) :
    IsRegular (a * b) 
Arguments: {R : Type u_1} [Semigroup R] {a b : R} (rra : IsRegular a) (rrb : IsRegular b)
Goal: IsRegular (a * b)
-- IsAddRegular.add
@[to_additive "In an additive semigroup, the sum of add-regular elements is add-regular."]
theorem IsRegular.mul (rra : IsRegular a) (rrb : IsRegular b) :
    IsRegular (a * b) 
Arguments: {R : Type u_1} [AddSemigroup R] {a b : R} (rra : IsAddRegular a) (rrb : IsAddRegular b)
Goal: IsAddRegular (a + b)
-- IsAddLeftRegular.of_add
@[to_additive "If an element `b` becomes add-left-regular after adding to it on the left
an add-left-regular element, then `b` is add-left-regular."]
theorem IsLeftRegular.of_mul (ab : IsLeftRegular (a * b)) : IsLeftRegular b 
Arguments: {R : Type u_1} [AddSemigroup R] {a b : R} (ab : IsAddLeftRegular (a + b))
Goal: IsAddLeftRegular b
-- IsLeftRegular.of_mul
@[to_additive "If an element `b` becomes add-left-regular after adding to it on the left
an add-left-regular element, then `b` is add-left-regular."]
theorem IsLeftRegular.of_mul (ab : IsLeftRegular (a * b)) : IsLeftRegular b 
Arguments: {R : Type u_1} [Semigroup R] {a b : R} (ab : IsLeftRegular (a * b))
Goal: IsLeftRegular b
-- mul_isLeftRegular_iff
@[to_additive (attr := simp) "An element is add-left-regular if and only if adding to it on the left
an add-left-regular element is add-left-regular."]
theorem mul_isLeftRegular_iff (b : R) (ha : IsLeftRegular a) :
    IsLeftRegular (a * b) ↔ IsLeftRegular b 
Arguments: {R : Type u_1} [Semigroup R] {a : R} (b : R) (ha : IsLeftRegular a)
Goal: IsLeftRegular (a * b) ↔ IsLeftRegular b
-- add_isAddLeftRegular_iff
@[to_additive (attr := simp) "An element is add-left-regular if and only if adding to it on the left
an add-left-regular element is add-left-regular."]
theorem mul_isLeftRegular_iff (b : R) (ha : IsLeftRegular a) :
    IsLeftRegular (a * b) ↔ IsLeftRegular b 
Arguments: {R : Type u_1} [AddSemigroup R] {a : R} (b : R) (ha : IsAddLeftRegular a)
Goal: IsAddLeftRegular (a + b) ↔ IsAddLeftRegular b
-- IsAddRightRegular.of_add
@[to_additive "If an element `b` becomes add-right-regular after adding to it on the right
an add-right-regular element, then `b` is add-right-regular."]
theorem IsRightRegular.of_mul (ab : IsRightRegular (b * a)) : IsRightRegular b 
Arguments: {R : Type u_1} [AddSemigroup R] {a b : R} (ab : IsAddRightRegular (b + a))
Goal: IsAddRightRegular b
-- IsRightRegular.of_mul
@[to_additive "If an element `b` becomes add-right-regular after adding to it on the right
an add-right-regular element, then `b` is add-right-regular."]
theorem IsRightRegular.of_mul (ab : IsRightRegular (b * a)) : IsRightRegular b 
Arguments: {R : Type u_1} [Semigroup R] {a b : R} (ab : IsRightRegular (b * a))
Goal: IsRightRegular b
-- add_isAddRightRegular_iff
@[to_additive (attr := simp)
"An element is add-right-regular if and only if adding it on the right to
an add-right-regular element is add-right-regular."]
theorem mul_isRightRegular_iff (b : R) (ha : IsRightRegular a) :
    IsRightRegular (b * a) ↔ IsRightRegular b 
Arguments: {R : Type u_1} [AddSemigroup R] {a : R} (b : R) (ha : IsAddRightRegular a)
Goal: IsAddRightRegular (b + a) ↔ IsAddRightRegular b
-- mul_isRightRegular_iff
@[to_additive (attr := simp)
"An element is add-right-regular if and only if adding it on the right to
an add-right-regular element is add-right-regular."]
theorem mul_isRightRegular_iff (b : R) (ha : IsRightRegular a) :
    IsRightRegular (b * a) ↔ IsRightRegular b 
Arguments: {R : Type u_1} [Semigroup R] {a : R} (b : R) (ha : IsRightRegular a)
Goal: IsRightRegular (b * a) ↔ IsRightRegular b
-- isAddRegular_add_and_add_iff
@[to_additive "Two elements `a` and `b` are add-regular if and only if both sums `a + b` and
`b + a` are add-regular."]
theorem isRegular_mul_and_mul_iff :
    IsRegular (a * b) ∧ IsRegular (b * a) ↔ IsRegular a ∧ IsRegular b 
Arguments: {R : Type u_1} [AddSemigroup R] {a b : R}
Goal: IsAddRegular (a + b) ∧ IsAddRegular (b + a) ↔ IsAddRegular a ∧ IsAddRegular b
-- isRegular_mul_and_mul_iff
@[to_additive "Two elements `a` and `b` are add-regular if and only if both sums `a + b` and
`b + a` are add-regular."]
theorem isRegular_mul_and_mul_iff :
    IsRegular (a * b) ∧ IsRegular (b * a) ↔ IsRegular a ∧ IsRegular b 
Arguments: {R : Type u_1} [Semigroup R] {a b : R}
Goal: IsRegular (a * b) ∧ IsRegular (b * a) ↔ IsRegular a ∧ IsRegular b
-- IsRegular.and_of_mul_of_mul
@[to_additive "The \"most used\" implication of `add_and_add_iff`, with split
hypotheses, instead of `∧`."]
theorem IsRegular.and_of_mul_of_mul (ab : IsRegular (a * b)) (ba : IsRegular (b * a)) :
    IsRegular a ∧ IsRegular b 
Arguments: {R : Type u_1} [Semigroup R] {a b : R} (ab : IsRegular (a * b)) (ba : IsRegular (b * a))
Goal: IsRegular a ∧ IsRegular b
-- IsAddRegular.and_of_add_of_add
@[to_additive "The \"most used\" implication of `add_and_add_iff`, with split
hypotheses, instead of `∧`."]
theorem IsRegular.and_of_mul_of_mul (ab : IsRegular (a * b)) (ba : IsRegular (b * a)) :
    IsRegular a ∧ IsRegular b 
Arguments: {R : Type u_1} [AddSemigroup R] {a b : R} (ab : IsAddRegular (a + b)) (ba : IsAddRegular (b + a))
Goal: IsAddRegular a ∧ IsAddRegular b
-- IsLeftRegular.subsingleton
theorem IsLeftRegular.subsingleton (h : IsLeftRegular (0 : R)) : Subsingleton R 
Arguments: {R : Type u_1} [MulZeroClass R] (h : IsLeftRegular 0)
Goal: Subsingleton R
-- IsRightRegular.subsingleton
theorem IsRightRegular.subsingleton (h : IsRightRegular (0 : R)) : Subsingleton R 
Arguments: {R : Type u_1} [MulZeroClass R] (h : IsRightRegular 0)
Goal: Subsingleton R
-- IsRegular.subsingleton
theorem IsRegular.subsingleton (h : IsRegular (0 : R)) : Subsingleton R 
Arguments: {R : Type u_1} [MulZeroClass R] (h : IsRegular 0)
Goal: Subsingleton R
-- isLeftRegular_zero_iff_subsingleton
theorem isLeftRegular_zero_iff_subsingleton : IsLeftRegular (0 : R) ↔ Subsingleton R 
Arguments: {R : Type u_1} [MulZeroClass R]
Goal: IsLeftRegular 0 ↔ Subsingleton R
-- not_isLeftRegular_zero_iff
theorem not_isLeftRegular_zero_iff : ¬IsLeftRegular (0 : R) ↔ Nontrivial R 
Arguments: {R : Type u_1} [MulZeroClass R]
Goal: ¬IsLeftRegular 0 ↔ Nontrivial R
-- isRightRegular_zero_iff_subsingleton
theorem isRightRegular_zero_iff_subsingleton : IsRightRegular (0 : R) ↔ Subsingleton R 
Arguments: {R : Type u_1} [MulZeroClass R]
Goal: IsRightRegular 0 ↔ Subsingleton R
-- not_isRightRegular_zero_iff
theorem not_isRightRegular_zero_iff : ¬IsRightRegular (0 : R) ↔ Nontrivial R 
Arguments: {R : Type u_1} [MulZeroClass R]
Goal: ¬IsRightRegular 0 ↔ Nontrivial R
-- isRegular_iff_subsingleton
theorem isRegular_iff_subsingleton : IsRegular (0 : R) ↔ Subsingleton R 
Arguments: {R : Type u_1} [MulZeroClass R]
Goal: IsRegular 0 ↔ Subsingleton R
-- IsLeftRegular.ne_zero
theorem IsLeftRegular.ne_zero [Nontrivial R] (la : IsLeftRegular a) : a ≠ 0 
Arguments: {R : Type u_1} [MulZeroClass R] {a : R} [Nontrivial R] (la : IsLeftRegular a)
Goal: a ≠ 0
-- IsRightRegular.ne_zero
theorem IsRightRegular.ne_zero [Nontrivial R] (ra : IsRightRegular a) : a ≠ 0 
Arguments: {R : Type u_1} [MulZeroClass R] {a : R} [Nontrivial R] (ra : IsRightRegular a)
Goal: a ≠ 0
-- IsRegular.ne_zero
theorem IsRegular.ne_zero [Nontrivial R] (la : IsRegular a) : a ≠ 0 
Arguments: {R : Type u_1} [MulZeroClass R] {a : R} [Nontrivial R] (la : IsRegular a)
Goal: a ≠ 0
-- not_isLeftRegular_zero
theorem not_isLeftRegular_zero [nR : Nontrivial R] : ¬IsLeftRegular (0 : R) 
Arguments: {R : Type u_1} [MulZeroClass R] [nR : Nontrivial R]
Goal: ¬IsLeftRegular 0
-- not_isRightRegular_zero
theorem not_isRightRegular_zero [nR : Nontrivial R] : ¬IsRightRegular (0 : R) 
Arguments: {R : Type u_1} [MulZeroClass R] [nR : Nontrivial R]
Goal: ¬IsRightRegular 0
-- not_isRegular_zero
theorem not_isRegular_zero [Nontrivial R] : ¬IsRegular (0 : R) 
Arguments: {R : Type u_1} [MulZeroClass R] [Nontrivial R]
Goal: ¬IsRegular 0
-- IsLeftRegular.mul_left_eq_zero_iff
@[simp] lemma IsLeftRegular.mul_left_eq_zero_iff (hb : IsLeftRegular b) : b * a = 0 ↔ a = 0 
Arguments: {R : Type u_1} [MulZeroClass R] {a b : R} (hb : IsLeftRegular b)
Goal: b * a = 0 ↔ a = 0
-- IsRightRegular.mul_right_eq_zero_iff
@[simp] lemma IsRightRegular.mul_right_eq_zero_iff (hb : IsRightRegular b) : a * b = 0 ↔ a = 0 
Arguments: {R : Type u_1} [MulZeroClass R] {a b : R} (hb : IsRightRegular b)
Goal: a * b = 0 ↔ a = 0
-- isAddRegular_zero
@[to_additive "If adding `0` on either side is the identity, `0` is regular."]
theorem isRegular_one : IsRegular (1 : R) 
Arguments: {R : Type u_1} [AddZeroClass R]
Goal: IsAddRegular 0
-- isRegular_one
@[to_additive "If adding `0` on either side is the identity, `0` is regular."]
theorem isRegular_one : IsRegular (1 : R) 
Arguments: {R : Type u_1} [MulOneClass R]
Goal: IsRegular 1
-- isAddRegular_add_iff
@[to_additive "A sum is add-regular if and only if the summands are."]
theorem isRegular_mul_iff : IsRegular (a * b) ↔ IsRegular a ∧ IsRegular b 
Arguments: {R : Type u_1} [AddCommSemigroup R] {a b : R}
Goal: IsAddRegular (a + b) ↔ IsAddRegular a ∧ IsAddRegular b
-- isRegular_mul_iff
@[to_additive "A sum is add-regular if and only if the summands are."]
theorem isRegular_mul_iff : IsRegular (a * b) ↔ IsRegular a ∧ IsRegular b 
Arguments: {R : Type u_1} [CommSemigroup R] {a b : R}
Goal: IsRegular (a * b) ↔ IsRegular a ∧ IsRegular b
-- isLeftRegular_of_mul_eq_one
@[to_additive "An element admitting a left additive opposite is add-left-regular."]
theorem isLeftRegular_of_mul_eq_one (h : b * a = 1) : IsLeftRegular a 
Arguments: {R : Type u_1} [Monoid R] {a b : R} (h : b * a = 1)
Goal: IsLeftRegular a
-- isAddLeftRegular_of_add_eq_zero
@[to_additive "An element admitting a left additive opposite is add-left-regular."]
theorem isLeftRegular_of_mul_eq_one (h : b * a = 1) : IsLeftRegular a 
Arguments: {R : Type u_1} [AddMonoid R] {a b : R} (h : b + a = 0)
Goal: IsAddLeftRegular a
-- isAddRightRegular_of_add_eq_zero
@[to_additive "An element admitting a right additive opposite is add-right-regular."]
theorem isRightRegular_of_mul_eq_one (h : a * b = 1) : IsRightRegular a 
Arguments: {R : Type u_1} [AddMonoid R] {a b : R} (h : a + b = 0)
Goal: IsAddRightRegular a
-- isRightRegular_of_mul_eq_one
@[to_additive "An element admitting a right additive opposite is add-right-regular."]
theorem isRightRegular_of_mul_eq_one (h : a * b = 1) : IsRightRegular a 
Arguments: {R : Type u_1} [Monoid R] {a b : R} (h : a * b = 1)
Goal: IsRightRegular a
-- Units.isRegular
@[to_additive "If `R` is an additive monoid, an element in `add_units R` is add-regular."]
theorem Units.isRegular (a : Rˣ) : IsRegular (a : R) 
Arguments: {R : Type u_1} [Monoid R] (a : Rˣ)
Goal: IsRegular ↑a
-- AddUnits.isAddRegular
@[to_additive "If `R` is an additive monoid, an element in `add_units R` is add-regular."]
theorem Units.isRegular (a : Rˣ) : IsRegular (a : R) 
Arguments: {R : Type u_1} [AddMonoid R] (a : AddUnits R)
Goal: IsAddRegular ↑a
-- IsUnit.isRegular
@[to_additive "An additive unit in an additive monoid is add-regular."]
theorem IsUnit.isRegular (ua : IsUnit a) : IsRegular a 
Arguments: {R : Type u_1} [Monoid R] {a : R} (ua : IsUnit a)
Goal: IsRegular a
-- IsAddUnit.isAddRegular
@[to_additive "An additive unit in an additive monoid is add-regular."]
theorem IsUnit.isRegular (ua : IsUnit a) : IsRegular a 
Arguments: {R : Type u_1} [AddMonoid R] {a : R} (ua : IsAddUnit a)
Goal: IsAddRegular a
-- IsLeftRegular.all
@[to_additive "If all additions cancel on the left then every element is add-left-regular."]
theorem IsLeftRegular.all [Mul R] [IsLeftCancelMul R] (g : R) : IsLeftRegular g 
Arguments: {R : Type u_1} [Mul R] [IsLeftCancelMul R] (g : R)
Goal: IsLeftRegular g
-- IsAddLeftRegular.all
@[to_additive "If all additions cancel on the left then every element is add-left-regular."]
theorem IsLeftRegular.all [Mul R] [IsLeftCancelMul R] (g : R) : IsLeftRegular g 
Arguments: {R : Type u_1} [Add R] [IsLeftCancelAdd R] (g : R)
Goal: IsAddLeftRegular g
-- IsAddRightRegular.all
@[to_additive "If all additions cancel on the right then every element is add-right-regular."]
theorem IsRightRegular.all [Mul R] [IsRightCancelMul R] (g : R) : IsRightRegular g 
Arguments: {R : Type u_1} [Add R] [IsRightCancelAdd R] (g : R)
Goal: IsAddRightRegular g
-- IsRightRegular.all
@[to_additive "If all additions cancel on the right then every element is add-right-regular."]
theorem IsRightRegular.all [Mul R] [IsRightCancelMul R] (g : R) : IsRightRegular g 
Arguments: {R : Type u_1} [Mul R] [IsRightCancelMul R] (g : R)
Goal: IsRightRegular g
-- IsAddRegular.all
@[to_additive "If all additions cancel then every element is add-regular."]
theorem IsRegular.all [Mul R] [IsCancelMul R] (g : R) : IsRegular g 
Arguments: {R : Type u_1} [Add R] [IsCancelAdd R] (g : R)
Goal: IsAddRegular g
-- IsRegular.all
@[to_additive "If all additions cancel then every element is add-regular."]
theorem IsRegular.all [Mul R] [IsCancelMul R] (g : R) : IsRegular g 
Arguments: {R : Type u_1} [Mul R] [IsCancelMul R] (g : R)
Goal: IsRegular g
-- isRegular_of_ne_zero
theorem isRegular_of_ne_zero (a0 : a ≠ 0) : IsRegular a 
Arguments: {R : Type u_1} [MulZeroClass R] [IsCancelMulZero R] {a : R} (a0 : a ≠ 0)
Goal: IsRegular a
-- isRegular_iff_ne_zero
theorem isRegular_iff_ne_zero [Nontrivial R] : IsRegular a ↔ a ≠ 0 
Arguments: {R : Type u_1} [MulZeroClass R] [IsCancelMulZero R] {a : R} [Nontrivial R]
Goal: IsRegular a ↔ a ≠ 0
-- IsLeftRegular.pow
theorem IsLeftRegular.pow (n : ℕ) (rla : IsLeftRegular a) : IsLeftRegular (a ^ n) 
Arguments: {R : Type u_1} {a : R} [Monoid R] (n : ℕ) (rla : IsLeftRegular a)
Goal: IsLeftRegular (a ^ n)
-- IsRightRegular.pow
theorem IsRightRegular.pow (n : ℕ) (rra : IsRightRegular a) : IsRightRegular (a ^ n) 
Arguments: {R : Type u_1} {a : R} [Monoid R] (n : ℕ) (rra : IsRightRegular a)
Goal: IsRightRegular (a ^ n)
-- IsRegular.pow
theorem IsRegular.pow (n : ℕ) (ra : IsRegular a) : IsRegular (a ^ n) 
Arguments: {R : Type u_1} {a : R} [Monoid R] (n : ℕ) (ra : IsRegular a)
Goal: IsRegular (a ^ n)
-- IsLeftRegular.pow_iff
theorem IsLeftRegular.pow_iff {n : ℕ} (n0 : 0 < n) : IsLeftRegular (a ^ n) ↔ IsLeftRegular a 
Arguments: {R : Type u_1} {a : R} [Monoid R] {n : ℕ} (n0 : 0 < n)
Goal: IsLeftRegular (a ^ n) ↔ IsLeftRegular a
-- IsRightRegular.pow_iff
theorem IsRightRegular.pow_iff {n : ℕ} (n0 : 0 < n) :
    IsRightRegular (a ^ n) ↔ IsRightRegular a 
Arguments: {R : Type u_1} {a : R} [Monoid R] {n : ℕ} (n0 : 0 < n)
Goal: IsRightRegular (a ^ n) ↔ IsRightRegular a
-- IsRegular.pow_iff
theorem IsRegular.pow_iff {n : ℕ} (n0 : 0 < n) : IsRegular (a ^ n) ↔ IsRegular a 
Arguments: {R : Type u_1} {a : R} [Monoid R] {n : ℕ} (n0 : 0 < n)
Goal: IsRegular (a ^ n) ↔ IsRegular a
-- IsLeftRegular.prod
lemma IsLeftRegular.prod (h : ∀ i ∈ s, IsLeftRegular (f i)) :
    IsLeftRegular (∏ i ∈ s, f i) 
Arguments: {ι : Type u_2} {R : Type u_3} [CommMonoid R] {s : Finset ι} {f : ι → R} (h : ∀ i ∈ s, IsLeftRegular (f i))
Goal: IsLeftRegular (∏ i ∈ s, f i)
-- IsRightRegular.prod
lemma IsRightRegular.prod (h : ∀ i ∈ s, IsRightRegular (f i)) :
    IsRightRegular (∏ i ∈ s, f i) 
Arguments: {ι : Type u_2} {R : Type u_3} [CommMonoid R] {s : Finset ι} {f : ι → R} (h : ∀ i ∈ s, IsRightRegular (f i))
Goal: IsRightRegular (∏ i ∈ s, f i)
-- IsRegular.prod
lemma IsRegular.prod (h : ∀ i ∈ s, IsRegular (f i)) :
    IsRegular (∏ i ∈ s, f i) 
Arguments: {ι : Type u_2} {R : Type u_3} [CommMonoid R] {s : Finset ι} {f : ι → R} (h : ∀ i ∈ s, IsRegular (f i))
Goal: IsRegular (∏ i ∈ s, f i)
-- IsLeftRegular.isSMulRegular
theorem IsLeftRegular.isSMulRegular [Mul R] {c : R} (h : IsLeftRegular c) : IsSMulRegular R c 
Arguments: {R : Type u_1} [Mul R] {c : R} (h : IsLeftRegular c)
Goal: IsSMulRegular R c
-- isLeftRegular_iff
theorem isLeftRegular_iff [Mul R] {a : R} : IsLeftRegular a ↔ IsSMulRegular R a 
Arguments: {R : Type u_1} [Mul R] {a : R}
Goal: IsLeftRegular a ↔ IsSMulRegular R a
-- IsRightRegular.isSMulRegular
theorem IsRightRegular.isSMulRegular [Mul R] {c : R} (h : IsRightRegular c) :
    IsSMulRegular R (MulOpposite.op c) 
Arguments: {R : Type u_1} [Mul R] {c : R} (h : IsRightRegular c)
Goal: IsSMulRegular R (MulOpposite.op c)
-- isRightRegular_iff
theorem isRightRegular_iff [Mul R] {a : R} :
    IsRightRegular a ↔ IsSMulRegular R (MulOpposite.op a) 
Arguments: {R : Type u_1} [Mul R] {a : R}
Goal: IsRightRegular a ↔ IsSMulRegular R (MulOpposite.op a)
-- IsSMulRegular.smul
theorem smul (ra : IsSMulRegular M a) (rs : IsSMulRegular M s) : IsSMulRegular M (a • s) 
Arguments: {R : Type u_1} {S : Type u_2} {M : Type u_3} {a : R} {s : S} [SMul R M] [SMul R S] [SMul S M] [IsScalarTower R S M] (ra : IsSMulRegular M a) (rs : IsSMulRegular M s)
Goal: IsSMulRegular M (a • s)
-- IsSMulRegular.of_smul
theorem of_smul (a : R) (ab : IsSMulRegular M (a • s)) : IsSMulRegular M s 
Arguments: {R : Type u_1} {S : Type u_2} {M : Type u_3} {s : S} [SMul R M] [SMul R S] [SMul S M] [IsScalarTower R S M] (a : R) (ab : IsSMulRegular M (a • s))
Goal: IsSMulRegular M s
-- IsSMulRegular.smul_iff
@[simp]
theorem smul_iff (b : S) (ha : IsSMulRegular M a) : IsSMulRegular M (a • b) ↔ IsSMulRegular M b 
Arguments: {R : Type u_1} {S : Type u_2} {M : Type u_3} {a : R} [SMul R M] [SMul R S] [SMul S M] [IsScalarTower R S M] (b : S) (ha : IsSMulRegular M a)
Goal: IsSMulRegular M (a • b) ↔ IsSMulRegular M b
-- IsSMulRegular.isLeftRegular
theorem isLeftRegular [Mul R] {a : R} (h : IsSMulRegular R a) : IsLeftRegular a 
Arguments: {R : Type u_1} [Mul R] {a : R} (h : IsSMulRegular R a)
Goal: IsLeftRegular a
-- IsSMulRegular.isRightRegular
theorem isRightRegular [Mul R] {a : R} (h : IsSMulRegular R (MulOpposite.op a)) :
    IsRightRegular a 
Arguments: {R : Type u_1} [Mul R] {a : R} (h : IsSMulRegular R (MulOpposite.op a))
Goal: IsRightRegular a
-- IsSMulRegular.mul
theorem mul [Mul R] [IsScalarTower R R M] (ra : IsSMulRegular M a) (rb : IsSMulRegular M b) :
    IsSMulRegular M (a * b) 
Arguments: {R : Type u_1} {M : Type u_3} {a b : R} [SMul R M] [Mul R] [IsScalarTower R R M] (ra : IsSMulRegular M a) (rb : IsSMulRegular M b)
Goal: IsSMulRegular M (a * b)
-- IsSMulRegular.of_mul
theorem of_mul [Mul R] [IsScalarTower R R M] (ab : IsSMulRegular M (a * b)) :
    IsSMulRegular M b 
Arguments: {R : Type u_1} {M : Type u_3} {a b : R} [SMul R M] [Mul R] [IsScalarTower R R M] (ab : IsSMulRegular M (a * b))
Goal: IsSMulRegular M b
-- IsSMulRegular.mul_iff_right
@[simp]
theorem mul_iff_right [Mul R] [IsScalarTower R R M] (ha : IsSMulRegular M a) :
    IsSMulRegular M (a * b) ↔ IsSMulRegular M b 
Arguments: {R : Type u_1} {M : Type u_3} {a b : R} [SMul R M] [Mul R] [IsScalarTower R R M] (ha : IsSMulRegular M a)
Goal: IsSMulRegular M (a * b) ↔ IsSMulRegular M b
-- IsSMulRegular.mul_and_mul_iff
theorem mul_and_mul_iff [Mul R] [IsScalarTower R R M] :
    IsSMulRegular M (a * b) ∧ IsSMulRegular M (b * a) ↔ IsSMulRegular M a ∧ IsSMulRegular M b 
Arguments: {R : Type u_1} {M : Type u_3} {a b : R} [SMul R M] [Mul R] [IsScalarTower R R M]
Goal: IsSMulRegular M (a * b) ∧ IsSMulRegular M (b * a) ↔ IsSMulRegular M a ∧ IsSMulRegular M b