File: Mathlib/Algebra/Regular/SMul.lean

full_name: IsSMulRegular
code: /-- An `M`-regular element is an element `c` such that multiplication on the left by `c` is an
injective map `M → M`. -/
def IsSMulRegular [SMul R M] (c : R) 
goal: Prop

full_name: IsLeftRegular.isSMulRegular
code: theorem IsLeftRegular.isSMulRegular [Mul R] {c : R} (h : IsLeftRegular c) : IsSMulRegular R c 
goal: IsSMulRegular R c

full_name: isLeftRegular_iff
code: /-- Left-regular multiplication on `R` is equivalent to `R`-regularity of `R` itself. -/
theorem isLeftRegular_iff [Mul R] {a : R} : IsLeftRegular a ↔ IsSMulRegular R a 
goal: IsLeftRegular a ↔ IsSMulRegular R a

full_name: IsRightRegular.isSMulRegular
code: theorem IsRightRegular.isSMulRegular [Mul R] {c : R} (h : IsRightRegular c) :
    IsSMulRegular R (MulOpposite.op c) 
goal: IsSMulRegular R (MulOpposite.op c)

full_name: isRightRegular_iff
code: /-- Right-regular multiplication on `R` is equivalent to `Rᵐᵒᵖ`-regularity of `R` itself. -/
theorem isRightRegular_iff [Mul R] {a : R} :
    IsRightRegular a ↔ IsSMulRegular R (MulOpposite.op a) 
goal: IsRightRegular a ↔ IsSMulRegular R (MulOpposite.op a)

full_name: IsSMulRegular.smul
code: /-- The product of `M`-regular elements is `M`-regular. -/
theorem smul (ra : IsSMulRegular M a) (rs : IsSMulRegular M s) : IsSMulRegular M (a • s) 
goal: IsSMulRegular M (a • s)

full_name: IsSMulRegular.of_smul
code: /-- If an element `b` becomes `M`-regular after multiplying it on the left by an `M`-regular
element, then `b` is `M`-regular. -/
theorem of_smul (a : R) (ab : IsSMulRegular M (a • s)) : IsSMulRegular M s 
goal: IsSMulRegular M s

full_name: IsSMulRegular.smul_iff
code: /-- An element is `M`-regular if and only if multiplying it on the left by an `M`-regular element
is `M`-regular. -/
@[simp]
theorem smul_iff (b : S) (ha : IsSMulRegular M a) : IsSMulRegular M (a • b) ↔ IsSMulRegular M b 
goal: IsSMulRegular M (a • b) ↔ IsSMulRegular M b

full_name: IsSMulRegular.isLeftRegular
code: theorem isLeftRegular [Mul R] {a : R} (h : IsSMulRegular R a) : IsLeftRegular a 
goal: IsLeftRegular a

full_name: IsSMulRegular.isRightRegular
code: theorem isRightRegular [Mul R] {a : R} (h : IsSMulRegular R (MulOpposite.op a)) :
    IsRightRegular a 
goal: IsRightRegular a

full_name: IsSMulRegular.mul
code: theorem mul [Mul R] [IsScalarTower R R M] (ra : IsSMulRegular M a) (rb : IsSMulRegular M b) :
    IsSMulRegular M (a * b) 
goal: IsSMulRegular M (a * b)

full_name: IsSMulRegular.of_mul
code: theorem of_mul [Mul R] [IsScalarTower R R M] (ab : IsSMulRegular M (a * b)) :
    IsSMulRegular M b 
goal: IsSMulRegular M b

full_name: IsSMulRegular.mul_iff_right
code: @[simp]
theorem mul_iff_right [Mul R] [IsScalarTower R R M] (ha : IsSMulRegular M a) :
    IsSMulRegular M (a * b) ↔ IsSMulRegular M b 
goal: IsSMulRegular M (a * b) ↔ IsSMulRegular M b

full_name: IsSMulRegular.mul_and_mul_iff
code: /-- Two elements `a` and `b` are `M`-regular if and only if both products `a * b` and `b * a`
are `M`-regular. -/
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 
goal: IsSMulRegular M (a * b) ∧ IsSMulRegular M (b * a) ↔ IsSMulRegular M a ∧ IsSMulRegular M b

full_name: IsSMulRegular.of_injective
code: lemma of_injective {N F} [SMul R N] [FunLike F M N] [MulActionHomClass F R M N]
    (f : F) {r : R} (h1 : Function.Injective f) (h2 : IsSMulRegular N r) :
    IsSMulRegular M r 
goal: IsSMulRegular M r

