File: Mathlib/Algebra/Module/Torsion.lean

full_name: Ideal.torsionOf_carrier
code: /-- The torsion ideal of `x`, containing all `a` such that `a • x = 0`. -/
@[simps!]
def torsionOf (x : M) : Ideal R 
goal: ↑(Ideal.torsionOf R M x) = ⇑(LinearMap.toSpanSingleton R M x) ⁻¹' {0}

full_name: Ideal.torsionOf
code: /-- The torsion ideal of `x`, containing all `a` such that `a • x = 0`. -/
@[simps!]
def torsionOf (x : M) : Ideal R 
goal: Ideal R

full_name: Ideal.torsionOf_zero
code: @[simp]
theorem torsionOf_zero : torsionOf R M (0 : M) = ⊤ 
goal: Ideal.torsionOf R M 0 = ⊤

full_name: Ideal.mem_torsionOf_iff
code: @[simp]
theorem mem_torsionOf_iff (x : M) (a : R) : a ∈ torsionOf R M x ↔ a • x = 0 
goal: a ∈ Ideal.torsionOf R M x ↔ a • x = 0

full_name: Ideal.torsionOf_eq_top_iff
code: @[simp]
theorem torsionOf_eq_top_iff (m : M) : torsionOf R M m = ⊤ ↔ m = 0 
goal: Ideal.torsionOf R M m = ⊤ ↔ m = 0

full_name: Ideal.torsionOf_eq_bot_iff_of_noZeroSMulDivisors
code: @[simp]
theorem torsionOf_eq_bot_iff_of_noZeroSMulDivisors [Nontrivial R] [NoZeroSMulDivisors R M] (m : M) :
    torsionOf R M m = ⊥ ↔ m ≠ 0 
goal: Ideal.torsionOf R M m = ⊥ ↔ m ≠ 0

full_name: Ideal.CompleteLattice.Independent.linear_independent'
code: /-- See also `CompleteLattice.Independent.linearIndependent` which provides the same conclusion
but requires the stronger hypothesis `NoZeroSMulDivisors R M`. -/
theorem CompleteLattice.Independent.linear_independent' {ι R M : Type*} {v : ι → M} [Ring R]
    [AddCommGroup M] [Module R M] (hv : CompleteLattice.Independent fun i => R ∙ v i)
    (h_ne_zero : ∀ i, Ideal.torsionOf R M (v i) = ⊥) : LinearIndependent R v 
goal: LinearIndependent R v

full_name: Ideal.quotTorsionOfEquivSpanSingleton
code: /-- The span of `x` in `M` is isomorphic to `R` quotiented by the torsion ideal of `x`. -/
noncomputable def quotTorsionOfEquivSpanSingleton (x : M) : (R ⧸ torsionOf R M x) ≃ₗ[R] R ∙ x 
goal: (R ⧸ Ideal.torsionOf R M x) ≃ₗ[R] ↥(Submodule.span R {x})

full_name: Ideal.quotTorsionOfEquivSpanSingleton_apply_mk
code: @[simp]
theorem quotTorsionOfEquivSpanSingleton_apply_mk (x : M) (a : R) :
    quotTorsionOfEquivSpanSingleton R M x (Submodule.Quotient.mk a) =
      a • ⟨x, Submodule.mem_span_singleton_self x⟩ 
goal: (Ideal.quotTorsionOfEquivSpanSingleton R M x) (Submodule.Quotient.mk a) = a • ⟨x, ⋯⟩

full_name: Submodule.torsionBy
code: /-- The `a`-torsion submodule for `a` in `R`, containing all elements `x` of `M` such that
  `a • x = 0`. -/
@[simps!]
def torsionBy (a : R) : Submodule R M 
goal: Submodule R M

full_name: Submodule.torsionBy_carrier
code: /-- The `a`-torsion submodule for `a` in `R`, containing all elements `x` of `M` such that
  `a • x = 0`. -/
@[simps!]
def torsionBy (a : R) : Submodule R M 
goal: ↑(Submodule.torsionBy R M a) = ⇑(DistribMulAction.toLinearMap R M a) ⁻¹' {0}

full_name: Submodule.torsionBySet
code: /-- The submodule containing all elements `x` of `M` such that `a • x = 0` for all `a` in `s`. -/
@[simps!]
def torsionBySet (s : Set R) : Submodule R M 
goal: Submodule R M

