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 ⌀ |
|---|---|---|---|---|---|---|
cotangentEquivIdeal_symm_apply (x : R) (hx : x ∈ I) :
I.cotangentEquivIdeal.symm ⟨(I ^ 2).mkQ x,
by exact Submodule.mem_map_of_mem (F := R →ₗ[R] R ⧸ I ^ 2) (f := (I ^ 2).mkQ) hx⟩ =
I.toCotangent (R := R) ⟨x, hx⟩ := by
apply I.cotangentEquivIdeal.injective
rw [I.cotangentEquivIdeal.apply_symm_apply]
ext
rfl
variable {A B : Type*} [CommRing A] [CommRing B] [Algebra R A] [Algebra R B] | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | cotangentEquivIdeal_symm_apply | null |
_root_.AlgHom.kerSquareLift (f : A →ₐ[R] B) : A ⧸ RingHom.ker f.toRingHom ^ 2 →ₐ[R] B := by
refine { Ideal.Quotient.lift (RingHom.ker f.toRingHom ^ 2) f.toRingHom ?_ with commutes' := ?_ }
· intro a ha; exact Ideal.pow_le_self two_ne_zero ha
· intro r
rw [IsScalarTower.algebraMap_apply R A, RingHom.toFun_eq_coe, Ideal.Quotient.algebraMap_eq,
Ideal.Quotient.lift_mk]
exact f.map_algebraMap r | def | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | _root_.AlgHom.kerSquareLift | The lift of `f : A →ₐ[R] B` to `A ⧸ J ^ 2 →ₐ[R] B` with `J` being the kernel of `f`. |
_root_.AlgHom.ker_kerSquareLift (f : A →ₐ[R] B) :
RingHom.ker f.kerSquareLift.toRingHom = (RingHom.ker f.toRingHom).cotangentIdeal := by
apply le_antisymm
· intro x hx; obtain ⟨x, rfl⟩ := Ideal.Quotient.mk_surjective x; exact ⟨x, hx, rfl⟩
· rintro _ ⟨x, hx, rfl⟩; exact hx | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | _root_.AlgHom.ker_kerSquareLift | null |
Algebra.kerSquareLift : Algebra (R ⧸ (RingHom.ker (algebraMap R A) ^ 2)) A :=
(Algebra.ofId R A).kerSquareLift.toAlgebra | instance | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | Algebra.kerSquareLift | null |
quotCotangent : (R ⧸ I ^ 2) ⧸ I.cotangentIdeal ≃+* R ⧸ I := by
refine (Ideal.quotEquivOfEq (Ideal.map_eq_submodule_map _ _).symm).trans ?_
refine (DoubleQuot.quotQuotEquivQuotSup _ _).trans ?_
exact Ideal.quotEquivOfEq (sup_eq_right.mpr <| Ideal.pow_le_self two_ne_zero) | def | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | quotCotangent | The quotient ring of `I ⧸ I ^ 2` is `R ⧸ I`. |
mapCotangent (I₁ : Ideal A) (I₂ : Ideal B) (f : A →ₐ[R] B) (h : I₁ ≤ I₂.comap f) :
I₁.Cotangent →ₗ[R] I₂.Cotangent := by
refine Submodule.mapQ ((I₁ • ⊤ : Submodule A I₁).restrictScalars R)
((I₂ • ⊤ : Submodule B I₂).restrictScalars R) ?_ ?_
· exact f.toLinearMap.restrict (p := I₁.restrictScalars R) (q := I₂.restrictScalars R) h
· intro x hx
rw [Submodule.restrictScalars_mem] at hx
refine Submodule.smul_induction_on hx ?_ (fun _ _ ↦ add_mem)
rintro a ha ⟨b, hb⟩ -
simp only [SetLike.mk_smul_mk, smul_eq_mul, Submodule.mem_comap, Submodule.restrictScalars_mem]
convert (Submodule.smul_mem_smul (M := I₂) (r := f a)
(n := ⟨f b, h hb⟩) (h ha) (Submodule.mem_top)) using 1
ext
exact map_mul f a b
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | mapCotangent | The map `I/I² → J/J²` if `I ≤ f⁻¹(J)`. |
mapCotangent_toCotangent
(I₁ : Ideal A) (I₂ : Ideal B) (f : A →ₐ[R] B) (h : I₁ ≤ I₂.comap f) (x : I₁) :
Ideal.mapCotangent I₁ I₂ f h (Ideal.toCotangent I₁ x) = Ideal.toCotangent I₂ ⟨f x, h x.2⟩ := rfl | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | mapCotangent_toCotangent | null |
CotangentSpace : Type _ := (maximalIdeal R).Cotangent | abbrev | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | CotangentSpace | The `A ⧸ I`-vector space `I ⧸ I ^ 2`. |
subsingleton_cotangentSpace_iff [IsNoetherianRing R] :
Subsingleton (CotangentSpace R) ↔ IsField R := by
refine (maximalIdeal R).cotangent_subsingleton_iff.trans ?_
rw [IsLocalRing.isField_iff_maximalIdeal_eq,
Ideal.isIdempotentElem_iff_eq_bot_or_top_of_isLocalRing]
simp [(maximalIdeal.isMaximal R).ne_top] | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | subsingleton_cotangentSpace_iff | null |
CotangentSpace.map_eq_top_iff [IsNoetherianRing R] {M : Submodule R (maximalIdeal R)} :
M.map (maximalIdeal R).toCotangent = ⊤ ↔ M = ⊤ := by
refine ⟨fun H ↦ eq_top_iff.mpr ?_, by rintro rfl; simp [Ideal.toCotangent_range]⟩
refine (Submodule.map_le_map_iff_of_injective (Submodule.injective_subtype _) _ _).mp ?_
rw [Submodule.map_top, Submodule.range_subtype]
apply Submodule.le_of_le_smul_of_le_jacobson_bot (IsNoetherian.noetherian _)
(IsLocalRing.jacobson_eq_maximalIdeal _ bot_ne_top).ge
rw [smul_eq_mul, ← pow_two, ← Ideal.map_toCotangent_ker, ← Submodule.map_sup,
← Submodule.comap_map_eq, H, Submodule.comap_top, Submodule.map_top, Submodule.range_subtype] | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | CotangentSpace.map_eq_top_iff | null |
CotangentSpace.span_image_eq_top_iff [IsNoetherianRing R] {s : Set (maximalIdeal R)} :
Submodule.span (ResidueField R) ((maximalIdeal R).toCotangent '' s) = ⊤ ↔
Submodule.span R s = ⊤ := by
rw [← map_eq_top_iff, ← (Submodule.restrictScalars_injective R ..).eq_iff,
Submodule.restrictScalars_span]
· simp only [Ideal.toCotangent_apply, Submodule.restrictScalars_top, Submodule.map_span]
· exact Ideal.Quotient.mk_surjective
open Module | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | CotangentSpace.span_image_eq_top_iff | null |
finrank_cotangentSpace_eq_zero_iff [IsNoetherianRing R] :
finrank (ResidueField R) (CotangentSpace R) = 0 ↔ IsField R := by
rw [finrank_zero_iff, subsingleton_cotangentSpace_iff] | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | finrank_cotangentSpace_eq_zero_iff | null |
finrank_cotangentSpace_eq_zero (R) [Field R] :
finrank (ResidueField R) (CotangentSpace R) = 0 :=
finrank_cotangentSpace_eq_zero_iff.mpr (Field.toIsField R)
open Submodule in | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | finrank_cotangentSpace_eq_zero | null |
finrank_cotangentSpace_le_one_iff [IsNoetherianRing R] :
finrank (ResidueField R) (CotangentSpace R) ≤ 1 ↔ (maximalIdeal R).IsPrincipal := by
rw [Module.finrank_le_one_iff_top_isPrincipal, isPrincipal_iff,
(maximalIdeal R).toCotangent_surjective.exists, isPrincipal_iff]
simp_rw [← Set.image_singleton, eq_comm (a := ⊤), CotangentSpace.span_image_eq_top_iff,
← (map_injective_of_injective (injective_subtype _)).eq_iff, map_span, Set.image_singleton,
Submodule.map_top, range_subtype, eq_comm (a := maximalIdeal R)]
exact ⟨fun ⟨x, h⟩ ↦ ⟨_, h⟩, fun ⟨x, h⟩ ↦ ⟨⟨x, h ▸ subset_span (Set.mem_singleton x)⟩, h⟩⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | finrank_cotangentSpace_le_one_iff | null |
Ideal (R : Type u) [Semiring R] :=
Submodule R R | abbrev | RingTheory | [
"Mathlib.Algebra.Module.Submodule.Defs",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Ideal/Defs.lean | Ideal | A (left) ideal in a semiring `R` is an additive submonoid `s` such that
`a * b ∈ s` whenever `b ∈ s`. If `R` is a ring, then `s` is an additive subgroup. |
@[mk_iff] IsTwoSided : Prop where
mul_mem_of_left {a : α} (b : α) : a ∈ I → a * b ∈ I | class | RingTheory | [
"Mathlib.Algebra.Module.Submodule.Defs",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Ideal/Defs.lean | IsTwoSided | A left ideal `I : Ideal R` is two-sided if it is also a right ideal. |
protected zero_mem : (0 : α) ∈ I :=
Submodule.zero_mem I | theorem | RingTheory | [
"Mathlib.Algebra.Module.Submodule.Defs",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Ideal/Defs.lean | zero_mem | null |
protected add_mem : a ∈ I → b ∈ I → a + b ∈ I :=
Submodule.add_mem I
variable (a) | theorem | RingTheory | [
"Mathlib.Algebra.Module.Submodule.Defs",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Ideal/Defs.lean | add_mem | null |
mul_mem_left : b ∈ I → a * b ∈ I :=
Submodule.smul_mem I a | theorem | RingTheory | [
"Mathlib.Algebra.Module.Submodule.Defs",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Ideal/Defs.lean | mul_mem_left | null |
mul_mem_right {α} {a : α} (b : α) [Semiring α] (I : Ideal α) [I.IsTwoSided]
(h : a ∈ I) : a * b ∈ I :=
IsTwoSided.mul_mem_of_left b h
variable {a}
@[ext] | theorem | RingTheory | [
"Mathlib.Algebra.Module.Submodule.Defs",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Ideal/Defs.lean | mul_mem_right | null |
ext {I J : Ideal α} (h : ∀ x, x ∈ I ↔ x ∈ J) : I = J :=
Submodule.ext h
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Module.Submodule.Defs",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Ideal/Defs.lean | ext | null |
unit_mul_mem_iff_mem {x y : α} (hy : IsUnit y) : y * x ∈ I ↔ x ∈ I := by
refine ⟨fun h => ?_, fun h => I.mul_mem_left y h⟩
obtain ⟨y', hy'⟩ := hy.exists_left_inv
have := I.mul_mem_left y' h
rwa [← mul_assoc, hy', one_mul] at this | theorem | RingTheory | [
"Mathlib.Algebra.Module.Submodule.Defs",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Ideal/Defs.lean | unit_mul_mem_iff_mem | null |
pow_mem_of_mem (ha : a ∈ I) (n : ℕ) (hn : 0 < n) : a ^ n ∈ I :=
Nat.casesOn n (Not.elim (by decide))
(fun m _hm => (pow_succ a m).symm ▸ I.mul_mem_left (a ^ m) ha) hn | theorem | RingTheory | [
"Mathlib.Algebra.Module.Submodule.Defs",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Ideal/Defs.lean | pow_mem_of_mem | null |
pow_mem_of_pow_mem {m n : ℕ} (ha : a ^ m ∈ I) (h : m ≤ n) : a ^ n ∈ I := by
rw [← Nat.add_sub_of_le h, add_comm, pow_add]
exact I.mul_mem_left _ ha | theorem | RingTheory | [
"Mathlib.Algebra.Module.Submodule.Defs",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Ideal/Defs.lean | pow_mem_of_pow_mem | null |
Module.eqIdeal (R) {M} [Semiring R] [AddCommMonoid M] [Module R M] (m m' : M) : Ideal R where
carrier := {r : R | r • m = r • m'}
add_mem' h h' := by simpa [add_smul] using congr($h + $h')
zero_mem' := by simp_rw [Set.mem_setOf, zero_smul]
smul_mem' _ _ h := by simpa [mul_smul] using congr(_ • $h) | def | RingTheory | [
"Mathlib.Algebra.Module.Submodule.Defs",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Ideal/Defs.lean | Module.eqIdeal | For two elements `m` and `m'` in an `R`-module `M`, the set of elements `r : R` with
equal scalar product with `m` and `m'` is an ideal of `R`. If `M` is a group, this coincides
with the kernel of `LinearMap.toSpanSingleton R M (m - m')`. |
@[simp]
mul_unit_mem_iff_mem {x y : α} (hy : IsUnit y) : x * y ∈ I ↔ x ∈ I :=
mul_comm y x ▸ unit_mul_mem_iff_mem I hy | theorem | RingTheory | [
"Mathlib.Algebra.Module.Submodule.Defs",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Ideal/Defs.lean | mul_unit_mem_iff_mem | null |
mem_of_dvd (hab : a ∣ b) (ha : a ∈ I) : b ∈ I := by
obtain ⟨c, rfl⟩ := hab; exact I.mul_mem_right _ ha | lemma | RingTheory | [
"Mathlib.Algebra.Module.Submodule.Defs",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Ideal/Defs.lean | mem_of_dvd | null |
protected neg_mem_iff : -a ∈ I ↔ a ∈ I :=
Submodule.neg_mem_iff I | theorem | RingTheory | [
"Mathlib.Algebra.Module.Submodule.Defs",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Ideal/Defs.lean | neg_mem_iff | null |
protected add_mem_iff_left : b ∈ I → (a + b ∈ I ↔ a ∈ I) :=
Submodule.add_mem_iff_left I | theorem | RingTheory | [
"Mathlib.Algebra.Module.Submodule.Defs",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Ideal/Defs.lean | add_mem_iff_left | null |
protected add_mem_iff_right : a ∈ I → (a + b ∈ I ↔ b ∈ I) :=
Submodule.add_mem_iff_right I | theorem | RingTheory | [
"Mathlib.Algebra.Module.Submodule.Defs",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Ideal/Defs.lean | add_mem_iff_right | null |
protected sub_mem : a ∈ I → b ∈ I → a - b ∈ I :=
Submodule.sub_mem I | theorem | RingTheory | [
"Mathlib.Algebra.Module.Submodule.Defs",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Ideal/Defs.lean | sub_mem | null |
mul_sub_mul_mem [I.IsTwoSided]
(h1 : a - b ∈ I) (h2 : c - d ∈ I) : a * c - b * d ∈ I := by
rw [show a * c - b * d = (a - b) * c + b * (c - d) by rw [sub_mul, mul_sub]; abel]
exact I.add_mem (I.mul_mem_right _ h1) (I.mul_mem_left _ h2) | theorem | RingTheory | [
"Mathlib.Algebra.Module.Submodule.Defs",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Ideal/Defs.lean | mul_sub_mul_mem | null |
@[stacks 00HV "(2)"]
Algebra.HasGoingDown (R S : Type*) [CommRing R] [CommRing S] [Algebra R S] : Prop where
exists_ideal_le_liesOver_of_lt {p : Ideal R} [p.IsPrime] (Q : Ideal S) [Q.IsPrime] :
p < Q.under R → ∃ P ≤ Q, P.IsPrime ∧ P.LiesOver p
variable {R S : Type*} [CommRing R] [CommRing S] [Algebra R S] | class | RingTheory | [
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Flat.FaithfullyFlat.Algebra",
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/Ideal/GoingDown.lean | Algebra.HasGoingDown | An `R`-algebra `S` satisfies `Algebra.HasGoingDown R S` if for every pair of
prime ideals `p ≤ q` of `R` with `Q` a prime of `S` lying above `q`, there exists a
prime `P ≤ Q` of `S` lying above `p`.
The condition only asks for `<` which is easier to prove, use
`Ideal.exists_ideal_le_liesOver_of_le` for applying it. |
Ideal.exists_ideal_le_liesOver_of_le [Algebra.HasGoingDown R S]
{p q : Ideal R} [p.IsPrime] [q.IsPrime] (Q : Ideal S) [Q.IsPrime] [Q.LiesOver q]
(hle : p ≤ q) :
∃ P ≤ Q, P.IsPrime ∧ P.LiesOver p := by
by_cases h : p = q
· subst h
use Q
· have := Q.over_def q
subst this
exact Algebra.HasGoingDown.exists_ideal_le_liesOver_of_lt Q (lt_of_le_of_ne hle h) | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Flat.FaithfullyFlat.Algebra",
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/Ideal/GoingDown.lean | Ideal.exists_ideal_le_liesOver_of_le | null |
Ideal.exists_ideal_lt_liesOver_of_lt [Algebra.HasGoingDown R S]
{p q : Ideal R} [p.IsPrime] [q.IsPrime] (Q : Ideal S) [Q.IsPrime] [Q.LiesOver q]
(hpq : p < q) : ∃ P < Q, P.IsPrime ∧ P.LiesOver p := by
obtain ⟨P, hPQ, _, _⟩ := Q.exists_ideal_le_liesOver_of_le (p := p) (q := q) hpq.le
refine ⟨P, ?_, inferInstance, inferInstance⟩
by_contra hc
have : P = Q := eq_of_le_of_not_lt hPQ hc
subst this
simp [P.over_def p, P.over_def q] at hpq | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Flat.FaithfullyFlat.Algebra",
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/Ideal/GoingDown.lean | Ideal.exists_ideal_lt_liesOver_of_lt | null |
Ideal.exists_ltSeries_of_hasGoingDown [Algebra.HasGoingDown R S]
(l : LTSeries (PrimeSpectrum R)) (P : Ideal S) [P.IsPrime] [lo : P.LiesOver l.last.asIdeal] :
∃ (L : LTSeries (PrimeSpectrum S)),
L.length = l.length ∧
L.last = ⟨P, inferInstance⟩ ∧
List.map (algebraMap R S).specComap L.toList = l.toList := by
induction l using RelSeries.inductionOn generalizing P with
| singleton q =>
use RelSeries.singleton _ ⟨P, inferInstance⟩
simp only [RelSeries.singleton_length, RelSeries.last_singleton, RelSeries.toList_singleton,
List.map_cons, List.map_nil, List.cons.injEq, and_true, true_and]
ext : 1
simpa using lo.over.symm
| cons l q lt ih =>
simp only [RelSeries.last_cons] at lo
obtain ⟨L, len, last, spec⟩ := ih P
have : L.head.asIdeal.LiesOver l.head.asIdeal := by
constructor
rw [← L.toList_getElem_zero_eq_head, ← l.toList_getElem_zero_eq_head, Ideal.under_def]
have : l.toList[0] = (algebraMap R S).specComap L.toList[0] := by
rw [List.getElem_map_rev (algebraMap R S).specComap, List.getElem_of_eq spec.symm _]
rwa [RingHom.specComap, PrimeSpectrum.ext_iff] at this
obtain ⟨Q, Qlt, hQ, Qlo⟩ := Ideal.exists_ideal_lt_liesOver_of_lt L.head.asIdeal lt
use L.cons ⟨Q, hQ⟩ Qlt
simp only [RelSeries.cons_length, add_left_inj, RelSeries.last_cons]
exact ⟨len, last, by simpa [spec] using PrimeSpectrum.ext_iff.mpr Qlo.over.symm⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Flat.FaithfullyFlat.Algebra",
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/Ideal/GoingDown.lean | Ideal.exists_ltSeries_of_hasGoingDown | null |
@[stacks 00HW "(1)"]
iff_generalizingMap_primeSpectrumComap :
Algebra.HasGoingDown R S ↔
GeneralizingMap (PrimeSpectrum.comap (algebraMap R S)) := by
refine ⟨?_, fun h ↦ ⟨fun {p} hp Q hQ hlt ↦ ?_⟩⟩
· intro h Q p hp
rw [← PrimeSpectrum.le_iff_specializes] at hp
obtain ⟨P, hle, hP, h⟩ := Q.asIdeal.exists_ideal_le_liesOver_of_le (p := p.asIdeal)
(q := Q.asIdeal.under R) hp
refine ⟨⟨P, hP⟩, (PrimeSpectrum.le_iff_specializes _ Q).mp hle, ?_⟩
ext : 1
exact h.over.symm
· have : (⟨p, hp⟩ : PrimeSpectrum R) ⤳ (PrimeSpectrum.comap (algebraMap R S) ⟨Q, hQ⟩) :=
(PrimeSpectrum.le_iff_specializes _ _).mp hlt.le
obtain ⟨P, hs, heq⟩ := h this
refine ⟨P.asIdeal, (PrimeSpectrum.le_iff_specializes _ _).mpr hs, P.2, ⟨?_⟩⟩
simpa [PrimeSpectrum.ext_iff] using heq.symm
variable (R S) in
@[stacks 00HX] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Flat.FaithfullyFlat.Algebra",
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/Ideal/GoingDown.lean | iff_generalizingMap_primeSpectrumComap | An `R`-algebra `S` has the going down property if and only if generalizations lift
along `Spec S → Spec R`. |
trans (T : Type*) [CommRing T] [Algebra R T] [Algebra S T] [IsScalarTower R S T]
[Algebra.HasGoingDown R S] [Algebra.HasGoingDown S T] :
Algebra.HasGoingDown R T := by
rw [iff_generalizingMap_primeSpectrumComap, IsScalarTower.algebraMap_eq R S T]
simp only [PrimeSpectrum.comap_comp, ContinuousMap.coe_comp]
apply GeneralizingMap.comp
· rwa [← iff_generalizingMap_primeSpectrumComap]
· rwa [← iff_generalizingMap_primeSpectrumComap] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Flat.FaithfullyFlat.Algebra",
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/Ideal/GoingDown.lean | trans | null |
of_specComap_localRingHom_surjective
(H : ∀ (P : Ideal S) [P.IsPrime], Function.Surjective
(Localization.localRingHom (P.under R) P (algebraMap R S) rfl).specComap) :
Algebra.HasGoingDown R S where
exists_ideal_le_liesOver_of_lt {p} _ Q _ hlt := by
let pl : Ideal (Localization.AtPrime <| Q.under R) := p.map (algebraMap R _)
have : pl.IsPrime :=
Ideal.isPrime_map_of_isLocalizationAtPrime (Q.under R) hlt.le
obtain ⟨⟨Pl, _⟩, hl⟩ := H Q ⟨pl, inferInstance⟩
refine ⟨Pl.under S, ?_, Ideal.IsPrime.under S Pl, ⟨?_⟩⟩
· exact (IsLocalization.AtPrime.orderIsoOfPrime _ Q ⟨Pl, inferInstance⟩).2.2
· replace hl : Pl.under _ = pl := by simpa using hl
rw [Ideal.under_under, ← Ideal.under_under (B := (Localization.AtPrime <| Q.under R)) Pl, hl,
Ideal.under_map_of_isLocalizationAtPrime (Q.under R) hlt.le] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Flat.FaithfullyFlat.Algebra",
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/Ideal/GoingDown.lean | of_specComap_localRingHom_surjective | If for every prime of `S`, the map `Spec Sₚ → Spec Rₚ` is surjective,
the algebra satisfies going down. |
@[stacks 00HS]
of_flat [Module.Flat R S] : Algebra.HasGoingDown R S := by
apply of_specComap_localRingHom_surjective
intro P hP
have : IsLocalHom (algebraMap (Localization.AtPrime <| P.under R) (Localization.AtPrime P)) := by
rw [RingHom.algebraMap_toAlgebra]
exact Localization.isLocalHom_localRingHom (P.under R) P (algebraMap R S) Ideal.LiesOver.over
have : Module.FaithfullyFlat (Localization.AtPrime (P.under R)) (Localization.AtPrime P) :=
Module.FaithfullyFlat.of_flat_of_isLocalHom
apply PrimeSpectrum.specComap_surjective_of_faithfullyFlat | instance | RingTheory | [
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Flat.FaithfullyFlat.Algebra",
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/Ideal/GoingDown.lean | of_flat | Flat algebras satisfy the going down property. |
coeff_zero_mem_comap_of_root_mem_of_eval_mem {r : S} (hr : r ∈ I) {p : R[X]}
(hp : p.eval₂ f r ∈ I) : p.coeff 0 ∈ I.comap f := by
rw [← p.divX_mul_X_add, eval₂_add, eval₂_C, eval₂_mul, eval₂_X] at hp
refine mem_comap.mpr ((I.add_mem_iff_right ?_).mp hp)
exact I.mul_mem_left _ hr | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | coeff_zero_mem_comap_of_root_mem_of_eval_mem | null |
coeff_zero_mem_comap_of_root_mem {r : S} (hr : r ∈ I) {p : R[X]} (hp : p.eval₂ f r = 0) :
p.coeff 0 ∈ I.comap f :=
coeff_zero_mem_comap_of_root_mem_of_eval_mem hr (hp.symm ▸ I.zero_mem) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | coeff_zero_mem_comap_of_root_mem | null |
exists_coeff_ne_zero_mem_comap_of_non_zero_divisor_root_mem {r : S}
(r_non_zero_divisor : ∀ {x}, x * r = 0 → x = 0) (hr : r ∈ I) {p : R[X]} :
p ≠ 0 → p.eval₂ f r = 0 → ∃ i, p.coeff i ≠ 0 ∧ p.coeff i ∈ I.comap f := by
refine p.recOnHorner ?_ ?_ ?_
· intro h
contradiction
· intro p a coeff_eq_zero a_ne_zero _ _ hp
refine ⟨0, ?_, coeff_zero_mem_comap_of_root_mem hr hp⟩
simp [coeff_eq_zero, a_ne_zero]
· intro p p_nonzero ih _ hp
rw [eval₂_mul, eval₂_X] at hp
obtain ⟨i, hi, mem⟩ := ih p_nonzero (r_non_zero_divisor hp)
refine ⟨i + 1, ?_, ?_⟩
· simp [hi]
· simpa [hi] using mem | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | exists_coeff_ne_zero_mem_comap_of_non_zero_divisor_root_mem | null |
injective_quotient_le_comap_map (P : Ideal R[X]) :
Function.Injective <|
Ideal.quotientMap
(Ideal.map (Polynomial.mapRingHom (Quotient.mk (P.comap (C : R →+* R[X])))) P)
(Polynomial.mapRingHom (Ideal.Quotient.mk (P.comap (C : R →+* R[X]))))
le_comap_map := by
refine quotientMap_injective' (le_of_eq ?_)
rw [comap_map_of_surjective (mapRingHom (Ideal.Quotient.mk (P.comap (C : R →+* R[X]))))
(map_surjective (Ideal.Quotient.mk (P.comap (C : R →+* R[X]))) Ideal.Quotient.mk_surjective)]
refine le_antisymm (sup_le le_rfl ?_) (le_sup_of_le_left le_rfl)
refine fun p hp =>
polynomial_mem_ideal_of_coeff_mem_ideal P p fun n => Ideal.Quotient.eq_zero_iff_mem.mp ?_
simpa only [coeff_map, coe_mapRingHom] using ext_iff.mp (Ideal.mem_bot.mp (mem_comap.mp hp)) n | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | injective_quotient_le_comap_map | Let `P` be an ideal in `R[x]`. The map
`R[x]/P → (R / (P ∩ R))[x] / (P / (P ∩ R))`
is injective. |
quotient_mk_maps_eq (P : Ideal R[X]) :
((Quotient.mk (map (mapRingHom (Quotient.mk (P.comap (C : R →+* R[X])))) P)).comp C).comp
(Quotient.mk (P.comap (C : R →+* R[X]))) =
(Ideal.quotientMap (map (mapRingHom (Quotient.mk (P.comap (C : R →+* R[X])))) P)
(mapRingHom (Quotient.mk (P.comap (C : R →+* R[X])))) le_comap_map).comp
((Quotient.mk P).comp C) := by
refine RingHom.ext fun x => ?_
repeat' rw [RingHom.coe_comp, Function.comp_apply]
rw [quotientMap_mk, coe_mapRingHom, map_C] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | quotient_mk_maps_eq | The identity in this lemma asserts that the "obvious" square
```
R → (R / (P ∩ R))
↓ ↓
R[x] / P → (R / (P ∩ R))[x] / (P / (P ∩ R))
```
commutes. It is used, for instance, in the proof of `quotient_mk_comp_C_is_integral_of_jacobson`,
in the file `Mathlib/RingTheory/Jacobson/Polynomial.lean`. |
exists_nonzero_mem_of_ne_bot {P : Ideal R[X]} (Pb : P ≠ ⊥) (hP : ∀ x : R, C x ∈ P → x = 0) :
∃ p : R[X], p ∈ P ∧ Polynomial.map (Quotient.mk (P.comap (C : R →+* R[X]))) p ≠ 0 := by
obtain ⟨m, hm⟩ := Submodule.nonzero_mem_of_bot_lt (bot_lt_iff_ne_bot.mpr Pb)
refine ⟨m, Submodule.coe_mem m, fun pp0 => hm (Submodule.coe_eq_zero.mp ?_)⟩
refine
(injective_iff_map_eq_zero (Polynomial.mapRingHom (Ideal.Quotient.mk
(P.comap (C : R →+* R[X]))))).mp
?_ _ pp0
refine map_injective _ ((RingHom.injective_iff_ker_eq_bot (Ideal.Quotient.mk (P.comap C))).mpr ?_)
rw [mk_ker]
exact (Submodule.eq_bot_iff _).mpr fun x hx => hP x (mem_comap.mp hx) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | exists_nonzero_mem_of_ne_bot | This technical lemma asserts the existence of a polynomial `p` in an ideal `P ⊂ R[x]`
that is non-zero in the quotient `R / (P ∩ R) [x]`. The assumptions are equivalent to
`P ≠ 0` and `P ∩ R = (0)`. |
exists_coeff_ne_zero_mem_comap_of_root_mem [IsDomain S] {r : S} (r_ne_zero : r ≠ 0)
(hr : r ∈ I) {p : R[X]} :
p ≠ 0 → p.eval₂ f r = 0 → ∃ i, p.coeff i ≠ 0 ∧ p.coeff i ∈ I.comap f :=
exists_coeff_ne_zero_mem_comap_of_non_zero_divisor_root_mem
(fun {_} h => Or.resolve_right (mul_eq_zero.mp h) r_ne_zero) hr | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | exists_coeff_ne_zero_mem_comap_of_root_mem | null |
exists_coeff_mem_comap_sdiff_comap_of_root_mem_sdiff [IsPrime I] (hIJ : I ≤ J) {r : S}
(hr : r ∈ (J : Set S) \ I) {p : R[X]} (p_ne_zero : p.map (Quotient.mk (I.comap f)) ≠ 0)
(hpI : p.eval₂ f r ∈ I) : ∃ i, p.coeff i ∈ (J.comap f : Set R) \ I.comap f := by
obtain ⟨hrJ, hrI⟩ := hr
have rbar_ne_zero : Ideal.Quotient.mk I r ≠ 0 := mt (Quotient.mk_eq_zero I).mp hrI
have rbar_mem_J : Ideal.Quotient.mk I r ∈ J.map (Ideal.Quotient.mk I) := mem_map_of_mem _ hrJ
have quotient_f : ∀ x ∈ I.comap f, (Ideal.Quotient.mk I).comp f x = 0 := by
simp [Quotient.eq_zero_iff_mem]
have rbar_root :
(p.map (Ideal.Quotient.mk (I.comap f))).eval₂ (Quotient.lift (I.comap f) _ quotient_f)
(Ideal.Quotient.mk I r) =
0 := by
convert Quotient.eq_zero_iff_mem.mpr hpI
exact _root_.trans (eval₂_map _ _ _) (hom_eval₂ p f (Ideal.Quotient.mk I) r).symm
obtain ⟨i, ne_zero, mem⟩ :=
exists_coeff_ne_zero_mem_comap_of_root_mem rbar_ne_zero rbar_mem_J p_ne_zero rbar_root
rw [coeff_map] at ne_zero mem
refine ⟨i, (mem_quotient_iff_mem hIJ).mp ?_, mt ?_ ne_zero⟩
· simpa using mem
simp [Quotient.eq_zero_iff_mem] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | exists_coeff_mem_comap_sdiff_comap_of_root_mem_sdiff | null |
comap_lt_comap_of_root_mem_sdiff [I.IsPrime] (hIJ : I ≤ J) {r : S}
(hr : r ∈ (J : Set S) \ I) {p : R[X]} (p_ne_zero : p.map (Quotient.mk (I.comap f)) ≠ 0)
(hp : p.eval₂ f r ∈ I) : I.comap f < J.comap f :=
let ⟨i, hJ, hI⟩ := exists_coeff_mem_comap_sdiff_comap_of_root_mem_sdiff hIJ hr p_ne_zero hp
SetLike.lt_iff_le_and_exists.mpr ⟨comap_mono hIJ, p.coeff i, hJ, hI⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | comap_lt_comap_of_root_mem_sdiff | null |
mem_of_one_mem (h : (1 : S) ∈ I) (x) : x ∈ I :=
(I.eq_top_iff_one.mpr h).symm ▸ mem_top | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | mem_of_one_mem | null |
comap_lt_comap_of_integral_mem_sdiff [Algebra R S] [hI : I.IsPrime] (hIJ : I ≤ J) {x : S}
(mem : x ∈ (J : Set S) \ I) (integral : IsIntegral R x) :
I.comap (algebraMap R S) < J.comap (algebraMap R S) := by
obtain ⟨p, p_monic, hpx⟩ := integral
refine comap_lt_comap_of_root_mem_sdiff hIJ mem (map_monic_ne_zero p_monic) ?_
convert I.zero_mem | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | comap_lt_comap_of_integral_mem_sdiff | null |
comap_ne_bot_of_root_mem [IsDomain S] {r : S} (r_ne_zero : r ≠ 0) (hr : r ∈ I) {p : R[X]}
(p_ne_zero : p ≠ 0) (hp : p.eval₂ f r = 0) : I.comap f ≠ ⊥ := fun h =>
let ⟨_, hi, mem⟩ := exists_coeff_ne_zero_mem_comap_of_root_mem r_ne_zero hr p_ne_zero hp
absurd (mem_bot.mp (eq_bot_iff.mp h mem)) hi | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | comap_ne_bot_of_root_mem | null |
isMaximal_of_isIntegral_of_isMaximal_comap [Algebra R S] [Algebra.IsIntegral R S]
(I : Ideal S) [I.IsPrime] (hI : IsMaximal (I.comap (algebraMap R S))) : IsMaximal I :=
⟨⟨mt comap_eq_top_iff.mpr hI.1.1, fun _ I_lt_J =>
let ⟨I_le_J, x, hxJ, hxI⟩ := SetLike.lt_iff_le_and_exists.mp I_lt_J
comap_eq_top_iff.1 <|
hI.1.2 _ (comap_lt_comap_of_integral_mem_sdiff I_le_J ⟨hxJ, hxI⟩
(Algebra.IsIntegral.isIntegral x))⟩⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | isMaximal_of_isIntegral_of_isMaximal_comap | null |
isMaximal_of_isIntegral_of_isMaximal_comap' (f : R →+* S) (hf : f.IsIntegral) (I : Ideal S)
[I.IsPrime] (hI : IsMaximal (I.comap f)) : IsMaximal I :=
let _ : Algebra R S := f.toAlgebra
have : Algebra.IsIntegral R S := ⟨hf⟩
isMaximal_of_isIntegral_of_isMaximal_comap (R := R) (S := S) I hI
variable [Algebra R S] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | isMaximal_of_isIntegral_of_isMaximal_comap' | null |
comap_ne_bot_of_algebraic_mem [IsDomain S] {x : S} (x_ne_zero : x ≠ 0) (x_mem : x ∈ I)
(hx : IsAlgebraic R x) : I.comap (algebraMap R S) ≠ ⊥ :=
let ⟨_, p_ne_zero, hp⟩ := hx
comap_ne_bot_of_root_mem x_ne_zero x_mem p_ne_zero hp | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | comap_ne_bot_of_algebraic_mem | null |
comap_ne_bot_of_integral_mem [Nontrivial R] [IsDomain S] {x : S} (x_ne_zero : x ≠ 0)
(x_mem : x ∈ I) (hx : IsIntegral R x) : I.comap (algebraMap R S) ≠ ⊥ :=
comap_ne_bot_of_algebraic_mem x_ne_zero x_mem hx.isAlgebraic | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | comap_ne_bot_of_integral_mem | null |
eq_bot_of_comap_eq_bot [Nontrivial R] [IsDomain S] [Algebra.IsIntegral R S]
(hI : I.comap (algebraMap R S) = ⊥) : I = ⊥ := by
refine eq_bot_iff.2 fun x hx => ?_
by_cases hx0 : x = 0
· exact hx0.symm ▸ Ideal.zero_mem ⊥
· exact absurd hI (comap_ne_bot_of_integral_mem hx0 hx (Algebra.IsIntegral.isIntegral x)) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | eq_bot_of_comap_eq_bot | null |
isMaximal_comap_of_isIntegral_of_isMaximal [Algebra.IsIntegral R S] (I : Ideal S)
[hI : I.IsMaximal] : IsMaximal (I.comap (algebraMap R S)) := by
refine Ideal.Quotient.maximal_of_isField _ ?_
haveI : IsPrime (I.comap (algebraMap R S)) := comap_isPrime _ _
exact isField_of_isIntegral_of_isField
algebraMap_quotient_injective (by rwa [← Quotient.maximal_ideal_iff_isField_quotient]) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | isMaximal_comap_of_isIntegral_of_isMaximal | null |
isMaximal_comap_of_isIntegral_of_isMaximal' {R S : Type*} [CommRing R] [CommRing S]
(f : R →+* S) (hf : f.IsIntegral) (I : Ideal S) [I.IsMaximal] : IsMaximal (I.comap f) :=
let _ : Algebra R S := f.toAlgebra
have : Algebra.IsIntegral R S := ⟨hf⟩
isMaximal_comap_of_isIntegral_of_isMaximal (R := R) (S := S) I | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | isMaximal_comap_of_isIntegral_of_isMaximal' | null |
IsIntegralClosure.comap_lt_comap {I J : Ideal A} [I.IsPrime] (I_lt_J : I < J) :
I.comap (algebraMap R A) < J.comap (algebraMap R A) :=
let ⟨I_le_J, x, hxJ, hxI⟩ := SetLike.lt_iff_le_and_exists.mp I_lt_J
comap_lt_comap_of_integral_mem_sdiff I_le_J ⟨hxJ, hxI⟩ (IsIntegralClosure.isIntegral R S x) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | IsIntegralClosure.comap_lt_comap | null |
IsIntegralClosure.isMaximal_of_isMaximal_comap (I : Ideal A) [I.IsPrime]
(hI : IsMaximal (I.comap (algebraMap R A))) : IsMaximal I :=
have : Algebra.IsIntegral R A := IsIntegralClosure.isIntegral_algebra R S
isMaximal_of_isIntegral_of_isMaximal_comap I hI
variable [IsDomain A] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | IsIntegralClosure.isMaximal_of_isMaximal_comap | null |
IsIntegralClosure.comap_ne_bot [Nontrivial R] {I : Ideal A} (I_ne_bot : I ≠ ⊥) :
I.comap (algebraMap R A) ≠ ⊥ :=
let ⟨x, x_mem, x_ne_zero⟩ := I.ne_bot_iff.mp I_ne_bot
comap_ne_bot_of_integral_mem x_ne_zero x_mem (IsIntegralClosure.isIntegral R S x) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | IsIntegralClosure.comap_ne_bot | null |
IsIntegralClosure.eq_bot_of_comap_eq_bot [Nontrivial R] {I : Ideal A} :
I.comap (algebraMap R A) = ⊥ → I = ⊥ := by
contrapose
exact IsIntegralClosure.comap_ne_bot S | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | IsIntegralClosure.eq_bot_of_comap_eq_bot | null |
IntegralClosure.comap_lt_comap {I J : Ideal (integralClosure R S)} [I.IsPrime]
(I_lt_J : I < J) :
I.comap (algebraMap R (integralClosure R S)) < J.comap (algebraMap R (integralClosure R S)) :=
IsIntegralClosure.comap_lt_comap S I_lt_J | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | IntegralClosure.comap_lt_comap | null |
IntegralClosure.isMaximal_of_isMaximal_comap (I : Ideal (integralClosure R S)) [I.IsPrime]
(hI : IsMaximal (I.comap (algebraMap R (integralClosure R S)))) : IsMaximal I :=
IsIntegralClosure.isMaximal_of_isMaximal_comap S I hI | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | IntegralClosure.isMaximal_of_isMaximal_comap | null |
IntegralClosure.comap_ne_bot [Nontrivial R] {I : Ideal (integralClosure R S)}
(I_ne_bot : I ≠ ⊥) : I.comap (algebraMap R (integralClosure R S)) ≠ ⊥ :=
IsIntegralClosure.comap_ne_bot S I_ne_bot | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | IntegralClosure.comap_ne_bot | null |
IntegralClosure.eq_bot_of_comap_eq_bot [Nontrivial R] {I : Ideal (integralClosure R S)} :
I.comap (algebraMap R (integralClosure R S)) = ⊥ → I = ⊥ :=
IsIntegralClosure.eq_bot_of_comap_eq_bot S | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | IntegralClosure.eq_bot_of_comap_eq_bot | null |
exists_ideal_over_prime_of_isIntegral_of_isDomain [Algebra.IsIntegral R S] (P : Ideal R)
[IsPrime P] (hP : RingHom.ker (algebraMap R S) ≤ P) :
∃ Q : Ideal S, IsPrime Q ∧ Q.comap (algebraMap R S) = P := by
have hP0 : (0 : S) ∉ Algebra.algebraMapSubmonoid S P.primeCompl := by
rintro ⟨x, ⟨hx, x0⟩⟩
exact absurd (hP x0) hx
let Rₚ := Localization P.primeCompl
let Sₚ := Localization (Algebra.algebraMapSubmonoid S P.primeCompl)
letI : IsDomain (Localization (Algebra.algebraMapSubmonoid S P.primeCompl)) :=
IsLocalization.isDomain_localization (le_nonZeroDivisors_of_noZeroDivisors hP0)
obtain ⟨Qₚ : Ideal Sₚ, Qₚ_maximal⟩ := exists_maximal Sₚ
let _ : Algebra Rₚ Sₚ := localizationAlgebra P.primeCompl S
have : Algebra.IsIntegral Rₚ Sₚ := ⟨isIntegral_localization⟩
have Qₚ_max : IsMaximal (comap _ Qₚ) :=
isMaximal_comap_of_isIntegral_of_isMaximal (R := Rₚ) (S := Sₚ) Qₚ
refine ⟨comap (algebraMap S Sₚ) Qₚ, ⟨comap_isPrime _ Qₚ, ?_⟩⟩
convert Localization.AtPrime.comap_maximalIdeal (I := P)
rw [comap_comap, ← IsLocalRing.eq_maximalIdeal Qₚ_max,
← IsLocalization.map_comp (P := S) (Q := Sₚ) (g := algebraMap R S)
(M := P.primeCompl) (T := Algebra.algebraMapSubmonoid S P.primeCompl) (S := Rₚ)
(fun p hp => Algebra.mem_algebraMapSubmonoid_of_mem ⟨p, hp⟩) ]
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | exists_ideal_over_prime_of_isIntegral_of_isDomain | `comap (algebraMap R S)` is a surjection from the prime spec of `R` to prime spec of `S`.
`hP : (algebraMap R S).ker ≤ P` is a slight generalization of the extension being injective |
exists_ideal_over_prime_of_isIntegral_of_isPrime
[Algebra.IsIntegral R S] (P : Ideal R) [IsPrime P]
(I : Ideal S) [IsPrime I] (hIP : I.comap (algebraMap R S) ≤ P) :
∃ Q ≥ I, IsPrime Q ∧ Q.comap (algebraMap R S) = P := by
obtain ⟨Q' : Ideal (S ⧸ I), ⟨Q'_prime, hQ'⟩⟩ :=
@exists_ideal_over_prime_of_isIntegral_of_isDomain (R ⧸ I.comap (algebraMap R S)) _ (S ⧸ I) _
Ideal.quotientAlgebra _ _
(map (Ideal.Quotient.mk (I.comap (algebraMap R S))) P)
(map_isPrime_of_surjective Quotient.mk_surjective (by simp [hIP]))
(le_trans (le_of_eq ((RingHom.injective_iff_ker_eq_bot _).1 algebraMap_quotient_injective))
bot_le)
refine ⟨Q'.comap _, le_trans (le_of_eq mk_ker.symm) (ker_le_comap _), ⟨comap_isPrime _ Q', ?_⟩⟩
rw [comap_comap]
refine _root_.trans ?_ (_root_.trans (congr_arg (comap (Ideal.Quotient.mk
(comap (algebraMap R S) I))) hQ') ?_)
· rw [comap_comap]
exact congr_arg (comap · Q') (RingHom.ext fun r => rfl)
· refine _root_.trans (comap_map_of_surjective _ Quotient.mk_surjective _) (sup_eq_left.2 ?_)
simpa [← RingHom.ker_eq_comap_bot] using hIP | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | exists_ideal_over_prime_of_isIntegral_of_isPrime | More general going-up theorem than `exists_ideal_over_prime_of_isIntegral_of_isDomain`.
TODO: Version of going-up theorem with arbitrary length chains (by induction on this)?
Not sure how best to write an ascending chain in Lean |
exists_ideal_over_prime_of_isIntegral [Algebra.IsIntegral R S] (P : Ideal R) [IsPrime P]
(I : Ideal S) (hIP : I.comap (algebraMap R S) ≤ P) :
∃ Q ≥ I, IsPrime Q ∧ Q.comap (algebraMap R S) = P := by
have ⟨P', hP, hP', hP''⟩ := exists_ideal_comap_le_prime P I hIP
obtain ⟨Q, hQ, hQ', hQ''⟩ := exists_ideal_over_prime_of_isIntegral_of_isPrime P P' hP''
exact ⟨Q, hP.trans hQ, hQ', hQ''⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | exists_ideal_over_prime_of_isIntegral | null |
nonempty_primesOver [Nontrivial S] [Algebra.IsIntegral R S] [NoZeroSMulDivisors R S]
(P : Ideal R) [P.IsPrime] :
Nonempty (primesOver P S) := by
obtain ⟨Q, _, hQ₁, hQ₂⟩ := exists_ideal_over_prime_of_isIntegral P (⊥ : Ideal S) (by simp)
exact ⟨Q, ⟨hQ₁, (liesOver_iff _ _).mpr hQ₂.symm⟩⟩ | instance | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | nonempty_primesOver | null |
exists_ideal_over_maximal_of_isIntegral [Algebra.IsIntegral R S]
(P : Ideal R) [P_max : IsMaximal P] (hP : RingHom.ker (algebraMap R S) ≤ P) :
∃ Q : Ideal S, IsMaximal Q ∧ Q.comap (algebraMap R S) = P := by
obtain ⟨Q, -, Q_prime, hQ⟩ := exists_ideal_over_prime_of_isIntegral P ⊥ hP
exact ⟨Q, isMaximal_of_isIntegral_of_isMaximal_comap _ (hQ.symm ▸ P_max), hQ⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | exists_ideal_over_maximal_of_isIntegral | `comap (algebraMap R S)` is a surjection from the max spec of `S` to max spec of `R`.
`hP : (algebraMap R S).ker ≤ P` is a slight generalization of the extension being injective |
map_eq_top_iff_of_ker_le {R S} [CommRing R] [CommRing S]
(f : R →+* S) {I : Ideal R} (hf₁ : RingHom.ker f ≤ I) (hf₂ : f.IsIntegral) :
I.map f = ⊤ ↔ I = ⊤ := by
constructor; swap
· rintro rfl; exact Ideal.map_top _
contrapose
intro h
obtain ⟨m, _, hm⟩ := Ideal.exists_le_maximal I h
let _ := f.toAlgebra
have : Algebra.IsIntegral _ _ := ⟨hf₂⟩
obtain ⟨m', _, rfl⟩ := exists_ideal_over_maximal_of_isIntegral m (hf₁.trans hm)
rw [← map_le_iff_le_comap] at hm
exact (hm.trans_lt (lt_top_iff_ne_top.mpr (IsMaximal.ne_top ‹_›))).ne | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | map_eq_top_iff_of_ker_le | null |
map_eq_top_iff {R S} [CommRing R] [CommRing S]
(f : R →+* S) {I : Ideal R} (hf₁ : Function.Injective f) (hf₂ : f.IsIntegral) :
I.map f = ⊤ ↔ I = ⊤ :=
map_eq_top_iff_of_ker_le f (by simp [(RingHom.injective_iff_ker_eq_bot f).mp hf₁]) hf₂ | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | map_eq_top_iff | null |
IsMaximal.under [P.IsMaximal] : (P.under A).IsMaximal :=
isMaximal_comap_of_isIntegral_of_isMaximal P | instance | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | IsMaximal.under | If `B` is an integral `A`-algebra, `P` is a maximal ideal of `B`, then the pull back of
`P` is also a maximal ideal of `A`. |
IsMaximal.of_liesOver_isMaximal [hpm : p.IsMaximal] [P.IsPrime] : P.IsMaximal := by
rw [P.over_def p] at hpm
exact isMaximal_of_isIntegral_of_isMaximal_comap P hpm | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | IsMaximal.of_liesOver_isMaximal | null |
IsMaximal.of_isMaximal_liesOver [P.IsMaximal] : p.IsMaximal := by
rw [P.over_def p]
exact isMaximal_comap_of_isIntegral_of_isMaximal P | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | IsMaximal.of_isMaximal_liesOver | null |
eq_bot_of_liesOver_bot [Nontrivial A] [IsDomain B] [h : P.LiesOver (⊥ : Ideal A)] :
P = ⊥ :=
eq_bot_of_comap_eq_bot <| ((liesOver_iff _ _).mp h).symm | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | eq_bot_of_liesOver_bot | null |
Quotient.algebra_isIntegral_of_liesOver : Algebra.IsIntegral (A ⧸ p) (B ⧸ P) :=
Algebra.IsIntegral.tower_top A | instance | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | Quotient.algebra_isIntegral_of_liesOver | `B ⧸ P` is an integral `A ⧸ p`-algebra if `B` is a integral `A`-algebra. |
exists_ideal_liesOver_maximal_of_isIntegral [p.IsMaximal] (B : Type*) [CommRing B]
[Nontrivial B] [Algebra A B] [NoZeroSMulDivisors A B] [Algebra.IsIntegral A B] :
∃ P : Ideal B, P.IsMaximal ∧ P.LiesOver p := by
obtain ⟨P, hm, hP⟩ := exists_ideal_over_maximal_of_isIntegral (S := B) p <| by simp
exact ⟨P, hm, ⟨hP.symm⟩⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | exists_ideal_liesOver_maximal_of_isIntegral | null |
primesOver.isMaximal : Q.1.IsMaximal :=
Ideal.IsMaximal.of_liesOver_isMaximal Q.1 p
variable (A B) in | instance | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | primesOver.isMaximal | null |
primesOver_bot [Nontrivial A] [IsDomain B] : primesOver (⊥ : Ideal A) B = {⊥} := by
ext p
refine ⟨fun ⟨_, ⟨h⟩⟩ ↦ p.eq_bot_of_comap_eq_bot h.symm, ?_⟩
rintro rfl
exact ⟨Ideal.bot_prime, Ideal.bot_liesOver_bot A B⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/Ideal/GoingUp.lean | primesOver_bot | null |
noncomputable Ideal.primeHeight [hI : I.IsPrime] : ℕ∞ :=
Order.height (⟨I, hI⟩ : PrimeSpectrum R) | def | RingTheory | [
"Mathlib.Algebra.Module.SpanRank",
"Mathlib.RingTheory.Spectrum.Prime.Noetherian",
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization"
] | Mathlib/RingTheory/Ideal/Height.lean | Ideal.primeHeight | The height of a prime ideal is defined as the supremum of the lengths of strictly decreasing
chains of prime ideals below it. |
noncomputable Ideal.height : ℕ∞ :=
⨅ J ∈ I.minimalPrimes, @Ideal.primeHeight _ _ J (minimalPrimes_isPrime ‹_›) | def | RingTheory | [
"Mathlib.Algebra.Module.SpanRank",
"Mathlib.RingTheory.Spectrum.Prime.Noetherian",
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization"
] | Mathlib/RingTheory/Ideal/Height.lean | Ideal.height | The height of an ideal is defined as the infimum of the heights of its minimal prime ideals. |
Ideal.height_eq_primeHeight [I.IsPrime] : I.height = I.primeHeight := by
unfold height primeHeight
simp_rw [Ideal.minimalPrimes_eq_subsingleton_self]
simp | lemma | RingTheory | [
"Mathlib.Algebra.Module.SpanRank",
"Mathlib.RingTheory.Spectrum.Prime.Noetherian",
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization"
] | Mathlib/RingTheory/Ideal/Height.lean | Ideal.height_eq_primeHeight | For a prime ideal, its height equals its prime height. |
@[mk_iff]
Ideal.FiniteHeight : Prop where
eq_top_or_height_ne_top : I = ⊤ ∨ I.height ≠ ⊤ | class | RingTheory | [
"Mathlib.Algebra.Module.SpanRank",
"Mathlib.RingTheory.Spectrum.Prime.Noetherian",
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization"
] | Mathlib/RingTheory/Ideal/Height.lean | Ideal.FiniteHeight | An ideal has finite height if it is either the unit ideal or its height is finite.
We include the unit ideal in order to have the instance `IsNoetherianRing R → FiniteHeight I`. |
Ideal.finiteHeight_iff_lt {I : Ideal R} :
Ideal.FiniteHeight I ↔ I = ⊤ ∨ I.height < ⊤ := by
rw [Ideal.finiteHeight_iff, lt_top_iff_ne_top] | lemma | RingTheory | [
"Mathlib.Algebra.Module.SpanRank",
"Mathlib.RingTheory.Spectrum.Prime.Noetherian",
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization"
] | Mathlib/RingTheory/Ideal/Height.lean | Ideal.finiteHeight_iff_lt | null |
Ideal.height_ne_top {I : Ideal R} (hI : I ≠ ⊤) [I.FiniteHeight] :
I.height ≠ ⊤ :=
(‹I.FiniteHeight›.eq_top_or_height_ne_top).resolve_left hI | lemma | RingTheory | [
"Mathlib.Algebra.Module.SpanRank",
"Mathlib.RingTheory.Spectrum.Prime.Noetherian",
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization"
] | Mathlib/RingTheory/Ideal/Height.lean | Ideal.height_ne_top | null |
Ideal.height_lt_top {I : Ideal R} (hI : I ≠ ⊤) [I.FiniteHeight] :
I.height < ⊤ :=
(Ideal.height_ne_top hI).lt_top | lemma | RingTheory | [
"Mathlib.Algebra.Module.SpanRank",
"Mathlib.RingTheory.Spectrum.Prime.Noetherian",
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization"
] | Mathlib/RingTheory/Ideal/Height.lean | Ideal.height_lt_top | null |
Ideal.primeHeight_ne_top (I : Ideal R) [I.FiniteHeight] [I.IsPrime] :
I.primeHeight ≠ ⊤ := by
rw [← I.height_eq_primeHeight]
exact Ideal.height_ne_top ‹I.IsPrime›.ne_top | lemma | RingTheory | [
"Mathlib.Algebra.Module.SpanRank",
"Mathlib.RingTheory.Spectrum.Prime.Noetherian",
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization"
] | Mathlib/RingTheory/Ideal/Height.lean | Ideal.primeHeight_ne_top | null |
Ideal.primeHeight_lt_top (I : Ideal R) [I.FiniteHeight] [I.IsPrime] :
I.primeHeight < ⊤ := by
rw [← I.height_eq_primeHeight]
exact Ideal.height_lt_top ‹I.IsPrime›.ne_top
@[gcongr] | lemma | RingTheory | [
"Mathlib.Algebra.Module.SpanRank",
"Mathlib.RingTheory.Spectrum.Prime.Noetherian",
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization"
] | Mathlib/RingTheory/Ideal/Height.lean | Ideal.primeHeight_lt_top | null |
Ideal.primeHeight_mono {I J : Ideal R} [I.IsPrime] [J.IsPrime] (h : I ≤ J) :
I.primeHeight ≤ J.primeHeight := by
unfold primeHeight
gcongr
exact h | lemma | RingTheory | [
"Mathlib.Algebra.Module.SpanRank",
"Mathlib.RingTheory.Spectrum.Prime.Noetherian",
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization"
] | Mathlib/RingTheory/Ideal/Height.lean | Ideal.primeHeight_mono | null |
Ideal.primeHeight_add_one_le_of_lt {I J : Ideal R} [I.IsPrime] [J.IsPrime] (h : I < J) :
I.primeHeight + 1 ≤ J.primeHeight := by
unfold primeHeight
exact Order.height_add_one_le h
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.Module.SpanRank",
"Mathlib.RingTheory.Spectrum.Prime.Noetherian",
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization"
] | Mathlib/RingTheory/Ideal/Height.lean | Ideal.primeHeight_add_one_le_of_lt | null |
Ideal.height_top : (⊤ : Ideal R).height = ⊤ := by
simp [height, minimalPrimes_top]
@[gcongr] | theorem | RingTheory | [
"Mathlib.Algebra.Module.SpanRank",
"Mathlib.RingTheory.Spectrum.Prime.Noetherian",
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization"
] | Mathlib/RingTheory/Ideal/Height.lean | Ideal.height_top | null |
Ideal.primeHeight_strict_mono {I J : Ideal R} [I.IsPrime] [J.IsPrime]
(h : I < J) [J.FiniteHeight] :
I.primeHeight < J.primeHeight := by
rw [primeHeight]
have : I.FiniteHeight := by
rw [Ideal.finiteHeight_iff, ← lt_top_iff_ne_top, Ideal.height_eq_primeHeight]
right
exact lt_of_le_of_lt (Ideal.primeHeight_mono h.le) (Ideal.primeHeight_lt_top J)
exact Order.height_strictMono h (Ideal.primeHeight_lt_top _)
@[gcongr] | lemma | RingTheory | [
"Mathlib.Algebra.Module.SpanRank",
"Mathlib.RingTheory.Spectrum.Prime.Noetherian",
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization"
] | Mathlib/RingTheory/Ideal/Height.lean | Ideal.primeHeight_strict_mono | null |
Ideal.height_mono {I J : Ideal R} (h : I ≤ J) : I.height ≤ J.height := by
simp only [height]
refine le_iInf₂ (fun p hp ↦ ?_)
have := Ideal.minimalPrimes_isPrime hp
obtain ⟨q, hq, e⟩ := Ideal.exists_minimalPrimes_le (h.trans hp.1.2)
haveI := Ideal.minimalPrimes_isPrime hq
exact (iInf₂_le q hq).trans (Ideal.primeHeight_mono e)
@[gcongr] | theorem | RingTheory | [
"Mathlib.Algebra.Module.SpanRank",
"Mathlib.RingTheory.Spectrum.Prime.Noetherian",
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization"
] | Mathlib/RingTheory/Ideal/Height.lean | Ideal.height_mono | null |
Ideal.height_strict_mono_of_is_prime {I J : Ideal R} [I.IsPrime]
(h : I < J) [I.FiniteHeight] : I.height < J.height := by
rw [Ideal.height_eq_primeHeight I]
by_cases hJ : J = ⊤
· rw [hJ, height_top]
exact I.primeHeight_lt_top
· rw [← ENat.add_one_le_iff I.primeHeight_ne_top, Ideal.height]
refine le_iInf₂ (fun K hK ↦ ?_)
haveI := Ideal.minimalPrimes_isPrime hK
have : I < K := lt_of_lt_of_le h hK.1.2
exact Ideal.primeHeight_add_one_le_of_lt this | lemma | RingTheory | [
"Mathlib.Algebra.Module.SpanRank",
"Mathlib.RingTheory.Spectrum.Prime.Noetherian",
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization"
] | Mathlib/RingTheory/Ideal/Height.lean | Ideal.height_strict_mono_of_is_prime | null |
Ideal.primeHeight_le_ringKrullDim {I : Ideal R} [I.IsPrime] :
I.primeHeight ≤ ringKrullDim R := Order.height_le_krullDim _ | lemma | RingTheory | [
"Mathlib.Algebra.Module.SpanRank",
"Mathlib.RingTheory.Spectrum.Prime.Noetherian",
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization"
] | Mathlib/RingTheory/Ideal/Height.lean | Ideal.primeHeight_le_ringKrullDim | null |
Ideal.height_le_ringKrullDim_of_ne_top {I : Ideal R} (h : I ≠ ⊤) :
I.height ≤ ringKrullDim R := by
rw [Ideal.height]
obtain ⟨P, hP⟩ : Nonempty (I.minimalPrimes) := Ideal.nonempty_minimalPrimes h
have := Ideal.minimalPrimes_isPrime hP
refine le_trans ?_ (Ideal.primeHeight_le_ringKrullDim (I := P))
simpa using iInf₂_le _ hP | lemma | RingTheory | [
"Mathlib.Algebra.Module.SpanRank",
"Mathlib.RingTheory.Spectrum.Prime.Noetherian",
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization"
] | Mathlib/RingTheory/Ideal/Height.lean | Ideal.height_le_ringKrullDim_of_ne_top | null |
Ideal.exists_isMaximal_height [FiniteRingKrullDim R] :
∃ (p : Ideal R), p.IsMaximal ∧ p.height = ringKrullDim R := by
let l := LTSeries.longestOf (PrimeSpectrum R)
obtain ⟨m, hm, hle⟩ := l.last.asIdeal.exists_le_maximal IsPrime.ne_top'
refine ⟨m, hm, le_antisymm (height_le_ringKrullDim_of_ne_top IsPrime.ne_top') ?_⟩
trans (l.last.asIdeal.height : WithBot ℕ∞)
· rw [Ideal.height_eq_primeHeight]
exact LTSeries.height_last_longestOf.symm.le
· norm_cast
exact height_mono hle | lemma | RingTheory | [
"Mathlib.Algebra.Module.SpanRank",
"Mathlib.RingTheory.Spectrum.Prime.Noetherian",
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization"
] | Mathlib/RingTheory/Ideal/Height.lean | Ideal.exists_isMaximal_height | If `R` has finite Krull dimension, there exists a maximal ideal `m` with `ht m = dim R`. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.