File: Mathlib/Algebra/Module/Submodule/Lattice.lean

full_name: Submodule.instBot
code: /-- The set `{0}` is the bottom element of the lattice of submodules. -/
instance : Bot (Submodule R M) 
goal: Bot (Submodule R M)

full_name: Submodule.inhabited'
code: instance inhabited' : Inhabited (Submodule R M) 
goal: Inhabited (Submodule R M)

full_name: Submodule.bot_coe
code: @[simp]
theorem bot_coe : ((⊥ : Submodule R M) : Set M) = {0} 
goal: ↑⊥ = {0}

full_name: Submodule.bot_toAddSubmonoid
code: @[simp]
theorem bot_toAddSubmonoid : (⊥ : Submodule R M).toAddSubmonoid = ⊥ 
goal: ⊥.toAddSubmonoid = ⊥

full_name: Submodule.bot_toAddSubgroup
code: @[simp]
lemma bot_toAddSubgroup {R M} [Ring R] [AddCommGroup M] [Module R M] :
    (⊥ : Submodule R M).toAddSubgroup = ⊥ 
goal: ⊥.toAddSubgroup = ⊥

full_name: Submodule.mem_bot
code: @[simp]
theorem mem_bot {x : M} : x ∈ (⊥ : Submodule R M) ↔ x = 0 
goal: x ∈ ⊥ ↔ x = 0

full_name: Submodule.uniqueBot
code: instance uniqueBot : Unique (⊥ : Submodule R M) 
goal: Unique ↥⊥

full_name: Submodule.instOrderBot
code: instance : OrderBot (Submodule R M) 
goal: OrderBot (Submodule R M)

full_name: Submodule.eq_bot_iff
code: protected theorem eq_bot_iff (p : Submodule R M) : p = ⊥ ↔ ∀ x ∈ p, x = (0 : M) 
goal: p = ⊥ ↔ ∀ x ∈ p, x = 0

full_name: Submodule.bot_ext
code: @[ext high]
protected theorem bot_ext (x y : (⊥ : Submodule R M)) : x = y 
goal: x = y

full_name: Submodule.ne_bot_iff
code: protected theorem ne_bot_iff (p : Submodule R M) : p ≠ ⊥ ↔ ∃ x ∈ p, x ≠ (0 : M) 
goal: p ≠ ⊥ ↔ ∃ x ∈ p, x ≠ 0

full_name: Submodule.nonzero_mem_of_bot_lt
code: theorem nonzero_mem_of_bot_lt {p : Submodule R M} (bot_lt : ⊥ < p) : ∃ a : p, a ≠ 0 
goal: ∃ a, a ≠ 0

full_name: Submodule.exists_mem_ne_zero_of_ne_bot
code: theorem exists_mem_ne_zero_of_ne_bot {p : Submodule R M} (h : p ≠ ⊥) : ∃ b : M, b ∈ p ∧ b ≠ 0 
goal: ∃ b ∈ p, b ≠ 0

full_name: Submodule.botEquivPUnit_apply
code: /-- The bottom submodule is linearly equivalent to punit as an `R`-module. -/
@[simps]
def botEquivPUnit : (⊥ : Submodule R M) ≃ₗ[R] PUnit.{v+1} 
goal: ∀ (x : ↥⊥), Submodule.botEquivPUnit x = PUnit.unit

full_name: Submodule.botEquivPUnit_symm_apply
code: /-- The bottom submodule is linearly equivalent to punit as an `R`-module. -/
@[simps]
def botEquivPUnit : (⊥ : Submodule R M) ≃ₗ[R] PUnit.{v+1} 
goal: ∀ (x : PUnit.{v + 1}), Submodule.botEquivPUnit.symm x = 0

full_name: Submodule.botEquivPUnit
code: /-- The bottom submodule is linearly equivalent to punit as an `R`-module. -/
@[simps]
def botEquivPUnit : (⊥ : Submodule R M) ≃ₗ[R] PUnit.{v+1} 
goal: ↥⊥ ≃ₗ[R] PUnit.{v + 1}

full_name: Submodule.subsingleton_iff_eq_bot
code: theorem subsingleton_iff_eq_bot : Subsingleton p ↔ p = ⊥ 
goal: Subsingleton ↥p ↔ p = ⊥

full_name: Submodule.eq_bot_of_subsingleton
code: theorem eq_bot_of_subsingleton [Subsingleton p] : p = ⊥ 
goal: p = ⊥

full_name: Submodule.nontrivial_iff_ne_bot
code: theorem nontrivial_iff_ne_bot : Nontrivial p ↔ p ≠ ⊥ 
goal: Nontrivial ↥p ↔ p ≠ ⊥

full_name: Submodule.instTop
code: /-- The universal set is the top element of the lattice of submodules. -/
instance : Top (Submodule R M) 
goal: Top (Submodule R M)

