File: Mathlib/Algebra/Module/Defs.lean

full_name: Module
code: /-- A module is a generalization of vector spaces to a scalar semiring.
  It consists of a scalar semiring `R` and an additive monoid of "vectors" `M`,
  connected by a "scalar multiplication" operation `r • x : M`
  (where `r : R` and `x : M`) with some natural associativity and
  distributivity axioms similar to those on a ring. -/
@[ext]
class Module (R : Type u) (M : Type v) [Semiring R] [AddCommMonoid M] extends
  DistribMulAction R M where
  /-- Scalar multiplication distributes over addition from the right. -/
  protected add_smul : ∀ (r s : R) (x : M), (r + s) • x = r • x + s • x
  /-- Scalar multiplication by zero gives zero. -/
  protected zero_smul : ∀ x : M, (0 : R) • x = 0
goal: Type (max u v)

full_name: Module.zero_smul
code: /-- A module is a generalization of vector spaces to a scalar semiring.
  It consists of a scalar semiring `R` and an additive monoid of "vectors" `M`,
  connected by a "scalar multiplication" operation `r • x : M`
  (where `r : R` and `x : M`) with some natural associativity and
  distributivity axioms similar to those on a ring. -/
@[ext]
class Module (R : Type u) (M : Type v) [Semiring R] [AddCommMonoid M] extends
  DistribMulAction R M where
  /-- Scalar multiplication distributes over addition from the right. -/
  protected add_smul : ∀ (r s : R) (x : M), (r + s) • x = r • x + s • x
  /-- Scalar multiplication by zero gives zero. -/
  protected zero_smul : ∀ x : M, (0 : R) • x = 0
goal: 0 • x = 0

full_name: Module.add_smul
code: /-- A module is a generalization of vector spaces to a scalar semiring.
  It consists of a scalar semiring `R` and an additive monoid of "vectors" `M`,
  connected by a "scalar multiplication" operation `r • x : M`
  (where `r : R` and `x : M`) with some natural associativity and
  distributivity axioms similar to those on a ring. -/
@[ext]
class Module (R : Type u) (M : Type v) [Semiring R] [AddCommMonoid M] extends
  DistribMulAction R M where
  /-- Scalar multiplication distributes over addition from the right. -/
  protected add_smul : ∀ (r s : R) (x : M), (r + s) • x = r • x + s • x
  /-- Scalar multiplication by zero gives zero. -/
  protected zero_smul : ∀ x : M, (0 : R) • x = 0
goal: (r + s) • x = r • x + s • x

full_name: Module.toMulActionWithZero
code: /-- A module over a semiring automatically inherits a `MulActionWithZero` structure. -/
instance (priority := 100) Module.toMulActionWithZero : MulActionWithZero R M 
goal: MulActionWithZero R M

full_name: AddCommMonoid.natModule
code: instance AddCommMonoid.natModule : Module ℕ M 
goal: Module ℕ M

full_name: AddMonoid.End.natCast_def
code: theorem AddMonoid.End.natCast_def (n : ℕ) :
    (↑n : AddMonoid.End M) = DistribMulAction.toAddMonoidEnd ℕ M n 
goal: ↑n = (DistribMulAction.toAddMonoidEnd ℕ M) n

full_name: add_smul
code: theorem add_smul : (r + s) • x = r • x + s • x 
goal: (r + s) • x = r • x + s • x

full_name: Convex.combo_self
code: theorem Convex.combo_self {a b : R} (h : a + b = 1) (x : M) : a • x + b • x = x 
goal: a • x + b • x = x

full_name: two_smul
code: theorem two_smul : (2 : R) • x = x + x 
goal: 2 • x = x + x

full_name: two_smul'
code: @[deprecated (since := "2022-12-31")]
theorem two_smul' : (2 : R) • x = (2 : ℕ) • x 
goal: 2 • x = 2 • x

