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 ⌀ |
|---|---|---|---|---|---|---|
isUnit_den_zero : IsUnit (den A (0 : K) : A) := by
simp [isUnit_den_iff, IsLocalization.isInteger_zero] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid"
] | Mathlib/RingTheory/Localization/NumDen.lean | isUnit_den_zero | null |
associated_den_num_inv (x : K) (hx : x ≠ 0) : Associated (den A x : A) (num A x⁻¹) :=
associated_of_dvd_dvd
(IsRelPrime.dvd_of_dvd_mul_right (IsFractionRing.num_den_reduced A x).symm <|
dvd_of_mul_left_dvd (a := (den A x⁻¹ : A)) <| dvd_of_eq <|
FaithfulSMul.algebraMap_injective A K <| Eq.symm <| eq_of_div_eq_one
(by simp [mul_div_mul_comm, hx]))
(IsRelPrime.dvd_of_dvd_mul_right (IsFractionRing.num_den_reduced A x⁻¹) <|
dvd_of_mul_left_dvd (a := (num A x : A)) <| dvd_of_eq <|
FaithfulSMul.algebraMap_injective A K <| eq_of_div_eq_one
(by simp [mul_div_mul_comm, hx])) | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid"
] | Mathlib/RingTheory/Localization/NumDen.lean | associated_den_num_inv | null |
associated_num_den_inv (x : K) (hx : x ≠ 0) : Associated (num A x : A) (den A x⁻¹) := by
have : Associated (num A x⁻¹⁻¹ : A) (den A x⁻¹) :=
(associated_den_num_inv x⁻¹ (inv_ne_zero hx)).symm
rw [inv_inv] at this
exact this | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid"
] | Mathlib/RingTheory/Localization/NumDen.lean | associated_num_den_inv | null |
isUnit_piRingHom_algebraMap_comp_piEvalRingHom (y : M) :
IsUnit ((Pi.ringHom fun i ↦ (algebraMap (R i) (S i)).comp (Pi.evalRingHom R i)) y) :=
Pi.isUnit_iff.mpr fun i ↦ map_units _ (⟨y.1 i, y, y.2, rfl⟩ : M.map (Pi.evalRingHom R i)) | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.BigOperators.Pi",
"Mathlib.Algebra.Divisibility.Prod",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.Algebra.Group.Pi.Units",
"Mathlib.RingTheory.KrullDimension.Ze... | Mathlib/RingTheory/Localization/Pi.lean | isUnit_piRingHom_algebraMap_comp_piEvalRingHom | If `S i` is a localization of `R i` at the submonoid `M i` for each `i`,
then `Π i, S i` is a localization of `Π i, R i` at the product submonoid. -/
instance (M : Π i, Submonoid (R i)) [∀ i, IsLocalization (M i) (S i)] :
IsLocalization (.pi .univ M) (Π i, S i) where
map_units m := Pi.isUnit_iff.mpr fun i ↦ map_units _ ⟨m.1 i, m.2 i ⟨⟩⟩
surj z := by
choose rm h using fun i ↦ surj (M := M i) (z i)
exact ⟨(fun i ↦ (rm i).1, ⟨_, fun i _ ↦ (rm i).2.2⟩), funext h⟩
exists_of_eq {x y} eq := by
choose c hc using fun i ↦ exists_of_eq (M := M i) (congr_fun eq i)
exact ⟨⟨_, fun i _ ↦ (c i).2⟩, funext hc⟩
variable (S' : Type*) [CommSemiring S'] [Algebra (Π i, R i) S'] (M : Submonoid (Π i, R i))
theorem iff_map_piEvalRingHom [Finite ι] :
IsLocalization M S' ↔ IsLocalization (.pi .univ fun i ↦ M.map (Pi.evalRingHom R i)) S' :=
iff_of_le_of_exists_dvd M _ (fun m hm i _ ↦ ⟨m, hm, rfl⟩) fun n hn ↦ by
choose m mem eq using hn
have := Fintype.ofFinite ι
refine ⟨∏ i, m i ⟨⟩, prod_mem fun i _ ↦ mem i _, pi_dvd_iff.mpr fun i ↦ ?_⟩
rw [Fintype.prod_apply]
exact (eq i ⟨⟩).symm.dvd.trans (Finset.dvd_prod_of_mem _ <| Finset.mem_univ _)
variable [∀ i, IsLocalization (M.map (Pi.evalRingHom R i)) (S i)]
/-- Let `M` be a submonoid of a direct product of commutative rings `R i`, and let `M' i` denote
the projection of `M` onto each corresponding factor. Given a ring homomorphism from the direct
product `Π i, R i` to the product of the localizations of each `R i` at `M' i`, every `y : M`
maps to a unit under this homomorphism. |
bijective_lift_piRingHom_algebraMap_comp_piEvalRingHom [IsLocalization M S'] [Finite ι] :
Function.Bijective (lift (S := S') (isUnit_piRingHom_algebraMap_comp_piEvalRingHom R S M)) :=
have := (iff_map_piEvalRingHom R (Π i, S i) M).mpr inferInstance
(ringEquivOfRingEquiv (M := M) (T := M) _ _ (.refl _) <|
Submonoid.map_equiv_eq_comap_symm _ _).bijective
open Function Ideal
include M in
variable {R} in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.BigOperators.Pi",
"Mathlib.Algebra.Divisibility.Prod",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.Algebra.Group.Pi.Units",
"Mathlib.RingTheory.KrullDimension.Ze... | Mathlib/RingTheory/Localization/Pi.lean | bijective_lift_piRingHom_algebraMap_comp_piEvalRingHom | Let `M` be a submonoid of a direct product of commutative rings `R i`, and let `M' i` denote
the projection of `M` onto each factor. Then the canonical map from the localization of the direct
product `Π i, R i` at `M` to the direct product of the localizations of each `R i` at `M' i`
is bijective. |
surjective_piRingHom_algebraMap_comp_piEvalRingHom
[∀ i, Ring.KrullDimLE 0 (R i)] [∀ i, IsLocalRing (R i)] :
Surjective (Pi.ringHom (fun i ↦ (algebraMap (R i) (S i)).comp (Pi.evalRingHom R i))) := by
apply Surjective.piMap (fun i ↦ ?_)
by_cases h₀ : (0 : R i) ∈ (M.map (Pi.evalRingHom R i))
· have := uniqueOfZeroMem h₀ (S := (S i))
exact surjective_to_subsingleton (algebraMap (R i) (S i))
· exact (IsLocalization.atUnits _ _ (by simpa)).surjective
variable {R} in | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.BigOperators.Pi",
"Mathlib.Algebra.Divisibility.Prod",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.Algebra.Group.Pi.Units",
"Mathlib.RingTheory.KrullDimension.Ze... | Mathlib/RingTheory/Localization/Pi.lean | surjective_piRingHom_algebraMap_comp_piEvalRingHom | null |
algebraMap_pi_surjective_of_isLocalization [∀ i, Ring.KrullDimLE 0 (R i)]
[∀ i, IsLocalRing (R i)] [IsLocalization M S']
[Finite ι] : Surjective (algebraMap (Π i, R i) S') := by
intro s
set S := fun (i : ι) => Localization (M.map (Pi.evalRingHom R i))
obtain ⟨r, hr⟩ :=
surjective_piRingHom_algebraMap_comp_piEvalRingHom
S M ((lift (isUnit_piRingHom_algebraMap_comp_piEvalRingHom R S M)) s)
refine ⟨r, (bijective_lift_piRingHom_algebraMap_comp_piEvalRingHom R S _ M).injective ?_⟩
rwa [lift_eq (isUnit_piRingHom_algebraMap_comp_piEvalRingHom R S M) r] | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.BigOperators.Pi",
"Mathlib.Algebra.Divisibility.Prod",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.Algebra.Group.Pi.Units",
"Mathlib.RingTheory.KrullDimension.Ze... | Mathlib/RingTheory/Localization/Pi.lean | algebraMap_pi_surjective_of_isLocalization | Let `M` be a submonoid of a direct product of commutative rings `R i`.
If each `R i` has maximal nilradical then the direct product `∏ R i` surjects onto the
localization of `∏ R i` at `M`. |
coeSubmodule (I : Ideal R) : Submodule R S :=
Submodule.map (Algebra.linearMap R S) I | def | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | coeSubmodule | Map from ideals of `R` to submodules of `S` induced by `f`. |
mem_coeSubmodule (I : Ideal R) {x : S} :
x ∈ coeSubmodule S I ↔ ∃ y : R, y ∈ I ∧ algebraMap R S y = x :=
Iff.rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | mem_coeSubmodule | null |
coeSubmodule_mono {I J : Ideal R} (h : I ≤ J) : coeSubmodule S I ≤ coeSubmodule S J :=
Submodule.map_mono h
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | coeSubmodule_mono | null |
coeSubmodule_bot : coeSubmodule S (⊥ : Ideal R) = ⊥ := by
rw [coeSubmodule, Submodule.map_bot]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | coeSubmodule_bot | null |
coeSubmodule_top : coeSubmodule S (⊤ : Ideal R) = 1 := by
rw [coeSubmodule, Submodule.map_top, Submodule.one_eq_range]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | coeSubmodule_top | null |
coeSubmodule_sup (I J : Ideal R) :
coeSubmodule S (I ⊔ J) = coeSubmodule S I ⊔ coeSubmodule S J :=
Submodule.map_sup _ _ _
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | coeSubmodule_sup | null |
coeSubmodule_mul (I J : Ideal R) :
coeSubmodule S (I * J) = coeSubmodule S I * coeSubmodule S J :=
Submodule.map_mul _ _ (Algebra.ofId R S) | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | coeSubmodule_mul | null |
coeSubmodule_fg (hS : Function.Injective (algebraMap R S)) (I : Ideal R) :
Submodule.FG (coeSubmodule S I) ↔ Submodule.FG I :=
⟨Submodule.fg_of_fg_map_injective _ hS, Submodule.FG.map _⟩
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | coeSubmodule_fg | null |
coeSubmodule_span (s : Set R) :
coeSubmodule S (Ideal.span s) = Submodule.span R (algebraMap R S '' s) := by
rw [IsLocalization.coeSubmodule, Ideal.span, Submodule.map_span]
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | coeSubmodule_span | null |
coeSubmodule_span_singleton (x : R) :
coeSubmodule S (Ideal.span {x}) = Submodule.span R {(algebraMap R S) x} := by
rw [coeSubmodule_span, Set.image_singleton]
variable [IsLocalization M S]
include M in | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | coeSubmodule_span_singleton | null |
isNoetherianRing (h : IsNoetherianRing R) : IsNoetherianRing S := by
rw [isNoetherianRing_iff, isNoetherian_iff] at h ⊢
exact OrderEmbedding.wellFounded (IsLocalization.orderEmbedding M S).dual h | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | isNoetherianRing | null |
_root_.Algebra.EssFiniteType.isNoetherianRing
(R S : Type*) [CommRing R] [CommRing S] [Algebra R S]
[Algebra.EssFiniteType R S] [IsNoetherianRing R] : IsNoetherianRing S := by
exact IsLocalization.isNoetherianRing (Algebra.EssFiniteType.submonoid R S) _
(Algebra.FiniteType.isNoetherianRing R _) | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | _root_.Algebra.EssFiniteType.isNoetherianRing | null |
@[mono]
coeSubmodule_le_coeSubmodule (h : M ≤ nonZeroDivisors R) {I J : Ideal R} :
coeSubmodule S I ≤ coeSubmodule S J ↔ I ≤ J :=
Submodule.map_le_map_iff_of_injective (f := Algebra.linearMap R S) (IsLocalization.injective _ h)
_ _
@[mono] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | coeSubmodule_le_coeSubmodule | null |
coeSubmodule_strictMono (h : M ≤ nonZeroDivisors R) :
StrictMono (coeSubmodule S : Ideal R → Submodule R S) :=
strictMono_of_le_iff_le fun _ _ => (coeSubmodule_le_coeSubmodule h).symm
variable (S) | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | coeSubmodule_strictMono | null |
coeSubmodule_injective (h : M ≤ nonZeroDivisors R) :
Function.Injective (coeSubmodule S : Ideal R → Submodule R S) :=
injective_of_le_imp_le _ fun hl => (coeSubmodule_le_coeSubmodule h).mp hl | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | coeSubmodule_injective | null |
coeSubmodule_isPrincipal {I : Ideal R} (h : M ≤ nonZeroDivisors R) :
(coeSubmodule S I).IsPrincipal ↔ I.IsPrincipal := by
constructor <;> rintro ⟨⟨x, hx⟩⟩
· have x_mem : x ∈ coeSubmodule S I := hx.symm ▸ Submodule.mem_span_singleton_self x
obtain ⟨x, _, rfl⟩ := (mem_coeSubmodule _ _).mp x_mem
refine ⟨⟨x, coeSubmodule_injective S h ?_⟩⟩
rw [Ideal.submodule_span_eq, hx, coeSubmodule_span_singleton]
· refine ⟨⟨algebraMap R S x, ?_⟩⟩
rw [hx, Ideal.submodule_span_eq, coeSubmodule_span_singleton] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | coeSubmodule_isPrincipal | null |
mem_span_iff {N : Type*} [AddCommMonoid N] [Module R N] [Module S N] [IsScalarTower R S N]
{x : N} {a : Set N} :
x ∈ Submodule.span S a ↔ ∃ y ∈ Submodule.span R a, ∃ z : M, x = mk' S 1 z • y := by
constructor
· intro h
refine Submodule.span_induction ?_ ?_ ?_ ?_ h
· rintro x hx
exact ⟨x, Submodule.subset_span hx, 1, by rw [mk'_one, map_one, one_smul]⟩
· exact ⟨0, Submodule.zero_mem _, 1, by rw [mk'_one, map_one, one_smul]⟩
· rintro _ _ _ _ ⟨y, hy, z, rfl⟩ ⟨y', hy', z', rfl⟩
refine
⟨(z' : R) • y + (z : R) • y',
Submodule.add_mem _ (Submodule.smul_mem _ _ hy) (Submodule.smul_mem _ _ hy'), z * z', ?_⟩
rw [smul_add, ← IsScalarTower.algebraMap_smul S (z : R), ←
IsScalarTower.algebraMap_smul S (z' : R), smul_smul, smul_smul]
congr 1
· rw [← mul_one (1 : R), mk'_mul, mul_assoc, mk'_spec, map_one, mul_one, mul_one]
· rw [← mul_one (1 : R), mk'_mul, mul_right_comm, mk'_spec, map_one, mul_one, one_mul]
· rintro a _ _ ⟨y, hy, z, rfl⟩
obtain ⟨y', z', rfl⟩ := mk'_surjective M a
refine ⟨y' • y, Submodule.smul_mem _ _ hy, z' * z, ?_⟩
rw [← IsScalarTower.algebraMap_smul S y', smul_smul, ← mk'_mul, smul_smul,
mul_comm (mk' S _ _), mul_mk'_eq_mk'_of_mul]
· rintro ⟨y, hy, z, rfl⟩
exact Submodule.smul_mem _ _ (Submodule.span_subset_span R S _ hy) | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | mem_span_iff | null |
mem_span_map {x : S} {a : Set R} :
x ∈ Ideal.span (algebraMap R S '' a) ↔ ∃ y ∈ Ideal.span a, ∃ z : M, x = mk' S y z := by
refine (mem_span_iff M).trans ?_
constructor
· rw [← coeSubmodule_span]
rintro ⟨_, ⟨y, hy, rfl⟩, z, hz⟩
refine ⟨y, hy, z, ?_⟩
rw [hz, Algebra.linearMap_apply, smul_eq_mul, mul_comm, mul_mk'_eq_mk'_of_mul, mul_one]
· rintro ⟨y, hy, z, hz⟩
refine ⟨algebraMap R S y, Submodule.map_mem_span_algebraMap_image _ _ hy, z, ?_⟩
rw [hz, smul_eq_mul, mul_comm, mul_mk'_eq_mk'_of_mul, mul_one] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | mem_span_map | null |
@[simp, mono]
coeSubmodule_le_coeSubmodule {I J : Ideal R} :
coeSubmodule K I ≤ coeSubmodule K J ↔ I ≤ J :=
IsLocalization.coeSubmodule_le_coeSubmodule le_rfl
@[mono] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | coeSubmodule_le_coeSubmodule | null |
coeSubmodule_strictMono : StrictMono (coeSubmodule K : Ideal R → Submodule R K) :=
strictMono_of_le_iff_le fun _ _ => coeSubmodule_le_coeSubmodule.symm
variable (R K) | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | coeSubmodule_strictMono | null |
coeSubmodule_injective : Function.Injective (coeSubmodule K : Ideal R → Submodule R K) :=
injective_of_le_imp_le _ fun hl => coeSubmodule_le_coeSubmodule.mp hl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | coeSubmodule_injective | null |
coeSubmodule_isPrincipal {I : Ideal R} : (coeSubmodule K I).IsPrincipal ↔ I.IsPrincipal :=
IsLocalization.coeSubmodule_isPrincipal _ le_rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.EssentialFiniteness"
] | Mathlib/RingTheory/Localization/Submodule.lean | coeSubmodule_isPrincipal | null |
LocalizationPreserves : Prop :=
∀ {R : Type u} [hR : CommRing R] (M : Submonoid R) (S : Type u) [hS : CommRing S] [Algebra R S]
[IsLocalization M S], @P R hR → @P S hS | def | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | LocalizationPreserves | A property `P` of comm rings is said to be preserved by localization
if `P` holds for `M⁻¹R` whenever `P` holds for `R`. |
OfLocalizationMaximal : Prop :=
∀ (R : Type u) [CommRing R],
(∀ (J : Ideal R) (_ : J.IsMaximal), P (Localization.AtPrime J)) → P R | def | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | OfLocalizationMaximal | A property `P` of comm rings satisfies `OfLocalizationMaximal`
if `P` holds for `R` whenever `P` holds for `Rₘ` for all maximal ideal `m`. |
RingHom.ContainsIdentities := ∀ (R : Type u) [CommRing R], P (RingHom.id R) | def | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.ContainsIdentities | A property `P` of ring homs is said to contain identities if `P` holds
for the identity homomorphism of every ring. |
RingHom.LocalizationPreserves :=
∀ ⦃R S : Type u⦄ [CommRing R] [CommRing S] (f : R →+* S) (M : Submonoid R) (R' S' : Type u)
[CommRing R'] [CommRing S'] [Algebra R R'] [Algebra S S'] [IsLocalization M R']
[IsLocalization (M.map f) S'],
P f → P (IsLocalization.map S' f (Submonoid.le_comap_map M) : R' →+* S') | def | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.LocalizationPreserves | A property `P` of ring homs is said to be preserved by localization
if `P` holds for `M⁻¹R →+* M⁻¹S` whenever `P` holds for `R →+* S`. |
RingHom.LocalizationAwayPreserves :=
∀ ⦃R S : Type u⦄ [CommRing R] [CommRing S] (f : R →+* S) (r : R) (R' S' : Type u)
[CommRing R'] [CommRing S'] [Algebra R R'] [Algebra S S'] [IsLocalization.Away r R']
[IsLocalization.Away (f r) S'],
P f → P (IsLocalization.Away.map R' S' f r : R' →+* S') | def | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.LocalizationAwayPreserves | A property `P` of ring homs is said to be preserved by localization away
if `P` holds for `Rᵣ →+* Sᵣ` whenever `P` holds for `R →+* S`. |
RingHom.OfLocalizationFiniteSpan :=
∀ ⦃R S : Type u⦄ [CommRing R] [CommRing S] (f : R →+* S) (s : Finset R)
(_ : Ideal.span (s : Set R) = ⊤) (_ : ∀ r : s, P (Localization.awayMap f r)), P f | def | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.OfLocalizationFiniteSpan | A property `P` of ring homs satisfies `RingHom.OfLocalizationFiniteSpan`
if `P` holds for `R →+* S` whenever there exists a finite set `{ r }` that spans `R` such that
`P` holds for `Rᵣ →+* Sᵣ`.
Note that this is equivalent to `RingHom.OfLocalizationSpan` via
`RingHom.ofLocalizationSpan_iff_finite`, but this is easier to prove. |
RingHom.OfLocalizationSpan :=
∀ ⦃R S : Type u⦄ [CommRing R] [CommRing S] (f : R →+* S) (s : Set R) (_ : Ideal.span s = ⊤)
(_ : ∀ r : s, P (Localization.awayMap f r)), P f | def | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.OfLocalizationSpan | A property `P` of ring homs satisfies `RingHom.OfLocalizationFiniteSpan`
if `P` holds for `R →+* S` whenever there exists a set `{ r }` that spans `R` such that
`P` holds for `Rᵣ →+* Sᵣ`.
Note that this is equivalent to `RingHom.OfLocalizationFiniteSpan` via
`RingHom.ofLocalizationSpan_iff_finite`, but this has less restrictions when applying. |
RingHom.HoldsForLocalizationAway : Prop :=
∀ ⦃R : Type u⦄ (S : Type u) [CommRing R] [CommRing S] [Algebra R S] (r : R)
[IsLocalization.Away r S], P (algebraMap R S) | def | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.HoldsForLocalizationAway | A property `P` of ring homs satisfies `RingHom.HoldsForLocalizationAway`
if `P` holds for each localization map `R →+* Rᵣ`. |
RingHom.StableUnderCompositionWithLocalizationAwaySource : Prop :=
∀ ⦃R : Type u⦄ (S : Type u) ⦃T : Type u⦄ [CommRing R] [CommRing S] [CommRing T] [Algebra R S]
(r : R) [IsLocalization.Away r S] (f : S →+* T), P f → P (f.comp (algebraMap R S)) | def | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.StableUnderCompositionWithLocalizationAwaySource | A property `P` of ring homs satisfies `RingHom.StableUnderCompositionWithLocalizationAwaySource`
if whenever `P` holds for `f` it also holds for the composition with
localization maps on the source. |
RingHom.StableUnderCompositionWithLocalizationAwayTarget : Prop :=
∀ ⦃R S : Type u⦄ (T : Type u) [CommRing R] [CommRing S] [CommRing T] [Algebra S T] (s : S)
[IsLocalization.Away s T] (f : R →+* S), P f → P ((algebraMap S T).comp f) | def | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.StableUnderCompositionWithLocalizationAwayTarget | A property `P` of ring homs satisfies `RingHom.StableUnderCompositionWithLocalizationAway`
if whenever `P` holds for `f` it also holds for the composition with
localization maps on the target. |
RingHom.StableUnderCompositionWithLocalizationAway : Prop :=
StableUnderCompositionWithLocalizationAwaySource P ∧
StableUnderCompositionWithLocalizationAwayTarget P | def | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.StableUnderCompositionWithLocalizationAway | A property `P` of ring homs satisfies `RingHom.StableUnderCompositionWithLocalizationAway`
if whenever `P` holds for `f` it also holds for the composition with
localization maps on the left and on the right. |
RingHom.OfLocalizationFiniteSpanTarget : Prop :=
∀ ⦃R S : Type u⦄ [CommRing R] [CommRing S] (f : R →+* S) (s : Finset S)
(_ : Ideal.span (s : Set S) = ⊤)
(_ : ∀ r : s, P ((algebraMap S (Localization.Away (r : S))).comp f)), P f | def | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.OfLocalizationFiniteSpanTarget | A property `P` of ring homs satisfies `RingHom.OfLocalizationFiniteSpanTarget`
if `P` holds for `R →+* S` whenever there exists a finite set `{ r }` that spans `S` such that
`P` holds for `R →+* Sᵣ`.
Note that this is equivalent to `RingHom.OfLocalizationSpanTarget` via
`RingHom.ofLocalizationSpanTarget_iff_finite`, but this is easier to prove. |
RingHom.OfLocalizationSpanTarget : Prop :=
∀ ⦃R S : Type u⦄ [CommRing R] [CommRing S] (f : R →+* S) (s : Set S) (_ : Ideal.span s = ⊤)
(_ : ∀ r : s, P ((algebraMap S (Localization.Away (r : S))).comp f)), P f | def | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.OfLocalizationSpanTarget | A property `P` of ring homs satisfies `RingHom.OfLocalizationSpanTarget`
if `P` holds for `R →+* S` whenever there exists a set `{ r }` that spans `S` such that
`P` holds for `R →+* Sᵣ`.
Note that this is equivalent to `RingHom.OfLocalizationFiniteSpanTarget` via
`RingHom.ofLocalizationSpanTarget_iff_finite`, but this has less restrictions when applying. |
RingHom.OfLocalizationPrime : Prop :=
∀ ⦃R S : Type u⦄ [CommRing R] [CommRing S] (f : R →+* S),
(∀ (J : Ideal S) (_ : J.IsPrime), P (Localization.localRingHom _ J f rfl)) → P f | def | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.OfLocalizationPrime | A property `P` of ring homs satisfies `RingHom.OfLocalizationPrime`
if `P` holds for `R` whenever `P` holds for `Rₘ` for all prime ideals `p`. |
RingHom.PropertyIsLocal : Prop where
localizationAwayPreserves : RingHom.LocalizationAwayPreserves @P
ofLocalizationSpanTarget : RingHom.OfLocalizationSpanTarget @P
ofLocalizationSpan : RingHom.OfLocalizationSpan @P
StableUnderCompositionWithLocalizationAwayTarget :
RingHom.StableUnderCompositionWithLocalizationAwayTarget @P | structure | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.PropertyIsLocal | A property of ring homs is local if it is preserved by localizations and compositions, and for
each `{ r }` that spans `S`, we have `P (R →+* S) ↔ ∀ r, P (R →+* Sᵣ)`. |
RingHom.ofLocalizationSpan_iff_finite :
RingHom.OfLocalizationSpan @P ↔ RingHom.OfLocalizationFiniteSpan @P := by
delta RingHom.OfLocalizationSpan RingHom.OfLocalizationFiniteSpan
apply forall₅_congr
intros
constructor
· intro h s; exact h s
· intro h s hs hs'
obtain ⟨s', h₁, h₂⟩ := (Ideal.span_eq_top_iff_finite s).mp hs
exact h s' h₂ fun x => hs' ⟨_, h₁ x.prop⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.ofLocalizationSpan_iff_finite | null |
RingHom.ofLocalizationSpanTarget_iff_finite :
RingHom.OfLocalizationSpanTarget @P ↔ RingHom.OfLocalizationFiniteSpanTarget @P := by
delta RingHom.OfLocalizationSpanTarget RingHom.OfLocalizationFiniteSpanTarget
apply forall₅_congr
intros
constructor
· intro h s; exact h s
· intro h s hs hs'
obtain ⟨s', h₁, h₂⟩ := (Ideal.span_eq_top_iff_finite s).mp hs
exact h s' h₂ fun x => hs' ⟨_, h₁ x.prop⟩
open TensorProduct
attribute [local instance] Algebra.TensorProduct.rightAlgebra in | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.ofLocalizationSpanTarget_iff_finite | null |
RingHom.OfLocalizationSpan.mk (hP : RingHom.RespectsIso P)
(H : ∀ {R S : Type u} [CommRing R] [CommRing S] [Algebra R S] (s : Set R),
Ideal.span s = ⊤ →
(∀ r ∈ s, P (algebraMap (Localization.Away r) (Localization.Away r ⊗[R] S))) →
P (algebraMap R S)) :
OfLocalizationSpan P := by
introv R hs hf
algebraize [f]
let _ := fun r : R => (Localization.awayMap (algebraMap R S) r).toAlgebra
refine H s hs (fun r hr ↦ ?_)
have : algebraMap (Localization.Away r) (Localization.Away r ⊗[R] S) =
((IsLocalization.Away.tensorRightEquiv S r (Localization.Away r)).symm : _ →+* _).comp
(algebraMap (Localization.Away r) (Localization.Away (algebraMap R S r))) := by
apply IsLocalization.ringHom_ext (Submonoid.powers r)
ext
simp [RingHom.algebraMap_toAlgebra, Localization.awayMap, IsLocalization.Away.map,
Algebra.TensorProduct.tmul_one_eq_one_tmul, RingHom.algebraMap_toAlgebra]
rw [this]
exact hP.1 _ _ (hf ⟨r, hr⟩) | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.OfLocalizationSpan.mk | null |
RingHom.HoldsForLocalizationAway.of_bijective
(H : RingHom.HoldsForLocalizationAway P) (hf : Function.Bijective f) :
P f := by
letI := f.toAlgebra
have := IsLocalization.at_units (.powers (1 : R)) (by simp)
have := IsLocalization.isLocalization_of_algEquiv (.powers (1 : R))
(AlgEquiv.ofBijective (Algebra.ofId R S) hf)
exact H _ 1
variable {P f R' S'} | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.HoldsForLocalizationAway.of_bijective | null |
RingHom.StableUnderComposition.stableUnderCompositionWithLocalizationAway
(hPc : RingHom.StableUnderComposition P) (hPl : HoldsForLocalizationAway P) :
StableUnderCompositionWithLocalizationAway P := by
constructor
· introv _ _ hf
exact hPc _ _ (hPl S r) hf
· introv _ _ hf
exact hPc _ _ hf (hPl T s) | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.StableUnderComposition.stableUnderCompositionWithLocalizationAway | null |
RingHom.HoldsForLocalizationAway.containsIdentities (hPl : HoldsForLocalizationAway P) :
ContainsIdentities P := by
introv R
exact hPl.of_bijective _ _ Function.bijective_id | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.HoldsForLocalizationAway.containsIdentities | null |
RingHom.LocalizationAwayPreserves.respectsIso
(hP : LocalizationAwayPreserves P) :
RespectsIso P where
left {R S T} _ _ _ f e hf := by
letI := e.toRingHom.toAlgebra
have : IsLocalization.Away (1 : R) R :=
IsLocalization.away_of_isUnit_of_bijective _ isUnit_one (Equiv.refl _).bijective
have : IsLocalization.Away (f 1) T :=
IsLocalization.away_of_isUnit_of_bijective _ (by simp) e.bijective
convert hP f 1 R T hf
trans (IsLocalization.Away.map R T f 1).comp (algebraMap R R)
· rw [IsLocalization.Away.map, IsLocalization.map_comp]; rfl
· rfl
right {R S T} _ _ _ f e hf := by
letI := e.symm.toRingHom.toAlgebra
have : IsLocalization.Away (1 : S) R :=
IsLocalization.away_of_isUnit_of_bijective _ isUnit_one e.symm.bijective
have : IsLocalization.Away (f 1) T :=
IsLocalization.away_of_isUnit_of_bijective _ (by simp) (Equiv.refl _).bijective
convert hP f 1 R T hf
have : (IsLocalization.Away.map R T f 1).comp e.symm.toRingHom = f :=
IsLocalization.map_comp ..
conv_lhs => rw [← this, RingHom.comp_assoc]
simp only [RingEquiv.toRingHom_eq_coe, RingEquiv.symm_comp, RingHomCompTriple.comp_eq] | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.LocalizationAwayPreserves.respectsIso | null |
RingHom.StableUnderCompositionWithLocalizationAway.respectsIso
(hP : StableUnderCompositionWithLocalizationAway P) :
RespectsIso P where
left {R S T} _ _ _ f e hf := by
letI := e.toRingHom.toAlgebra
have : IsLocalization.Away (1 : S) T :=
IsLocalization.away_of_isUnit_of_bijective _ isUnit_one e.bijective
exact hP.right T (1 : S) f hf
right {R S T} _ _ _ f e hf := by
letI := e.toRingHom.toAlgebra
have : IsLocalization.Away (1 : R) S :=
IsLocalization.away_of_isUnit_of_bijective _ isUnit_one e.bijective
exact hP.left S (1 : R) f hf | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.StableUnderCompositionWithLocalizationAway.respectsIso | null |
RingHom.PropertyIsLocal.respectsIso (hP : RingHom.PropertyIsLocal @P) :
RingHom.RespectsIso @P :=
hP.localizationAwayPreserves.respectsIso | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.PropertyIsLocal.respectsIso | null |
RingHom.LocalizationPreserves.away (H : RingHom.LocalizationPreserves @P) :
RingHom.LocalizationAwayPreserves P := by
intro R S _ _ f r R' S' _ _ _ _ _ _ hf
have : IsLocalization ((Submonoid.powers r).map f) S' := by rw [Submonoid.map_powers]; assumption
exact H f (Submonoid.powers r) R' S' hf | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.LocalizationPreserves.away | null |
RingHom.PropertyIsLocal.HoldsForLocalizationAway (hP : RingHom.PropertyIsLocal @P)
(hPi : ContainsIdentities P) :
RingHom.HoldsForLocalizationAway @P := by
introv R _
have : algebraMap R S = (algebraMap R S).comp (RingHom.id R) := by simp
rw [this]
apply hP.StableUnderCompositionWithLocalizationAwayTarget S r
apply hPi | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.PropertyIsLocal.HoldsForLocalizationAway | null |
RingHom.OfLocalizationSpanTarget.ofLocalizationSpan
(hP : RingHom.OfLocalizationSpanTarget @P)
(hP' : RingHom.StableUnderCompositionWithLocalizationAwaySource @P) :
RingHom.OfLocalizationSpan @P := by
introv R hs hs'
apply_fun Ideal.map f at hs
rw [Ideal.map_span, Ideal.map_top] at hs
apply hP _ _ hs
rintro ⟨_, r, hr, rfl⟩
rw [← IsLocalization.map_comp (M := Submonoid.powers r) (S := Localization.Away r)
(T := Submonoid.powers (f r))]
· apply hP' _ r
exact hs' ⟨r, hr⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.OfLocalizationSpanTarget.ofLocalizationSpan | null |
RingHom.OfLocalizationSpan.ofIsLocalization
(hP : RingHom.OfLocalizationSpan P) (hPi : RingHom.RespectsIso P)
{R S : Type u} [CommRing R] [CommRing S] (f : R →+* S) (s : Set R) (hs : Ideal.span s = ⊤)
(hT : ∀ r : s, ∃ (Rᵣ Sᵣ : Type u) (_ : CommRing Rᵣ) (_ : CommRing Sᵣ)
(_ : Algebra R Rᵣ) (_ : Algebra S Sᵣ) (_ : IsLocalization.Away r.val Rᵣ)
(_ : IsLocalization.Away (f r.val) Sᵣ) (fᵣ : Rᵣ →+* Sᵣ)
(_ : fᵣ.comp (algebraMap R Rᵣ) = (algebraMap S Sᵣ).comp f),
P fᵣ) : P f := by
apply hP _ s hs
intro r
obtain ⟨Rᵣ, Sᵣ, _, _, _, _, _, _, fᵣ, hfᵣ, hf⟩ := hT r
let e₁ := (Localization.algEquiv (.powers r.val) Rᵣ).toRingEquiv
let e₂ := (IsLocalization.algEquiv (.powers (f r.val))
(Localization (.powers (f r.val))) Sᵣ).symm.toRingEquiv
have : Localization.awayMap f r.val =
(e₂.toRingHom.comp fᵣ).comp e₁.toRingHom := by
apply IsLocalization.ringHom_ext (.powers r.val)
ext x
have : fᵣ ((algebraMap R Rᵣ) x) = algebraMap S Sᵣ (f x) := by
rw [← RingHom.comp_apply, hfᵣ, RingHom.comp_apply]
simp [-AlgEquiv.symm_toRingEquiv, e₂, e₁, Localization.awayMap, IsLocalization.Away.map, this]
rw [this]
apply hPi.right
apply hPi.left
exact hf | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.OfLocalizationSpan.ofIsLocalization | null |
RingHom.OfLocalizationSpan.ofIsLocalization'
(hP : RingHom.OfLocalizationSpan P) (hPi : RingHom.RespectsIso P)
{R S : Type u} [CommRing R] [CommRing S] (f : R →+* S) (s : Set R) (hs : Ideal.span s = ⊤)
(hT : ∀ r : s, ∃ (Rᵣ Sᵣ : Type u) (_ : CommRing Rᵣ) (_ : CommRing Sᵣ)
(_ : Algebra R Rᵣ) (_ : Algebra S Sᵣ) (_ : IsLocalization.Away r.val Rᵣ)
(_ : IsLocalization.Away (f r.val) Sᵣ),
P (IsLocalization.Away.map Rᵣ Sᵣ f r)) : P f := by
apply hP.ofIsLocalization hPi _ s hs
intro r
obtain ⟨Rᵣ, Sᵣ, _, _, _, _, _, _, hf⟩ := hT r
exact ⟨Rᵣ, Sᵣ, inferInstance, inferInstance, inferInstance, inferInstance,
inferInstance, inferInstance, IsLocalization.Away.map Rᵣ Sᵣ f r, IsLocalization.map_comp _, hf⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.OfLocalizationSpan.ofIsLocalization' | Variant of `RingHom.OfLocalizationSpan.ofIsLocalization` where
`fᵣ = IsLocalization.Away.map`. |
RingHom.OfLocalizationSpanTarget.ofIsLocalization
(hP : RingHom.OfLocalizationSpanTarget P) (hP' : RingHom.RespectsIso P)
{R S : Type u} [CommRing R] [CommRing S] (f : R →+* S) (s : Set S) (hs : Ideal.span s = ⊤)
(hT : ∀ r : s, ∃ (T : Type u) (_ : CommRing T) (_ : Algebra S T)
(_ : IsLocalization.Away (r : S) T), P ((algebraMap S T).comp f)) : P f := by
apply hP _ s hs
intro r
obtain ⟨T, _, _, _, hT⟩ := hT r
convert hP'.1 _
(Localization.algEquiv (R := S) (Submonoid.powers (r : S)) T).symm.toRingEquiv hT
rw [← RingHom.comp_assoc, RingEquiv.toRingHom_eq_coe, AlgEquiv.toRingEquiv_eq_coe,
AlgEquiv.toRingEquiv_toRingHom, Localization.coe_algEquiv_symm, IsLocalization.map_comp,
RingHom.comp_id] | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.OfLocalizationSpanTarget.ofIsLocalization | null |
RingHom.OfLocalizationSpanTarget.and (hP : OfLocalizationSpanTarget P)
(hQ : OfLocalizationSpanTarget Q) :
OfLocalizationSpanTarget (fun f ↦ P f ∧ Q f) := by
introv R hs hf
exact ⟨hP f s hs fun r ↦ (hf r).1, hQ f s hs fun r ↦ (hf r).2⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.OfLocalizationSpanTarget.and | null |
RingHom.OfLocalizationSpan.and (hP : OfLocalizationSpan P) (hQ : OfLocalizationSpan Q) :
OfLocalizationSpan (fun f ↦ P f ∧ Q f) := by
introv R hs hf
exact ⟨hP f s hs fun r ↦ (hf r).1, hQ f s hs fun r ↦ (hf r).2⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.OfLocalizationSpan.and | null |
RingHom.LocalizationAwayPreserves.and (hP : LocalizationAwayPreserves P)
(hQ : LocalizationAwayPreserves Q) :
LocalizationAwayPreserves (fun f ↦ P f ∧ Q f) := by
introv R h
exact ⟨hP f r R' S' h.1, hQ f r R' S' h.2⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.LocalizationAwayPreserves.and | null |
RingHom.StableUnderCompositionWithLocalizationAwayTarget.and
(hP : StableUnderCompositionWithLocalizationAwayTarget P)
(hQ : StableUnderCompositionWithLocalizationAwayTarget Q) :
StableUnderCompositionWithLocalizationAwayTarget (fun f ↦ P f ∧ Q f) := by
introv R h hf
exact ⟨hP T s f hf.1, hQ T s f hf.2⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.StableUnderCompositionWithLocalizationAwayTarget.and | null |
RingHom.PropertyIsLocal.and (hP : PropertyIsLocal P) (hQ : PropertyIsLocal Q) :
PropertyIsLocal (fun f ↦ P f ∧ Q f) where
localizationAwayPreserves := hP.localizationAwayPreserves.and hQ.localizationAwayPreserves
ofLocalizationSpanTarget := hP.ofLocalizationSpanTarget.and hQ.ofLocalizationSpanTarget
ofLocalizationSpan := hP.ofLocalizationSpan.and hQ.ofLocalizationSpan
StableUnderCompositionWithLocalizationAwayTarget :=
hP.StableUnderCompositionWithLocalizationAwayTarget.and
hQ.StableUnderCompositionWithLocalizationAwayTarget | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.PropertyIsLocal.and | null |
RingHom.IsStableUnderBaseChange.of_isLocalization [Algebra R S] [Algebra R Sᵣ] [Algebra Rᵣ Sᵣ]
[IsScalarTower R S Sᵣ] [IsScalarTower R Rᵣ Sᵣ]
(M : Submonoid R) [IsLocalization M Rᵣ] [IsLocalization (Algebra.algebraMapSubmonoid S M) Sᵣ]
(h : P (algebraMap R S)) : P (algebraMap Rᵣ Sᵣ) :=
letI : Algebra.IsPushout R S Rᵣ Sᵣ := Algebra.isPushout_of_isLocalization M Rᵣ S Sᵣ
hP R S Rᵣ Sᵣ h | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.IsStableUnderBaseChange.of_isLocalization | Let `S` be an `R`-algebra and `Sᵣ` and `Rᵣ` be the respective localizations at a submonoid
`M` of `R`. If `P` is stable under base change and `P` holds for `algebraMap R S`, then
`P` holds for `algebraMap Rᵣ Sᵣ`. |
RingHom.IsStableUnderBaseChange.isLocalization_map (M : Submonoid R) [IsLocalization M Rᵣ]
(f : R →+* S) [IsLocalization (M.map f) Sᵣ] (hf : P f) :
P (IsLocalization.map Sᵣ f M.le_comap_map : Rᵣ →+* Sᵣ) := by
algebraize [f, IsLocalization.map (S := Rᵣ) Sᵣ f M.le_comap_map,
(IsLocalization.map (S := Rᵣ) Sᵣ f M.le_comap_map).comp (algebraMap R Rᵣ)]
haveI : IsScalarTower R S Sᵣ := IsScalarTower.of_algebraMap_eq'
(IsLocalization.map_comp M.le_comap_map)
haveI : IsLocalization (Algebra.algebraMapSubmonoid S M) Sᵣ :=
inferInstanceAs <| IsLocalization (M.map f) Sᵣ
apply hP.of_isLocalization M hf | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.IsStableUnderBaseChange.isLocalization_map | If `P` is stable under base change and holds for `f`, then `P` holds for `f` localized
at any submonoid `M` of `R`. |
RingHom.IsStableUnderBaseChange.localizationPreserves : LocalizationPreserves P := by
introv R hf
exact hP.isLocalization_map _ _ hf | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | RingHom.IsStableUnderBaseChange.localizationPreserves | null |
Ideal.localized'_eq_map (I : Ideal R) :
Submodule.localized' S p (Algebra.linearMap R S) I = I.map (algebraMap R S) := by
rw [map, span, Submodule.localized'_eq_span, Algebra.coe_linearMap] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | Ideal.localized'_eq_map | null |
Ideal.localized₀_eq_restrictScalars_map (I : Ideal R) :
Submodule.localized₀ p (Algebra.linearMap R S) I = (I.map (algebraMap R S)).restrictScalars R :=
congr(Submodule.restrictScalars R $(localized'_eq_map S p I)) | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | Ideal.localized₀_eq_restrictScalars_map | null |
Algebra.idealMap_eq_ofEq_comp_toLocalized₀ (I : Ideal R) :
Algebra.idealMap S I =
(LinearEquiv.ofEq _ _ <| Ideal.localized₀_eq_restrictScalars_map S p I).toLinearMap ∘ₗ
Submodule.toLocalized₀ p (Algebra.linearMap R S) I :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | Algebra.idealMap_eq_ofEq_comp_toLocalized₀ | null |
Ideal.mem_of_localization_maximal {r : R} {J : Ideal R}
(h : ∀ (P : Ideal R) (_ : P.IsMaximal),
algebraMap R _ r ∈ Ideal.map (algebraMap R (Localization.AtPrime P)) J) :
r ∈ J :=
Submodule.mem_of_localization_maximal _ _ _ _ fun P hP ↦ by
apply (localized'_eq_map (Localization.AtPrime P) P.primeCompl J).symm ▸ h P hP | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | Ideal.mem_of_localization_maximal | null |
Ideal.le_of_localization_maximal {I J : Ideal R}
(h : ∀ (P : Ideal R) (_ : P.IsMaximal),
Ideal.map (algebraMap R (Localization.AtPrime P)) I ≤
Ideal.map (algebraMap R (Localization.AtPrime P)) J) :
I ≤ J :=
fun _ hm ↦ mem_of_localization_maximal fun P hP ↦ h P hP (mem_map_of_mem _ hm) | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | Ideal.le_of_localization_maximal | Let `I J : Ideal R`. If the localization of `I` at each maximal ideal `P` is included in
the localization of `J` at `P`, then `I ≤ J`. |
Ideal.eq_of_localization_maximal {I J : Ideal R}
(h : ∀ (P : Ideal R) (_ : P.IsMaximal),
Ideal.map (algebraMap R (Localization.AtPrime P)) I =
Ideal.map (algebraMap R (Localization.AtPrime P)) J) :
I = J :=
le_antisymm (le_of_localization_maximal fun P hP ↦ (h P hP).le)
(le_of_localization_maximal fun P hP ↦ (h P hP).ge) | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | Ideal.eq_of_localization_maximal | Let `I J : Ideal R`. If the localization of `I` at each maximal ideal `P` is equal to
the localization of `J` at `P`, then `I = J`. |
ideal_eq_bot_of_localization' (I : Ideal R)
(h : ∀ (J : Ideal R) (_ : J.IsMaximal),
Ideal.map (algebraMap R (Localization.AtPrime J)) I = ⊥) :
I = ⊥ :=
Ideal.eq_of_localization_maximal fun P hP => by simpa using h P hP | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | ideal_eq_bot_of_localization' | An ideal is trivial if its localization at every maximal ideal is trivial. |
eq_zero_of_localization (r : R)
(h : ∀ (J : Ideal R) (_ : J.IsMaximal), algebraMap R (Localization.AtPrime J) r = 0) :
r = 0 :=
Module.eq_zero_of_localization_maximal _ (fun _ _ ↦ Algebra.linearMap R _) r h | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | eq_zero_of_localization | null |
ideal_eq_bot_of_localization (I : Ideal R)
(h : ∀ (J : Ideal R) (_ : J.IsMaximal),
IsLocalization.coeSubmodule (Localization.AtPrime J) I = ⊥) :
I = ⊥ :=
bot_unique fun r hr ↦ eq_zero_of_localization r fun J hJ ↦ (h J hJ).le ⟨r, hr, rfl⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Submodule",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/LocalProperties/Basic.lean | ideal_eq_bot_of_localization | An ideal is trivial if its localization at every maximal ideal is trivial. |
injective_of_isLocalized_maximal
(H : ∀ (P : Ideal R) [P.IsMaximal], Function.Injective (map P.primeCompl (f P) (g P) F)) :
Function.Injective F :=
fun x y eq ↦ Module.eq_of_localization_maximal _ f _ _ fun P _ ↦ H P <| by simp [eq] | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.Algebra.Module.LocalizedModule.AtPrime",
"Mathlib.Algebra.Module.LocalizedModule.Away"
] | Mathlib/RingTheory/LocalProperties/Exactness.lean | injective_of_isLocalized_maximal | null |
surjective_of_isLocalized_maximal
(H : ∀ (P : Ideal R) [P.IsMaximal], Function.Surjective (map P.primeCompl (f P) (g P) F)) :
Function.Surjective F :=
range_eq_top.mp <| eq_top_of_localization₀_maximal Nₚ g _ <|
fun P _ ↦ (range_localizedMap_eq_localized₀_range _ (f P) (g P) F).symm.trans <|
range_eq_top.mpr <| H P | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.Algebra.Module.LocalizedModule.AtPrime",
"Mathlib.Algebra.Module.LocalizedModule.Away"
] | Mathlib/RingTheory/LocalProperties/Exactness.lean | surjective_of_isLocalized_maximal | null |
bijective_of_isLocalized_maximal
(H : ∀ (P : Ideal R) [P.IsMaximal], Function.Bijective (map P.primeCompl (f P) (g P) F)) :
Function.Bijective F :=
⟨injective_of_isLocalized_maximal Mₚ f Nₚ g F fun J _ ↦ (H J).1,
surjective_of_isLocalized_maximal Mₚ f Nₚ g F fun J _ ↦ (H J).2⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.Algebra.Module.LocalizedModule.AtPrime",
"Mathlib.Algebra.Module.LocalizedModule.Away"
] | Mathlib/RingTheory/LocalProperties/Exactness.lean | bijective_of_isLocalized_maximal | null |
exact_of_isLocalized_maximal (H : ∀ (J : Ideal R) [J.IsMaximal],
Function.Exact (map J.primeCompl (f J) (g J) F) (map J.primeCompl (g J) (h J) G)) :
Function.Exact F G := by
simp only [LinearMap.exact_iff] at H ⊢
apply eq_of_localization₀_maximal Nₚ g
intro J hJ
rw [← LinearMap.range_localizedMap_eq_localized₀_range _ (f J) (g J) F,
← LinearMap.ker_localizedMap_eq_localized₀_ker J.primeCompl (g J) (h J) G]
have := SetLike.ext_iff.mp <| H J
ext x
simp only [mem_range, mem_ker] at this ⊢
exact this x | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.Algebra.Module.LocalizedModule.AtPrime",
"Mathlib.Algebra.Module.LocalizedModule.Away"
] | Mathlib/RingTheory/LocalProperties/Exactness.lean | exact_of_isLocalized_maximal | null |
injective_of_localized_maximal
(h : ∀ (J : Ideal R) [J.IsMaximal], Function.Injective (map J.primeCompl f)) :
Function.Injective f :=
injective_of_isLocalized_maximal _ (fun _ _ ↦ mkLinearMap _ _) _ (fun _ _ ↦ mkLinearMap _ _) f h | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.Algebra.Module.LocalizedModule.AtPrime",
"Mathlib.Algebra.Module.LocalizedModule.Away"
] | Mathlib/RingTheory/LocalProperties/Exactness.lean | injective_of_localized_maximal | null |
surjective_of_localized_maximal
(h : ∀ (J : Ideal R) [J.IsMaximal], Function.Surjective (map J.primeCompl f)) :
Function.Surjective f :=
surjective_of_isLocalized_maximal _ (fun _ _ ↦ mkLinearMap _ _) _ (fun _ _ ↦ mkLinearMap _ _) f h | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.Algebra.Module.LocalizedModule.AtPrime",
"Mathlib.Algebra.Module.LocalizedModule.Away"
] | Mathlib/RingTheory/LocalProperties/Exactness.lean | surjective_of_localized_maximal | null |
bijective_of_localized_maximal
(h : ∀ (J : Ideal R) [J.IsMaximal], Function.Bijective (map J.primeCompl f)) :
Function.Bijective f :=
⟨injective_of_localized_maximal _ fun J _ ↦ (h J).1,
surjective_of_localized_maximal _ fun J _ ↦ (h J).2⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.Algebra.Module.LocalizedModule.AtPrime",
"Mathlib.Algebra.Module.LocalizedModule.Away"
] | Mathlib/RingTheory/LocalProperties/Exactness.lean | bijective_of_localized_maximal | null |
exact_of_localized_maximal
(h : ∀ (J : Ideal R) [J.IsMaximal], Function.Exact (map J.primeCompl f) (map J.primeCompl g)) :
Function.Exact f g :=
exact_of_isLocalized_maximal _ (fun _ _ ↦ mkLinearMap _ _) _ (fun _ _ ↦ mkLinearMap _ _)
_ (fun _ _ ↦ mkLinearMap _ _) f g h | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.Algebra.Module.LocalizedModule.AtPrime",
"Mathlib.Algebra.Module.LocalizedModule.Away"
] | Mathlib/RingTheory/LocalProperties/Exactness.lean | exact_of_localized_maximal | null |
injective_of_isLocalized_span
(H : ∀ r : s, Function.Injective (map (.powers r.1) (f r) (g r) F)) :
Function.Injective F :=
fun x y eq ↦ Module.eq_of_isLocalized_span _ spn _ f _ _ fun P ↦ H P <| by simp [eq] | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.Algebra.Module.LocalizedModule.AtPrime",
"Mathlib.Algebra.Module.LocalizedModule.Away"
] | Mathlib/RingTheory/LocalProperties/Exactness.lean | injective_of_isLocalized_span | null |
surjective_of_isLocalized_span
(H : ∀ r : s, Function.Surjective (map (.powers r.1) (f r) (g r) F)) :
Function.Surjective F :=
range_eq_top.mp <| eq_top_of_isLocalized₀_span s spn Nₚ g fun r ↦
(range_localizedMap_eq_localized₀_range _ (f r) (g r) F).symm.trans <| range_eq_top.mpr <| H r | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.Algebra.Module.LocalizedModule.AtPrime",
"Mathlib.Algebra.Module.LocalizedModule.Away"
] | Mathlib/RingTheory/LocalProperties/Exactness.lean | surjective_of_isLocalized_span | null |
bijective_of_isLocalized_span
(H : ∀ r : s, Function.Bijective (map (.powers r.1) (f r) (g r) F)) :
Function.Bijective F :=
⟨injective_of_isLocalized_span _ spn Mₚ f Nₚ g F fun r ↦ (H r).1,
surjective_of_isLocalized_span _ spn Mₚ f Nₚ g F fun r ↦ (H r).2⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.Algebra.Module.LocalizedModule.AtPrime",
"Mathlib.Algebra.Module.LocalizedModule.Away"
] | Mathlib/RingTheory/LocalProperties/Exactness.lean | bijective_of_isLocalized_span | null |
exact_of_isLocalized_span (H : ∀ r : s, Function.Exact
(map (.powers r.1) (f r) (g r) F) (map (.powers r.1) (g r) (h r) G)) :
Function.Exact F G := by
simp only [LinearMap.exact_iff] at H ⊢
apply Submodule.eq_of_isLocalized₀_span s spn Nₚ g
intro r
rw [← LinearMap.range_localizedMap_eq_localized₀_range _ (f r) (g r) F]
rw [← LinearMap.ker_localizedMap_eq_localized₀_ker (.powers r.1) (g r) (h r) G]
have := SetLike.ext_iff.mp <| H r
ext x
simp only [mem_range, mem_ker] at this ⊢
exact this x | lemma | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.Algebra.Module.LocalizedModule.AtPrime",
"Mathlib.Algebra.Module.LocalizedModule.Away"
] | Mathlib/RingTheory/LocalProperties/Exactness.lean | exact_of_isLocalized_span | null |
injective_of_localized_span
(h : ∀ r : s, Function.Injective (map (.powers r.1) f)) :
Function.Injective f :=
injective_of_isLocalized_span s spn _ (fun _ ↦ mkLinearMap _ _) _ (fun _ ↦ mkLinearMap _ _) f h | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.Algebra.Module.LocalizedModule.AtPrime",
"Mathlib.Algebra.Module.LocalizedModule.Away"
] | Mathlib/RingTheory/LocalProperties/Exactness.lean | injective_of_localized_span | null |
surjective_of_localized_span
(h : ∀ r : s, Function.Surjective (map (.powers r.1) f)) :
Function.Surjective f :=
surjective_of_isLocalized_span s spn _ (fun _ ↦ mkLinearMap _ _) _ (fun _ ↦ mkLinearMap _ _) f h | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.Algebra.Module.LocalizedModule.AtPrime",
"Mathlib.Algebra.Module.LocalizedModule.Away"
] | Mathlib/RingTheory/LocalProperties/Exactness.lean | surjective_of_localized_span | null |
bijective_of_localized_span
(h : ∀ r : s, Function.Bijective (map (.powers r.1) f)) :
Function.Bijective f :=
⟨injective_of_localized_span _ spn _ fun r ↦ (h r).1,
surjective_of_localized_span _ spn _ fun r ↦ (h r).2⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.Algebra.Module.LocalizedModule.AtPrime",
"Mathlib.Algebra.Module.LocalizedModule.Away"
] | Mathlib/RingTheory/LocalProperties/Exactness.lean | bijective_of_localized_span | null |
exact_of_localized_span
(h : ∀ r : s, Function.Exact (map (.powers r.1) f) (map (.powers r.1) g)) :
Function.Exact f g :=
exact_of_isLocalized_span s spn _ (fun _ ↦ mkLinearMap _ _) _ (fun _ ↦ mkLinearMap _ _)
_ (fun _ ↦ mkLinearMap _ _) f g h | lemma | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.LocalProperties.Submodule",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.Algebra.Module.LocalizedModule.AtPrime",
"Mathlib.Algebra.Module.LocalizedModule.Away"
] | Mathlib/RingTheory/LocalProperties/Exactness.lean | exact_of_localized_span | null |
IsIntegrallyClosed.iInf {ι : Type*} (S : ι → Subalgebra R K)
(h : ∀ i, IsIntegrallyClosed (S i)) :
IsIntegrallyClosed (⨅ i, S i : Subalgebra R K) := by
refine (isIntegrallyClosed_iff K).mpr (fun {x} hx ↦ CanLift.prf x (Algebra.mem_iInf.mpr ?_))
intro i
have le : (⨅ i : ι, S i : Subalgebra R K) ≤ S i := iInf_le S i
algebraize [(Subalgebra.inclusion le).toRingHom]
have : IsScalarTower ↥(⨅ i, S i) (S i) K := Subalgebra.inclusion.isScalarTower_right le K
rcases (isIntegrallyClosed_iff K).mp (h i) hx.tower_top with ⟨⟨_, hin⟩, hy⟩
rwa [← hy] | theorem | RingTheory | [
"Mathlib.RingTheory.IntegralClosure.IntegrallyClosed",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Spectrum.Maximal.Localization"
] | Mathlib/RingTheory/LocalProperties/IntegrallyClosed.lean | IsIntegrallyClosed.iInf | null |
IsIntegrallyClosed.of_iInf_eq_bot {ι : Type*} (S : ι → Subalgebra R K)
(h : ∀ i : ι, IsIntegrallyClosed (S i)) (hs : ⨅ i : ι, S i = ⊥) : IsIntegrallyClosed R :=
have f : (⊥ : Subalgebra R K) ≃ₐ[R] R :=
Algebra.botEquivOfInjective (FaithfulSMul.algebraMap_injective R K)
(IsIntegrallyClosed.iInf S h).of_equiv (hs ▸ f).toRingEquiv | theorem | RingTheory | [
"Mathlib.RingTheory.IntegralClosure.IntegrallyClosed",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Spectrum.Maximal.Localization"
] | Mathlib/RingTheory/LocalProperties/IntegrallyClosed.lean | IsIntegrallyClosed.of_iInf_eq_bot | null |
IsIntegrallyClosed.of_localization_submonoid [IsDomain R] {ι : Type*} (S : ι → Submonoid R)
(h : ∀ i : ι, S i ≤ R⁰) (hi : ∀ i : ι, IsIntegrallyClosed (Localization (S i)))
(hs : ⨅ i : ι, Localization.subalgebra (FractionRing R) (S i) (h i) = ⊥) :
IsIntegrallyClosed R :=
IsIntegrallyClosed.of_iInf_eq_bot (fun i ↦ Localization.subalgebra (FractionRing R) (S i) (h i))
(fun i ↦ (hi i).of_equiv (IsLocalization.algEquiv (S i) (Localization (S i)) _).toRingEquiv) hs | theorem | RingTheory | [
"Mathlib.RingTheory.IntegralClosure.IntegrallyClosed",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Spectrum.Maximal.Localization"
] | Mathlib/RingTheory/LocalProperties/IntegrallyClosed.lean | IsIntegrallyClosed.of_localization_submonoid | null |
IsIntegrallyClosed.of_localization [IsDomain R] (S : Set (PrimeSpectrum R))
(h : ∀ p ∈ S, IsIntegrallyClosed (Localization.AtPrime p.1))
(hs : ⨅ p ∈ S, (Localization.subalgebra (FractionRing R) p.1.primeCompl
p.1.primeCompl_le_nonZeroDivisors) = ⊥) : IsIntegrallyClosed R := by
apply IsIntegrallyClosed.of_localization_submonoid (fun p : S ↦ p.1.1.primeCompl)
(fun p ↦ p.1.1.primeCompl_le_nonZeroDivisors) (fun p ↦ h p.1 p.2)
ext x
simp only [← hs, Algebra.mem_iInf, Subtype.forall] | theorem | RingTheory | [
"Mathlib.RingTheory.IntegralClosure.IntegrallyClosed",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Spectrum.Maximal.Localization"
] | Mathlib/RingTheory/LocalProperties/IntegrallyClosed.lean | IsIntegrallyClosed.of_localization | An integral domain $R$ is integrally closed if there exists a set of prime ideals $S$ such that
$\bigcap_{\mathfrak{p} \in S} R_{\mathfrak{p}} = R$ and for every $\mathfrak{p} \in S$,
$R_{\mathfrak{p}}$ is integrally closed. |
IsIntegrallyClosed.of_localization_maximal [IsDomain R]
(h : ∀ p : Ideal R, p ≠ ⊥ → [p.IsMaximal] → IsIntegrallyClosed (Localization.AtPrime p)) :
IsIntegrallyClosed R := by
by_cases hf : IsField R
· exact hf.toField.instIsIntegrallyClosed
refine of_localization (.range MaximalSpectrum.toPrimeSpectrum) (fun _ ↦ ?_) ?_
· rintro ⟨p, rfl⟩
exact h p.asIdeal (Ring.ne_bot_of_isMaximal_of_not_isField p.isMaximal hf)
· rw [iInf_range]
convert MaximalSpectrum.iInf_localization_eq_bot R (FractionRing R)
rw [subalgebra.ofField_eq, MaximalSpectrum.toPrimeSpectrum] | theorem | RingTheory | [
"Mathlib.RingTheory.IntegralClosure.IntegrallyClosed",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Spectrum.Maximal.Localization"
] | Mathlib/RingTheory/LocalProperties/IntegrallyClosed.lean | IsIntegrallyClosed.of_localization_maximal | An integral domain `R` is integral closed if `Rₘ` is integral closed
for any maximal ideal `m` of `R`. |
isIntegrallyClosed_ofLocalizationMaximal :
OfLocalizationMaximal fun R _ => ([IsDomain R] → IsIntegrallyClosed R) :=
fun _ _ h _ ↦ IsIntegrallyClosed.of_localization_maximal fun p _ hpm ↦ h p hpm | theorem | RingTheory | [
"Mathlib.RingTheory.IntegralClosure.IntegrallyClosed",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Spectrum.Maximal.Localization"
] | Mathlib/RingTheory/LocalProperties/IntegrallyClosed.lean | isIntegrallyClosed_ofLocalizationMaximal | null |
Module.free_of_isLocalizedModule {Rₛ Mₛ} [AddCommGroup Mₛ] [Module R Mₛ]
[CommRing Rₛ] [Algebra R Rₛ] [Module Rₛ Mₛ] [IsScalarTower R Rₛ Mₛ]
(S) (f : M →ₗ[R] Mₛ) [IsLocalization S Rₛ] [IsLocalizedModule S f] [Module.Free R M] :
Module.Free Rₛ Mₛ :=
Free.of_equiv (IsLocalizedModule.isBaseChange S Rₛ f).equiv
universe uR' uM' in | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.Dimension.Constructions",
"Mathlib.LinearAlgebra.FreeModule.StrongRankCondition",
"Mathlib.RingTheory.LocalProperties.Submodule"
] | Mathlib/RingTheory/LocalProperties/Projective.lean | Module.free_of_isLocalizedModule | null |
Module.lift_rank_of_isLocalizedModule_of_free
(Rₛ : Type uR') {Mₛ : Type uM'} [AddCommGroup Mₛ] [Module R Mₛ]
[CommRing Rₛ] [Algebra R Rₛ] [Module Rₛ Mₛ] [IsScalarTower R Rₛ Mₛ] (S : Submonoid R)
(f : M →ₗ[R] Mₛ) [IsLocalization S Rₛ] [IsLocalizedModule S f] [Module.Free R M]
[Nontrivial Rₛ] :
Cardinal.lift.{uM} (Module.rank Rₛ Mₛ) = Cardinal.lift.{uM'} (Module.rank R M) := by
apply Cardinal.lift_injective.{max uM' uR'}
have := (algebraMap R Rₛ).domain_nontrivial
have := (IsLocalizedModule.isBaseChange S Rₛ f).equiv.lift_rank_eq.symm
simp only [rank_tensorProduct, rank_self,
Cardinal.lift_one, one_mul, Cardinal.lift_lift] at this ⊢
convert this
exact Cardinal.lift_umax | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.Dimension.Constructions",
"Mathlib.LinearAlgebra.FreeModule.StrongRankCondition",
"Mathlib.RingTheory.LocalProperties.Submodule"
] | Mathlib/RingTheory/LocalProperties/Projective.lean | Module.lift_rank_of_isLocalizedModule_of_free | Also see `IsLocalizedModule.lift_rank_eq` for a version for non-free modules,
but requires `S` to not contain any zero-divisors. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.