full_name: Submodule.top_coe
code: @[simp]
theorem top_coe : ((⊤ : Submodule R M) : Set M) = Set.univ 
goal: ↑⊤ = Set.univ

full_name: Submodule.top_toAddSubmonoid
code: @[simp]
theorem top_toAddSubmonoid : (⊤ : Submodule R M).toAddSubmonoid = ⊤ 
goal: ⊤.toAddSubmonoid = ⊤

full_name: Submodule.top_toAddSubgroup
code: @[simp]
lemma top_toAddSubgroup {R M} [Ring R] [AddCommGroup M] [Module R M] :
    (⊤ : Submodule R M).toAddSubgroup = ⊤ 
goal: ⊤.toAddSubgroup = ⊤

full_name: Submodule.mem_top
code: @[simp]
theorem mem_top {x : M} : x ∈ (⊤ : Submodule R M) 
goal: x ∈ ⊤

full_name: Submodule.instOrderTop
code: instance : OrderTop (Submodule R M) 
goal: OrderTop (Submodule R M)

full_name: Submodule.eq_top_iff'
code: theorem eq_top_iff' {p : Submodule R M} : p = ⊤ ↔ ∀ x, x ∈ p 
goal: p = ⊤ ↔ ∀ (x : M), x ∈ p

full_name: Submodule.topEquiv
code: /-- The top submodule is linearly equivalent to the module.

This is the module version of `AddSubmonoid.topEquiv`. -/
@[simps]
def topEquiv : (⊤ : Submodule R M) ≃ₗ[R] M 
goal: ↥⊤ ≃ₗ[R] M

full_name: Submodule.topEquiv_symm_apply_coe
code: /-- The top submodule is linearly equivalent to the module.

This is the module version of `AddSubmonoid.topEquiv`. -/
@[simps]
def topEquiv : (⊤ : Submodule R M) ≃ₗ[R] M 
goal: ↑(Submodule.topEquiv.symm x) = x

full_name: Submodule.topEquiv_apply
code: /-- The top submodule is linearly equivalent to the module.

This is the module version of `AddSubmonoid.topEquiv`. -/
@[simps]
def topEquiv : (⊤ : Submodule R M) ≃ₗ[R] M 
goal: Submodule.topEquiv x = ↑x

full_name: Submodule.instInfSet
code: instance : InfSet (Submodule R M) 
goal: InfSet (Submodule R M)

full_name: _private.Mathlib.Algebra.Module.Submodule.Lattice.0.Submodule.sInf_le'
code: private theorem sInf_le' {S : Set (Submodule R M)} {p} : p ∈ S → sInf S ≤ p 
goal: p ∈ S → sInf S ≤ p

full_name: _private.Mathlib.Algebra.Module.Submodule.Lattice.0.Submodule.le_sInf'
code: private theorem le_sInf' {S : Set (Submodule R M)} {p} : (∀ q ∈ S, p ≤ q) → p ≤ sInf S 
goal: (∀ q ∈ S, p ≤ q) → p ≤ sInf S

full_name: Submodule.instInf
code: instance : Inf (Submodule R M) 
goal: Inf (Submodule R M)

full_name: Submodule.completeLattice
code: instance completeLattice : CompleteLattice (Submodule R M) 
goal: CompleteLattice (Submodule R M)

full_name: Submodule.inf_coe
code: @[simp]
theorem inf_coe : ↑(p ⊓ q) = (p ∩ q : Set M) 
goal: ↑(p ⊓ q) = ↑p ∩ ↑q

full_name: Submodule.mem_inf
code: @[simp]
theorem mem_inf {p q : Submodule R M} {x : M} : x ∈ p ⊓ q ↔ x ∈ p ∧ x ∈ q 
goal: x ∈ p ⊓ q ↔ x ∈ p ∧ x ∈ q

full_name: Submodule.sInf_coe
code: @[simp]
theorem sInf_coe (P : Set (Submodule R M)) : (↑(sInf P) : Set M) = ⋂ p ∈ P, ↑p 
goal: ↑(sInf P) = ⋂ p ∈ P, ↑p

full_name: Submodule.finset_inf_coe
code: @[simp]
theorem finset_inf_coe {ι} (s : Finset ι) (p : ι → Submodule R M) :
    (↑(s.inf p) : Set M) = ⋂ i ∈ s, ↑(p i) 
goal: ↑(s.inf p) = ⋂ i ∈ s, ↑(p i)

full_name: Submodule.iInf_coe
code: @[simp]
theorem iInf_coe {ι} (p : ι → Submodule R M) : (↑(⨅ i, p i) : Set M) = ⋂ i, ↑(p i) 
goal: ↑(⨅ i, p i) = ⋂ i, ↑(p i)