full_name: invOf_two_smul_add_invOf_two_smul
code: @[simp]
theorem invOf_two_smul_add_invOf_two_smul [Invertible (2 : R)] (x : M) :
    (⅟ 2 : R) • x + (⅟ 2 : R) • x = x 
goal: ⅟2 • x + ⅟2 • x = x

full_name: Function.Injective.module
code: /-- Pullback a `Module` structure along an injective additive monoid homomorphism.
See note [reducible non-instances]. -/
protected abbrev Function.Injective.module [AddCommMonoid M₂] [SMul R M₂] (f : M₂ →+ M)
    (hf : Injective f) (smul : ∀ (c : R) (x), f (c • x) = c • f x) : Module R M₂ 
goal: Module R M₂

full_name: Function.Surjective.module
code: /-- Pushforward a `Module` structure along a surjective additive monoid homomorphism.
See note [reducible non-instances]. -/
protected abbrev Function.Surjective.module [AddCommMonoid M₂] [SMul R M₂] (f : M →+ M₂)
    (hf : Surjective f) (smul : ∀ (c : R) (x), f (c • x) = c • f x) : Module R M₂ 
goal: Module R M₂

full_name: Function.Surjective.moduleLeft
code: /-- Push forward the action of `R` on `M` along a compatible surjective map `f : R →+* S`.

See also `Function.Surjective.mulActionLeft` and `Function.Surjective.distribMulActionLeft`.
-/
abbrev Function.Surjective.moduleLeft {R S M : Type*} [Semiring R] [AddCommMonoid M] [Module R M]
    [Semiring S] [SMul S M] (f : R →+* S) (hf : Function.Surjective f)
    (hsmul : ∀ (c) (x : M), f c • x = c • x) : Module S M 
goal: Module S M

full_name: Module.compHom
code: /-- Compose a `Module` with a `RingHom`, with action `f s • m`.

See note [reducible non-instances]. -/
abbrev Module.compHom [Semiring S] (f : S →+* R) : Module S M 
goal: Module S M

full_name: Module.toAddMonoidEnd
code: /-- `(•)` as an `AddMonoidHom`.

This is a stronger version of `DistribMulAction.toAddMonoidEnd` -/
@[simps! apply_apply]
def Module.toAddMonoidEnd : R →+* AddMonoid.End M 
goal: R →+* AddMonoid.End M

full_name: Module.toAddMonoidEnd_apply_apply
code: /-- `(•)` as an `AddMonoidHom`.

This is a stronger version of `DistribMulAction.toAddMonoidEnd` -/
@[simps! apply_apply]
def Module.toAddMonoidEnd : R →+* AddMonoid.End M 
goal: ∀ (x_1 : M), ((Module.toAddMonoidEnd R M) x) x_1 = x • x_1

full_name: smulAddHom
code: /-- A convenience alias for `Module.toAddMonoidEnd` as an `AddMonoidHom`, usually to allow the
use of `AddMonoidHom.flip`. -/
def smulAddHom : R →+ M →+ M 
goal: R →+ M →+ M

full_name: smulAddHom_apply
code: @[simp]
theorem smulAddHom_apply (r : R) (x : M) : smulAddHom R M r x = r • x 
goal: ((smulAddHom R M) r) x = r • x

full_name: Module.eq_zero_of_zero_eq_one
code: theorem Module.eq_zero_of_zero_eq_one (zero_eq_one : (0 : R) = 1) : x = 0 
goal: x = 0

full_name: smul_add_one_sub_smul
code: @[simp]
theorem smul_add_one_sub_smul {R : Type*} [Ring R] [Module R M] {r : R} {m : M} :
    r • m + (1 - r) • m = m 
goal: r • m + (1 - r) • m = m

full_name: AddCommGroup.intModule
code: instance AddCommGroup.intModule : Module ℤ M 
goal: Module ℤ M