full_name: IsSMulRegular.one
code: /-- One is always `M`-regular. -/
@[simp]
theorem one : IsSMulRegular M (1 : R) 
goal: IsSMulRegular M 1

full_name: IsSMulRegular.of_mul_eq_one
code: /-- An element of `R` admitting a left inverse is `M`-regular. -/
theorem of_mul_eq_one (h : a * b = 1) : IsSMulRegular M b 
goal: IsSMulRegular M b

full_name: IsSMulRegular.pow
code: /-- Any power of an `M`-regular element is `M`-regular. -/
theorem pow (n : ℕ) (ra : IsSMulRegular M a) : IsSMulRegular M (a ^ n) 
goal: IsSMulRegular M (a ^ n)

full_name: IsSMulRegular.pow_iff
code: /-- An element `a` is `M`-regular if and only if a positive power of `a` is `M`-regular. -/
theorem pow_iff {n : ℕ} (n0 : 0 < n) : IsSMulRegular M (a ^ n) ↔ IsSMulRegular M a 
goal: IsSMulRegular M (a ^ n) ↔ IsSMulRegular M a

full_name: IsSMulRegular.of_smul_eq_one
code: /-- An element of `S` admitting a left inverse in `R` is `M`-regular. -/
theorem of_smul_eq_one (h : a • s = 1) : IsSMulRegular M s 
goal: IsSMulRegular M s

full_name: IsSMulRegular.subsingleton
code: /-- The element `0` is `M`-regular if and only if `M` is trivial. -/
protected theorem subsingleton (h : IsSMulRegular M (0 : R)) : Subsingleton M 
goal: Subsingleton M

full_name: IsSMulRegular.zero_iff_subsingleton
code: /-- The element `0` is `M`-regular if and only if `M` is trivial. -/
theorem zero_iff_subsingleton : IsSMulRegular M (0 : R) ↔ Subsingleton M 
goal: IsSMulRegular M 0 ↔ Subsingleton M

full_name: IsSMulRegular.not_zero_iff
code: /-- The `0` element is not `M`-regular, on a non-trivial module. -/
theorem not_zero_iff : ¬IsSMulRegular M (0 : R) ↔ Nontrivial M 
goal: ¬IsSMulRegular M 0 ↔ Nontrivial M

full_name: IsSMulRegular.zero
code: /-- The element `0` is `M`-regular when `M` is trivial. -/
theorem zero [sM : Subsingleton M] : IsSMulRegular M (0 : R) 
goal: IsSMulRegular M 0

full_name: IsSMulRegular.not_zero
code: /-- The `0` element is not `M`-regular, on a non-trivial module. -/
theorem not_zero [nM : Nontrivial M] : ¬IsSMulRegular M (0 : R) 
goal: ¬IsSMulRegular M 0

full_name: IsSMulRegular.mul_iff
code: /-- A product is `M`-regular if and only if the factors are. -/
theorem mul_iff : IsSMulRegular M (a * b) ↔ IsSMulRegular M a ∧ IsSMulRegular M b 
goal: IsSMulRegular M (a * b) ↔ IsSMulRegular M a ∧ IsSMulRegular M b

full_name: isSMulRegular_of_group
code: /-- An element of a group acting on a Type is regular. This relies on the availability
of the inverse given by groups, since there is no `LeftCancelSMul` typeclass. -/
theorem isSMulRegular_of_group [MulAction G R] (g : G) : IsSMulRegular R g 
goal: IsSMulRegular R g

full_name: Units.isSMulRegular
code: /-- Any element in `Rˣ` is `M`-regular. -/
theorem Units.isSMulRegular (a : Rˣ) : IsSMulRegular M (a : R) 
goal: IsSMulRegular M ↑a

full_name: IsUnit.isSMulRegular
code: /-- A unit is `M`-regular. -/
theorem IsUnit.isSMulRegular (ua : IsUnit a) : IsSMulRegular M a 
goal: IsSMulRegular M a

full_name: IsSMulRegular.eq_zero_of_smul_eq_zero
code: protected
lemma IsSMulRegular.eq_zero_of_smul_eq_zero [Zero M] [SMulZeroClass R M]
    {r : R} {x : M} (h1 : IsSMulRegular M r) (h2 : r • x = 0) : x = 0 
goal: x = 0

full_name: Equiv.isSMulRegular_congr
code: lemma Equiv.isSMulRegular_congr {R S M M'} [SMul R M] [SMul S M'] {e : M ≃ M'}
    {r : R} {s : S} (h : ∀ x, e (r • x) = s • e x) :
    IsSMulRegular M r ↔ IsSMulRegular M' s 
goal: IsSMulRegular M r ↔ IsSMulRegular M' s