full_name: Submodule.mem_sInf
code: @[simp]
theorem mem_sInf {S : Set (Submodule R M)} {x : M} : x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p 
goal: x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p

full_name: Submodule.mem_iInf
code: @[simp]
theorem mem_iInf {ι} (p : ι → Submodule R M) {x} : (x ∈ ⨅ i, p i) ↔ ∀ i, x ∈ p i 
goal: x ∈ ⨅ i, p i ↔ ∀ (i : ι), x ∈ p i

full_name: Submodule.mem_finset_inf
code: @[simp]
theorem mem_finset_inf {ι} {s : Finset ι} {p : ι → Submodule R M} {x : M} :
    x ∈ s.inf p ↔ ∀ i ∈ s, x ∈ p i 
goal: x ∈ s.inf p ↔ ∀ i ∈ s, x ∈ p i

full_name: Submodule.mem_sup_left
code: theorem mem_sup_left {S T : Submodule R M} : ∀ {x : M}, x ∈ S → x ∈ S ⊔ T 
goal: x ∈ S → x ∈ S ⊔ T

full_name: Submodule.mem_sup_right
code: theorem mem_sup_right {S T : Submodule R M} : ∀ {x : M}, x ∈ T → x ∈ S ⊔ T 
goal: x ∈ T → x ∈ S ⊔ T

full_name: Submodule.add_mem_sup
code: theorem add_mem_sup {S T : Submodule R M} {s t : M} (hs : s ∈ S) (ht : t ∈ T) : s + t ∈ S ⊔ T 
goal: s + t ∈ S ⊔ T