full_name: AddMonoid.End.intCast_def
code: theorem AddMonoid.End.intCast_def (z : ℤ) :
    (↑z : AddMonoid.End M) = DistribMulAction.toAddMonoidEnd ℤ M z 
goal: ↑z = (DistribMulAction.toAddMonoidEnd ℤ M) z

full_name: Convex.combo_eq_smul_sub_add
code: theorem Convex.combo_eq_smul_sub_add [Module R M] {x y : M} {a b : R} (h : a + b = 1) :
    a • x + b • y = b • (y - x) + x 
goal: a • x + b • y = b • (y - x) + x

full_name: Module.ext'
code: /-- A variant of `Module.ext` that's convenient for term-mode. -/
theorem Module.ext' {R : Type*} [Semiring R] {M : Type*} [AddCommMonoid M] (P Q : Module R M)
    (w : ∀ (r : R) (m : M), (haveI := P; r • m) = (haveI := Q; r • m)) :
    P = Q 
goal: P = Q

full_name: neg_smul
code: @[simp]
theorem neg_smul : -r • x = -(r • x) 
goal: -r • x = -(r • x)

full_name: neg_smul_neg
code: theorem neg_smul_neg : -r • -x = r • x 
goal: -r • -x = r • x

full_name: Units.neg_smul
code: @[simp]
theorem Units.neg_smul (u : Rˣ) (x : M) : -u • x = -(u • x) 
goal: -u • x = -(u • x)

full_name: neg_one_smul
code: theorem neg_one_smul (x : M) : (-1 : R) • x = -x 
goal: -1 • x = -x

full_name: sub_smul
code: theorem sub_smul (r s : R) (y : M) : (r - s) • y = r • y - s • y 
goal: (r - s) • y = r • y - s • y

full_name: Module.addCommMonoidToAddCommGroup
code: /-- An `AddCommMonoid` that is a `Module` over a `Ring` carries a natural `AddCommGroup`
structure.
See note [reducible non-instances]. -/
abbrev Module.addCommMonoidToAddCommGroup
    [Ring R] [AddCommMonoid M] [Module R M] : AddCommGroup M 
goal: AddCommGroup M

full_name: Module.subsingleton
code: /-- A module over a `Subsingleton` semiring is a `Subsingleton`. We cannot register this
as an instance because Lean has no way to guess `R`. -/
protected theorem Module.subsingleton (R M : Type*) [Semiring R] [Subsingleton R] [AddCommMonoid M]
    [Module R M] : Subsingleton M 
goal: Subsingleton M

full_name: Module.nontrivial
code: /-- A semiring is `Nontrivial` provided that there exists a nontrivial module over this semiring. -/
protected theorem Module.nontrivial (R M : Type*) [Semiring R] [Nontrivial M] [AddCommMonoid M]
    [Module R M] : Nontrivial R 
goal: Nontrivial R

full_name: Semiring.toModule
code: instance (priority := 910) Semiring.toModule [Semiring R] : Module R R 
goal: Module R R

full_name: Semiring.toOppositeModule
code: /-- Like `Semiring.toModule`, but multiplies on the right. -/
instance (priority := 910) Semiring.toOppositeModule [Semiring R] : Module Rᵐᵒᵖ R 
goal: Module Rᵐᵒᵖ R

full_name: RingHom.toModule
code: /-- A ring homomorphism `f : R →+* M` defines a module structure by `r • x = f r * x`. -/
def RingHom.toModule [Semiring R] [Semiring S] (f : R →+* S) : Module R S 
goal: Module R S

full_name: RingHom.smulOneHom
code: /-- If the module action of `R` on `S` is compatible with multiplication on `S`, then
`fun x ↦ x • 1` is a ring homomorphism from `R` to `S`.

This is the `RingHom` version of `MonoidHom.smulOneHom`.

When `R` is commutative, usually `algebraMap` should be preferred. -/
@[simps!] def RingHom.smulOneHom
    [Semiring R] [NonAssocSemiring S] [Module R S] [IsScalarTower R S S] : R →+* S 