full_name: Submodule.torsionBySet_carrier
code: /-- The submodule containing all elements `x` of `M` such that `a • x = 0` for all `a` in `s`. -/
@[simps!]
def torsionBySet (s : Set R) : Submodule R M 
goal: ↑(Submodule.torsionBySet R M s) = ⋂ y ∈ s, ⇑(DistribMulAction.toLinearMap R M y) ⁻¹' {0}

full_name: Submodule.torsion'AddSubMonoid_coe
code: /-- The additive submonoid of all elements `x` of `M` such that `a • x = 0`
for some `a` in `S`. -/
@[simps!]
def torsion'AddSubMonoid (S : Type*) [CommMonoid S] [DistribMulAction S M] :
    AddSubmonoid M 
goal: ↑(Submodule.torsion'AddSubMonoid M S) = {x | ∃ a, a • x = 0}

full_name: Submodule.torsion'AddSubMonoid
code: /-- The additive submonoid of all elements `x` of `M` such that `a • x = 0`
for some `a` in `S`. -/
@[simps!]
def torsion'AddSubMonoid (S : Type*) [CommMonoid S] [DistribMulAction S M] :
    AddSubmonoid M 
goal: AddSubmonoid M

full_name: Submodule.torsion'
code: /-- The `S`-torsion submodule, containing all elements `x` of `M` such that `a • x = 0` for some
`a` in `S`. -/
@[simps!]
def torsion' (S : Type*) [CommMonoid S] [DistribMulAction S M] [SMulCommClass S R M] :
    Submodule R M 
goal: Submodule R M

full_name: Submodule.torsion'_carrier
code: /-- The `S`-torsion submodule, containing all elements `x` of `M` such that `a • x = 0` for some
`a` in `S`. -/
@[simps!]
def torsion' (S : Type*) [CommMonoid S] [DistribMulAction S M] [SMulCommClass S R M] :
    Submodule R M 
goal: ↑(Submodule.torsion' R M S) = {x | ∃ a, a • x = 0}

full_name: Submodule.torsion
code: /-- The torsion submodule, containing all elements `x` of `M` such that `a • x = 0` for some
  non-zero-divisor `a` in `R`. -/
abbrev torsion 
goal: Submodule R M

full_name: Module.IsTorsionBy
code: /-- An `a`-torsion module is a module where every element is `a`-torsion. -/
abbrev IsTorsionBy (a : R) 
goal: Prop

full_name: Module.IsTorsionBySet
code: /-- A module where every element is `a`-torsion for all `a` in `s`. -/
abbrev IsTorsionBySet (s : Set R) 
goal: Prop

full_name: Module.IsTorsion'
code: /-- An `S`-torsion module is a module where every element is `a`-torsion for some `a` in `S`. -/
abbrev IsTorsion' (S : Type*) [SMul S M] 
goal: Prop

full_name: Module.IsTorsion
code: /-- A torsion module is a module where every element is `a`-torsion for some non-zero-divisor `a`.
-/
abbrev IsTorsion 
goal: Prop

full_name: Module.isTorsionBySet_annihilator
code: theorem isTorsionBySet_annihilator : IsTorsionBySet R M (Module.annihilator R M) 
goal: Module.IsTorsionBySet R M ↑(Module.annihilator R M)

full_name: isSMulRegular_iff_torsionBy_eq_bot
code: lemma isSMulRegular_iff_torsionBy_eq_bot {R} (M : Type*)
    [CommRing R] [AddCommGroup M] [Module R M] (r : R) :
    IsSMulRegular M r ↔ Submodule.torsionBy R M r = ⊥ 
goal: IsSMulRegular M r ↔ Submodule.torsionBy R M r = ⊥

full_name: Submodule.smul_torsionBy
code: @[simp]
theorem smul_torsionBy (x : torsionBy R M a) : a • x = 0 
goal: a • x = 0

full_name: Submodule.smul_coe_torsionBy
code: @[simp]
theorem smul_coe_torsionBy (x : torsionBy R M a) : a • (x : M) = 0 
goal: a • ↑x = 0

full_name: Submodule.mem_torsionBy_iff
code: @[simp]
theorem mem_torsionBy_iff (x : M) : x ∈ torsionBy R M a ↔ a • x = 0 
goal: x ∈ Submodule.torsionBy R M a ↔ a • x = 0

full_name: Submodule.mem_torsionBySet_iff
code: @[simp]
theorem mem_torsionBySet_iff (x : M) : x ∈ torsionBySet R M s ↔ ∀ a : s, (a : R) • x = 0 
goal: x ∈ Submodule.torsionBySet R M s ↔ ∀ (a : ↑s), ↑a • x = 0

full_name: Submodule.torsionBySet_singleton_eq
code: @[simp]
theorem torsionBySet_singleton_eq : torsionBySet R M {a} = torsionBy R M a 
goal: Submodule.torsionBySet R M {a} = Submodule.torsionBy R M a

full_name: Submodule.torsionBySet_le_torsionBySet_of_subset
code: theorem torsionBySet_le_torsionBySet_of_subset {s t : Set R} (st : s ⊆ t) :
    torsionBySet R M t ≤ torsionBySet R M s 
goal: Submodule.torsionBySet R M t ≤ Submodule.torsionBySet R M s

full_name: Submodule.torsionBySet_eq_torsionBySet_span
code: /-- Torsion by a set is torsion by the ideal generated by it. -/
theorem torsionBySet_eq_torsionBySet_span :
    torsionBySet R M s = torsionBySet R M (Ideal.span s) 
goal: Submodule.torsionBySet R M s = Submodule.torsionBySet R M ↑(Ideal.span s)

full_name: Submodule.torsionBySet_span_singleton_eq
code: theorem torsionBySet_span_singleton_eq : torsionBySet R M (R ∙ a) = torsionBy R M a 
goal: Submodule.torsionBySet R M ↑(Submodule.span R {a}) = Submodule.torsionBy R M a

full_name: Submodule.torsionBy_le_torsionBy_of_dvd
code: theorem torsionBy_le_torsionBy_of_dvd (a b : R) (dvd : a ∣ b) :
    torsionBy R M a ≤ torsionBy R M b 
goal: Submodule.torsionBy R M a ≤ Submodule.torsionBy R M b

full_name: Submodule.torsionBy_one
code: @[simp]
theorem torsionBy_one : torsionBy R M 1 = ⊥ 
goal: Submodule.torsionBy R M 1 = ⊥

full_name: Submodule.torsionBySet_univ
code: @[simp]
theorem torsionBySet_univ : torsionBySet R M Set.univ = ⊥ 
goal: Submodule.torsionBySet R M Set.univ = ⊥

full_name: Module.isTorsionBySet_singleton_iff
code: @[simp]
theorem isTorsionBySet_singleton_iff : IsTorsionBySet R M {a} ↔ IsTorsionBy R M a 
goal: Module.IsTorsionBySet R M {a} ↔ Module.IsTorsionBy R M a

full_name: Module.isTorsionBySet_iff_torsionBySet_eq_top
code: theorem isTorsionBySet_iff_torsionBySet_eq_top :
    IsTorsionBySet R M s ↔ Submodule.torsionBySet R M s = ⊤ 
goal: Module.IsTorsionBySet R M s ↔ Submodule.torsionBySet R M s = ⊤

full_name: Module.isTorsionBy_iff_torsionBy_eq_top
code: /-- An `a`-torsion module is a module whose `a`-torsion submodule is the full space. -/
theorem isTorsionBy_iff_torsionBy_eq_top : IsTorsionBy R M a ↔ torsionBy R M a = ⊤ 
goal: Module.IsTorsionBy R M a ↔ Submodule.torsionBy R M a = ⊤

full_name: Module.isTorsionBySet_iff_is_torsion_by_span
code: theorem isTorsionBySet_iff_is_torsion_by_span :
    IsTorsionBySet R M s ↔ IsTorsionBySet R M (Ideal.span s) 
goal: Module.IsTorsionBySet R M s ↔ Module.IsTorsionBySet R M ↑(Ideal.span s)

full_name: Module.isTorsionBySet_span_singleton_iff
code: theorem isTorsionBySet_span_singleton_iff : IsTorsionBySet R M (R ∙ a) ↔ IsTorsionBy R M a 
goal: Module.IsTorsionBySet R M ↑(Submodule.span R {a}) ↔ Module.IsTorsionBy R M a

full_name: Module.isTorsionBySet_iff_subseteq_ker_lsmul
code: theorem isTorsionBySet_iff_subseteq_ker_lsmul :
    IsTorsionBySet R M s ↔ s ⊆ LinearMap.ker (LinearMap.lsmul R M) 
goal: Module.IsTorsionBySet R M s ↔ s ⊆ ↑(LinearMap.ker (LinearMap.lsmul R M))

full_name: Module.isTorsionBy_iff_mem_ker_lsmul
code: theorem isTorsionBy_iff_mem_ker_lsmul :
    IsTorsionBy R M a ↔ a ∈ LinearMap.ker (LinearMap.lsmul R M) 
goal: Module.IsTorsionBy R M a ↔ a ∈ LinearMap.ker (LinearMap.lsmul R M)

full_name: Submodule.torsionBySet_isTorsionBySet
code: theorem torsionBySet_isTorsionBySet : IsTorsionBySet R (torsionBySet R M s) s 
goal: Module.IsTorsionBySet R (↥(Submodule.torsionBySet R M s)) s

full_name: Submodule.torsionBy_isTorsionBy
code: /-- The `a`-torsion submodule is an `a`-torsion module. -/
theorem torsionBy_isTorsionBy : IsTorsionBy R (torsionBy R M a) a 
goal: Module.IsTorsionBy R (↥(Submodule.torsionBy R M a)) a

full_name: Submodule.torsionBy_torsionBy_eq_top
code: @[simp]
theorem torsionBy_torsionBy_eq_top : torsionBy R (torsionBy R M a) a = ⊤ 
goal: Submodule.torsionBy R (↥(Submodule.torsionBy R M a)) a = ⊤

full_name: Submodule.torsionBySet_torsionBySet_eq_top
code: @[simp]
theorem torsionBySet_torsionBySet_eq_top : torsionBySet R (torsionBySet R M s) s = ⊤ 
goal: Submodule.torsionBySet R (↥(Submodule.torsionBySet R M s)) s = ⊤

full_name: Submodule.torsion_gc
code: theorem torsion_gc :
    @GaloisConnection (Submodule R M) (Ideal R)ᵒᵈ _ _ annihilator fun I =>
      torsionBySet R M ↑(OrderDual.ofDual I) 
goal: GaloisConnection Submodule.annihilator fun I => Submodule.torsionBySet R M ↑(OrderDual.ofDual I)

full_name: Submodule.iSup_torsionBySet_ideal_eq_torsionBySet_iInf
code: theorem iSup_torsionBySet_ideal_eq_torsionBySet_iInf :
    ⨆ i ∈ S, torsionBySet R M (p i) = torsionBySet R M ↑(⨅ i ∈ S, p i) 
goal: ⨆ i ∈ S, Submodule.torsionBySet R M ↑(p i) = Submodule.torsionBySet R M ↑(⨅ i ∈ S, p i)

full_name: Submodule.supIndep_torsionBySet_ideal
code: theorem supIndep_torsionBySet_ideal : S.SupIndep fun i => torsionBySet R M <| p i 
goal: S.SupIndep fun i => Submodule.torsionBySet R M ↑(p i)

full_name: Submodule.iSup_torsionBy_eq_torsionBy_prod
code: theorem iSup_torsionBy_eq_torsionBy_prod :
    ⨆ i ∈ S, torsionBy R M (q i) = torsionBy R M (∏ i ∈ S, q i) 
goal: ⨆ i ∈ S, Submodule.torsionBy R M (q i) = Submodule.torsionBy R M (∏ i ∈ S, q i)

full_name: Submodule.supIndep_torsionBy
code: theorem supIndep_torsionBy : S.SupIndep fun i => torsionBy R M <| q i 
goal: S.SupIndep fun i => Submodule.torsionBy R M (q i)

full_name: Submodule.torsionBySet_isInternal
code: /-- If the `p i` are pairwise coprime, a `⨅ i, p i`-torsion module is the internal direct sum of
its `p i`-torsion submodules. -/
theorem torsionBySet_isInternal {p : ι → Ideal R}
    (hp : (S : Set ι).Pairwise fun i j => p i ⊔ p j = ⊤)
    (hM : Module.IsTorsionBySet R M (⨅ i ∈ S, p i : Ideal R)) :
    DirectSum.IsInternal fun i : S => torsionBySet R M <| p i 
goal: DirectSum.IsInternal fun i => Submodule.torsionBySet R M ↑(p ↑i)

full_name: Submodule.torsionBy_isInternal
code: /-- If the `q i` are pairwise coprime, a `∏ i, q i`-torsion module is the internal direct sum of
its `q i`-torsion submodules. -/
theorem torsionBy_isInternal {q : ι → R} (hq : (S : Set ι).Pairwise <| (IsCoprime on q))
    (hM : Module.IsTorsionBy R M <| ∏ i ∈ S, q i) :
    DirectSum.IsInternal fun i : S => torsionBy R M <| q i 
goal: DirectSum.IsInternal fun i => Submodule.torsionBy R M (q ↑i)

full_name: Module.IsTorsionBySet.hasSMul
code: /-- can't be an instance because `hM` can't be inferred -/
def IsTorsionBySet.hasSMul (hM : IsTorsionBySet R M I) : SMul (R ⧸ I) M 
goal: SMul (R ⧸ I) M

full_name: Module.IsTorsionBy.hasSMul
code: /-- can't be an instance because `hM` can't be inferred -/
abbrev IsTorsionBy.hasSMul (hM : IsTorsionBy R M r) : SMul (R ⧸ Ideal.span {r}) M 
goal: SMul (R ⧸ Ideal.span {r}) M

full_name: Module.IsTorsionBySet.mk_smul
code: @[simp]
theorem IsTorsionBySet.mk_smul (hM : IsTorsionBySet R M I) (b : R) (x : M) :
    haveI := hM.hasSMul
    Ideal.Quotient.mk I b • x = b • x 
goal: (Ideal.Quotient.mk I) b • x = b • x

full_name: Module.IsTorsionBy.mk_smul
code: @[simp]
theorem IsTorsionBy.mk_smul (hM : IsTorsionBy R M r) (b : R) (x : M) :
    haveI := hM.hasSMul
    Ideal.Quotient.mk (Ideal.span {r}) b • x = b • x 
goal: (Ideal.Quotient.mk (Ideal.span {r})) b • x = b • x

full_name: Module.IsTorsionBySet.module
code: /-- An `(R ⧸ I)`-module is an `R`-module which `IsTorsionBySet R M I`. -/
def IsTorsionBySet.module (hM : IsTorsionBySet R M I) : Module (R ⧸ I) M 
goal: Module (R ⧸ I) M

full_name: Module.IsTorsionBySet.isScalarTower
code: instance IsTorsionBySet.isScalarTower (hM : IsTorsionBySet R M I)
    {S : Type*} [SMul S R] [SMul S M] [IsScalarTower S R M] [IsScalarTower S R R] :
    @IsScalarTower S (R ⧸ I) M _ (IsTorsionBySet.module hM).toSMul _ 
goal: IsScalarTower S (R ⧸ I) M

full_name: Module.IsTorsionBy.module
code: /-- An `(R ⧸ Ideal.span {r})`-module is an `R`-module for which `IsTorsionBy R M r`. -/
abbrev IsTorsionBy.module (hM : IsTorsionBy R M r) : Module (R ⧸ Ideal.span {r}) M 
goal: Module (R ⧸ Ideal.span {r}) M

full_name: Module.quotientAnnihilator
code: /-- Any module is also a module over the quotient of the ring by the annihilator.
Not an instance because it causes synthesis failures / timeouts. -/
def quotientAnnihilator : Module (R ⧸ Module.annihilator R M) M 
goal: Module (R ⧸ Module.annihilator R M) M

full_name: Module.isTorsionBy_quotient_iff
code: theorem isTorsionBy_quotient_iff (N : Submodule R M) (r : R) :
    IsTorsionBy R (M⧸N) r ↔ ∀ x, r • x ∈ N 
goal: Module.IsTorsionBy R (M ⧸ N) r ↔ ∀ (x : M), r • x ∈ N

full_name: Module.IsTorsionBy.quotient
code: theorem IsTorsionBy.quotient (N : Submodule R M) {r : R}
    (h : IsTorsionBy R M r) : IsTorsionBy R (M⧸N) r 
goal: Module.IsTorsionBy R (M ⧸ N) r

full_name: Module.isTorsionBySet_quotient_iff
code: theorem isTorsionBySet_quotient_iff (N : Submodule R M) (s : Set R) :
    IsTorsionBySet R (M⧸N) s ↔ ∀ x, ∀ r ∈ s, r • x ∈ N 
goal: Module.IsTorsionBySet R (M ⧸ N) s ↔ ∀ (x : M), ∀ r ∈ s, r • x ∈ N

full_name: Module.IsTorsionBySet.quotient
code: theorem IsTorsionBySet.quotient (N : Submodule R M) {s}
    (h : IsTorsionBySet R M s) : IsTorsionBySet R (M⧸N) s 
goal: Module.IsTorsionBySet R (M ⧸ N) s

full_name: Module.isTorsionBySet_quotient_set_smul
code: lemma isTorsionBySet_quotient_set_smul :
    IsTorsionBySet R (M⧸s • (⊤ : Submodule R M)) s 
goal: Module.IsTorsionBySet R (M ⧸ s • ⊤) s

full_name: Module.isTorsionBy_quotient_element_smul
code: lemma isTorsionBy_quotient_element_smul :
    IsTorsionBy R (M⧸r • (⊤ : Submodule R M)) r 
goal: Module.IsTorsionBy R (M ⧸ r • ⊤) r

full_name: Module.isTorsionBySet_quotient_ideal_smul
code: lemma isTorsionBySet_quotient_ideal_smul :
    IsTorsionBySet R (M⧸I • (⊤ : Submodule R M)) I 
goal: Module.IsTorsionBySet R (M ⧸ I • ⊤) ↑I

full_name: Module.instQuotientIdealSpanSubmoduleHSMulSetTop
code: instance : Module (R ⧸ Ideal.span s) (M ⧸ s • (⊤ : Submodule R M)) 
goal: Module (R ⧸ Ideal.span s) (M ⧸ s • ⊤)

full_name: Module.instQuotientIdealSubmoduleHSMulTop
code: instance : Module (R ⧸ I) (M ⧸ I • (⊤ : Submodule R M)) 
goal: Module (R ⧸ I) (M ⧸ I • ⊤)

full_name: Module.instQuotientIdealSpanSingletonSetSubmoduleHSMulTop
code: instance : Module (R ⧸ Ideal.span {r}) (M ⧸ r • (⊤ : Submodule R M)) 
goal: Module (R ⧸ Ideal.span {r}) (M ⧸ r • ⊤)

full_name: Module.Quotient.mk_smul_mk
code: lemma Quotient.mk_smul_mk (r : R) (m : M) :
    Ideal.Quotient.mk I r •
      Submodule.Quotient.mk (p := (I • ⊤ : Submodule R M)) m =
      Submodule.Quotient.mk (p := (I • ⊤ : Submodule R M)) (r • m) 
goal: (Ideal.Quotient.mk I) r • Submodule.Quotient.mk m = Submodule.Quotient.mk (r • m)

full_name: Submodule.instModuleQuotientIdealSubtypeMemTorsionBySetCoe
code: instance (I : Ideal R) : Module (R ⧸ I) (torsionBySet R M I) 
goal: Module (R ⧸ I) ↥(Submodule.torsionBySet R M ↑I)

full_name: Submodule.torsionBySet.mk_smul
code: @[simp]
theorem torsionBySet.mk_smul (I : Ideal R) (b : R) (x : torsionBySet R M I) :
    Ideal.Quotient.mk I b • x = b • x 
goal: (Ideal.Quotient.mk I) b • x = b • x

full_name: Submodule.instIsScalarTowerQuotientIdealSubtypeMemTorsionBySetCoe
code: instance (I : Ideal R) {S : Type*} [SMul S R] [SMul S M] [IsScalarTower S R M]
    [IsScalarTower S R R] : IsScalarTower S (R ⧸ I) (torsionBySet R M I) 
goal: IsScalarTower S (R ⧸ I) ↥(Submodule.torsionBySet R M ↑I)

full_name: Submodule.instModuleQuotientTorsionBy
code: /-- The `a`-torsion submodule as an `(R ⧸ R∙a)`-module. -/
instance instModuleQuotientTorsionBy (a : R) : Module (R ⧸ R ∙ a) (torsionBy R M a) 
goal: Module (R ⧸ Submodule.span R {a}) ↥(Submodule.torsionBy R M a)

full_name: Submodule.instModuleQuotientIdealSpanSingletonSetSubtypeMemTorsionBy
code: instance (a : R) : Module (R ⧸ Ideal.span {a}) (torsionBy R M a) 
goal: Module (R ⧸ Ideal.span {a}) ↥(Submodule.torsionBy R M a)

full_name: Submodule.torsionBy.mk_ideal_smul
code: @[simp]
theorem torsionBy.mk_ideal_smul (a b : R) (x : torsionBy R M a) :
    (Ideal.Quotient.mk (Ideal.span {a})) b • x = b • x 
goal: (Ideal.Quotient.mk (Ideal.span {a})) b • x = b • x

full_name: Submodule.torsionBy.mk_smul
code: theorem torsionBy.mk_smul (a b : R) (x : torsionBy R M a) :
    Ideal.Quotient.mk (R ∙ a) b • x = b • x 
goal: (Ideal.Quotient.mk (Submodule.span R {a})) b • x = b • x

full_name: Submodule.instIsScalarTowerQuotientSpanSingletonSetSubtypeMemTorsionBy
code: instance (a : R) {S : Type*} [SMul S R] [SMul S M] [IsScalarTower S R M] [IsScalarTower S R R] :
    IsScalarTower S (R ⧸ R ∙ a) (torsionBy R M a) 
goal: IsScalarTower S (R ⧸ Submodule.span R {a}) ↥(Submodule.torsionBy R M a)

full_name: Submodule.submodule_torsionBy_orderIso
code: /-- Given an `R`-module `M` and an element `a` in `R`, submodules of the `a`-torsion submodule of
`M` do not depend on whether we take scalars to be `R` or `R ⧸ R ∙ a`. -/
def submodule_torsionBy_orderIso (a : R) :
    Submodule (R ⧸ R ∙ a) (torsionBy R M a) ≃o Submodule R (torsionBy R M a) 
goal: Submodule (R ⧸ Submodule.span R {a}) ↥(Submodule.torsionBy R M a) ≃o Submodule R ↥(Submodule.torsionBy R M a)

full_name: Submodule.mem_torsion'_iff
code: @[simp]
theorem mem_torsion'_iff (x : M) : x ∈ torsion' R M S ↔ ∃ a : S, a • x = 0 
goal: x ∈ Submodule.torsion' R M S ↔ ∃ a, a • x = 0

full_name: Submodule.mem_torsion_iff
code: theorem mem_torsion_iff (x : M) : x ∈ torsion R M ↔ ∃ a : R⁰, a • x = 0 
goal: x ∈ Submodule.torsion R M ↔ ∃ a, a • x = 0

full_name: Submodule.instSMulSubtypeMemTorsion'
code: @[simps]
instance : SMul S (torsion' R M S) 
goal: SMul S ↥(Submodule.torsion' R M S)

full_name: Submodule.instSMulSubtypeMemTorsion'_smul_coe
code: @[simps]
instance : SMul S (torsion' R M S) 
goal: ↑(s • x) = s • ↑x

full_name: Submodule.instDistribMulActionSubtypeMemTorsion'
code: instance : DistribMulAction S (torsion' R M S) 
goal: DistribMulAction S ↥(Submodule.torsion' R M S)

full_name: Submodule.instSMulCommClassSubtypeMemTorsion'
code: instance : SMulCommClass S R (torsion' R M S) 
goal: SMulCommClass S R ↥(Submodule.torsion' R M S)

full_name: Submodule.isTorsion'_iff_torsion'_eq_top
code: /-- An `S`-torsion module is a module whose `S`-torsion submodule is the full space. -/
theorem isTorsion'_iff_torsion'_eq_top : IsTorsion' M S ↔ torsion' R M S = ⊤ 
goal: Module.IsTorsion' M S ↔ Submodule.torsion' R M S = ⊤

full_name: Submodule.torsion'_isTorsion'
code: /-- The `S`-torsion submodule is an `S`-torsion module. -/
theorem torsion'_isTorsion' : IsTorsion' (torsion' R M S) S 
goal: Module.IsTorsion' (↥(Submodule.torsion' R M S)) S

full_name: Submodule.torsion'_torsion'_eq_top
code: @[simp]
theorem torsion'_torsion'_eq_top : torsion' R (torsion' R M S) S = ⊤ 
goal: Submodule.torsion' R (↥(Submodule.torsion' R M S)) S = ⊤

full_name: Submodule.torsion_torsion_eq_top
code: /-- The torsion submodule of the torsion submodule (viewed as a module) is the full
torsion module. -/
-- @[simp] Porting note (#10618): simp can prove this
theorem torsion_torsion_eq_top : torsion R (torsion R M) = ⊤ 
goal: Submodule.torsion R ↥(Submodule.torsion R M) = ⊤

full_name: Submodule.torsion_isTorsion
code: /-- The torsion submodule is always a torsion module. -/
theorem torsion_isTorsion : Module.IsTorsion R (torsion R M) 
goal: Module.IsTorsion R ↥(Submodule.torsion R M)

full_name: Module.isTorsionBySet_annihilator_top
code: theorem _root_.Module.isTorsionBySet_annihilator_top :
    Module.IsTorsionBySet R M (⊤ : Submodule R M).annihilator 
goal: Module.IsTorsionBySet R M ↑⊤.annihilator

full_name: Submodule.annihilator_top_inter_nonZeroDivisors
code: theorem _root_.Submodule.annihilator_top_inter_nonZeroDivisors [Module.Finite R M]
    (hM : Module.IsTorsion R M) : ((⊤ : Submodule R M).annihilator : Set R) ∩ R⁰ ≠ ∅ 
goal: ↑⊤.annihilator ∩ ↑R⁰ ≠ ∅

full_name: Submodule.coe_torsion_eq_annihilator_ne_bot
code: theorem coe_torsion_eq_annihilator_ne_bot :
    (torsion R M : Set M) = { x : M | (R ∙ x).annihilator ≠ ⊥ } 
goal: ↑(Submodule.torsion R M) = {x | (Submodule.span R {x}).annihilator ≠ ⊥}

full_name: Submodule.noZeroSMulDivisors_iff_torsion_eq_bot
code: /-- A module over a domain has `NoZeroSMulDivisors` iff its torsion submodule is trivial. -/
theorem noZeroSMulDivisors_iff_torsion_eq_bot : NoZeroSMulDivisors R M ↔ torsion R M = ⊥ 
goal: NoZeroSMulDivisors R M ↔ Submodule.torsion R M = ⊥

full_name: Submodule.torsion_int
code: lemma torsion_int {G} [AddCommGroup G] :
    (torsion ℤ G).toAddSubgroup = AddCommGroup.torsion G 
goal: (Submodule.torsion ℤ G).toAddSubgroup = AddCommGroup.torsion G

full_name: Submodule.QuotientTorsion.torsion_eq_bot
code: /-- Quotienting by the torsion submodule gives a torsion-free module. -/
@[simp]
theorem torsion_eq_bot : torsion R (M ⧸ torsion R M) = ⊥ 
goal: Submodule.torsion R (M ⧸ Submodule.torsion R M) = ⊥

full_name: Submodule.QuotientTorsion.noZeroSMulDivisors
code: instance noZeroSMulDivisors [IsDomain R] : NoZeroSMulDivisors R (M ⧸ torsion R M) 
goal: NoZeroSMulDivisors R (M ⧸ Submodule.torsion R M)

full_name: Submodule.isTorsion'_powers_iff
code: theorem isTorsion'_powers_iff (p : R) :
    IsTorsion' M (Submonoid.powers p) ↔ ∀ x : M, ∃ n : ℕ, p ^ n • x = 0 
goal: Module.IsTorsion' M ↥(Submonoid.powers p) ↔ ∀ (x : M), ∃ n, p ^ n • x = 0

full_name: Submodule.pOrder
code: /-- In a `p ^ ∞`-torsion module (that is, a module where all elements are cancelled by scalar
multiplication by some power of `p`), the smallest `n` such that `p ^ n • x = 0`. -/
def pOrder {p : R} (hM : IsTorsion' M <| Submonoid.powers p) (x : M)
    [∀ n : ℕ, Decidable (p ^ n • x = 0)] 
goal: ℕ

full_name: Submodule.pow_pOrder_smul
code: @[simp]
theorem pow_pOrder_smul {p : R} (hM : IsTorsion' M <| Submonoid.powers p) (x : M)
    [∀ n : ℕ, Decidable (p ^ n • x = 0)] : p ^ pOrder hM x • x = 0 
goal: p ^ Submodule.pOrder hM x • x = 0

full_name: Submodule.exists_isTorsionBy
code: theorem exists_isTorsionBy {p : R} (hM : IsTorsion' M <| Submonoid.powers p) (d : ℕ) (hd : d ≠ 0)
    (s : Fin d → M) (hs : span R (Set.range s) = ⊤) :
    ∃ j : Fin d, Module.IsTorsionBy R M (p ^ pOrder hM (s j)) 
goal: ∃ j, Module.IsTorsionBy R M (p ^ Submodule.pOrder hM (s j))

full_name: Ideal.Quotient.torsionBy_eq_span_singleton
code: theorem torsionBy_eq_span_singleton {R : Type w} [CommRing R] (a b : R) (ha : a ∈ R⁰) :
    torsionBy R (R ⧸ R ∙ a * b) a = R ∙ mk (R ∙ a * b) b 
goal: Submodule.torsionBy R (R ⧸ Submodule.span R {a * b}) a =
  Submodule.span R {(Ideal.Quotient.mk (Submodule.span R {a * b})) b}

full_name: AddMonoid.isTorsion_iff_isTorsion_nat
code: theorem isTorsion_iff_isTorsion_nat [AddCommMonoid M] :
    AddMonoid.IsTorsion M ↔ Module.IsTorsion ℕ M 
goal: AddMonoid.IsTorsion M ↔ Module.IsTorsion ℕ M

full_name: AddMonoid.isTorsion_iff_isTorsion_int
code: theorem isTorsion_iff_isTorsion_int [AddCommGroup M] :
    AddMonoid.IsTorsion M ↔ Module.IsTorsion ℤ M 
goal: AddMonoid.IsTorsion M ↔ Module.IsTorsion ℤ M