full_name: Submodule.sub_mem_sup
code: theorem sub_mem_sup {R' M' : Type*} [Ring R'] [AddCommGroup M'] [Module R' M']
    {S T : Submodule R' M'} {s t : M'} (hs : s ∈ S) (ht : t ∈ T) : s - t ∈ S ⊔ T 
goal: s - t ∈ S ⊔ T

full_name: Submodule.mem_iSup_of_mem
code: theorem mem_iSup_of_mem {ι : Sort*} {b : M} {p : ι → Submodule R M} (i : ι) (h : b ∈ p i) :
    b ∈ ⨆ i, p i 
goal: b ∈ ⨆ i, p i

full_name: Submodule.sum_mem_iSup
code: theorem sum_mem_iSup {ι : Type*} [Fintype ι] {f : ι → M} {p : ι → Submodule R M}
    (h : ∀ i, f i ∈ p i) : (∑ i, f i) ∈ ⨆ i, p i 
goal: ∑ i : ι, f i ∈ ⨆ i, p i

full_name: Submodule.sum_mem_biSup
code: theorem sum_mem_biSup {ι : Type*} {s : Finset ι} {f : ι → M} {p : ι → Submodule R M}
    (h : ∀ i ∈ s, f i ∈ p i) : (∑ i ∈ s, f i) ∈ ⨆ i ∈ s, p i 
goal: ∑ i ∈ s, f i ∈ ⨆ i ∈ s, p i

full_name: Submodule.mem_sSup_of_mem
code: theorem mem_sSup_of_mem {S : Set (Submodule R M)} {s : Submodule R M} (hs : s ∈ S) :
    ∀ {x : M}, x ∈ s → x ∈ sSup S 
goal: x ∈ s → x ∈ sSup S

full_name: Submodule.toAddSubmonoid_sSup
code: @[simp]
theorem toAddSubmonoid_sSup (s : Set (Submodule R M)) :
    (sSup s).toAddSubmonoid = sSup (toAddSubmonoid '' s) 
goal: (sSup s).toAddSubmonoid = sSup (Submodule.toAddSubmonoid '' s)

full_name: Submodule.subsingleton_iff
code: @[simp]
theorem subsingleton_iff : Subsingleton (Submodule R M) ↔ Subsingleton M 
goal: Subsingleton (Submodule R M) ↔ Subsingleton M

full_name: Submodule.nontrivial_iff
code: @[simp]
theorem nontrivial_iff : Nontrivial (Submodule R M) ↔ Nontrivial M 
goal: Nontrivial (Submodule R M) ↔ Nontrivial M

full_name: Submodule.instUniqueOfSubsingleton
code: instance [Subsingleton M] : Unique (Submodule R M) 
goal: Unique (Submodule R M)

full_name: Submodule.unique'
code: instance unique' [Subsingleton R] : Unique (Submodule R M) 
goal: Unique (Submodule R M)

full_name: Submodule.instNontrivial
code: instance [Nontrivial M] : Nontrivial (Submodule R M) 
goal: Nontrivial (Submodule R M)

full_name: Submodule.disjoint_def
code: theorem disjoint_def {p p' : Submodule R M} : Disjoint p p' ↔ ∀ x ∈ p, x ∈ p' → x = (0 : M) 
goal: Disjoint p p' ↔ ∀ x ∈ p, x ∈ p' → x = 0

full_name: Submodule.disjoint_def'
code: theorem disjoint_def' {p p' : Submodule R M} :
    Disjoint p p' ↔ ∀ x ∈ p, ∀ y ∈ p', x = y → x = (0 : M) 
goal: Disjoint p p' ↔ ∀ x ∈ p, ∀ y ∈ p', x = y → x = 0

full_name: Submodule.eq_zero_of_coe_mem_of_disjoint
code: theorem eq_zero_of_coe_mem_of_disjoint (hpq : Disjoint p q) {a : p} (ha : (a : M) ∈ q) : a = 0 
goal: a = 0

full_name: Submodule.mem_right_iff_eq_zero_of_disjoint
code: theorem mem_right_iff_eq_zero_of_disjoint {p p' : Submodule R M} (h : Disjoint p p') {x : p} :
    (x : M) ∈ p' ↔ x = 0 
goal: ↑x ∈ p' ↔ x = 0

full_name: Submodule.mem_left_iff_eq_zero_of_disjoint
code: theorem mem_left_iff_eq_zero_of_disjoint {p p' : Submodule R M} (h : Disjoint p p') {x : p'} :
    (x : M) ∈ p ↔ x = 0 
goal: ↑x ∈ p ↔ x = 0

full_name: AddSubmonoid.toNatSubmodule
code: /-- An additive submonoid is equivalent to a ℕ-submodule. -/
def AddSubmonoid.toNatSubmodule : AddSubmonoid M ≃o Submodule ℕ M 
goal: AddSubmonoid M ≃o Submodule ℕ M

full_name: AddSubmonoid.toNatSubmodule_symm
code: @[simp]
theorem AddSubmonoid.toNatSubmodule_symm :
    ⇑(AddSubmonoid.toNatSubmodule.symm : _ ≃o AddSubmonoid M) = Submodule.toAddSubmonoid 
goal: ⇑AddSubmonoid.toNatSubmodule.symm = Submodule.toAddSubmonoid

full_name: AddSubmonoid.coe_toNatSubmodule
code: @[simp]
theorem AddSubmonoid.coe_toNatSubmodule (S : AddSubmonoid M) :
    (AddSubmonoid.toNatSubmodule S : Set M) = S 
goal: ↑(AddSubmonoid.toNatSubmodule S) = ↑S

full_name: AddSubmonoid.toNatSubmodule_toAddSubmonoid
code: @[simp]
theorem AddSubmonoid.toNatSubmodule_toAddSubmonoid (S : AddSubmonoid M) :
    S.toNatSubmodule.toAddSubmonoid = S 
goal: (AddSubmonoid.toNatSubmodule S).toAddSubmonoid = S

full_name: Submodule.toAddSubmonoid_toNatSubmodule
code: @[simp]
theorem Submodule.toAddSubmonoid_toNatSubmodule (S : Submodule ℕ M) :
    AddSubmonoid.toNatSubmodule S.toAddSubmonoid = S 
goal: AddSubmonoid.toNatSubmodule S.toAddSubmonoid = S

full_name: AddSubgroup.toIntSubmodule
code: /-- An additive subgroup is equivalent to a ℤ-submodule. -/
def AddSubgroup.toIntSubmodule : AddSubgroup M ≃o Submodule ℤ M 
goal: AddSubgroup M ≃o Submodule ℤ M

full_name: AddSubgroup.toIntSubmodule_symm
code: @[simp]
theorem AddSubgroup.toIntSubmodule_symm :
    ⇑(AddSubgroup.toIntSubmodule.symm : _ ≃o AddSubgroup M) = Submodule.toAddSubgroup 
goal: ⇑AddSubgroup.toIntSubmodule.symm = Submodule.toAddSubgroup

full_name: AddSubgroup.coe_toIntSubmodule
code: @[simp]
theorem AddSubgroup.coe_toIntSubmodule (S : AddSubgroup M) :
    (AddSubgroup.toIntSubmodule S : Set M) = S 
goal: ↑(AddSubgroup.toIntSubmodule S) = ↑S

full_name: AddSubgroup.toIntSubmodule_toAddSubgroup
code: @[simp]
theorem AddSubgroup.toIntSubmodule_toAddSubgroup (S : AddSubgroup M) :
    S.toIntSubmodule.toAddSubgroup = S 
goal: (AddSubgroup.toIntSubmodule S).toAddSubgroup = S

full_name: Submodule.toAddSubgroup_toIntSubmodule
code: @[simp]
theorem Submodule.toAddSubgroup_toIntSubmodule (S : Submodule ℤ M) :
    AddSubgroup.toIntSubmodule S.toAddSubgroup = S 
goal: AddSubgroup.toIntSubmodule S.toAddSubgroup = S