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 ⌀ |
|---|---|---|---|---|---|---|
noncomputable mapₐ (f : A →ₐ[R] B) (a : A) [Away a Aₚ] [Away (f a) Bₚ] : Aₚ →ₐ[R] Bₚ :=
⟨map Aₚ Bₚ f.toRingHom a, fun r ↦ by
dsimp only [AlgHom.toRingHom_eq_coe, map, RingHom.coe_coe, OneHom.toFun_eq_coe]
rw [IsScalarTower.algebraMap_apply R A Aₚ, IsScalarTower.algebraMap_eq R B Bₚ]
simp⟩
@[simp] | def | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | mapₐ | Given a algebra map `f : A →ₐ[R] B` and an element `a : A`, we may construct a map
`Aₐ →ₐ[R] Bₐ`. |
mapₐ_apply (f : A →ₐ[R] B) (a : A) [Away a Aₚ] [Away (f a) Bₚ] (x : Aₚ) :
mapₐ Aₚ Bₚ f a x = map Aₚ Bₚ f.toRingHom a x :=
rfl
variable {Aₚ} {Bₚ} | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | mapₐ_apply | null |
mapₐ_injective_of_injective {f : A →ₐ[R] B} (a : A) [Away a Aₚ] [Away (f a) Bₚ]
(hf : Function.Injective f) : Function.Injective (mapₐ Aₚ Bₚ f a) :=
IsLocalization.map_injective_of_injective _ _ _ hf | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | mapₐ_injective_of_injective | null |
mapₐ_surjective_of_surjective {f : A →ₐ[R] B} (a : A) [Away a Aₚ] [Away (f a) Bₚ]
(hf : Function.Surjective f) : Function.Surjective (mapₐ Aₚ Bₚ f a) :=
have : IsLocalization (Submonoid.map f.toRingHom (Submonoid.powers a)) Bₚ := by
simp only [AlgHom.toRingHom_eq_coe, Submonoid.map_powers, RingHom.coe_coe]
infer_instance
IsLocalization.map_surjective_of_surjective _ _ _ hf | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | mapₐ_surjective_of_surjective | null |
mul (T : Type*) [CommSemiring T] [Algebra S T]
[Algebra R T] [IsScalarTower R S T] (x y : R)
[IsLocalization.Away x S] [IsLocalization.Away (algebraMap R S y) T] :
IsLocalization.Away (y * x) T := by
refine mk _ ?_ (fun z ↦ ?_) (fun a b h ↦ ?_)
· simp only [map_mul, IsUnit.mul_iff, IsScalarTower.algebraMap_apply R S T]
exact ⟨algebraMap_isUnit _, IsUnit.map _ (algebraMap_isUnit x)⟩
· obtain ⟨m, p, hpq⟩ := surj (algebraMap R S y) z
obtain ⟨n, a, hab⟩ := surj x p
use m + n, a * x ^ m * y ^ n
simp only [mul_pow, pow_add, map_pow, map_mul, ← mul_assoc, hpq,
IsScalarTower.algebraMap_apply R S T, ← hab]
ring
· repeat rw [IsScalarTower.algebraMap_apply R S T] at h
obtain ⟨n, hn⟩ := exists_of_eq (algebraMap R S y) h
simp only [← map_pow, ← map_mul, ← map_mul] at hn
obtain ⟨m, hm⟩ := exists_of_eq x hn
use n + m
convert_to y ^ m * x ^ n * (x ^ m * (y ^ n * a)) = y ^ m * x ^ n * (x ^ m * (y ^ n * b))
· ring
· ring
· rw [hm] | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | mul | Localizing the localization of `R` at `x` at the image of `y` is the same as localizing
`R` at `y * x`. See `IsLocalization.Away.mul'` for the `x * y` version. |
mul' (T : Type*) [CommSemiring T] [Algebra S T] [Algebra R T] [IsScalarTower R S T] (x y : R)
[IsLocalization.Away x S] [IsLocalization.Away (algebraMap R S y) T] :
IsLocalization.Away (x * y) T :=
mul_comm x y ▸ mul S T x y | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | mul' | Localizing the localization of `R` at `x` at the image of `y` is the same as localizing
`R` at `x * y`. See `IsLocalization.Away.mul` for the `y * x` version. |
commutes {R : Type*} [CommSemiring R] (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] (x y : R)
[IsLocalization.Away x S₁] [IsLocalization.Away y S₂]
[IsLocalization.Away (algebraMap R S₂ x) T] :
IsLocalization.Away (algebraMap R S₁ y) T := by
haveI : IsLocalization (Algebra.algebraMapSubmonoid S₂ (Submonoid.powers x)) T := by
simp only [Algebra.algebraMapSubmonoid, Submonoid.map_powers]
infer_instance
convert IsLocalization.commutes S₁ S₂ T (Submonoid.powers x) (Submonoid.powers y)
ext x
simp [Algebra.algebraMapSubmonoid] | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | commutes | Localizing the localization of `R` at `x` at the image of `y` is the same as localizing
`R` at `y * x`. -/
instance (x y : R) [IsLocalization.Away x S] :
IsLocalization.Away (y * x) (Localization.Away (algebraMap R S y)) :=
IsLocalization.Away.mul S (Localization.Away (algebraMap R S y)) _ _
/-- Localizing the localization of `R` at `x` at the image of `y` is the same as localizing
`R` at `x * y`. -/
instance (x y : R) [IsLocalization.Away x S] :
IsLocalization.Away (x * y) (Localization.Away (algebraMap R S y)) :=
IsLocalization.Away.mul' S (Localization.Away (algebraMap R S y)) _ _
/-- If `S₁` is the localization of `R` away from `f` and `S₂` is the localization away from `g`,
then any localization `T` of `S₂` away from `f` is also a localization of `S₁` away from `g`. |
noncomputable atUnit (x : R) (e : IsUnit x) [IsLocalization.Away x S] : R ≃ₐ[R] S :=
atUnits R (Submonoid.powers x)
(by rwa [Submonoid.powers_eq_closure, Submonoid.closure_le, Set.singleton_subset_iff]) | def | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | atUnit | The localization away from a unit is isomorphic to the ring. |
noncomputable atOne [IsLocalization.Away (1 : R) S] : R ≃ₐ[R] S :=
@atUnit R _ S _ _ (1 : R) isUnit_one _ | def | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | atOne | The localization at one is isomorphic to the ring. |
away_of_isUnit_of_bijective {R : Type*} (S : Type*) [CommSemiring R] [CommSemiring S]
[Algebra R S] {r : R} (hr : IsUnit r) (H : Function.Bijective (algebraMap R S)) :
IsLocalization.Away r S :=
{ map_units := by
rintro ⟨_, n, rfl⟩
exact (algebraMap R S).isUnit_map (hr.pow _)
surj := fun z => by
obtain ⟨z', rfl⟩ := H.2 z
exact ⟨⟨z', 1⟩, by simp⟩
exists_of_eq := fun {x y} => by
rw [H.1.eq_iff]
rintro rfl
exact ⟨1, rfl⟩ } | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | away_of_isUnit_of_bijective | null |
away_of_isIdempotentElem_of_mul {R S} [CommSemiring R] [CommSemiring S] [Algebra R S]
{e : R} (he : IsIdempotentElem e)
(H : ∀ x y, algebraMap R S x = algebraMap R S y ↔ e * x = e * y)
(H' : Function.Surjective (algebraMap R S)) :
IsLocalization.Away e S where
map_units r := by
obtain ⟨r, n, rfl⟩ := r
simp [show algebraMap R S e = 1 by rw [← (algebraMap R S).map_one, H, mul_one, he]]
surj z := by
obtain ⟨z, rfl⟩ := H' z
exact ⟨⟨z, 1⟩, by simp⟩
exists_of_eq {x y} h := ⟨⟨e, Submonoid.mem_powers e⟩, (H x y).mp h⟩ | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | away_of_isIdempotentElem_of_mul | null |
away_of_isIdempotentElem {R S} [CommRing R] [CommRing S] [Algebra R S]
{e : R} (he : IsIdempotentElem e)
(H : RingHom.ker (algebraMap R S) = Ideal.span {1 - e})
(H' : Function.Surjective (algebraMap R S)) :
IsLocalization.Away e S :=
away_of_isIdempotentElem_of_mul he (fun x y ↦ by
rw [← sub_eq_zero, ← map_sub, ← RingHom.mem_ker, H, ← he.ker_toSpanSingleton_eq_span,
LinearMap.mem_ker, LinearMap.toSpanSingleton_apply, sub_smul, sub_eq_zero]
simp_rw [mul_comm e, smul_eq_mul]) H' | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | away_of_isIdempotentElem | null |
away_fst {R S} [CommSemiring R] [CommSemiring S] :
letI := (RingHom.fst R S).toAlgebra
IsLocalization.Away (R := R × S) (1, 0) R :=
letI := (RingHom.fst R S).toAlgebra
away_of_isIdempotentElem_of_mul (by ext <;> simp)
(fun ⟨xR, xS⟩ ⟨yR, yS⟩ ↦ show xR = yR ↔ _ by simp) Prod.fst_surjective | instance | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | away_fst | null |
away_snd {R S} [CommSemiring R] [CommSemiring S] :
letI := (RingHom.snd R S).toAlgebra
IsLocalization.Away (R := R × S) (0, 1) S :=
letI := (RingHom.snd R S).toAlgebra
away_of_isIdempotentElem_of_mul (by ext <;> simp)
(fun ⟨xR, xS⟩ ⟨yR, yS⟩ ↦ show xS = yS ↔ _ by simp) Prod.snd_surjective | instance | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | away_snd | null |
noncomputable awayLift (f : R →+* P) (r : R) (hr : IsUnit (f r)) :
Localization.Away r →+* P :=
IsLocalization.Away.lift r hr | abbrev | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | awayLift | Given a map `f : R →+* S` and an element `r : R`, such that `f r` is invertible,
we may construct a map `Rᵣ →+* S`. |
awayLift_mk {A : Type*} [CommSemiring A] (f : R →+* A) (r : R)
(a : R) (v : A) (hv : f r * v = 1) (j : ℕ) :
Localization.awayLift f r (isUnit_iff_exists_inv.mpr ⟨v, hv⟩)
(Localization.mk a ⟨r ^ j, j, rfl⟩) = f a * v ^ j := by
simp [Localization.mk_eq_mk', awayLift, Away.lift, IsLocalization.lift_mk',
Units.mul_inv_eq_iff_eq_mul, IsUnit.liftRight, mul_assoc, ← mul_pow, (mul_comm _ _).trans hv] | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | awayLift_mk | null |
noncomputable awayMap (f : R →+* P) (r : R) :
Localization.Away r →+* Localization.Away (f r) :=
IsLocalization.Away.map _ _ f r
variable {A : Type*} [CommSemiring A] [Algebra R A]
variable {B : Type*} [CommSemiring B] [Algebra R B] | abbrev | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | awayMap | Given a map `f : R →+* S` and an element `r : R`, we may construct a map `Rᵣ →+* Sᵣ`. |
noncomputable awayMapₐ (f : A →ₐ[R] B) (a : A) :
Localization.Away a →ₐ[R] Localization.Away (f a) :=
IsLocalization.Away.mapₐ _ _ f a | abbrev | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | awayMapₐ | Given a map `f : A →ₐ[R] B` and an element `a : A`, we may construct a map `Aₐ →ₐ[R] Bₐ`. |
algebraMap_injective_of_span_eq_top (s : Set R) (span_eq : Ideal.span s = ⊤) :
Function.Injective (algebraMap R <| Π a : s, Away a.1) := fun x y eq ↦ by
suffices Module.eqIdeal R x y = ⊤ by simpa [Module.eqIdeal] using (Ideal.eq_top_iff_one _).mp this
by_contra ne
have ⟨r, hrs, disj⟩ := Ideal.exists_disjoint_powers_of_span_eq_top s span_eq _ ne
let r : s := ⟨r, hrs⟩
have ⟨⟨_, n, rfl⟩, eq⟩ := (IsLocalization.eq_iff_exists (.powers r.1) _).mp (congr_fun eq r)
exact Set.disjoint_left.mp disj eq ⟨n, rfl⟩ | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | algebraMap_injective_of_span_eq_top | null |
existsUnique_algebraMap_eq_of_span_eq_top (s : Set R) (span_eq : Ideal.span s = ⊤)
(f : Π a : s, Away a.1) (h : ∀ a b : s,
Away.awayToAwayRight (P := Away (a * b : R)) a.1 b (f a) = Away.awayToAwayLeft b.1 a (f b)) :
∃! r : R, ∀ a : s, algebraMap R _ r = f a := by
have mem := (Ideal.eq_top_iff_one _).mp span_eq; clear span_eq
wlog finset_eq : ∃ t : Finset R, t = s generalizing s
· have ⟨t, hts, mem⟩ := Submodule.mem_span_finite_of_mem_span mem
have ⟨r, eq, uniq⟩ := this t (fun a ↦ f ⟨a, hts a.2⟩)
(fun a b ↦ h ⟨a, hts a.2⟩ ⟨b, hts b.2⟩) mem ⟨_, rfl⟩
refine ⟨r, fun a ↦ ?_, fun _ eq ↦ uniq _ fun a ↦ eq ⟨a, hts a.2⟩⟩
replace hts := Set.insert_subset a.2 hts
classical
have ⟨r', eq, _⟩ := this ({a.1} ∪ t) (fun a ↦ f ⟨a, hts a.2⟩) (fun a b ↦
h ⟨a, hts a.2⟩ ⟨b, hts b.2⟩) (Ideal.span_mono (fun _ ↦ .inr) mem) ⟨{a.1} ∪ t, by simp⟩
exact (congr_arg _ (uniq _ fun b ↦ eq ⟨b, .inr b.2⟩).symm).trans (eq ⟨a, .inl rfl⟩)
have span_eq := (Ideal.eq_top_iff_one _).mpr mem
refine existsUnique_of_exists_of_unique ?_ fun x y hx hy ↦
algebraMap_injective_of_span_eq_top s span_eq (funext fun a ↦ (hx a).trans (hy a).symm)
obtain ⟨s, rfl⟩ := finset_eq
choose n r eq using fun a ↦ Away.surj a.1 (f a)
let N := s.attach.sup n
let r a := a ^ (N - n a) * r a
have eq a : f a * algebraMap R _ (a ^ N) = algebraMap R _ (r a) := by
rw [map_mul, ← eq, mul_left_comm, ← map_pow, ← map_mul, ← pow_add,
Nat.sub_add_cancel (Finset.le_sup <| s.mem_attach a)]
have eq2 a b : ∃ N', (a * b) ^ N' * (r a * b ^ N) = (a * b) ^ N' * (r b * a ^ N) :=
Away.exists_of_eq (S := Away (a * b : R)) _ <| by
simp_rw [map_mul, ← Away.awayToAwayRight_eq (S := Away a.1) a.1 b (r a),
← Away.awayToAwayLeft_eq (S := Away b.1) b.1 a (r b), ← eq, map_mul,
Away.awayToAwayRight_eq, Away.awayToAwayLeft_eq, h, mul_assoc, ← map_mul, mul_comm]
choose N' hN' using eq2
let N' := (s ×ˢ s).attach.sup fun a ↦ N'
⟨_, (Finset.mem_product.mp a.2).1⟩ ⟨_, (Finset.mem_product.mp a.2).2⟩
have eq2 a b : (a * b) ^ N' * (r a * b ^ N) = (a * b) ^ N' * (r b * a ^ N) := by
dsimp only [N']; rw [← Nat.sub_add_cancel (Finset.le_sup <| (Finset.mem_attach _ ⟨⟨a, b⟩,
Finset.mk_mem_product a.2 b.2⟩)), pow_add, mul_assoc, hN', ← mul_assoc]
let N := N' + N
let r a := a ^ N' * r a
have eq a : f a * algebraMap R _ (a ^ N) = algebraMap R _ (r a) := by
rw [map_mul, ← eq, mul_left_comm, ← map_mul, ← pow_add]
have eq2 a b : r a * b ^ N = r b * a ^ N := by
rw [pow_add, mul_mul_mul_comm, ← mul_pow, eq2,
mul_comm a.1, mul_pow, mul_mul_mul_comm, ← pow_add]
have ⟨c, eq1⟩ := (Submodule.mem_span_range_iff_exists_fun _).mp <|
(Ideal.eq_top_iff_one _).mp <| (Set.image_eq_range _ _ ▸ Ideal.span_pow_eq_top _ span_eq N)
refine ⟨∑ b, c b * r b, fun a ↦ ((Away.algebraMap_isUnit a.1).pow N).mul_left_inj.mp ?_⟩
simp_rw [← map_pow, eq, ← map_mul, Finset.sum_mul, mul_assoc, eq2 _ a, mul_left_comm (c _),
← Finset.mul_sum, ← smul_eq_mul (a := c _), eq1, mul_one] | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | existsUnique_algebraMap_eq_of_span_eq_top | The sheaf condition for the structure sheaf on `Spec R`
for a covering of the whole prime spectrum by basic opens. |
noncomputable selfZPow (m : ℤ) : B :=
if _ : 0 ≤ m then algebraMap _ _ x ^ m.natAbs else mk' _ (1 : R) (Submonoid.pow x m.natAbs) | def | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | selfZPow | `selfZPow x (m : ℤ)` is `x ^ m` as an element of the localization away from `x`. |
selfZPow_of_nonneg {n : ℤ} (hn : 0 ≤ n) : selfZPow x B n = algebraMap R B x ^ n.natAbs :=
dif_pos hn
@[simp] | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | selfZPow_of_nonneg | null |
selfZPow_natCast (d : ℕ) : selfZPow x B d = algebraMap R B x ^ d :=
selfZPow_of_nonneg _ _ (Int.natCast_nonneg d)
@[simp] | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | selfZPow_natCast | null |
selfZPow_zero : selfZPow x B 0 = 1 := by
simp [selfZPow_of_nonneg _ _ le_rfl] | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | selfZPow_zero | null |
selfZPow_of_neg {n : ℤ} (hn : n < 0) :
selfZPow x B n = mk' _ (1 : R) (Submonoid.pow x n.natAbs) :=
dif_neg hn.not_ge | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | selfZPow_of_neg | null |
selfZPow_of_nonpos {n : ℤ} (hn : n ≤ 0) :
selfZPow x B n = mk' _ (1 : R) (Submonoid.pow x n.natAbs) := by
by_cases hn0 : n = 0
· simp [hn0, selfZPow_zero, Submonoid.pow_apply]
· simp [selfZPow_of_neg _ _ (lt_of_le_of_ne hn hn0)]
@[simp] | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | selfZPow_of_nonpos | null |
selfZPow_neg_natCast (d : ℕ) : selfZPow x B (-d) = mk' _ (1 : R) (Submonoid.pow x d) := by
simp [selfZPow_of_nonpos _ _ (neg_nonpos.mpr (Int.natCast_nonneg d))]
@[simp] | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | selfZPow_neg_natCast | null |
selfZPow_sub_natCast {n m : ℕ} :
selfZPow x B (n - m) = mk' _ (x ^ n) (Submonoid.pow x m) := by
by_cases h : m ≤ n
· rw [IsLocalization.eq_mk'_iff_mul_eq, Submonoid.pow_apply, Subtype.coe_mk, ← Int.ofNat_sub h,
selfZPow_natCast, ← map_pow, ← map_mul, ← pow_add, Nat.sub_add_cancel h]
· rw [← neg_sub, ← Int.ofNat_sub (le_of_not_ge h), selfZPow_neg_natCast,
IsLocalization.mk'_eq_iff_eq]
simp [Submonoid.pow_apply, ← pow_add, Nat.sub_add_cancel (le_of_not_ge h)]
@[simp] | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | selfZPow_sub_natCast | null |
selfZPow_add {n m : ℤ} : selfZPow x B (n + m) = selfZPow x B n * selfZPow x B m := by
rcases le_or_gt 0 n with hn | hn <;> rcases le_or_gt 0 m with hm | hm
· rw [selfZPow_of_nonneg _ _ hn, selfZPow_of_nonneg _ _ hm,
selfZPow_of_nonneg _ _ (add_nonneg hn hm), Int.natAbs_add_of_nonneg hn hm, pow_add]
· have : n + m = n.natAbs - m.natAbs := by
rw [Int.natAbs_of_nonneg hn, Int.ofNat_natAbs_of_nonpos hm.le, sub_neg_eq_add]
rw [selfZPow_of_nonneg _ _ hn, selfZPow_of_neg _ _ hm, this, selfZPow_sub_natCast,
IsLocalization.mk'_eq_mul_mk'_one, map_pow]
· have : n + m = m.natAbs - n.natAbs := by
rw [Int.natAbs_of_nonneg hm, Int.ofNat_natAbs_of_nonpos hn.le, sub_neg_eq_add, add_comm]
rw [selfZPow_of_nonneg _ _ hm, selfZPow_of_neg _ _ hn, this, selfZPow_sub_natCast,
IsLocalization.mk'_eq_mul_mk'_one, map_pow, mul_comm]
· rw [selfZPow_of_neg _ _ hn, selfZPow_of_neg _ _ hm, selfZPow_of_neg _ _ (add_neg hn hm),
Int.natAbs_add_of_nonpos hn.le hm.le, ← mk'_mul, one_mul]
congr
ext
simp [pow_add] | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | selfZPow_add | null |
selfZPow_mul_neg (d : ℤ) : selfZPow x B d * selfZPow x B (-d) = 1 := by
by_cases hd : d ≤ 0
· rw [selfZPow_of_nonpos x B hd, selfZPow_of_nonneg, ← map_pow, Int.natAbs_neg,
Submonoid.pow_apply, IsLocalization.mk'_spec, map_one]
apply nonneg_of_neg_nonpos
rwa [neg_neg]
· rw [selfZPow_of_nonneg x B (le_of_not_ge hd), selfZPow_of_nonpos, ← map_pow, Int.natAbs_neg,
Submonoid.pow_apply, IsLocalization.mk'_spec'_mk, map_one]
refine nonpos_of_neg_nonneg (le_of_lt ?_)
rwa [neg_neg, ← not_le] | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | selfZPow_mul_neg | null |
selfZPow_neg_mul (d : ℤ) : selfZPow x B (-d) * selfZPow x B d = 1 := by
rw [mul_comm, selfZPow_mul_neg x B d] | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | selfZPow_neg_mul | null |
selfZPow_pow_sub (a : R) (b : B) (m d : ℤ) :
selfZPow x B (m - d) * mk' B a (1 : Submonoid.powers x) = b ↔
selfZPow x B m * mk' B a (1 : Submonoid.powers x) = selfZPow x B d * b := by
rw [sub_eq_add_neg, selfZPow_add, mul_assoc, mul_comm _ (mk' B a 1), ← mul_assoc]
constructor
· intro h
have := congr_arg (fun s : B => s * selfZPow x B d) h
simp only at this
rwa [mul_assoc, mul_assoc, selfZPow_neg_mul, mul_one, mul_comm b _] at this
· intro h
have := congr_arg (fun s : B => s * selfZPow x B (-d)) h
simp only at this
rwa [mul_comm _ b, mul_assoc b _ _, selfZPow_mul_neg, mul_one] at this
variable {R : Type*} [CommRing R] (x : R) (B : Type*) [CommRing B]
variable [Algebra R B] [IsLocalization.Away x B] [IsDomain R] [WfDvdMonoid R] | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | selfZPow_pow_sub | null |
exists_reduced_fraction' {b : B} (hb : b ≠ 0) (hx : Irreducible x) :
∃ (a : R) (n : ℤ), ¬x ∣ a ∧ selfZPow x B n * algebraMap R B a = b := by
obtain ⟨⟨a₀, y⟩, H⟩ := surj (Submonoid.powers x) b
obtain ⟨d, hy⟩ := (Submonoid.mem_powers_iff y.1 x).mp y.2
have ha₀ : a₀ ≠ 0 := by
haveI := isDomain_of_le_nonZeroDivisors B
(powers_le_nonZeroDivisors_of_noZeroDivisors hx.ne_zero)
simp only [← hy, map_pow] at H
apply ((injective_iff_map_eq_zero' (algebraMap R B)).mp _ a₀).mpr.mt
· rw [← H]
apply mul_ne_zero hb (pow_ne_zero _ _)
exact
IsLocalization.to_map_ne_zero_of_mem_nonZeroDivisors B
(powers_le_nonZeroDivisors_of_noZeroDivisors hx.ne_zero)
(mem_nonZeroDivisors_iff_ne_zero.mpr hx.ne_zero)
· exact IsLocalization.injective B (powers_le_nonZeroDivisors_of_noZeroDivisors hx.ne_zero)
simp only [← hy] at H
obtain ⟨m, a, hyp1, hyp2⟩ := WfDvdMonoid.max_power_factor ha₀ hx
refine ⟨a, m - d, ?_⟩
rw [← mk'_one (M := Submonoid.powers x) B, selfZPow_pow_sub, selfZPow_natCast, selfZPow_natCast,
← map_pow _ _ d, mul_comm _ b, H, hyp2, map_mul, map_pow _ _ m]
exact ⟨hyp1, congr_arg _ (IsLocalization.mk'_one _ _)⟩ | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | exists_reduced_fraction' | null |
noncomputable mulNumerator (s : Set R)
{Rₜ : s → Type*} [∀ t, CommRing (Rₜ t)] [∀ t, Algebra R (Rₜ t)]
[∀ t, IsLocalization.Away t.val (Rₜ t)]
(p : (t : s) → Set (Rₜ t)) (x : (t : s) × p t) : R :=
x.1 * (IsLocalization.Away.sec x.1.1 x.2.1).1 | def | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Submodule"
] | Mathlib/RingTheory/Localization/Away/Lemmas.lean | mulNumerator | Given a set `s` in a ring `R` and for every `t : s` a set `p t` of fractions in
a localization of `R` at `t`, this is the function sending a pair `(t, y)`, with
`t : s` and `y : t a`, to `t` multiplied with a numerator of `y`. The range
of this function spans the unit ideal, if `s` and every `p t` do. |
span_range_mulNumerator_eq_top {s : Set R}
(hsone : Ideal.span s = ⊤) {Rₜ : s → Type*} [∀ t, CommRing (Rₜ t)] [∀ t, Algebra R (Rₜ t)]
[∀ t, IsLocalization.Away t.val (Rₜ t)]
{p : (t : s) → Set (Rₜ t)} (htone : ∀ (r : s), Ideal.span (p r) = ⊤) :
Ideal.span (Set.range (IsLocalization.Away.mulNumerator s p)) = ⊤ := by
rw [← Ideal.radical_eq_top, eq_top_iff, ← hsone, Ideal.span_le]
intro a ha
haveI : IsLocalization (Submonoid.powers a) (Rₜ ⟨a, ha⟩) :=
inferInstanceAs <| IsLocalization.Away (⟨a, ha⟩ : s).val (Rₜ ⟨a, ha⟩)
have h₁ : Ideal.span (p ⟨a, ha⟩) ≤ Ideal.span
(algebraMap R (Rₜ ⟨a, ha⟩) '' Set.range (IsLocalization.Away.mulNumerator s p)) := by
rw [Ideal.span_le]
intro x hx
rw [SetLike.mem_coe, IsLocalization.mem_span_map (Submonoid.powers a)]
refine ⟨a * (IsLocalization.Away.sec a x).1, Ideal.subset_span ⟨⟨⟨a, ha⟩, ⟨x, hx⟩⟩, rfl⟩, ?_⟩
use ⟨a ^ ((IsLocalization.Away.sec a x).2 + 1), _, rfl⟩
rw [IsLocalization.eq_mk'_iff_mul_eq, map_pow, map_mul, ← map_pow, pow_add, map_mul,
← mul_assoc, IsLocalization.Away.sec_spec a x, mul_comm, pow_one]
have h₂ : IsLocalization.mk' (Rₜ ⟨a, ha⟩) 1 (1 : Submonoid.powers a) ∈ Ideal.span
(algebraMap R (Rₜ ⟨a, ha⟩) ''
(Set.range <| IsLocalization.Away.mulNumerator s p)) := by
rw [IsLocalization.mk'_one]
apply h₁
simp [htone]
rw [IsLocalization.mem_span_map (Submonoid.powers a)] at h₂
obtain ⟨y, hy, ⟨-, m, rfl⟩, hyz⟩ := h₂
rw [IsLocalization.eq] at hyz
obtain ⟨⟨-, n, rfl⟩, hc⟩ := hyz
simp only [OneMemClass.coe_one, one_mul, mul_one] at hc
use n + m
simpa [pow_add, hc] using Ideal.mul_mem_left _ _ hy | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Submodule"
] | Mathlib/RingTheory/Localization/Away/Lemmas.lean | span_range_mulNumerator_eq_top | null |
quotient_of_isIdempotentElem {e : R} (he : IsIdempotentElem e) :
IsLocalization.Away e (R ⧸ Ideal.span {1 - e}) :=
away_of_isIdempotentElem he Ideal.mk_ker Quotient.mk_surjective | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Submodule"
] | Mathlib/RingTheory/Localization/Away/Lemmas.lean | quotient_of_isIdempotentElem | null |
@[simp]
mem_maximalIdeal (x) : x ∈ maximalIdeal R ↔ x ∈ nonunits R :=
Iff.rfl
variable (R) | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Defs",
"Mathlib.RingTheory.Spectrum.Maximal.Defs"
] | Mathlib/RingTheory/LocalRing/MaximalIdeal/Basic.lean | mem_maximalIdeal | null |
maximalIdeal.isMaximal : (maximalIdeal R).IsMaximal := by
rw [Ideal.isMaximal_iff]
constructor
· intro h
apply h
exact isUnit_one
· intro I x _ hx H
rw [mem_maximalIdeal, mem_nonunits_iff, Classical.not_not] at hx
rcases hx with ⟨u, rfl⟩
simpa using I.mul_mem_left (↑u⁻¹) H | instance | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Defs",
"Mathlib.RingTheory.Spectrum.Maximal.Defs"
] | Mathlib/RingTheory/LocalRing/MaximalIdeal/Basic.lean | maximalIdeal.isMaximal | null |
isMaximal_iff {I : Ideal R} : I.IsMaximal ↔ I = maximalIdeal R where
mp hI := hI.eq_of_le (maximalIdeal.isMaximal R).1.1 fun _ h ↦ hI.1.1 ∘ I.eq_top_of_isUnit_mem h
mpr e := e ▸ maximalIdeal.isMaximal R | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Defs",
"Mathlib.RingTheory.Spectrum.Maximal.Defs"
] | Mathlib/RingTheory/LocalRing/MaximalIdeal/Basic.lean | isMaximal_iff | null |
maximal_ideal_unique : ∃! I : Ideal R, I.IsMaximal := by
simp [isMaximal_iff]
variable {R} | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Defs",
"Mathlib.RingTheory.Spectrum.Maximal.Defs"
] | Mathlib/RingTheory/LocalRing/MaximalIdeal/Basic.lean | maximal_ideal_unique | null |
eq_maximalIdeal {I : Ideal R} (hI : I.IsMaximal) : I = maximalIdeal R :=
ExistsUnique.unique (maximal_ideal_unique R) hI <| maximalIdeal.isMaximal R | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Defs",
"Mathlib.RingTheory.Spectrum.Maximal.Defs"
] | Mathlib/RingTheory/LocalRing/MaximalIdeal/Basic.lean | eq_maximalIdeal | null |
of_singleton_maximalSpectrum [Subsingleton (MaximalSpectrum R)]
[Nonempty (MaximalSpectrum R)] : IsLocalRing R :=
let m := Classical.arbitrary (MaximalSpectrum R)
.of_unique_max_ideal ⟨m.asIdeal, m.isMaximal,
fun I hI ↦ MaximalSpectrum.mk.inj <| Subsingleton.elim ⟨I, hI⟩ m⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Defs",
"Mathlib.RingTheory.Spectrum.Maximal.Defs"
] | Mathlib/RingTheory/LocalRing/MaximalIdeal/Basic.lean | of_singleton_maximalSpectrum | The maximal spectrum of a local ring is a singleton. -/
instance : Unique (MaximalSpectrum R) where
default := ⟨maximalIdeal R, maximalIdeal.isMaximal R⟩
uniq := fun I ↦ MaximalSpectrum.ext_iff.mpr <| eq_maximalIdeal I.isMaximal
omit [IsLocalRing R] in
/-- If the maximal spectrum of a ring is a singleton, then the ring is local. |
le_maximalIdeal {J : Ideal R} (hJ : J ≠ ⊤) : J ≤ maximalIdeal R := by
rcases Ideal.exists_le_maximal J hJ with ⟨M, hM1, hM2⟩
rwa [← eq_maximalIdeal hM1] | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Defs",
"Mathlib.RingTheory.Spectrum.Maximal.Defs"
] | Mathlib/RingTheory/LocalRing/MaximalIdeal/Basic.lean | le_maximalIdeal | null |
le_maximalIdeal_of_isPrime (p : Ideal R) [hp : p.IsPrime] : p ≤ maximalIdeal R :=
le_maximalIdeal hp.ne_top | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Defs",
"Mathlib.RingTheory.Spectrum.Maximal.Defs"
] | Mathlib/RingTheory/LocalRing/MaximalIdeal/Basic.lean | le_maximalIdeal_of_isPrime | null |
notMem_maximalIdeal {x : R} : x ∉ maximalIdeal R ↔ IsUnit x := by
simp only [mem_maximalIdeal, mem_nonunits_iff, not_not]
@[deprecated (since := "2025-05-23")] alias not_mem_maximalIdeal := notMem_maximalIdeal | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Defs",
"Mathlib.RingTheory.Spectrum.Maximal.Defs"
] | Mathlib/RingTheory/LocalRing/MaximalIdeal/Basic.lean | notMem_maximalIdeal | An element `x` of a commutative local semiring is not contained in the maximal ideal
iff it is a unit. |
isField_iff_maximalIdeal_eq : IsField R ↔ maximalIdeal R = ⊥ :=
not_iff_not.mp
⟨Ring.ne_bot_of_isMaximal_of_not_isField inferInstance, fun h =>
Ring.not_isField_iff_exists_prime.mpr ⟨_, h, Ideal.IsMaximal.isPrime' _⟩⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Defs",
"Mathlib.RingTheory.Spectrum.Maximal.Defs"
] | Mathlib/RingTheory/LocalRing/MaximalIdeal/Basic.lean | isField_iff_maximalIdeal_eq | null |
maximalIdeal_le_jacobson (I : Ideal R) :
IsLocalRing.maximalIdeal R ≤ I.jacobson :=
le_sInf fun _ ⟨_, h⟩ => le_of_eq (IsLocalRing.eq_maximalIdeal h).symm | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Defs",
"Mathlib.RingTheory.Spectrum.Maximal.Defs"
] | Mathlib/RingTheory/LocalRing/MaximalIdeal/Basic.lean | maximalIdeal_le_jacobson | null |
jacobson_eq_maximalIdeal (I : Ideal R) (h : I ≠ ⊤) :
I.jacobson = IsLocalRing.maximalIdeal R :=
le_antisymm (sInf_le ⟨le_maximalIdeal h, maximalIdeal.isMaximal R⟩)
(maximalIdeal_le_jacobson I) | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Defs",
"Mathlib.RingTheory.Spectrum.Maximal.Defs"
] | Mathlib/RingTheory/LocalRing/MaximalIdeal/Basic.lean | jacobson_eq_maximalIdeal | null |
ker_eq_maximalIdeal [DivisionRing K] (φ : R →+* K) (hφ : Function.Surjective φ) :
RingHom.ker φ = maximalIdeal R :=
IsLocalRing.eq_maximalIdeal <| (RingHom.ker_isMaximal_of_surjective φ) hφ | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Defs",
"Mathlib.RingTheory.Spectrum.Maximal.Defs"
] | Mathlib/RingTheory/LocalRing/MaximalIdeal/Basic.lean | ker_eq_maximalIdeal | null |
IsLocalRing.maximalIdeal_eq_bot {R : Type*} [Field R] : IsLocalRing.maximalIdeal R = ⊥ :=
IsLocalRing.isField_iff_maximalIdeal_eq.mp (Field.toIsField R) | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Defs",
"Mathlib.RingTheory.Spectrum.Maximal.Defs"
] | Mathlib/RingTheory/LocalRing/MaximalIdeal/Basic.lean | IsLocalRing.maximalIdeal_eq_bot | null |
maximalIdeal : Ideal R where
carrier := nonunits R
zero_mem' := zero_mem_nonunits.2 <| zero_ne_one
add_mem' {_ _} hx hy := nonunits_add hx hy
smul_mem' _ _ := mul_mem_nonunits_right | def | RingTheory | [
"Mathlib.RingTheory.LocalRing.Basic"
] | Mathlib/RingTheory/LocalRing/MaximalIdeal/Defs.lean | maximalIdeal | The ideal of elements that are not units. |
residue_def (x) : residue R x = Ideal.Quotient.mk (maximalIdeal R) x := rfl | lemma | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | residue_def | null |
ker_residue : RingHom.ker (residue R) = maximalIdeal R :=
Ideal.mk_ker
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | ker_residue | null |
residue_eq_zero_iff (x : R) : residue R x = 0 ↔ x ∈ maximalIdeal R := by
rw [← RingHom.mem_ker, ker_residue] | lemma | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | residue_eq_zero_iff | null |
residue_ne_zero_iff_isUnit (x : R) : residue R x ≠ 0 ↔ IsUnit x := by
simp | lemma | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | residue_ne_zero_iff_isUnit | null |
residue_surjective :
Function.Surjective (IsLocalRing.residue R) :=
Ideal.Quotient.mk_surjective
variable (R) | lemma | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | residue_surjective | null |
ResidueField.algebra {R₀} [CommRing R₀] [Algebra R₀ R] :
Algebra R₀ (ResidueField R) :=
Ideal.Quotient.algebra _ | instance | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | ResidueField.algebra | null |
@[simp]
ResidueField.algebraMap_eq : algebraMap R (ResidueField R) = residue R :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | ResidueField.algebraMap_eq | null |
lift {R S : Type*} [CommRing R] [IsLocalRing R] [Field S] (f : R →+* S) [IsLocalHom f] :
IsLocalRing.ResidueField R →+* S :=
Ideal.Quotient.lift _ f fun a ha =>
by_contradiction fun h => ha (isUnit_of_map_unit f a (isUnit_iff_ne_zero.mpr h)) | def | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | lift | A local ring homomorphism into a field can be descended onto the residue field. |
lift_comp_residue {R S : Type*} [CommRing R] [IsLocalRing R] [Field S] (f : R →+* S)
[IsLocalHom f] : (lift f).comp (residue R) = f :=
RingHom.ext fun _ => rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | lift_comp_residue | null |
lift_residue_apply {R S : Type*} [CommRing R] [IsLocalRing R] [Field S] (f : R →+* S)
[IsLocalHom f] (x) : lift f (residue R x) = f x :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | lift_residue_apply | null |
noncomputable map (f : R →+* S) [IsLocalHom f] : ResidueField R →+* ResidueField S :=
Ideal.Quotient.lift (maximalIdeal R) ((Ideal.Quotient.mk _).comp f) fun a ha => by
unfold ResidueField
rw [RingHom.comp_apply, Ideal.Quotient.eq_zero_iff_mem]
exact map_nonunit f a ha | def | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | map | The map on residue fields induced by a local homomorphism between local rings |
@[simp]
map_id :
IsLocalRing.ResidueField.map (RingHom.id R) = RingHom.id (IsLocalRing.ResidueField R) :=
Ideal.Quotient.ringHom_ext <| RingHom.ext fun _ => rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | map_id | Applying `IsLocalRing.ResidueField.map` to the identity ring homomorphism gives the identity
ring homomorphism. |
map_comp (f : T →+* R) (g : R →+* S) [IsLocalHom f] [IsLocalHom g] :
IsLocalRing.ResidueField.map (g.comp f) =
(IsLocalRing.ResidueField.map g).comp (IsLocalRing.ResidueField.map f) :=
Ideal.Quotient.ringHom_ext <| RingHom.ext fun _ => rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | map_comp | The composite of two `IsLocalRing.ResidueField.map`s is the `IsLocalRing.ResidueField.map` of
the composite. |
map_comp_residue (f : R →+* S) [IsLocalHom f] :
(ResidueField.map f).comp (residue R) = (residue S).comp f :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | map_comp_residue | null |
map_residue (f : R →+* S) [IsLocalHom f] (r : R) :
ResidueField.map f (residue R r) = residue S (f r) :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | map_residue | null |
map_id_apply (x : ResidueField R) : map (RingHom.id R) x = x :=
DFunLike.congr_fun map_id x
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | map_id_apply | null |
map_map (f : R →+* S) (g : S →+* T) (x : ResidueField R) [IsLocalHom f]
[IsLocalHom g] : map g (map f x) = map (g.comp f) x :=
DFunLike.congr_fun (map_comp f g).symm x | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | map_map | null |
@[simps apply]
noncomputable mapEquiv (f : R ≃+* S) :
IsLocalRing.ResidueField R ≃+* IsLocalRing.ResidueField S where
toFun := map (f : R →+* S)
invFun := map (f.symm : S →+* R)
left_inv x := by simp only [map_map, RingEquiv.symm_comp, map_id, RingHom.id_apply]
right_inv x := by simp only [map_map, RingEquiv.comp_symm, map_id, RingHom.id_apply]
map_mul' := RingHom.map_mul _
map_add' := RingHom.map_add _
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | mapEquiv | A ring isomorphism defines an isomorphism of residue fields. |
mapEquiv.symm (f : R ≃+* S) : (mapEquiv f).symm = mapEquiv f.symm :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | mapEquiv.symm | null |
mapEquiv_trans (e₁ : R ≃+* S) (e₂ : S ≃+* T) :
mapEquiv (e₁.trans e₂) = (mapEquiv e₁).trans (mapEquiv e₂) :=
RingEquiv.toRingHom_injective <| map_comp (e₁ : R →+* S) (e₂ : S →+* T)
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | mapEquiv_trans | null |
mapEquiv_refl : mapEquiv (RingEquiv.refl R) = RingEquiv.refl _ :=
RingEquiv.toRingHom_injective map_id | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | mapEquiv_refl | null |
@[simps]
noncomputable mapAut : RingAut R →* RingAut (IsLocalRing.ResidueField R) where
toFun := mapEquiv
map_mul' e₁ e₂ := mapEquiv_trans e₂ e₁
map_one' := mapEquiv_refl | def | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | mapAut | The group homomorphism from `RingAut R` to `RingAut k` where `k`
is the residue field of `R`. |
@[simp]
residue_smul (g : G) (r : R) : residue R (g • r) = g • residue R r :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | residue_smul | null |
finite_of_module_finite [Module.Finite R S] :
Module.Finite (ResidueField R) (ResidueField S) :=
.of_restrictScalars_finite R _ _ | instance | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | finite_of_module_finite | null |
finite_of_finite [Module.Finite R S] (hfin : Finite (ResidueField R)) :
Finite (ResidueField S) := Module.finite_of_finite (ResidueField R) | lemma | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | finite_of_finite | null |
isLocalHom_residue : IsLocalHom (IsLocalRing.residue R) := by
constructor
intro a ha
by_contra h
rw [residue_def, Ideal.Quotient.eq_zero_iff_mem.mpr ((IsLocalRing.mem_maximalIdeal _).mpr h)]
at ha
exact ha.ne_zero rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs",
"Mathlib.RingTheory.LocalRing.RingHom.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean | isLocalHom_residue | null |
ResidueField :=
R ⧸ maximalIdeal R
deriving CommRing, Inhabited | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Defs.lean | ResidueField | The residue field of a local ring is the quotient of the ring by its maximal ideal. |
noncomputable ResidueField.field : Field (ResidueField R) :=
Ideal.Quotient.field (maximalIdeal R) | instance | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Defs.lean | ResidueField.field | null |
residue : R →+* ResidueField R :=
Ideal.Quotient.mk _ | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic"
] | Mathlib/RingTheory/LocalRing/ResidueField/Defs.lean | residue | The quotient map from a local ring to its residue field. |
noncomputable PrimeSpectrum.preimageOrderIsoTensorResidueField (R S : Type*) [CommRing R]
[CommRing S] [Algebra R S] (p : PrimeSpectrum R) :
(algebraMap R S).specComap ⁻¹' {p} ≃o
PrimeSpectrum (p.asIdeal.ResidueField ⊗[R] S) := by
let Rp := Localization.AtPrime p.asIdeal
refine .trans ?_ <| comapEquiv
((Algebra.TensorProduct.comm ..).trans <| cancelBaseChange R Rp ..).toRingEquiv
refine .trans (.symm ((Ideal.primeSpectrumQuotientOrderIsoZeroLocus _).trans ?_)) <|
comapEquiv (quotIdealMapEquivTensorQuot ..).toRingEquiv
letI := rightAlgebra (R := R) (A := Rp) (B := S)
let e := IsLocalization.primeSpectrumOrderIso
(algebraMapSubmonoid S p.asIdeal.primeCompl) (Rp ⊗[R] S) |>.trans <|
.setCongr _ {q | (algebraMap R S).specComap q ≤ p} <| Set.ext fun _ ↦
disjoint_comm.trans (Ideal.disjoint_map_primeCompl_iff_comap_le ..)
have {q : PrimeSpectrum (Rp ⊗[R] S)} :
q ∈ zeroLocus ((IsLocalRing.maximalIdeal _).map (algebraMap Rp (Rp ⊗[R] S))) ↔
p ≤ (algebraMap R S).specComap (e q) := by
rw [mem_zeroLocus, SetLike.coe_subset_coe, ← Localization.AtPrime.map_eq_maximalIdeal,
Ideal.map_map, Ideal.map_le_iff_le_comap, show algebraMap Rp _ = includeLeftRingHom from rfl,
includeLeftRingHom_comp_algebraMap]; rfl
exact
{ toFun q := ⟨e q, (e q).2.antisymm (this.mp q.2)⟩
invFun q := ⟨e.symm ⟨q, q.2.le⟩, this.mpr <| by rw [e.apply_symm_apply]; exact q.2.ge⟩
left_inv q := Subtype.ext (e.left_inv q)
right_inv q := Subtype.ext <| by apply Subtype.ext_iff.mp (e.right_inv ⟨q, q.2.le⟩)
map_rel_iff' := e.map_rel_iff } | def | RingTheory | [
"Mathlib.RingTheory.Spectrum.Prime.RingHom",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.TensorProduct.Quotient"
] | Mathlib/RingTheory/LocalRing/ResidueField/Fiber.lean | PrimeSpectrum.preimageOrderIsoTensorResidueField | The `OrderIso` between fiber of a ring homomorphism `algebraMap R S : R →+* S` at a prime ideal
`p : PrimeSpectrum R` and the prime spectrum of the tensor product of `S` and the residue field of
`p`. |
Ideal.ResidueField : Type _ :=
IsLocalRing.ResidueField (Localization.AtPrime I) | abbrev | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/LocalRing/ResidueField/Ideal.lean | Ideal.ResidueField | The residue field at a prime ideal, defined to be the residue field of the local ring
`Localization.Prime I`.
We also provide an `IsFractionRing (R ⧸ I) I.ResidueField` instance. |
noncomputable
Ideal.ResidueField.map (I : Ideal R) [I.IsPrime] (J : Ideal A) [J.IsPrime]
(f : R →+* A) (hf : I = J.comap f) : I.ResidueField →+* J.ResidueField :=
IsLocalRing.ResidueField.map (Localization.localRingHom I J f hf) | abbrev | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/LocalRing/ResidueField/Ideal.lean | Ideal.ResidueField.map | If `I = f⁻¹(J)`, then there is an canonical embedding `κ(I) ↪ κ(J)`. |
noncomputable
Ideal.ResidueField.mapₐ (I : Ideal R) [I.IsPrime] (J : Ideal A) [J.IsPrime]
(hf : I = J.comap (algebraMap R A)) : I.ResidueField →ₐ[R] J.ResidueField where
__ := Ideal.ResidueField.map I J (algebraMap R A) hf
commutes' r := by
rw [IsScalarTower.algebraMap_apply R (Localization.AtPrime I),
IsLocalRing.ResidueField.algebraMap_eq]
simp only [RingHom.toMonoidHom_eq_coe, OneHom.toFun_eq_coe, MonoidHom.toOneHom_coe,
MonoidHom.coe_coe, IsLocalRing.ResidueField.map_residue, Localization.localRingHom_to_map]
rfl
@[simp] lemma Ideal.ResidueField.mapₐ_apply (I : Ideal R) [I.IsPrime] (J : Ideal A) [J.IsPrime]
(hf : I = J.comap (algebraMap R A)) (x) :
Ideal.ResidueField.mapₐ I J hf x = Ideal.ResidueField.map I J _ hf x := rfl
variable {I} in
@[simp high] -- marked `high` to override the more general `FaithfulSMul.algebraMap_eq_zero_iff` | def | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/LocalRing/ResidueField/Ideal.lean | Ideal.ResidueField.mapₐ | If `I = f⁻¹(J)`, then there is an canonical embedding `κ(I) ↪ κ(J)`. |
Ideal.algebraMap_residueField_eq_zero {x} :
algebraMap R I.ResidueField x = 0 ↔ x ∈ I := by
rw [IsScalarTower.algebraMap_apply R (Localization.AtPrime I),
IsLocalRing.ResidueField.algebraMap_eq, IsLocalRing.residue_eq_zero_iff]
exact IsLocalization.AtPrime.to_map_mem_maximal_iff _ _ _
@[simp high] -- marked `high` to override the more general `FaithfulSMul.ker_algebraMap_eq_bot` | lemma | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/LocalRing/ResidueField/Ideal.lean | Ideal.algebraMap_residueField_eq_zero | null |
Ideal.ker_algebraMap_residueField :
RingHom.ker (algebraMap R I.ResidueField) = I :=
Ideal.ext fun _ ↦ Ideal.algebraMap_residueField_eq_zero
attribute [-instance] IsLocalRing.ResidueField.field in | lemma | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/LocalRing/ResidueField/Ideal.lean | Ideal.ker_algebraMap_residueField | null |
@[simp]
algebraMap_mk (x) :
algebraMap (R ⧸ I) I.ResidueField (Ideal.Quotient.mk _ x) =
algebraMap R I.ResidueField x := rfl | lemma | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/LocalRing/ResidueField/Ideal.lean | algebraMap_mk | null |
Ideal.injective_algebraMap_quotient_residueField :
Function.Injective (algebraMap (R ⧸ I) I.ResidueField) := by
rw [RingHom.injective_iff_ker_eq_bot]
refine (Ideal.ker_quotient_lift _ _).trans ?_
change map (Quotient.mk I) (RingHom.ker (algebraMap R I.ResidueField)) = ⊥
rw [Ideal.ker_algebraMap_residueField, map_quotient_self] | lemma | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/LocalRing/ResidueField/Ideal.lean | Ideal.injective_algebraMap_quotient_residueField | null |
Ideal.bijective_algebraMap_quotient_residueField (I : Ideal R) [I.IsMaximal] :
Function.Bijective (algebraMap (R ⧸ I) I.ResidueField) :=
⟨I.injective_algebraMap_quotient_residueField, IsFractionRing.surjective_iff_isField.mpr
((Quotient.maximal_ideal_iff_isField_quotient I).mp inferInstance)⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/LocalRing/ResidueField/Ideal.lean | Ideal.bijective_algebraMap_quotient_residueField | null |
Algebra.isSeparable_residueField_iff [p.IsMaximal] [q.IsMaximal] :
Algebra.IsSeparable p.ResidueField q.ResidueField ↔ Algebra.IsSeparable (A ⧸ p) (B ⧸ q) :=
⟨fun _ ↦ inferInstance, fun _ ↦ inferInstance⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mathlib.FieldTheory.Separable"
] | Mathlib/RingTheory/LocalRing/ResidueField/Instances.lean | Algebra.isSeparable_residueField_iff | null |
@[instance]
isLocalHom_id (R : Type*) [Semiring R] : IsLocalHom (RingHom.id R) where
map_nonunit _ := id | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.Data.ZMod.Basic",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/LocalRing/RingHom/Basic.lean | isLocalHom_id | null |
@[instance 100]
isLocalHom_toRingHom {F : Type*} [FunLike F R S]
[RingHomClass F R S] (f : F) [IsLocalHom f] : IsLocalHom (f : R →+* S) :=
⟨IsLocalHom.map_nonunit (f := f)⟩
@[instance] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.Data.ZMod.Basic",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/LocalRing/RingHom/Basic.lean | isLocalHom_toRingHom | null |
RingHom.isLocalHom_comp (g : S →+* T) (f : R →+* S) [IsLocalHom g]
[IsLocalHom f] : IsLocalHom (g.comp f) where
map_nonunit a := IsLocalHom.map_nonunit a ∘ IsLocalHom.map_nonunit (f := g) (f a) | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.Data.ZMod.Basic",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/LocalRing/RingHom/Basic.lean | RingHom.isLocalHom_comp | null |
isLocalHom_of_comp (f : R →+* S) (g : S →+* T) [IsLocalHom (g.comp f)] :
IsLocalHom f :=
⟨fun _ ha => (isUnit_map_iff (g.comp f) _).mp (g.isUnit_map ha)⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.Data.ZMod.Basic",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/LocalRing/RingHom/Basic.lean | isLocalHom_of_comp | null |
RingHom.domain_isLocalRing {R S : Type*} [Semiring R] [CommSemiring S] [IsLocalRing S]
(f : R →+* S) [IsLocalHom f] : IsLocalRing R := by
haveI : Nontrivial R := f.domain_nontrivial
apply IsLocalRing.of_nonunits_add
intro a b
simp_rw [← map_mem_nonunits_iff f, f.map_add]
exact IsLocalRing.nonunits_add | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.Data.ZMod.Basic",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/LocalRing/RingHom/Basic.lean | RingHom.domain_isLocalRing | If `f : R →+* S` is a local ring hom, then `R` is a local ring if `S` is. |
map_nonunit (f : R →+* S) [IsLocalHom f] (a : R) (h : a ∈ maximalIdeal R) :
f a ∈ maximalIdeal S := fun H => h <| isUnit_of_map_unit f a H | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.Data.ZMod.Basic",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/LocalRing/RingHom/Basic.lean | map_nonunit | The image of the maximal ideal of the source is contained within the maximal ideal of the target. |
@[stacks 07BJ]
local_hom_TFAE (f : R →+* S) :
List.TFAE
[IsLocalHom f, f '' (maximalIdeal R).1 ⊆ maximalIdeal S,
(maximalIdeal R).map f ≤ maximalIdeal S, maximalIdeal R ≤ (maximalIdeal S).comap f,
(maximalIdeal S).comap f = maximalIdeal R] := by
tfae_have 1 → 2
| _, _, ⟨a, ha, rfl⟩ => map_nonunit f a ha
tfae_have 2 → 4 := Set.image_subset_iff.1
tfae_have 3 ↔ 4 := Ideal.map_le_iff_le_comap
tfae_have 4 → 1 := fun h ↦ ⟨fun x => not_imp_not.1 (@h x)⟩
tfae_have 1 → 5
| _ => by ext; exact not_iff_not.2 (isUnit_map_iff f _)
tfae_have 5 → 4 := fun h ↦ le_of_eq h.symm
tfae_finish | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.Data.ZMod.Basic",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/LocalRing/RingHom/Basic.lean | local_hom_TFAE | A ring homomorphism between local rings is a local ring hom iff it reflects units,
i.e. any preimage of a unit is still a unit. |
of_surjective [CommSemiring R] [IsLocalRing R] [Semiring S] [Nontrivial S] (f : R →+* S)
[IsLocalHom f] (hf : Function.Surjective f) : IsLocalRing S :=
of_isUnit_or_isUnit_of_isUnit_add (by
intro a b hab
obtain ⟨a, rfl⟩ := hf a
obtain ⟨b, rfl⟩ := hf b
rw [← map_add] at hab
exact
(isUnit_or_isUnit_of_isUnit_add <| IsLocalHom.map_nonunit _ hab).imp f.isUnit_map
f.isUnit_map) | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.Data.ZMod.Basic",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/LocalRing/RingHom/Basic.lean | of_surjective | null |
_root_.IsLocalHom.of_surjective [CommRing R] [CommRing S] [Nontrivial S] [IsLocalRing R]
(f : R →+* S) (hf : Function.Surjective f) :
IsLocalHom f := by
have := IsLocalRing.of_surjective' f ‹_›
refine ((local_hom_TFAE f).out 3 0).mp ?_
have := Ideal.comap_isMaximal_of_surjective f hf (K := maximalIdeal S)
exact ((maximal_ideal_unique R).unique (inferInstanceAs (maximalIdeal R).IsMaximal) this).le
alias _root_.Function.Surjective.isLocalHom := _root_.IsLocalHom.of_surjective | lemma | RingTheory | [
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.Data.ZMod.Basic",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/LocalRing/RingHom/Basic.lean | _root_.IsLocalHom.of_surjective | null |
surjective_units_map_of_local_ringHom [Semiring R] [Semiring S] (f : R →+* S)
(hf : Function.Surjective f) (h : IsLocalHom f) :
Function.Surjective (Units.map <| f.toMonoidHom) := by
intro a
obtain ⟨b, hb⟩ := hf (a : S)
use (isUnit_of_map_unit f b (by rw [hb]; exact Units.isUnit _)).unit
ext
exact hb | theorem | RingTheory | [
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.Data.ZMod.Basic",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/LocalRing/RingHom/Basic.lean | surjective_units_map_of_local_ringHom | If `f : R →+* S` is a surjective local ring hom, then the induced units map is surjective. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.