File: Mathlib/RingTheory/Localization/Algebra.lean

full_name: Algebra.idealMap_isLocalizedModule
code: /-- The span of `I` in a localization of `R` at `M` is the localization of `I` at `M`. -/
instance Algebra.idealMap_isLocalizedModule (I : Ideal R) :
    IsLocalizedModule M (Algebra.idealMap I (S := S)) 
goal: IsLocalizedModule M (Algebra.idealMap S I)

full_name: IsLocalization.ker_map
code: lemma IsLocalization.ker_map (hT : Submonoid.map g M = T) :
    RingHom.ker (IsLocalization.map Q g (hT.symm ▸ M.le_comap_map) : S →+* Q) =
      (RingHom.ker g).map (algebraMap R S) 
goal: RingHom.ker (IsLocalization.map Q g ⋯) = Ideal.map (algebraMap R S) (RingHom.ker g)

full_name: RingHom.toKerIsLocalization
code: /-- The canonical linear map from the kernel of `g` to the kernel of its localization. -/
def RingHom.toKerIsLocalization (hy : M ≤ Submonoid.comap g T) :
    RingHom.ker g →ₗ[R] RingHom.ker (IsLocalization.map Q g hy : S →+* Q) 
goal: ↥(RingHom.ker g) →ₗ[R] ↥(RingHom.ker (IsLocalization.map Q g hy))

full_name: RingHom.toKerIsLocalization_apply
code: @[simp]
lemma RingHom.toKerIsLocalization_apply (hy : M ≤ Submonoid.comap g T) (r : RingHom.ker g) :
    (RingHom.toKerIsLocalization S Q g hy r).val = algebraMap R S r 
goal: ↑((RingHom.toKerIsLocalization S Q g hy) r) = (algebraMap R S) ↑r

full_name: RingHom.toKerIsLocalization_isLocalizedModule
code: /-- The canonical linear map from the kernel of `g` to the kernel of its localization
is localizing. In other words, localization commutes with taking kernels. -/
lemma RingHom.toKerIsLocalization_isLocalizedModule (hT : Submonoid.map g M = T) :
    IsLocalizedModule M (toKerIsLocalization S Q g (hT.symm ▸ Submonoid.le_comap_map M)) 
goal: IsLocalizedModule M (RingHom.toKerIsLocalization S Q g ⋯)

full_name: IsLocalization.isLocalization_algebraMapSubmonoid_map_algHom
code: instance isLocalization_algebraMapSubmonoid_map_algHom (f : A →ₐ[R] B) :
    IsLocalization ((algebraMapSubmonoid A M).map f.toRingHom) Bₚ 
goal: IsLocalization (Submonoid.map f.toRingHom (Algebra.algebraMapSubmonoid A M)) Bₚ

full_name: IsLocalization.mapₐ
code: /-- An algebra map `A →ₐ[R] B` induces an algebra map on localizations `Aₚ →ₐ[Rₚ] Bₚ`. -/
noncomputable def mapₐ (f : A →ₐ[R] B) : Aₚ →ₐ[Rₚ] Bₚ 
goal: Aₚ →ₐ[Rₚ] Bₚ

full_name: IsLocalization.mapₐ_coe
code: @[simp]
lemma mapₐ_coe (f : A →ₐ[R] B) :
    (mapₐ M Rₚ Aₚ Bₚ f : Aₚ → Bₚ) = map Bₚ f.toRingHom (algebraMapSubmonoid_le_comap M f)  
goal: ⇑(IsLocalization.mapₐ M Rₚ Aₚ Bₚ f) = ⇑(IsLocalization.map Bₚ f.toRingHom ⋯)

full_name: IsLocalization.mapₐ_injective_of_injective
code: lemma mapₐ_injective_of_injective (f : A →ₐ[R] B) (hf : Function.Injective f) :
    Function.Injective (mapₐ M Rₚ Aₚ Bₚ f) 
goal: Function.Injective ⇑(IsLocalization.mapₐ M Rₚ Aₚ Bₚ f)

full_name: IsLocalization.mapₐ_surjective_of_surjective
code: lemma mapₐ_surjective_of_surjective (f : A →ₐ[R] B) (hf : Function.Surjective f) :
    Function.Surjective (mapₐ M Rₚ Aₚ Bₚ f) 
goal: Function.Surjective ⇑(IsLocalization.mapₐ M Rₚ Aₚ Bₚ f)

full_name: AlgHom.toKerIsLocalization
code: /-- The canonical linear map from the kernel of an algebra homomorphism to its localization. -/
def AlgHom.toKerIsLocalization (f : A →ₐ[R] B) :
    RingHom.ker f →ₗ[A] RingHom.ker (mapₐ M Rₚ Aₚ Bₚ f) 
goal: ↥(RingHom.ker f) →ₗ[A] ↥(RingHom.ker (IsLocalization.mapₐ M Rₚ Aₚ Bₚ f))

full_name: AlgHom.toKerIsLocalization_apply
code: @[simp]
lemma AlgHom.toKerIsLocalization_apply (f : A →ₐ[R] B) (x : RingHom.ker f) :
    AlgHom.toKerIsLocalization M Rₚ Aₚ Bₚ f x =
      RingHom.toKerIsLocalization Aₚ Bₚ f.toRingHom (algebraMapSubmonoid_le_comap M f) x 
goal: (AlgHom.toKerIsLocalization M Rₚ Aₚ Bₚ f) x = (RingHom.toKerIsLocalization Aₚ Bₚ f.toRingHom ⋯) x

full_name: AlgHom.toKerIsLocalization_isLocalizedModule
code: /-- The canonical linear map from the kernel of an algebra homomorphism to its localization
is localizing. -/
lemma AlgHom.toKerIsLocalization_isLocalizedModule (f : A →ₐ[R] B) :
    IsLocalizedModule (Algebra.algebraMapSubmonoid A M)
      (AlgHom.toKerIsLocalization M Rₚ Aₚ Bₚ f) 
goal: IsLocalizedModule (Algebra.algebraMapSubmonoid A M) (AlgHom.toKerIsLocalization M Rₚ Aₚ Bₚ f)