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

full_name: Submodule.localized'
code: /-- Let `S` be the localization of `R` at `p` and `N` be the localization of `M` at `p`.
This is the localization of an `R`-submodule of `M` viewed as an `S`-submodule of `N`. -/
def Submodule.localized' : Submodule S N 
goal: Submodule S N

full_name: Submodule.mem_localized'
code: lemma Submodule.mem_localized' (x : N) :
    x ∈ Submodule.localized' S p f M' ↔ ∃ m ∈ M', ∃ s : p, IsLocalizedModule.mk' f m s = x 
goal: x ∈ Submodule.localized' S p f M' ↔ ∃ m ∈ M', ∃ s, IsLocalizedModule.mk' f m s = x

full_name: Submodule.localized
code: /-- The localization of an `R`-submodule of `M` at `p` viewed as an `Rₚ`-submodule of `Mₚ`. -/
abbrev Submodule.localized : Submodule (Localization p) (LocalizedModule p M) 
goal: Submodule (Localization p) (LocalizedModule p M)

full_name: Submodule.toLocalized'
code: /-- The localization map of a submodule. -/
@[simps!]
def Submodule.toLocalized' : M' →ₗ[R] M'.localized' S p f 
goal: ↥M' →ₗ[R] ↥(Submodule.localized' S p f M')

full_name: Submodule.toLocalized'_apply_coe
code: /-- The localization map of a submodule. -/
@[simps!]
def Submodule.toLocalized' : M' →ₗ[R] M'.localized' S p f 
goal: ↑((Submodule.toLocalized' S p f M') c) = f ↑c

full_name: Submodule.toLocalized
code: /-- The localization map of a submodule. -/
abbrev Submodule.toLocalized : M' →ₗ[R] M'.localized p 
goal: ↥M' →ₗ[R] ↥(Submodule.localized p M')

full_name: Submodule.isLocalizedModule
code: instance Submodule.isLocalizedModule : IsLocalizedModule p (M'.toLocalized' S p f) 
goal: IsLocalizedModule p (Submodule.toLocalized' S p f M')

full_name: Submodule.toLocalizedQuotient'
code: /-- The localization map of a quotient module. -/
def Submodule.toLocalizedQuotient' : M ⧸ M' →ₗ[R] N ⧸ M'.localized' S p f 
goal: M ⧸ M' →ₗ[R] N ⧸ Submodule.localized' S p f M'

full_name: Submodule.toLocalizedQuotient
code: /-- The localization map of a quotient module. -/
abbrev Submodule.toLocalizedQuotient : M ⧸ M' →ₗ[R] LocalizedModule p M ⧸ M'.localized p 
goal: M ⧸ M' →ₗ[R] LocalizedModule p M ⧸ Submodule.localized p M'

full_name: Submodule.toLocalizedQuotient'_mk
code: @[simp]
lemma Submodule.toLocalizedQuotient'_mk (x : M) :
    M'.toLocalizedQuotient' S p f (Submodule.Quotient.mk x) = Submodule.Quotient.mk (f x) 
goal: (Submodule.toLocalizedQuotient' S p f M') (Submodule.Quotient.mk x) = Submodule.Quotient.mk (f x)

full_name: IsLocalizedModule.toLocalizedQuotient'
code: instance IsLocalizedModule.toLocalizedQuotient' (M' : Submodule R M) :
    IsLocalizedModule p (M'.toLocalizedQuotient' S p f) 
goal: IsLocalizedModule p (Submodule.toLocalizedQuotient' S p f M')

full_name: instIsLocalizedModuleQuotientSubmoduleLocalizedModuleLocalizationLocalizedToLocalizedQuotient
code: instance (M' : Submodule R M) : IsLocalizedModule p (M'.toLocalizedQuotient p) 
goal: IsLocalizedModule p (Submodule.toLocalizedQuotient p M')

full_name: LinearMap.localized'_ker_eq_ker_localizedMap
code: lemma LinearMap.localized'_ker_eq_ker_localizedMap (g : M →ₗ[R] P) :
    Submodule.localized' S p f (LinearMap.ker g) =
      LinearMap.ker ((IsLocalizedModule.map p f f' g).extendScalarsOfIsLocalization p S) 
goal: Submodule.localized' S p f (LinearMap.ker g) =
  LinearMap.ker (LinearMap.extendScalarsOfIsLocalization p S ((IsLocalizedModule.map p f f') g))

full_name: LinearMap.ker_localizedMap_eq_localized'_ker
code: lemma LinearMap.ker_localizedMap_eq_localized'_ker (g : M →ₗ[R] P) :
    LinearMap.ker (IsLocalizedModule.map p f f' g) =
      ((LinearMap.ker g).localized' S p f).restrictScalars _ 
goal: LinearMap.ker ((IsLocalizedModule.map p f f') g) =
  Submodule.restrictScalars R (Submodule.localized' S p f (LinearMap.ker g))

full_name: LinearMap.toKerIsLocalized_apply_coe
code: /--
The canonical map from the kernel of `g` to the kernel of `g` localized at a submonoid.

This is a localization map by `LinearMap.toKerLocalized_isLocalizedModule`.
-/
@[simps!]
noncomputable def LinearMap.toKerIsLocalized (g : M →ₗ[R] P) :
    ker g →ₗ[R] ker (IsLocalizedModule.map p f f' g) 
goal: ↑((LinearMap.toKerIsLocalized p f f' g) c) = f ↑c

full_name: LinearMap.toKerIsLocalized
code: /--
The canonical map from the kernel of `g` to the kernel of `g` localized at a submonoid.

This is a localization map by `LinearMap.toKerLocalized_isLocalizedModule`.
-/
@[simps!]
noncomputable def LinearMap.toKerIsLocalized (g : M →ₗ[R] P) :
    ker g →ₗ[R] ker (IsLocalizedModule.map p f f' g) 
goal: ↥(LinearMap.ker g) →ₗ[R] ↥(LinearMap.ker ((IsLocalizedModule.map p f f') g))

full_name: LinearMap.toKerLocalized_isLocalizedModule
code: /-- The canonical map to the kernel of the localization of `g` is localizing.
In other words, localization commutes with kernels. -/
lemma LinearMap.toKerLocalized_isLocalizedModule (g : M →ₗ[R] P) :
    IsLocalizedModule p (toKerIsLocalized p f f' g) 
goal: IsLocalizedModule p (LinearMap.toKerIsLocalized p f f' g)