goal: R →+* S

full_name: RingHom.smulOneHom_apply
code: /-- If the module action of `R` on `S` is compatible with multiplication on `S`, then
`fun x ↦ x • 1` is a ring homomorphism from `R` to `S`.

This is the `RingHom` version of `MonoidHom.smulOneHom`.

When `R` is commutative, usually `algebraMap` should be preferred. -/
@[simps!] def RingHom.smulOneHom
    [Semiring R] [NonAssocSemiring S] [Module R S] [IsScalarTower R S S] : R →+* S 
goal: RingHom.smulOneHom x = x • 1

full_name: ringHomEquivModuleIsScalarTower
code: /-- A homomorphism between semirings R and S can be equivalently specified by a R-module
structure on S such that S/S/R is a scalar tower. -/
def ringHomEquivModuleIsScalarTower [Semiring R] [Semiring S] :
    (R →+* S) ≃ {_inst : Module R S // IsScalarTower R S S} 
goal: (R →+* S) ≃ { _inst // IsScalarTower R S S }

full_name: Nat.cast_smul_eq_nsmul
code: /-- `nsmul` is equal to any other module structure via a cast. -/
lemma Nat.cast_smul_eq_nsmul (n : ℕ) (b : M) : (n : R) • b = n • b 
goal: ↑n • b = n • b

full_name: ofNat_smul_eq_nsmul
code: /-- `nsmul` is equal to any other module structure via a cast. -/
-- See note [no_index around OfNat.ofNat]
lemma ofNat_smul_eq_nsmul (n : ℕ) [n.AtLeastTwo] (b : M) :
    (no_index OfNat.ofNat n : R) • b = OfNat.ofNat n • b 
goal: OfNat.ofNat n • b = OfNat.ofNat n • b

full_name: nsmul_eq_smul_cast
code: /-- `nsmul` is equal to any other module structure via a cast. -/
@[deprecated Nat.cast_smul_eq_nsmul (since := "2024-07-23")]
lemma nsmul_eq_smul_cast (n : ℕ) (b : M) : n • b = (n : R) • b 
goal: n • b = ↑n • b

full_name: nat_smul_eq_nsmul
code: /-- Convert back any exotic `ℕ`-smul to the canonical instance. This should not be needed since in
mathlib all `AddCommMonoid`s should normally have exactly one `ℕ`-module structure by design.
-/
theorem nat_smul_eq_nsmul (h : Module ℕ M) (n : ℕ) (x : M) : @SMul.smul ℕ M h.toSMul n x = n • x 
goal: SMul.smul n x = n • x

full_name: AddCommMonoid.natModule.unique
code: /-- All `ℕ`-module structures are equal. Not an instance since in mathlib all `AddCommMonoid`
should normally have exactly one `ℕ`-module structure by design. -/
def AddCommMonoid.natModule.unique : Unique (Module ℕ M) 
goal: Unique (Module ℕ M)

full_name: AddCommMonoid.nat_isScalarTower
code: instance AddCommMonoid.nat_isScalarTower : IsScalarTower ℕ R M 
goal: IsScalarTower ℕ R M

full_name: Int.cast_smul_eq_nsmul
code: /-- `zsmul` is equal to any other module structure via a cast. -/
lemma Int.cast_smul_eq_nsmul (n : ℤ) (b : M) : (n : R) • b = n • b 
goal: ↑n • b = n • b

full_name: zsmul_eq_smul_cast
code: /-- `zsmul` is equal to any other module structure via a cast. -/
@[deprecated Int.cast_smul_eq_nsmul (since := "2024-07-23")]
theorem zsmul_eq_smul_cast (n : ℤ) (b : M) : n • b = (n : R) • b 
goal: n • b = ↑n • b

full_name: int_smul_eq_zsmul
code: /-- Convert back any exotic `ℤ`-smul to the canonical instance. This should not be needed since in
mathlib all `AddCommGroup`s should normally have exactly one `ℤ`-module structure by design. -/
theorem int_smul_eq_zsmul (h : Module ℤ M) (n : ℤ) (x : M) : @SMul.smul ℤ M h.toSMul n x = n • x 
goal: SMul.smul n x = n • x

full_name: AddCommGroup.intModule.unique
code: /-- All `ℤ`-module structures are equal. Not an instance since in mathlib all `AddCommGroup`
should normally have exactly one `ℤ`-module structure by design. -/
def AddCommGroup.intModule.unique : Unique (Module ℤ M) 
goal: Unique (Module ℤ M)

full_name: map_intCast_smul
code: theorem map_intCast_smul [AddCommGroup M] [AddCommGroup M₂] {F : Type*} [FunLike F M M₂]
    [AddMonoidHomClass F M M₂] (f : F) (R S : Type*) [Ring R] [Ring S] [Module R M] [Module S M₂]
    (x : ℤ) (a : M) :
    f ((x : R) • a) = (x : S) • f a 
goal: f (↑x • a) = ↑x • f a

full_name: map_natCast_smul
code: theorem map_natCast_smul [AddCommMonoid M] [AddCommMonoid M₂] {F : Type*} [FunLike F M M₂]
    [AddMonoidHomClass F M M₂] (f : F) (R S : Type*) [Semiring R] [Semiring S] [Module R M]
    [Module S M₂] (x : ℕ) (a : M) : f ((x : R) • a) = (x : S) • f a 
goal: f (↑x • a) = ↑x • f a

full_name: AddCommGroup.intIsScalarTower
code: instance AddCommGroup.intIsScalarTower {R : Type u} {M : Type v} [Ring R] [AddCommGroup M]
    [Module R M] : IsScalarTower ℤ R M 
goal: IsScalarTower ℤ R M

full_name: NoZeroSMulDivisors.eq_zero_or_eq_zero_of_smul_eq_zero
code: /-- `NoZeroSMulDivisors R M` states that a scalar multiple is `0` only if either argument is `0`.
This is a version of saying that `M` is torsion free, without assuming `R` is zero-divisor free.

The main application of `NoZeroSMulDivisors R M`, when `M` is a module,
is the result `smul_eq_zero`: a scalar multiple is `0` iff either argument is `0`.

It is a generalization of the `NoZeroDivisors` class to heterogeneous multiplication.
-/
@[mk_iff]
class NoZeroSMulDivisors (R M : Type*) [Zero R] [Zero M] [SMul R M] : Prop where
  /-- If scalar multiplication yields zero, either the scalar or the vector was zero. -/
  eq_zero_or_eq_zero_of_smul_eq_zero : ∀ {c : R} {x : M}, c • x = 0 → c = 0 ∨ x = 0
goal: c • x = 0 → c = 0 ∨ x = 0

full_name: noZeroSMulDivisors_iff
code: /-- `NoZeroSMulDivisors R M` states that a scalar multiple is `0` only if either argument is `0`.
This is a version of saying that `M` is torsion free, without assuming `R` is zero-divisor free.

The main application of `NoZeroSMulDivisors R M`, when `M` is a module,
is the result `smul_eq_zero`: a scalar multiple is `0` iff either argument is `0`.

It is a generalization of the `NoZeroDivisors` class to heterogeneous multiplication.
-/
@[mk_iff]
class NoZeroSMulDivisors (R M : Type*) [Zero R] [Zero M] [SMul R M] : Prop where
  /-- If scalar multiplication yields zero, either the scalar or the vector was zero. -/
  eq_zero_or_eq_zero_of_smul_eq_zero : ∀ {c : R} {x : M}, c • x = 0 → c = 0 ∨ x = 0
goal: NoZeroSMulDivisors R M ↔ ∀ {c : R} {x : M}, c • x = 0 → c = 0 ∨ x = 0

full_name: NoZeroSMulDivisors
code: /-- `NoZeroSMulDivisors R M` states that a scalar multiple is `0` only if either argument is `0`.
This is a version of saying that `M` is torsion free, without assuming `R` is zero-divisor free.

The main application of `NoZeroSMulDivisors R M`, when `M` is a module,
is the result `smul_eq_zero`: a scalar multiple is `0` iff either argument is `0`.

It is a generalization of the `NoZeroDivisors` class to heterogeneous multiplication.
-/
@[mk_iff]
class NoZeroSMulDivisors (R M : Type*) [Zero R] [Zero M] [SMul R M] : Prop where
  /-- If scalar multiplication yields zero, either the scalar or the vector was zero. -/
  eq_zero_or_eq_zero_of_smul_eq_zero : ∀ {c : R} {x : M}, c • x = 0 → c = 0 ∨ x = 0
goal: Prop

full_name: Function.Injective.noZeroSMulDivisors
code: /-- Pullback a `NoZeroSMulDivisors` instance along an injective function. -/
theorem Function.Injective.noZeroSMulDivisors {R M N : Type*} [Zero R] [Zero M] [Zero N]
    [SMul R M] [SMul R N] [NoZeroSMulDivisors R N] (f : M → N) (hf : Function.Injective f)
    (h0 : f 0 = 0) (hs : ∀ (c : R) (x : M), f (c • x) = c • f x) : NoZeroSMulDivisors R M 
goal: NoZeroSMulDivisors R M

full_name: NoZeroDivisors.toNoZeroSMulDivisors
code: instance (priority := 100) NoZeroDivisors.toNoZeroSMulDivisors [Zero R] [Mul R]
    [NoZeroDivisors R] : NoZeroSMulDivisors R R 
goal: NoZeroSMulDivisors R R

full_name: smul_ne_zero
code: theorem smul_ne_zero [Zero R] [Zero M] [SMul R M] [NoZeroSMulDivisors R M] {c : R} {x : M}
    (hc : c ≠ 0) (hx : x ≠ 0) : c • x ≠ 0 
goal: c • x ≠ 0

full_name: smul_eq_zero
code: @[simp]
theorem smul_eq_zero : c • x = 0 ↔ c = 0 ∨ x = 0 
goal: c • x = 0 ↔ c = 0 ∨ x = 0

full_name: smul_ne_zero_iff
code: theorem smul_ne_zero_iff : c • x ≠ 0 ↔ c ≠ 0 ∧ x ≠ 0 
goal: c • x ≠ 0 ↔ c ≠ 0 ∧ x ≠ 0

full_name: smul_eq_zero_iff_left
code: lemma smul_eq_zero_iff_left (hx : x ≠ 0) : c • x = 0 ↔ c = 0 
goal: c • x = 0 ↔ c = 0

full_name: smul_eq_zero_iff_right
code: lemma smul_eq_zero_iff_right (hc : c ≠ 0) : c • x = 0 ↔ x = 0 
goal: c • x = 0 ↔ x = 0

full_name: smul_ne_zero_iff_left
code: lemma smul_ne_zero_iff_left (hx : x ≠ 0) : c • x ≠ 0 ↔ c ≠ 0 
goal: c • x ≠ 0 ↔ c ≠ 0

full_name: smul_ne_zero_iff_right
code: lemma smul_ne_zero_iff_right (hc : c ≠ 0) : c • x ≠ 0 ↔ x ≠ 0 
goal: c • x ≠ 0 ↔ x ≠ 0

full_name: Nat.noZeroSMulDivisors
code: theorem Nat.noZeroSMulDivisors
    (R) (M) [Semiring R] [CharZero R] [AddCommMonoid M] [Module R M] [NoZeroSMulDivisors R M] :
    NoZeroSMulDivisors ℕ M 
goal: NoZeroSMulDivisors ℕ M

full_name: two_nsmul_eq_zero
code: theorem two_nsmul_eq_zero
    (R) (M) [Semiring R] [CharZero R] [AddCommMonoid M] [Module R M] [NoZeroSMulDivisors R M]
    {v : M} : 2 • v = 0 ↔ v = 0 
goal: 2 • v = 0 ↔ v = 0

full_name: CharZero.of_module
code: /-- If `M` is an `R`-module with one and `M` has characteristic zero, then `R` has characteristic
zero as well. Usually `M` is an `R`-algebra. -/
theorem CharZero.of_module (M) [AddCommMonoidWithOne M] [CharZero M] [Module R M] : CharZero R 
goal: CharZero R

full_name: smul_right_injective
code: theorem smul_right_injective [NoZeroSMulDivisors R M] {c : R} (hc : c ≠ 0) :
    Function.Injective (c • · : M → M) 
goal: Function.Injective fun x => c • x

full_name: smul_right_inj
code: theorem smul_right_inj [NoZeroSMulDivisors R M] {c : R} (hc : c ≠ 0) {x y : M} :
    c • x = c • y ↔ x = y 
goal: c • x = c • y ↔ x = y

full_name: self_eq_neg
code: theorem self_eq_neg
    (R) (M) [Semiring R] [CharZero R] [AddCommGroup M] [Module R M] [NoZeroSMulDivisors R M]
    {v : M} : v = -v ↔ v = 0 
goal: v = -v ↔ v = 0

full_name: neg_eq_self
code: theorem neg_eq_self
    (R) (M) [Semiring R] [CharZero R] [AddCommGroup M] [Module R M] [NoZeroSMulDivisors R M]
    {v : M} : -v = v ↔ v = 0 
goal: -v = v ↔ v = 0

full_name: self_ne_neg
code: theorem self_ne_neg
    (R) (M) [Semiring R] [CharZero R] [AddCommGroup M] [Module R M] [NoZeroSMulDivisors R M]
    {v : M} : v ≠ -v ↔ v ≠ 0 
goal: v ≠ -v ↔ v ≠ 0

full_name: neg_ne_self
code: theorem neg_ne_self
    (R) (M) [Semiring R] [CharZero R] [AddCommGroup M] [Module R M] [NoZeroSMulDivisors R M]
    {v : M} : -v ≠ v ↔ v ≠ 0 
goal: -v ≠ v ↔ v ≠ 0

full_name: smul_left_injective
code: theorem smul_left_injective {x : M} (hx : x ≠ 0) : Function.Injective fun c : R => c • x 
goal: Function.Injective fun c => c • x

full_name: instNoZeroSMulDivisorsNatOfInt
code: instance [NoZeroSMulDivisors ℤ M] : NoZeroSMulDivisors ℕ M 
goal: NoZeroSMulDivisors ℕ M

full_name: NoZeroSMulDivisors.int_of_charZero
code: theorem NoZeroSMulDivisors.int_of_charZero
    (R) (M) [Ring R] [AddCommGroup M] [Module R M] [NoZeroSMulDivisors R M] [CharZero R] :
    NoZeroSMulDivisors ℤ M 
goal: NoZeroSMulDivisors ℤ M

full_name: CharZero.of_noZeroSMulDivisors
code: /-- Only a ring of characteristic zero can can have a non-trivial module without additive or
scalar torsion. -/
theorem CharZero.of_noZeroSMulDivisors [Nontrivial M] [NoZeroSMulDivisors ℤ M] : CharZero R 
goal: CharZero R

full_name: Nat.smul_one_eq_cast
code: theorem Nat.smul_one_eq_cast {R : Type*} [NonAssocSemiring R] (m : ℕ) : m • (1 : R) = ↑m 
goal: m • 1 = ↑m

full_name: Int.smul_one_eq_cast
code: theorem Int.smul_one_eq_cast {R : Type*} [NonAssocRing R] (m : ℤ) : m • (1 : R) = ↑m 
goal: m • 1 = ↑m