fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
Algebra.isLocalization_iff_isPushout :
IsLocalization (Algebra.algebraMapSubmonoid T S) B ↔ IsPushout R T A B := by
rw [Algebra.IsPushout.comm, Algebra.isPushout_iff, ← isLocalizedModule_iff_isLocalization]
rw [← isLocalizedModule_iff_isBaseChange (S := S)] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | Algebra.isLocalization_iff_isPushout | null |
Algebra.isPushout_of_isLocalization [IsLocalization (Algebra.algebraMapSubmonoid T S) B] :
Algebra.IsPushout R T A B :=
(Algebra.isLocalization_iff_isPushout S _).mp inferInstance
open TensorProduct in | lemma | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | Algebra.isPushout_of_isLocalization | null |
IsLocalizedModule.rTensor (g : M →ₗ[A] M') [h : IsLocalizedModule S g] :
IsLocalizedModule S (AlgebraTensorModule.rTensor R N g) := by
let Aₚ := Localization S
letI : Module Aₚ M' := (IsLocalizedModule.iso S g).symm.toAddEquiv.module Aₚ
haveI : IsScalarTower A Aₚ M' := (IsLocalizedModule.iso S g).symm.isScalarTower Aₚ
haveI : IsScalarTower R Aₚ M' :=
IsScalarTower.of_algebraMap_smul <| fun r x ↦ by simp [IsScalarTower.algebraMap_apply R A Aₚ]
rw [isLocalizedModule_iff_isBaseChange (S := S) (A := Aₚ)] at h ⊢
exact isBaseChange_tensorProduct_map _ h
variable {P : Type*} [AddCommMonoid P] [Module R P] (f : N →ₗ[R] P) | instance | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | IsLocalizedModule.rTensor | `S⁻¹M ⊗[R] N = S⁻¹(M ⊗[R] N)`. |
IsLocalizedModule.map_lTensor (g : M →ₗ[A] M') [h : IsLocalizedModule S g] :
IsLocalizedModule.map S (AlgebraTensorModule.rTensor R N g) (AlgebraTensorModule.rTensor R P g)
(AlgebraTensorModule.lTensor A M f) = AlgebraTensorModule.lTensor A M' f := by
apply linearMap_ext S (AlgebraTensorModule.rTensor R N g) (AlgebraTensorModule.rTensor R P g)
rw [map_comp]
ext
simp | lemma | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | IsLocalizedModule.map_lTensor | null |
IsLocalization.tensor (M : Submonoid R) [IsLocalization M A] :
IsLocalization (Algebra.algebraMapSubmonoid S M) (S ⊗[R] A) := by
let _ : Algebra A (S ⊗[R] A) := Algebra.TensorProduct.rightAlgebra
rw [Algebra.isLocalization_iff_isPushout _ A]
infer_instance
attribute [local instance] Algebra.TensorProduct.rightAlgebra | instance | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | IsLocalization.tensor | null |
IsLocalization.tensorRight (M : Submonoid R) [IsLocalization M A] :
IsLocalization (Algebra.algebraMapSubmonoid S M) (A ⊗[R] S) := by
rw [Algebra.isLocalization_iff_isPushout _ A]
infer_instance
open Algebra.TensorProduct in | instance | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | IsLocalization.tensorRight | null |
IsLocalization.tmul_mk' (M : Submonoid R) [IsLocalization M A] (s : S) (x : R) (y : M) :
s ⊗ₜ IsLocalization.mk' A x y =
IsLocalization.mk' (S ⊗[R] A) (algebraMap R S x * s)
⟨algebraMap R S y.1, Algebra.mem_algebraMapSubmonoid_of_mem _⟩ := by
rw [IsLocalization.eq_mk'_iff_mul_eq, algebraMap_apply, Algebra.algebraMap_self,
RingHomCompTriple.comp_apply, tmul_one_eq_one_tmul, tmul_mul_tmul, mul_one, mul_comm,
IsLocalization.mk'_spec', algebraMap_apply, Algebra.algebraMap_self, RingHom.id_apply,
← Algebra.smul_def, smul_tmul, Algebra.smul_def, mul_one]
open Algebra.TensorProduct in | lemma | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | IsLocalization.tmul_mk' | null |
IsLocalization.mk'_tmul (M : Submonoid R) [IsLocalization M A] (s : S) (x : R) (y : M) :
IsLocalization.mk' A x y ⊗ₜ s =
IsLocalization.mk' (A ⊗[R] S) (algebraMap R S x * s)
⟨algebraMap R S y.1, Algebra.mem_algebraMapSubmonoid_of_mem _⟩ := by
simp [IsLocalization.eq_mk'_iff_mul_eq, map_mul,
RingHom.algebraMap_toAlgebra] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | IsLocalization.mk'_tmul | null |
tensor [IsLocalization.Away r A] :
IsLocalization.Away (algebraMap R S r) (S ⊗[R] A) := by
simp only [IsLocalization.Away, ← Algebra.algebraMapSubmonoid_powers]
infer_instance
variable (S) in | instance | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | tensor | null |
noncomputable tensorEquiv [IsLocalization.Away r A] :
S ⊗[R] A ≃ₐ[S] Localization.Away (algebraMap R S r) :=
IsLocalization.algEquiv (Submonoid.powers <| algebraMap R S r) _ _
attribute [local instance] Algebra.TensorProduct.rightAlgebra | abbrev | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | tensorEquiv | The `S`-isomorphism `S ⊗[R] Rᵣ ≃ₐ Sᵣ`. |
tensorRight [IsLocalization.Away r A] :
IsLocalization.Away (algebraMap R S r) (A ⊗[R] S) := by
simp only [IsLocalization.Away, ← Algebra.algebraMapSubmonoid_powers]
infer_instance
variable (S) in | instance | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | tensorRight | null |
noncomputable tensorRightEquiv [IsLocalization.Away r A] :
A ⊗[R] S ≃ₐ[S] Localization.Away (algebraMap R S r) :=
IsLocalization.algEquiv (Submonoid.powers <| algebraMap R S r) _ _ | abbrev | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | tensorRightEquiv | The `S`-isomorphism `S ⊗[R] Rᵣ ≃ₐ Sᵣ`. |
with an isomorphic one; one way around this is to isolate a predicate characterizing
a structure up to isomorphism, and reason about things that satisfy the predicate.
A previous version of this file used a fully bundled type of ring localization maps,
then used a type synonym `f.codomain` for `f : LocalizationMap M S` to instantiate the
`R`-algebra structure on `S`. This results in defining ad-hoc copies for everything already
defined on `S`. By making `IsLocalization` a predicate on the `algebraMap R S`,
we can ensure the localization map commutes nicely with other `algebraMap`s.
To prove most lemmas about a localization map `algebraMap R S` in this file we invoke the
corresponding proof for the underlying `CommMonoid` localization map
`IsLocalization.toLocalizationMap M S`, which can be found in `GroupTheory.MonoidLocalization`
and the namespace `Submonoid.LocalizationMap`.
To reason about the localization as a quotient type, use `mk_eq_of_mk'` and associated lemmas.
These show the quotient map `mk : R → M → Localization M` equals the surjection
`LocalizationMap.mk'` induced by the map `algebraMap : R →+* Localization M`.
The lemma `mk_eq_of_mk'` hence gives you access to the results in the rest of the file,
which are about the `LocalizationMap.mk'` induced by any localization map.
The proof that "a `CommRing` `K` which is the localization of an integral domain `R` at `R \ {0}`
is a field" is a `def` rather than an `instance`, so if you want to reason about a field of
fractions `K`, assume `[Field K]` instead of just `[CommRing K]`. | structure | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | with | null |
noncomputable mapPiEvalRingHom :
Localization (S.comap <| Pi.evalRingHom R i) →+* Localization S :=
map (T := S) _ (Pi.evalRingHom R i) le_rfl
open Function in | abbrev | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | mapPiEvalRingHom | `IsLocalization.map` applied to a projection homomorphism from a product ring. |
mapPiEvalRingHom_bijective : Bijective (mapPiEvalRingHom S) := by
let T := S.comap (Pi.evalRingHom R i)
classical
refine ⟨fun x₁ x₂ eq ↦ ?_, fun x ↦ ?_⟩
· obtain ⟨r₁, s₁, rfl⟩ := mk'_surjective T x₁
obtain ⟨r₂, s₂, rfl⟩ := mk'_surjective T x₂
simp_rw [map_mk'] at eq
rw [IsLocalization.eq] at eq ⊢
obtain ⟨s, hs⟩ := eq
refine ⟨⟨update 0 i s, by apply update_self i s.1 0 ▸ s.2⟩, funext fun j ↦ ?_⟩
obtain rfl | ne := eq_or_ne j i
· simpa using hs
· simp [update_of_ne ne]
· obtain ⟨r, s, rfl⟩ := mk'_surjective S x
exact ⟨mk' (M := T) _ (update 0 i r) ⟨update 0 i s, by apply update_self i s.1 0 ▸ s.2⟩,
by simp [map_mk']⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | mapPiEvalRingHom_bijective | null |
protected finite [Finite R] : Finite S := by
have : Function.Surjective (Function.uncurry (mk' (M := M) S)) := fun x ↦ by
simpa using IsLocalization.mk'_surjective M x
exact .of_surjective _ this
variable (M S) in
include M in | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | finite | null |
linearMap_compatibleSMul (N₁ N₂) [AddCommMonoid N₁] [AddCommMonoid N₂] [Module R N₁]
[Module S N₁] [Module R N₂] [Module S N₂] [IsScalarTower R S N₁] [IsScalarTower R S N₂] :
LinearMap.CompatibleSMul N₁ N₂ S R where
map_smul f s s' := by
obtain ⟨r, m, rfl⟩ := mk'_surjective M s
rw [← (map_units S m).smul_left_cancel]
simp_rw [algebraMap_smul, ← map_smul, ← smul_assoc, smul_mk'_self, algebraMap_smul, map_smul]
variable {g : R →+* P} (hg : ∀ y : M, IsUnit (g y))
variable (M) in
include M in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | linearMap_compatibleSMul | null |
algHom_subsingleton [Algebra R P] : Subsingleton (S →ₐ[R] P) :=
⟨fun f g =>
AlgHom.coe_ringHom_injective <|
IsLocalization.ringHom_ext M <| by rw [f.comp_algebraMap, g.comp_algebraMap]⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | algHom_subsingleton | null |
@[simps!]
noncomputable algEquiv : S ≃ₐ[R] Q :=
{ ringEquivOfRingEquiv S Q (RingEquiv.refl R) M.map_id with
commutes' := ringEquivOfRingEquiv_eq _ } | def | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | algEquiv | If `S`, `Q` are localizations of `R` at the submonoid `M` respectively,
there is an isomorphism of localizations `S ≃ₐ[R] Q`. |
algEquiv_mk' (x : R) (y : M) : algEquiv M S Q (mk' S x y) = mk' Q x y := by
simp | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | algEquiv_mk' | null |
algEquiv_symm_mk' (x : R) (y : M) : (algEquiv M S Q).symm (mk' Q x y) = mk' S x y := by simp
variable (M) in
include M in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | algEquiv_symm_mk' | null |
protected bijective (f : S →+* Q) (hf : f.comp (algebraMap R S) = algebraMap R Q) :
Function.Bijective f :=
(show f = IsLocalization.algEquiv M S Q by
apply IsLocalization.ringHom_ext M; rw [hf]; ext; simp) ▸
(IsLocalization.algEquiv M S Q).toEquiv.bijective | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | bijective | null |
noncomputable liftAlgHom : S →ₐ[A] P where
__ := lift hf
commutes' r := show lift hf (algebraMap A S r) = _ by
simp [IsScalarTower.algebraMap_apply A R S] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | liftAlgHom | `AlgHom` version of `IsLocalization.lift`. |
liftAlgHom_toRingHom : (liftAlgHom hf : S →ₐ[A] P).toRingHom = lift hf := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | liftAlgHom_toRingHom | null |
coe_liftAlgHom : ⇑(liftAlgHom hf : S →ₐ[A] P) = lift hf := rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | coe_liftAlgHom | null |
liftAlgHom_apply : liftAlgHom hf x = lift hf x := rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | liftAlgHom_apply | null |
@[simps!]
noncomputable algEquivOfAlgEquiv : S ≃ₐ[A] Q where
__ := ringEquivOfRingEquiv S Q h.toRingEquiv H
commutes' _ := by dsimp; rw [IsScalarTower.algebraMap_apply A R S, map_eq,
RingHom.coe_coe, AlgEquiv.commutes, IsScalarTower.algebraMap_apply A P Q]
variable {S Q h} | def | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | algEquivOfAlgEquiv | If `S`, `Q` are localizations of `R` and `P` at submonoids `M`, `T` respectively,
an isomorphism `h : R ≃ₐ[A] P` such that `h(M) = T` induces an isomorphism of localizations
`S ≃ₐ[A] Q`. |
algEquivOfAlgEquiv_eq_map :
(algEquivOfAlgEquiv S Q h H : S →+* Q) =
map Q (h : R →+* P) (M.le_comap_of_map_le (le_of_eq H)) :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | algEquivOfAlgEquiv_eq_map | null |
algEquivOfAlgEquiv_eq (x : R) :
algEquivOfAlgEquiv S Q h H ((algebraMap R S) x) = algebraMap P Q (h x) := by
simp
set_option linter.docPrime false in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | algEquivOfAlgEquiv_eq | null |
algEquivOfAlgEquiv_mk' (x : R) (y : M) :
algEquivOfAlgEquiv S Q h H (mk' S x y) =
mk' Q (h x) ⟨h y, show h y ∈ T from H ▸ Set.mem_image_of_mem h y.2⟩ := by
simp [map_mk'] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | algEquivOfAlgEquiv_mk' | null |
algEquivOfAlgEquiv_symm : (algEquivOfAlgEquiv S Q h H).symm =
algEquivOfAlgEquiv Q S h.symm (show Submonoid.map h.symm T = M by
rw [← H, ← Submonoid.map_coe_toMulEquiv, AlgEquiv.symm_toMulEquiv,
← Submonoid.comap_equiv_eq_map_symm, ← Submonoid.map_coe_toMulEquiv,
Submonoid.comap_map_eq_of_injective (h : R ≃* P).injective]) := rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | algEquivOfAlgEquiv_symm | null |
smul_mem_iff {N' : Submodule R' M'} {x : M'} {s : S} :
s • x ∈ N' ↔ x ∈ N' := by
refine ⟨fun h ↦ ?_, fun h ↦ Submodule.smul_of_tower_mem N' s h⟩
rwa [← Submodule.smul_mem_iff_of_isUnit (r := algebraMap R R' s) N' (map_units R' s),
algebraMap_smul] | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | smul_mem_iff | If `x` in a `R' = S⁻¹ R`-module `M'`, then for a submodule `N'` of `M'`,
`s • x ∈ N'` if and only if `x ∈ N'` for some `s` in S. |
noncomputable atUnits (H : M ≤ IsUnit.submonoid R) : R ≃ₐ[R] S := by
refine AlgEquiv.ofBijective (Algebra.ofId R S) ⟨?_, ?_⟩
· intro x y hxy
obtain ⟨c, eq⟩ := (IsLocalization.eq_iff_exists M S).mp hxy
obtain ⟨u, hu⟩ := H c.prop
rwa [← hu, Units.mul_right_inj] at eq
· intro y
obtain ⟨⟨x, s⟩, eq⟩ := IsLocalization.surj M y
obtain ⟨u, hu⟩ := H s.prop
use x * u.inv
dsimp [Algebra.ofId, RingHom.toFun_eq_coe, AlgHom.coe_mks]
rw [RingHom.map_mul, ← eq, ← hu, mul_assoc, ← RingHom.map_mul]
simp | def | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | atUnits | The localization at a module of units is isomorphic to the ring. |
isLocalization_of_algEquiv [Algebra R P] [IsLocalization M S] (h : S ≃ₐ[R] P) :
IsLocalization M P := by
constructor
· intro y
convert (IsLocalization.map_units S y).map h.toAlgHom.toRingHom.toMonoidHom
exact (h.commutes y).symm
· intro y
obtain ⟨⟨x, s⟩, e⟩ := IsLocalization.surj M (h.symm y)
apply_fun (show S → P from h) at e
simp only [map_mul, h.apply_symm_apply, h.commutes] at e
exact ⟨⟨x, s⟩, e⟩
· intro x y
rw [← h.symm.toEquiv.injective.eq_iff, ← IsLocalization.eq_iff_exists M S, ← h.symm.commutes, ←
h.symm.commutes]
exact id | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | isLocalization_of_algEquiv | null |
isLocalization_iff_of_algEquiv [Algebra R P] (h : S ≃ₐ[R] P) :
IsLocalization M S ↔ IsLocalization M P :=
⟨fun _ => isLocalization_of_algEquiv M h, fun _ => isLocalization_of_algEquiv M h.symm⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | isLocalization_iff_of_algEquiv | null |
isLocalization_iff_of_ringEquiv (h : S ≃+* P) :
IsLocalization M S ↔
haveI := (h.toRingHom.comp <| algebraMap R S).toAlgebra; IsLocalization M P :=
letI := (h.toRingHom.comp <| algebraMap R S).toAlgebra
isLocalization_iff_of_algEquiv M { h with commutes' := fun _ => rfl }
variable (S) in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | isLocalization_iff_of_ringEquiv | null |
isLocalization_iff_of_isLocalization [IsLocalization M S] [IsLocalization N S]
[Algebra R P] : IsLocalization M P ↔ IsLocalization N P :=
⟨fun _ ↦ isLocalization_of_algEquiv N (algEquiv M S P),
fun _ ↦ isLocalization_of_algEquiv M (algEquiv N S P)⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | isLocalization_iff_of_isLocalization | If an algebra is simultaneously localizations for two submonoids, then an arbitrary algebra
is a localization of one submonoid iff it is a localization of the other. |
iff_of_le_of_exists_dvd (N : Submonoid R) (h₁ : M ≤ N) (h₂ : ∀ n ∈ N, ∃ m ∈ M, n ∣ m) :
IsLocalization M S ↔ IsLocalization N S :=
have : IsLocalization N (Localization M) := of_le_of_exists_dvd _ _ h₁ h₂
isLocalization_iff_of_isLocalization _ _ (Localization M) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | iff_of_le_of_exists_dvd | null |
commutes (S₁ S₂ T : Type*) [CommSemiring S₁]
[CommSemiring S₂] [CommSemiring T] [Algebra R S₁] [Algebra R S₂] [Algebra R T] [Algebra S₁ T]
[Algebra S₂ T] [IsScalarTower R S₁ T] [IsScalarTower R S₂ T] (M₁ M₂ : Submonoid R)
[IsLocalization M₁ S₁] [IsLocalization M₂ S₂]
[IsLocalization (Algebra.algebraMapSubmonoid S₂ M₁) T] :
IsLocalization (Algebra.algebraMapSubmonoid S₁ M₂) T where
map_units := by
rintro ⟨m, ⟨a, ha, rfl⟩⟩
rw [← IsScalarTower.algebraMap_apply, IsScalarTower.algebraMap_apply R S₂ T]
exact IsUnit.map _ (IsLocalization.map_units _ ⟨a, ha⟩)
surj a := by
obtain ⟨⟨y, -, m, hm, rfl⟩, hy⟩ := surj (M := Algebra.algebraMapSubmonoid S₂ M₁) a
rw [← IsScalarTower.algebraMap_apply, IsScalarTower.algebraMap_apply R S₁ T] at hy
obtain ⟨⟨z, n, hn⟩, hz⟩ := IsLocalization.surj (M := M₂) y
have hunit : IsUnit (algebraMap R S₁ m) := map_units _ ⟨m, hm⟩
use ⟨algebraMap R S₁ z * hunit.unit⁻¹, ⟨algebraMap R S₁ n, n, hn, rfl⟩⟩
rw [map_mul, ← IsScalarTower.algebraMap_apply, IsScalarTower.algebraMap_apply R S₂ T]
conv_rhs => rw [← IsScalarTower.algebraMap_apply]
rw [IsScalarTower.algebraMap_apply R S₂ T, ← hz, map_mul, ← hy]
convert_to _ = a * (algebraMap S₂ T) ((algebraMap R S₂) n) *
(algebraMap S₁ T) (((algebraMap R S₁) m) * hunit.unit⁻¹.val)
· rw [map_mul]
ring
simp
exists_of_eq {x y} hxy := by
obtain ⟨r, s, d, hr, hs⟩ := IsLocalization.surj₂ M₁ S₁ x y
apply_fun (· * algebraMap S₁ T (algebraMap R S₁ d)) at hxy
simp_rw [← map_mul, hr, hs, ← IsScalarTower.algebraMap_apply,
IsScalarTower.algebraMap_apply R S₂ T] at hxy
obtain ⟨⟨-, c, hmc, rfl⟩, hc⟩ := exists_of_eq (M := Algebra.algebraMapSubmonoid S₂ M₁) hxy
simp_rw [← map_mul] at hc
obtain ⟨a, ha⟩ := IsLocalization.exists_of_eq (M := M₂) hc
use ⟨algebraMap R S₁ a, a, a.property, rfl⟩
apply (map_units S₁ d).mul_right_cancel
rw [mul_assoc, hr, mul_assoc, hs]
apply (map_units S₁ ⟨c, hmc⟩).mul_right_cancel
rw [← map_mul, ← map_mul, mul_assoc, mul_comm _ c, ha, map_mul, map_mul]
ring
variable (Rₘ Sₙ Rₘ' Sₙ' : Type*) [CommSemiring Rₘ] [CommSemiring Sₙ] [CommSemiring Rₘ']
[CommSemiring Sₙ'] [Algebra R Rₘ] [Algebra S Sₙ] [Algebra R Rₘ'] [Algebra S Sₙ'] [Algebra R Sₙ]
[Algebra Rₘ Sₙ] [Algebra Rₘ' Sₙ'] [Algebra R Sₙ'] (N : Submonoid S) [IsLocalization M Rₘ]
[IsLocalization N Sₙ] [IsLocalization M Rₘ'] [IsLocalization N Sₙ'] [IsScalarTower R Rₘ Sₙ]
[IsScalarTower R S Sₙ] [IsScalarTower R Rₘ' Sₙ'] [IsScalarTower R S Sₙ'] | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | commutes | If `S₁` is the localization of `R` at `M₁` and `S₂` is the localization of
`R` at `M₂`, then every localization `T` of `S₂` at `M₁` is also a localization of
`S₁` at `M₂`, in other words `M₁⁻¹M₂⁻¹R` can be identified with `M₂⁻¹M₁⁻¹R`. |
algEquiv_comp_algebraMap : (algEquiv N Sₙ Sₙ' : _ →+* Sₙ').comp (algebraMap Rₘ Sₙ) =
(algebraMap Rₘ' Sₙ').comp (algEquiv M Rₘ Rₘ') := by
refine IsLocalization.ringHom_ext M (RingHom.ext fun x => ?_)
simp only [RingHom.coe_comp, RingHom.coe_coe, Function.comp_apply, AlgEquiv.commutes]
rw [← IsScalarTower.algebraMap_apply, ← IsScalarTower.algebraMap_apply,
← AlgEquiv.restrictScalars_apply R, AlgEquiv.commutes]
variable {Rₘ} in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | algEquiv_comp_algebraMap | null |
algEquiv_comp_algebraMap_apply (x : Rₘ) :
(algEquiv N Sₙ Sₙ' : _ →+* Sₙ').comp (algebraMap Rₘ Sₙ) x =
(algebraMap Rₘ' Sₙ').comp (algEquiv M Rₘ Rₘ') x := by
rw [algEquiv_comp_algebraMap M Rₘ Sₙ Rₘ'] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | algEquiv_comp_algebraMap_apply | null |
mk_natCast (m : ℕ) : (mk m 1 : Localization M) = m := by
simpa using mk_algebraMap (R := R) (A := ℕ) _
variable [IsLocalization M S] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | mk_natCast | null |
@[simps!]
noncomputable algEquiv : Localization M ≃ₐ[R] S :=
IsLocalization.algEquiv M _ _ | def | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | algEquiv | The localization of `R` at `M` as a quotient type is isomorphic to any other localization. |
noncomputable _root_.IsLocalization.unique (R Rₘ) [CommSemiring R] [CommSemiring Rₘ]
(M : Submonoid R) [Subsingleton R] [Algebra R Rₘ] [IsLocalization M Rₘ] : Unique Rₘ :=
have : Inhabited Rₘ := ⟨1⟩
(algEquiv M Rₘ).symm.injective.unique | def | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | _root_.IsLocalization.unique | The localization of a singleton is a singleton. Cannot be an instance due to metavariables. |
algEquiv_mk (x y) : algEquiv M S (mk x y) = mk' S x y := by rw [mk_eq_mk', algEquiv_mk'] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | algEquiv_mk | null |
algEquiv_symm_mk (x : R) (y : M) : (algEquiv M S).symm (mk' S x y) = mk x y := by
rw [mk_eq_mk', algEquiv_symm_mk'] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | algEquiv_symm_mk | null |
coe_algEquiv :
(Localization.algEquiv M S : Localization M →+* S) =
IsLocalization.map (M := M) (T := M) _ (RingHom.id R) le_rfl := rfl | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | coe_algEquiv | null |
coe_algEquiv_symm :
((Localization.algEquiv M S).symm : S →+* Localization M) =
IsLocalization.map (M := M) (T := M) _ (RingHom.id R) le_rfl := rfl | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | coe_algEquiv_symm | null |
IsField.localization_map_bijective {R Rₘ : Type*} [CommRing R] [CommRing Rₘ]
{M : Submonoid R} (hM : (0 : R) ∉ M) (hR : IsField R) [Algebra R Rₘ] [IsLocalization M Rₘ] :
Function.Bijective (algebraMap R Rₘ) := by
letI := hR.toField
replace hM := le_nonZeroDivisors_of_noZeroDivisors hM
refine ⟨IsLocalization.injective _ hM, fun x => ?_⟩
obtain ⟨r, ⟨m, hm⟩, rfl⟩ := mk'_surjective M x
obtain ⟨n, hn⟩ := hR.mul_inv_cancel (nonZeroDivisors.ne_zero <| hM hm)
exact ⟨r * n, by rw [eq_mk'_iff_mul_eq, ← map_mul, mul_assoc, _root_.mul_comm n, hn, mul_one]⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | IsField.localization_map_bijective | If `R` is a field, then localizing at a submonoid not containing `0` adds no new elements. |
Field.localization_map_bijective {K Kₘ : Type*} [Field K] [CommRing Kₘ] {M : Submonoid K}
(hM : (0 : K) ∉ M) [Algebra K Kₘ] [IsLocalization M Kₘ] :
Function.Bijective (algebraMap K Kₘ) :=
(Field.toIsField K).localization_map_bijective hM | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | Field.localization_map_bijective | If `R` is a field, then localizing at a submonoid not containing `0` adds no new elements. |
noncomputable localizationAlgebra : Algebra Rₘ Sₘ :=
(map Sₘ (algebraMap R S)
(show _ ≤ (Algebra.algebraMapSubmonoid S M).comap _ from M.le_comap_map) :
Rₘ →+* Sₘ).toAlgebra | def | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | localizationAlgebra | Definition of the natural algebra induced by the localization of an algebra.
Given an algebra `R → S`, a submonoid `R` of `M`, and a localization `Rₘ` for `M`,
let `Sₘ` be the localization of `S` to the image of `M` under `algebraMap R S`.
Then this is the natural algebra structure on `Rₘ → Sₘ`, such that the entire square commutes,
where `localization_map.map_comp` gives the commutativity of the underlying maps.
This instance can be helpful if you define `Sₘ := Localization (Algebra.algebraMapSubmonoid S M)`,
however we will instead use the hypotheses `[Algebra Rₘ Sₘ] [IsScalarTower R Rₘ Sₘ]` in lemmas
since the algebra structure may arise in different ways. |
IsLocalization.map_units_map_submonoid (y : M) : IsUnit (algebraMap R Sₘ y) := by
rw [IsScalarTower.algebraMap_apply _ S]
exact IsLocalization.map_units Sₘ ⟨algebraMap R S y, Algebra.mem_algebraMapSubmonoid_of_mem y⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | IsLocalization.map_units_map_submonoid | null |
IsLocalization.algebraMap_mk' (x : R) (y : M) :
algebraMap Rₘ Sₘ (IsLocalization.mk' Rₘ x y) =
IsLocalization.mk' Sₘ (algebraMap R S x)
⟨algebraMap R S y, Algebra.mem_algebraMapSubmonoid_of_mem y⟩ := by
rw [IsLocalization.eq_mk'_iff_mul_eq, Subtype.coe_mk, ← IsScalarTower.algebraMap_apply, ←
IsScalarTower.algebraMap_apply, IsScalarTower.algebraMap_apply R Rₘ Sₘ,
IsScalarTower.algebraMap_apply R Rₘ Sₘ, ← map_mul, mul_comm,
IsLocalization.mul_mk'_eq_mk'_of_mul]
exact congr_arg (algebraMap Rₘ Sₘ) (IsLocalization.mk'_mul_cancel_left x y)
variable (M) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | IsLocalization.algebraMap_mk' | null |
IsLocalization.algebraMap_eq_map_map_submonoid :
algebraMap Rₘ Sₘ =
map Sₘ (algebraMap R S)
(show _ ≤ (Algebra.algebraMapSubmonoid S M).comap _ from M.le_comap_map) :=
Eq.symm <|
IsLocalization.map_unique _ (algebraMap Rₘ Sₘ) fun x => by
rw [← IsScalarTower.algebraMap_apply R S Sₘ, ← IsScalarTower.algebraMap_apply R Rₘ Sₘ] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | IsLocalization.algebraMap_eq_map_map_submonoid | If the square below commutes, the bottom map is uniquely specified:
```
R → S
↓ ↓
Rₘ → Sₘ
``` |
IsLocalization.algebraMap_apply_eq_map_map_submonoid (x) :
algebraMap Rₘ Sₘ x =
map Sₘ (algebraMap R S)
(show _ ≤ (Algebra.algebraMapSubmonoid S M).comap _ from M.le_comap_map) x :=
DFunLike.congr_fun (IsLocalization.algebraMap_eq_map_map_submonoid _ _ _ _) x | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | IsLocalization.algebraMap_apply_eq_map_map_submonoid | If the square below commutes, the bottom map is uniquely specified:
```
R → S
↓ ↓
Rₘ → Sₘ
``` |
IsLocalization.lift_algebraMap_eq_algebraMap :
IsLocalization.lift (M := M) (IsLocalization.map_units_map_submonoid S Sₘ) =
algebraMap Rₘ Sₘ :=
IsLocalization.lift_unique _ fun _ => (IsScalarTower.algebraMap_apply _ _ _ _).symm | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | IsLocalization.lift_algebraMap_eq_algebraMap | null |
localizationAlgebraMap_def :
@algebraMap Rₘ Sₘ _ _ (localizationAlgebra M S) =
map Sₘ (algebraMap R S)
(show _ ≤ (Algebra.algebraMapSubmonoid S M).comap _ from M.le_comap_map) :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | localizationAlgebraMap_def | null |
localizationAlgebra_injective (hRS : Function.Injective (algebraMap R S)) :
Function.Injective (@algebraMap Rₘ Sₘ _ _ (localizationAlgebra M S)) :=
have : IsLocalization (M.map (algebraMap R S)) Sₘ := i
IsLocalization.map_injective_of_injective _ _ _ hRS | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | localizationAlgebra_injective | Injectivity of the underlying `algebraMap` descends to the algebra induced by localization. |
Localization.mk_intCast (m : ℤ) : (mk m 1 : Localization M) = m := by
simpa using mk_algebraMap (R := R) (A := ℤ) _ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Field.IsField",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Data.Finite.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.OreLocalization.Ring"
] | Mathlib/RingTheory/Localization/Basic.lean | Localization.mk_intCast | null |
lift_cardinalMk_le (S : Submonoid R) [IsLocalization S L] :
Cardinal.lift.{u} #L ≤ Cardinal.lift.{v} #R := by
have := Localization.cardinalMk_le S
rwa [← lift_le.{v}, lift_mk_eq'.2 ⟨(Localization.algEquiv S L).toEquiv⟩] at this | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.GroupTheory.MonoidLocalization.Cardinality",
"Mathlib.RingTheory.OreLocalization.Cardinality"
] | Mathlib/RingTheory/Localization/Cardinality.lean | lift_cardinalMk_le | null |
cardinalMk_le {L : Type u} [CommSemiring L] [Algebra R L]
(S : Submonoid R) [IsLocalization S L] : #L ≤ #R := by
simpa using lift_cardinalMk_le (L := L) S | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.GroupTheory.MonoidLocalization.Cardinality",
"Mathlib.RingTheory.OreLocalization.Cardinality"
] | Mathlib/RingTheory/Localization/Cardinality.lean | cardinalMk_le | A localization always has cardinality less than or equal to the base ring. |
cardinalMk {S : Submonoid R} (hS : S ≤ R⁰) : #(Localization S) = #R := by
apply OreLocalization.cardinalMk
rwa [nonZeroDivisorsLeft_eq_nonZeroDivisors] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.GroupTheory.MonoidLocalization.Cardinality",
"Mathlib.RingTheory.OreLocalization.Cardinality"
] | Mathlib/RingTheory/Localization/Cardinality.lean | cardinalMk | null |
lift_cardinalMk (S : Submonoid R) [IsLocalization S L] (hS : S ≤ R⁰) :
Cardinal.lift.{u} #L = Cardinal.lift.{v} #R := by
have := Localization.cardinalMk hS
rwa [← lift_inj.{u, v}, lift_mk_eq'.2 ⟨(Localization.algEquiv S L).toEquiv⟩] at this | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.GroupTheory.MonoidLocalization.Cardinality",
"Mathlib.RingTheory.OreLocalization.Cardinality"
] | Mathlib/RingTheory/Localization/Cardinality.lean | lift_cardinalMk | null |
cardinalMk (L : Type u) [CommRing L] [Algebra R L]
(S : Submonoid R) [IsLocalization S L] (hS : S ≤ R⁰) : #L = #R := by
simpa using lift_cardinalMk L S hS | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.GroupTheory.MonoidLocalization.Cardinality",
"Mathlib.RingTheory.OreLocalization.Cardinality"
] | Mathlib/RingTheory/Localization/Cardinality.lean | cardinalMk | If you do not localize at any zero-divisors, localization preserves cardinality. |
@[simp]
Cardinal.mk_fractionRing (R : Type u) [CommRing R] : #(FractionRing R) = #R :=
IsLocalization.cardinalMk (FractionRing R) R⁰ le_rfl
alias FractionRing.cardinalMk := Cardinal.mk_fractionRing | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.GroupTheory.MonoidLocalization.Cardinality",
"Mathlib.RingTheory.OreLocalization.Cardinality"
] | Mathlib/RingTheory/Localization/Cardinality.lean | Cardinal.mk_fractionRing | null |
lift_cardinalMk [IsFractionRing R L] : Cardinal.lift.{u} #L = Cardinal.lift.{v} #R :=
IsLocalization.lift_cardinalMk L _ le_rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.GroupTheory.MonoidLocalization.Cardinality",
"Mathlib.RingTheory.OreLocalization.Cardinality"
] | Mathlib/RingTheory/Localization/Cardinality.lean | lift_cardinalMk | null |
cardinalMk (L : Type u) [CommRing L] [Algebra R L] [IsFractionRing R L] : #L = #R :=
IsLocalization.cardinalMk L _ le_rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.GroupTheory.MonoidLocalization.Cardinality",
"Mathlib.RingTheory.OreLocalization.Cardinality"
] | Mathlib/RingTheory/Localization/Cardinality.lean | cardinalMk | null |
with an isomorphic one; one way around this is to isolate a predicate characterizing
a structure up to isomorphism, and reason about things that satisfy the predicate.
A previous version of this file used a fully bundled type of ring localization maps,
then used a type synonym `f.codomain` for `f : LocalizationMap M S` to instantiate the
`R`-algebra structure on `S`. This results in defining ad-hoc copies for everything already
defined on `S`. By making `IsLocalization` a predicate on the `algebraMap R S`,
we can ensure the localization map commutes nicely with other `algebraMap`s.
To prove most lemmas about a localization map `algebraMap R S` in this file we invoke the
corresponding proof for the underlying `CommMonoid` localization map
`IsLocalization.toLocalizationMap M S`, which can be found in `GroupTheory.MonoidLocalization`
and the namespace `Submonoid.LocalizationMap`.
To reason about the localization as a quotient type, use `mk_eq_of_mk'` and associated lemmas.
These show the quotient map `mk : R → M → Localization M` equals the surjection
`LocalizationMap.mk'` induced by the map `algebraMap : R →+* Localization M`.
The lemma `mk_eq_of_mk'` hence gives you access to the results in the rest of the file,
which are about the `LocalizationMap.mk'` induced by any localization map.
The proof that "a `CommRing` `K` which is the localization of an integral domain `R` at `R \ {0}`
is a field" is a `def` rather than an `instance`, so if you want to reason about a field of
fractions `K`, assume `[Field K]` instead of just `[CommRing K]`. | structure | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | with | null |
@[mk_iff]
IsLocalization (M : Submonoid R) (S : Type*) [CommSemiring S] [Algebra R S] : Prop where
/-- Everything in the image of `algebraMap` is a unit -/
map_units (S) : ∀ y : M, IsUnit (algebraMap R S y)
/-- The `algebraMap` is surjective -/
surj (M) : ∀ z : S, ∃ x : R × M, z * algebraMap R S x.2 = algebraMap R S x.1
/-- The kernel of `algebraMap` is contained in the annihilator of `M`;
it is then equal to the annihilator by `map_units'` -/
exists_of_eq : ∀ {x y}, algebraMap R S x = algebraMap R S y → ∃ c : M, ↑c * x = ↑c * y
variable {M} | class | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | IsLocalization | The typeclass `IsLocalization (M : Submonoid R) S` where `S` is an `R`-algebra
expresses that `S` is isomorphic to the localization of `R` at `M`. |
@[inherit_doc IsLocalization.exists_of_eq]
eq_iff_exists {x y} : algebraMap R S x = algebraMap R S y ↔ ∃ c : M, ↑c * x = ↑c * y :=
Iff.intro IsLocalization.exists_of_eq fun ⟨c, h⟩ ↦ by
apply_fun algebraMap R S at h
rw [map_mul, map_mul] at h
exact (IsLocalization.map_units S c).mul_right_inj.mp h | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | eq_iff_exists | null |
injective_iff_isRegular : Injective (algebraMap R S) ↔ ∀ c : M, IsRegular (c : R) := by
simp_rw [Commute.isRegular_iff (Commute.all _), IsLeftRegular,
Injective, eq_iff_exists M, exists_imp, forall_comm (α := M)] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | injective_iff_isRegular | null |
of_le (N : Submonoid R) (h₁ : M ≤ N) (h₂ : ∀ r ∈ N, IsUnit (algebraMap R S r)) :
IsLocalization N S where
map_units r := h₂ r r.2
surj s :=
have ⟨⟨x, y, hy⟩, H⟩ := IsLocalization.surj M s
⟨⟨x, y, h₁ hy⟩, H⟩
exists_of_eq {x y} := by
rw [IsLocalization.eq_iff_exists M]
rintro ⟨c, hc⟩
exact ⟨⟨c, h₁ c.2⟩, hc⟩ | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | of_le | null |
of_le_of_exists_dvd (N : Submonoid R) (h₁ : M ≤ N) (h₂ : ∀ n ∈ N, ∃ m ∈ M, n ∣ m) :
IsLocalization N S :=
of_le M N h₁ fun n hn ↦ have ⟨m, hm, dvd⟩ := h₂ n hn
isUnit_of_dvd_unit (map_dvd _ dvd) (map_units S ⟨m, hm⟩) | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | of_le_of_exists_dvd | null |
algebraMap_isUnit_iff {x : R} : IsUnit (algebraMap R S x) ↔ ∃ m ∈ M, x ∣ m := by
refine ⟨fun h ↦ ?_, fun ⟨m, hm, dvd⟩ ↦ isUnit_of_dvd_unit (map_dvd _ dvd) (map_units S ⟨m, hm⟩)⟩
have ⟨s, hxs⟩ := isUnit_iff_dvd_one.mp h
have ⟨⟨r, m⟩, hrm⟩ := surj M s
apply_fun (algebraMap R S x * ·) at hrm
rw [← mul_assoc, ← hxs, one_mul, ← map_mul] at hrm
have ⟨m', eq⟩ := exists_of_eq (M := M) hrm
exact ⟨m' * m, mul_mem m'.2 m.2, _, mul_left_comm _ x _ ▸ eq⟩
variable (S) | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | algebraMap_isUnit_iff | null |
toLocalizationMap : M.LocalizationMap S where
__ := algebraMap R S
toFun := algebraMap R S
map_units' := IsLocalization.map_units _
surj' := IsLocalization.surj _
exists_of_eq _ _ := IsLocalization.exists_of_eq
@[deprecated (since := "2025-08-01")] alias toLocalizationWithZeroMap := toLocalizationMap
@[simp] | abbrev | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | toLocalizationMap | `IsLocalization.toLocalizationMap M S` shows `S` is the monoid localization of `R` at `M`. |
toLocalizationMap_toMonoidHom :
(toLocalizationMap M S).toMonoidHom = (algebraMap R S : R →*₀ S) := rfl
@[deprecated (since := "2025-08-13")] alias toLocalizationMap_toMap := toLocalizationMap_toMonoidHom
@[simp] lemma coe_toLocalizationMap : ⇑(toLocalizationMap M S) = algebraMap R S := rfl
@[deprecated (since := "2025-08-13")] alias toLocalizationMap_toMap_apply := coe_toLocalizationMap | lemma | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | toLocalizationMap_toMonoidHom | null |
toLocalizationMap_apply (x) : toLocalizationMap M S x = algebraMap R S x := rfl | lemma | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | toLocalizationMap_apply | null |
surj₂ : ∀ z w : S, ∃ z' w' : R, ∃ d : M,
(z * algebraMap R S d = algebraMap R S z') ∧ (w * algebraMap R S d = algebraMap R S w') :=
(toLocalizationMap M S).surj₂ | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | surj₂ | null |
noncomputable sec (z : S) : R × M :=
Classical.choose <| IsLocalization.surj _ z
@[simp] | def | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | sec | Given a localization map `f : M →* N`, a section function sending `z : N` to some
`(x, y) : M × S` such that `f x * (f y)⁻¹ = z`. |
toLocalizationMap_sec : (toLocalizationMap M S).sec = sec M :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | toLocalizationMap_sec | null |
sec_spec (z : S) :
z * algebraMap R S (IsLocalization.sec M z).2 = algebraMap R S (IsLocalization.sec M z).1 :=
Classical.choose_spec <| IsLocalization.surj _ z | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | sec_spec | Given `z : S`, `IsLocalization.sec M z` is defined to be a pair `(x, y) : R × M` such
that `z * f y = f x` (so this lemma is true by definition). |
sec_spec' (z : S) :
algebraMap R S (IsLocalization.sec M z).1 = algebraMap R S (IsLocalization.sec M z).2 * z := by
rw [mul_comm, sec_spec]
variable {M} | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | sec_spec' | Given `z : S`, `IsLocalization.sec M z` is defined to be a pair `(x, y) : R × M` such
that `z * f y = f x`, so this lemma is just an application of `S`'s commutativity. |
subsingleton (h : 0 ∈ M) : Subsingleton S := (toLocalizationMap M S).subsingleton h | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | subsingleton | If `M` contains `0` then the localization at `M` is trivial. |
protected subsingleton_iff : Subsingleton S ↔ 0 ∈ M :=
(toLocalizationMap M S).subsingleton_iff | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | subsingleton_iff | null |
map_right_cancel {x y} {c : M} (h : algebraMap R S (c * x) = algebraMap R S (c * y)) :
algebraMap R S x = algebraMap R S y :=
(toLocalizationMap M S).map_right_cancel h | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | map_right_cancel | null |
map_left_cancel {x y} {c : M} (h : algebraMap R S (x * c) = algebraMap R S (y * c)) :
algebraMap R S x = algebraMap R S y :=
(toLocalizationMap M S).map_left_cancel h | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | map_left_cancel | null |
eq_zero_of_fst_eq_zero {z x} {y : M} (h : z * algebraMap R S y = algebraMap R S x)
(hx : x = 0) : z = 0 := by
rw [hx, (algebraMap R S).map_zero] at h
exact (IsUnit.mul_left_eq_zero (IsLocalization.map_units S y)).1 h
variable (M S) | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | eq_zero_of_fst_eq_zero | null |
map_eq_zero_iff (r : R) : algebraMap R S r = 0 ↔ ∃ m : M, ↑m * r = 0 :=
(toLocalizationMap M S).map_eq_zero_iff
variable {M} | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | map_eq_zero_iff | null |
noncomputable mk' (x : R) (y : M) : S :=
(toLocalizationMap M S).mk' x y
@[simp] | def | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | mk' | `IsLocalization.mk' S` is the surjection sending `(x, y) : R × M` to
`f x * (f y)⁻¹`. |
mk'_sec (z : S) : mk' S (IsLocalization.sec M z).1 (IsLocalization.sec M z).2 = z :=
(toLocalizationMap M S).mk'_sec _ | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | mk'_sec | null |
mk'_mul (x₁ x₂ : R) (y₁ y₂ : M) : mk' S (x₁ * x₂) (y₁ * y₂) = mk' S x₁ y₁ * mk' S x₂ y₂ :=
(toLocalizationMap M S).mk'_mul _ _ _ _ | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | mk'_mul | null |
mk'_one (x) : mk' S x (1 : M) = algebraMap R S x :=
(toLocalizationMap M S).mk'_one _
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | mk'_one | null |
mk'_spec (x) (y : M) : mk' S x y * algebraMap R S y = algebraMap R S x :=
(toLocalizationMap M S).mk'_spec _ _
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | mk'_spec | null |
mk'_spec' (x) (y : M) : algebraMap R S y * mk' S x y = algebraMap R S x :=
(toLocalizationMap M S).mk'_spec' _ _
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | mk'_spec' | null |
mk'_spec_mk (x) (y : R) (hy : y ∈ M) :
mk' S x ⟨y, hy⟩ * algebraMap R S y = algebraMap R S x :=
mk'_spec S x ⟨y, hy⟩
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | mk'_spec_mk | null |
mk'_spec'_mk (x) (y : R) (hy : y ∈ M) :
algebraMap R S y * mk' S x ⟨y, hy⟩ = algebraMap R S x :=
mk'_spec' S x ⟨y, hy⟩
variable {S} | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | mk'_spec'_mk | null |
eq_mk'_iff_mul_eq {x} {y : M} {z} :
z = mk' S x y ↔ z * algebraMap R S y = algebraMap R S x :=
(toLocalizationMap M S).eq_mk'_iff_mul_eq | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | eq_mk'_iff_mul_eq | null |
eq_mk'_of_mul_eq {x : R} {y : M} {z : R} (h : z * y = x) : (algebraMap R S) z = mk' S x y :=
eq_mk'_iff_mul_eq.mpr (by rw [← h, map_mul]) | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | eq_mk'_of_mul_eq | null |
mk'_eq_iff_eq_mul {x} {y : M} {z} :
mk' S x y = z ↔ algebraMap R S x = z * algebraMap R S y :=
(toLocalizationMap M S).mk'_eq_iff_eq_mul | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | mk'_eq_iff_eq_mul | null |
mk'_add_eq_iff_add_mul_eq_mul {x} {y : M} {z₁ z₂} :
mk' S x y + z₁ = z₂ ↔ algebraMap R S x + z₁ * algebraMap R S y = z₂ * algebraMap R S y := by
rw [← mk'_spec S x y, ← IsUnit.mul_left_inj (IsLocalization.map_units S y), right_distrib] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Defs",
"Mathlib.Algebra.Regular.Basic",
"Mathlib.Algebra.Ring.NonZeroDivisors",
"Mathlib.Data.Fintype.Prod",
"Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero",
"Mathlib.RingTheory.OreLocalization.Ring",
"Mathlib.Tactic.ApplyFun",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Localization/Defs.lean | mk'_add_eq_iff_add_mul_eq_mul | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.