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 ⌀ |
|---|---|---|---|---|---|---|
protected iInf {κ : Sort*} {f : κ → Ideal A} (h : ∀ i, (f i).IsHomogeneous 𝒜) :
(⨅ i, f i).IsHomogeneous 𝒜 := by
intro i x hx
simp only [Ideal.mem_iInf] at hx ⊢
exact fun j => h _ _ (hx j) | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | iInf | null |
iSup₂ {κ : Sort*} {κ' : κ → Sort*} {f : ∀ i, κ' i → Ideal A}
(h : ∀ i j, (f i j).IsHomogeneous 𝒜) : (⨆ (i) (j), f i j).IsHomogeneous 𝒜 :=
IsHomogeneous.iSup fun i => IsHomogeneous.iSup <| h i | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | iSup₂ | null |
iInf₂ {κ : Sort*} {κ' : κ → Sort*} {f : ∀ i, κ' i → Ideal A}
(h : ∀ i j, (f i j).IsHomogeneous 𝒜) : (⨅ (i) (j), f i j).IsHomogeneous 𝒜 :=
IsHomogeneous.iInf fun i => IsHomogeneous.iInf <| h i | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | iInf₂ | null |
sSup {ℐ : Set (Ideal A)} (h : ∀ I ∈ ℐ, Ideal.IsHomogeneous 𝒜 I) :
(sSup ℐ).IsHomogeneous 𝒜 := by
rw [sSup_eq_iSup]
exact iSup₂ h | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | sSup | null |
sInf {ℐ : Set (Ideal A)} (h : ∀ I ∈ ℐ, Ideal.IsHomogeneous 𝒜 I) :
(sInf ℐ).IsHomogeneous 𝒜 := by
rw [sInf_eq_iInf]
exact iInf₂ h | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | sInf | null |
@[simp]
coe_top : ((⊤ : HomogeneousIdeal 𝒜) : Set A) = univ :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | coe_top | null |
coe_bot : ((⊥ : HomogeneousIdeal 𝒜) : Set A) = 0 :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | coe_bot | null |
coe_sup (I J : HomogeneousIdeal 𝒜) : ↑(I ⊔ J) = (I + J : Set A) :=
Submodule.coe_sup _ _
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | coe_sup | null |
coe_inf (I J : HomogeneousIdeal 𝒜) : (↑(I ⊓ J) : Set A) = ↑I ∩ ↑J :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | coe_inf | null |
toIdeal_top : (⊤ : HomogeneousIdeal 𝒜).toIdeal = (⊤ : Ideal A) :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | toIdeal_top | null |
toIdeal_bot : (⊥ : HomogeneousIdeal 𝒜).toIdeal = (⊥ : Ideal A) :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | toIdeal_bot | null |
toIdeal_sup (I J : HomogeneousIdeal 𝒜) : (I ⊔ J).toIdeal = I.toIdeal ⊔ J.toIdeal :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | toIdeal_sup | null |
toIdeal_inf (I J : HomogeneousIdeal 𝒜) : (I ⊓ J).toIdeal = I.toIdeal ⊓ J.toIdeal :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | toIdeal_inf | null |
toIdeal_sSup (ℐ : Set (HomogeneousIdeal 𝒜)) : (sSup ℐ).toIdeal = ⨆ s ∈ ℐ, toIdeal s :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | toIdeal_sSup | null |
toIdeal_sInf (ℐ : Set (HomogeneousIdeal 𝒜)) : (sInf ℐ).toIdeal = ⨅ s ∈ ℐ, toIdeal s :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | toIdeal_sInf | null |
toIdeal_iSup {κ : Sort*} (s : κ → HomogeneousIdeal 𝒜) :
(⨆ i, s i).toIdeal = ⨆ i, (s i).toIdeal := by
rw [iSup, toIdeal_sSup, iSup_range]
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | toIdeal_iSup | null |
toIdeal_iInf {κ : Sort*} (s : κ → HomogeneousIdeal 𝒜) :
(⨅ i, s i).toIdeal = ⨅ i, (s i).toIdeal := by
rw [iInf, toIdeal_sInf, iInf_range] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | toIdeal_iInf | null |
toIdeal_iSup₂ {κ : Sort*} {κ' : κ → Sort*} (s : ∀ i, κ' i → HomogeneousIdeal 𝒜) :
(⨆ (i) (j), s i j).toIdeal = ⨆ (i) (j), (s i j).toIdeal := by
simp_rw [toIdeal_iSup] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | toIdeal_iSup₂ | null |
toIdeal_iInf₂ {κ : Sort*} {κ' : κ → Sort*} (s : ∀ i, κ' i → HomogeneousIdeal 𝒜) :
(⨅ (i) (j), s i j).toIdeal = ⨅ (i) (j), (s i j).toIdeal := by
simp_rw [toIdeal_iInf]
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | toIdeal_iInf₂ | null |
eq_top_iff (I : HomogeneousIdeal 𝒜) : I = ⊤ ↔ I.toIdeal = ⊤ :=
toIdeal_injective.eq_iff.symm
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | eq_top_iff | null |
eq_bot_iff (I : HomogeneousIdeal 𝒜) : I = ⊥ ↔ I.toIdeal = ⊥ :=
toIdeal_injective.eq_iff.symm | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | eq_bot_iff | null |
completeLattice : CompleteLattice (HomogeneousIdeal 𝒜) :=
toIdeal_injective.completeLattice _ toIdeal_sup toIdeal_inf toIdeal_sSup toIdeal_sInf toIdeal_top
toIdeal_bot | instance | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | completeLattice | null |
@[simp]
toIdeal_add (I J : HomogeneousIdeal 𝒜) : (I + J).toIdeal = I.toIdeal + J.toIdeal :=
rfl | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | toIdeal_add | null |
Ideal.IsHomogeneous.mul {I J : Ideal A} (HI : I.IsHomogeneous 𝒜) (HJ : J.IsHomogeneous 𝒜) :
(I * J).IsHomogeneous 𝒜 := by
rw [Ideal.IsHomogeneous.iff_exists] at HI HJ ⊢
obtain ⟨⟨s₁, rfl⟩, ⟨s₂, rfl⟩⟩ := HI, HJ
rw [Ideal.span_mul_span']
exact ⟨s₁ * s₂, congr_arg _ <| (Set.image_mul (homogeneousSubmonoid 𝒜).subtype).symm⟩ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | Ideal.IsHomogeneous.mul | null |
@[simp]
HomogeneousIdeal.toIdeal_mul (I J : HomogeneousIdeal 𝒜) :
(I * J).toIdeal = I.toIdeal * J.toIdeal :=
rfl | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | HomogeneousIdeal.toIdeal_mul | null |
Ideal.homogeneousCore.gc : GaloisConnection toIdeal (Ideal.homogeneousCore 𝒜) := fun I _ =>
⟨fun H => I.toIdeal_homogeneousCore_eq_self ▸ Ideal.homogeneousCore_mono 𝒜 H,
fun H => le_trans H (Ideal.homogeneousCore'_le _ _)⟩ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | Ideal.homogeneousCore.gc | null |
Ideal.homogeneousCore.gi : GaloisCoinsertion toIdeal (Ideal.homogeneousCore 𝒜) where
choice I HI :=
⟨I, le_antisymm (I.toIdeal_homogeneousCore_le 𝒜) HI ▸ HomogeneousIdeal.isHomogeneous _⟩
gc := Ideal.homogeneousCore.gc 𝒜
u_l_le _ := Ideal.homogeneousCore'_le _ _
choice_eq I H := le_antisymm H (I.toIdeal_homogeneousCore_le _) | def | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | Ideal.homogeneousCore.gi | `toIdeal : HomogeneousIdeal 𝒜 → Ideal A` and `Ideal.homogeneousCore 𝒜` forms a Galois
coinsertion. |
Ideal.homogeneousCore_eq_sSup :
I.homogeneousCore 𝒜 = sSup { J : HomogeneousIdeal 𝒜 | J.toIdeal ≤ I } :=
Eq.symm <| IsLUB.sSup_eq <| (Ideal.homogeneousCore.gc 𝒜).isGreatest_u.isLUB | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | Ideal.homogeneousCore_eq_sSup | null |
Ideal.homogeneousCore'_eq_sSup :
I.homogeneousCore' 𝒜 = sSup { J : Ideal A | J.IsHomogeneous 𝒜 ∧ J ≤ I } := by
refine (IsLUB.sSup_eq ?_).symm
apply IsGreatest.isLUB
have coe_mono : Monotone (toIdeal : HomogeneousIdeal 𝒜 → Ideal A) := fun x y => id
convert coe_mono.map_isGreatest (Ideal.homogeneousCore.gc 𝒜).isGreatest_u using 1
ext x
rw [mem_image, mem_setOf_eq]
refine ⟨fun hI => ⟨⟨x, hI.1⟩, ⟨hI.2, rfl⟩⟩, ?_⟩
rintro ⟨x, ⟨hx, rfl⟩⟩
exact ⟨x.isHomogeneous, hx⟩ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | Ideal.homogeneousCore'_eq_sSup | null |
Ideal.homogeneousHull : HomogeneousIdeal 𝒜 :=
⟨Ideal.span { r : A | ∃ (i : ι) (x : I), (DirectSum.decompose 𝒜 (x : A) i : A) = r }, by
refine Ideal.homogeneous_span _ _ fun x hx => ?_
obtain ⟨i, x, rfl⟩ := hx
apply SetLike.isHomogeneousElem_coe⟩ | def | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | Ideal.homogeneousHull | For any `I : Ideal A`, not necessarily homogeneous, `I.homogeneousHull 𝒜` is
the smallest homogeneous ideal containing `I`. |
Ideal.le_toIdeal_homogeneousHull : I ≤ (Ideal.homogeneousHull 𝒜 I).toIdeal := by
intro r hr
classical
rw [← DirectSum.sum_support_decompose 𝒜 r]
refine Ideal.sum_mem _ ?_
intro j _
apply Ideal.subset_span
use j
use ⟨r, hr⟩ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | Ideal.le_toIdeal_homogeneousHull | null |
Ideal.homogeneousHull_mono : Monotone (Ideal.homogeneousHull 𝒜) := fun I J I_le_J => by
apply Ideal.span_mono
rintro r ⟨hr1, ⟨x, hx⟩, rfl⟩
exact ⟨hr1, ⟨⟨x, I_le_J hx⟩, rfl⟩⟩
variable {I 𝒜} | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | Ideal.homogeneousHull_mono | null |
Ideal.IsHomogeneous.toIdeal_homogeneousHull_eq_self (h : I.IsHomogeneous 𝒜) :
(Ideal.homogeneousHull 𝒜 I).toIdeal = I := by
apply le_antisymm _ (Ideal.le_toIdeal_homogeneousHull _ _)
apply Ideal.span_le.2
rintro _ ⟨i, x, rfl⟩
exact h _ x.prop
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | Ideal.IsHomogeneous.toIdeal_homogeneousHull_eq_self | null |
HomogeneousIdeal.homogeneousHull_toIdeal_eq_self (I : HomogeneousIdeal 𝒜) :
I.toIdeal.homogeneousHull 𝒜 = I :=
HomogeneousIdeal.toIdeal_injective <| I.isHomogeneous.toIdeal_homogeneousHull_eq_self
variable (I 𝒜) | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | HomogeneousIdeal.homogeneousHull_toIdeal_eq_self | null |
Ideal.toIdeal_homogeneousHull_eq_iSup :
(I.homogeneousHull 𝒜).toIdeal = ⨆ i, Ideal.span (GradedRing.proj 𝒜 i '' I) := by
rw [← Ideal.span_iUnion]
apply congr_arg Ideal.span _
ext1
simp only [Set.mem_iUnion, Set.mem_image, mem_setOf_eq, GradedRing.proj_apply, SetLike.exists,
exists_prop, SetLike.mem_coe] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | Ideal.toIdeal_homogeneousHull_eq_iSup | null |
Ideal.homogeneousHull_eq_iSup :
I.homogeneousHull 𝒜 =
⨆ i, ⟨Ideal.span (GradedRing.proj 𝒜 i '' I), Ideal.homogeneous_span 𝒜 _ (by
rintro _ ⟨x, -, rfl⟩
apply SetLike.isHomogeneousElem_coe)⟩ := by
ext1
rw [Ideal.toIdeal_homogeneousHull_eq_iSup, toIdeal_iSup] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | Ideal.homogeneousHull_eq_iSup | null |
Ideal.homogeneousHull.gc : GaloisConnection (Ideal.homogeneousHull 𝒜) toIdeal := fun _ J =>
⟨le_trans (Ideal.le_toIdeal_homogeneousHull _ _),
fun H => J.homogeneousHull_toIdeal_eq_self ▸ Ideal.homogeneousHull_mono 𝒜 H⟩ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | Ideal.homogeneousHull.gc | null |
Ideal.homogeneousHull.gi : GaloisInsertion (Ideal.homogeneousHull 𝒜) toIdeal where
choice I H := ⟨I, le_antisymm H (I.le_toIdeal_homogeneousHull 𝒜) ▸ isHomogeneous _⟩
gc := Ideal.homogeneousHull.gc 𝒜
le_l_u _ := Ideal.le_toIdeal_homogeneousHull _ _
choice_eq I H := le_antisymm (I.le_toIdeal_homogeneousHull 𝒜) H | def | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | Ideal.homogeneousHull.gi | `Ideal.homogeneousHull 𝒜` and `toIdeal : HomogeneousIdeal 𝒜 → Ideal A` form a Galois
insertion. |
Ideal.homogeneousHull_eq_sInf (I : Ideal A) :
Ideal.homogeneousHull 𝒜 I = sInf { J : HomogeneousIdeal 𝒜 | I ≤ J.toIdeal } :=
Eq.symm <| IsGLB.sInf_eq <| (Ideal.homogeneousHull.gc 𝒜).isLeast_l.isGLB | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | Ideal.homogeneousHull_eq_sInf | null |
HomogeneousIdeal.irrelevant : HomogeneousIdeal 𝒜 :=
⟨RingHom.ker (GradedRing.projZeroRingHom 𝒜), fun i r (hr : (decompose 𝒜 r 0 : A) = 0) => by
change (decompose 𝒜 (decompose 𝒜 r _ : A) 0 : A) = 0
by_cases h : i = 0
· rw [h, hr, decompose_zero, zero_apply, ZeroMemClass.coe_zero]
· rw [decompose_of_mem_ne 𝒜 (SetLike.coe_mem _) h]⟩
@[simp] | def | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | HomogeneousIdeal.irrelevant | For a graded ring `⨁ᵢ 𝒜ᵢ` graded by a `CanonicallyOrderedAddCommMonoid ι`, the irrelevant ideal
refers to `⨁_{i>0} 𝒜ᵢ`, or equivalently `{a | a₀ = 0}`. This definition is used in `Proj`
construction where `ι` is always `ℕ` so the irrelevant ideal is simply elements with `0` as
0-th coordinate.
# Future work
Here in the definition, `ι` is assumed to be `CanonicallyOrderedAddCommMonoid`. However, the notion
of irrelevant ideal makes sense in a more general setting by defining it as the ideal of elements
with `0` as i-th coordinate for all `i ≤ 0`, i.e. `{a | ∀ (i : ι), i ≤ 0 → aᵢ = 0}`. |
HomogeneousIdeal.mem_irrelevant_iff (a : A) :
a ∈ HomogeneousIdeal.irrelevant 𝒜 ↔ proj 𝒜 0 a = 0 :=
Iff.rfl
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | HomogeneousIdeal.mem_irrelevant_iff | null |
HomogeneousIdeal.toIdeal_irrelevant :
(HomogeneousIdeal.irrelevant 𝒜).toIdeal = RingHom.ker (GradedRing.projZeroRingHom 𝒜) :=
rfl | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.SumProd",
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.BigOperators",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Ideal.lean | HomogeneousIdeal.toIdeal_irrelevant | null |
that `HomogeneousSubmodule` is a complete lattice cannot be synthesized due to
synthesization order. | instance | RingTheory | [
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.Algebra.GradedMulAction"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Submodule.lean | that | null |
Submodule.IsHomogeneous (p : Submodule A M) (ℳ : ιM → σM)
[DecidableEq ιM] [SetLike σM M] [AddSubmonoidClass σM M] [Decomposition ℳ] : Prop :=
SetLike.IsHomogeneous ℳ p | def | RingTheory | [
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.Algebra.GradedMulAction"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Submodule.lean | Submodule.IsHomogeneous | An `A`-submodule `p ⊆ M` is homogeneous if for every `m ∈ p`, all homogeneous components of `m` are
in `p`. |
Submodule.IsHomogeneous.mem_iff {p : Submodule A M}
(ℳ : ιM → σM)
[DecidableEq ιM] [SetLike σM M] [AddSubmonoidClass σM M] [Decomposition ℳ]
(hp : p.IsHomogeneous ℳ) {x} :
x ∈ p ↔ ∀ i, (decompose ℳ x i : M) ∈ p :=
AddSubmonoidClass.IsHomogeneous.mem_iff ℳ _ hp | theorem | RingTheory | [
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.Algebra.GradedMulAction"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Submodule.lean | Submodule.IsHomogeneous.mem_iff | null |
HomogeneousSubmodule (𝒜 : ιA → σA) (ℳ : ιM → σM)
[DecidableEq ιA] [AddMonoid ιA] [SetLike σA A] [AddSubmonoidClass σA A] [GradedRing 𝒜]
[DecidableEq ιM] [SetLike σM M] [AddSubmonoidClass σM M] [Decomposition ℳ]
[VAdd ιA ιM] [GradedSMul 𝒜 ℳ]
extends Submodule A M where
is_homogeneous' : toSubmodule.IsHomogeneous ℳ
variable (𝒜 : ιA → σA) (ℳ : ιM → σM)
variable [DecidableEq ιA] [AddMonoid ιA] [SetLike σA A] [AddSubmonoidClass σA A] [GradedRing 𝒜]
variable [DecidableEq ιM] [SetLike σM M] [AddSubmonoidClass σM M] [Decomposition ℳ]
variable [VAdd ιA ιM] [GradedSMul 𝒜 ℳ] | structure | RingTheory | [
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.Algebra.GradedMulAction"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Submodule.lean | HomogeneousSubmodule | For any `Semiring A`, we collect the homogeneous submodule of `A`-modules into a type. |
HomogeneousSubmodule.isHomogeneous (p : HomogeneousSubmodule 𝒜 ℳ) :
p.toSubmodule.IsHomogeneous ℳ :=
p.is_homogeneous' | theorem | RingTheory | [
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.Algebra.GradedMulAction"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Submodule.lean | HomogeneousSubmodule.isHomogeneous | null |
HomogeneousSubmodule.toSubmodule_injective :
Function.Injective
(HomogeneousSubmodule.toSubmodule : HomogeneousSubmodule 𝒜 ℳ → Submodule A M) :=
fun ⟨x, hx⟩ ⟨y, hy⟩ ↦ fun (h : x = y) ↦ by simp [h] | theorem | RingTheory | [
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.Algebra.GradedMulAction"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Submodule.lean | HomogeneousSubmodule.toSubmodule_injective | null |
HomogeneousSubmodule.setLike : SetLike (HomogeneousSubmodule 𝒜 ℳ) M where
coe p := p.toSubmodule
coe_injective' _ _ h := HomogeneousSubmodule.toSubmodule_injective 𝒜 ℳ <| SetLike.coe_injective h
@[ext] | instance | RingTheory | [
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.Algebra.GradedMulAction"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Submodule.lean | HomogeneousSubmodule.setLike | null |
HomogeneousSubmodule.ext
{I J : HomogeneousSubmodule 𝒜 ℳ} (h : I.toSubmodule = J.toSubmodule) : I = J :=
HomogeneousSubmodule.toSubmodule_injective _ _ h | theorem | RingTheory | [
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.Algebra.GradedMulAction"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Submodule.lean | HomogeneousSubmodule.ext | null |
HomogeneousSubmodule.ext' {I J : HomogeneousSubmodule 𝒜 ℳ}
(h : ∀ i, ∀ x ∈ ℳ i, x ∈ I ↔ x ∈ J) :
I = J := by
ext
rw [I.isHomogeneous.mem_iff, J.isHomogeneous.mem_iff]
apply forall_congr'
exact fun i ↦ h i _ (decompose ℳ _ i).2
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.Algebra.GradedMulAction"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Submodule.lean | HomogeneousSubmodule.ext' | The set-theoretic extensionality of `HomogeneousSubmodule`. |
HomogeneousSubmodule.mem_toSubmodule_iff {I : HomogeneousSubmodule 𝒜 ℳ} {x : M} :
x ∈ I.toSubmodule (A := A) ↔ x ∈ I :=
Iff.rfl | theorem | RingTheory | [
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.Algebra.GradedMulAction"
] | Mathlib/RingTheory/GradedAlgebra/Homogeneous/Submodule.lean | HomogeneousSubmodule.mem_toSubmodule_iff | null |
IsAssociatedPrime : Prop :=
I.IsPrime ∧ ∃ x : M, I = ker (toSpanSingleton R M x) | def | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Noetherian.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean | IsAssociatedPrime | `IsAssociatedPrime I M` if the prime ideal `I` is the annihilator of some `x : M`. |
isAssociatedPrime_iff_exists_injective_linearMap :
IsAssociatedPrime I M ↔ I.IsPrime ∧ ∃ (f : R ⧸ I →ₗ[R] M), Function.Injective f := by
rw [IsAssociatedPrime]
congr! 1
refine ⟨fun ⟨_, h⟩ ↦ ⟨Submodule.liftQ _ _ h.le, ker_eq_bot.1 (Submodule.ker_liftQ_eq_bot' _ _ h)⟩,
fun ⟨f, h⟩ ↦ ⟨(f ∘ₗ Submodule.mkQ I) 1, ?_⟩⟩
have := I.ker_mkQ ▸ ker_comp_of_ker_eq_bot (Submodule.mkQ I) (ker_eq_bot_of_injective h)
convert this.symm using 2
ext; simp
variable (R) | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Noetherian.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean | isAssociatedPrime_iff_exists_injective_linearMap | null |
associatedPrimes : Set (Ideal R) :=
{ I | IsAssociatedPrime I M }
variable {I J M R}
variable {M' : Type*} [AddCommGroup M'] [Module R M'] (f : M →ₗ[R] M') | def | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Noetherian.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean | associatedPrimes | The set of associated primes of a module. |
AssociatePrimes.mem_iff : I ∈ associatedPrimes R M ↔ IsAssociatedPrime I M := Iff.rfl | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Noetherian.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean | AssociatePrimes.mem_iff | null |
IsAssociatedPrime.isPrime (h : IsAssociatedPrime I M) : I.IsPrime := h.1 | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Noetherian.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean | IsAssociatedPrime.isPrime | null |
IsAssociatedPrime.map_of_injective (h : IsAssociatedPrime I M) (hf : Function.Injective f) :
IsAssociatedPrime I M' := by
obtain ⟨x, rfl⟩ := h.2
refine ⟨h.1, ⟨f x, ?_⟩⟩
ext r
simp_rw [mem_ker, toSpanSingleton_apply, ← map_smul, ← f.map_zero, hf.eq_iff] | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Noetherian.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean | IsAssociatedPrime.map_of_injective | null |
LinearEquiv.isAssociatedPrime_iff (l : M ≃ₗ[R] M') :
IsAssociatedPrime I M ↔ IsAssociatedPrime I M' :=
⟨fun h => h.map_of_injective l l.injective,
fun h => h.map_of_injective l.symm l.symm.injective⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Noetherian.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean | LinearEquiv.isAssociatedPrime_iff | null |
not_isAssociatedPrime_of_subsingleton [Subsingleton M] : ¬IsAssociatedPrime I M := by
rintro ⟨hI, x, hx⟩
apply hI.ne_top
simpa [Subsingleton.elim x 0] using hx
variable (R) in | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Noetherian.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean | not_isAssociatedPrime_of_subsingleton | null |
exists_le_isAssociatedPrime_of_isNoetherianRing [H : IsNoetherianRing R] (x : M)
(hx : x ≠ 0) : ∃ P : Ideal R, IsAssociatedPrime P M ∧ ker (toSpanSingleton R M x) ≤ P := by
have : ker (toSpanSingleton R M x) ≠ ⊤ := by
rwa [Ne, Ideal.eq_top_iff_one, mem_ker, toSpanSingleton_apply, one_smul]
obtain ⟨P, ⟨l, h₁, y, rfl⟩, h₃⟩ :=
set_has_maximal_iff_noetherian.mpr H
{ P | ker (toSpanSingleton R M x) ≤ P ∧ P ≠ ⊤ ∧ ∃ y : M, P = ker (toSpanSingleton R M y) }
⟨_, rfl.le, this, x, rfl⟩
refine ⟨_, ⟨⟨h₁, ?_⟩, y, rfl⟩, l⟩
intro a b hab
rw [or_iff_not_imp_left]
intro ha
rw [mem_ker, toSpanSingleton_apply] at ha hab
have H₁ : ker (toSpanSingleton R M y) ≤ ker (toSpanSingleton R M (a • y)) := by
intro c hc
rw [mem_ker, toSpanSingleton_apply] at hc ⊢
rw [smul_comm, hc, smul_zero]
have H₂ : ker (toSpanSingleton R M (a • y)) ≠ ⊤ := by
rwa [Ne, ker_eq_top, toSpanSingleton_eq_zero_iff]
rwa [H₁.eq_of_not_lt (h₃ _ ⟨l.trans H₁, H₂, _, rfl⟩),
mem_ker, toSpanSingleton_apply, smul_comm, smul_smul] | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Noetherian.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean | exists_le_isAssociatedPrime_of_isNoetherianRing | null |
@[stacks 02M3 "first part"]
subset_of_injective (hf : Function.Injective f) :
associatedPrimes R M ⊆ associatedPrimes R M' := fun _I h => h.map_of_injective f hf | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Noetherian.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean | subset_of_injective | If `M → M'` is injective, then the set of associated primes of `M` is
contained in that of `M'`. |
@[stacks 02M3 "second part"]
subset_union_of_exact (hf : Function.Injective f) (hfg : Function.Exact f g) :
associatedPrimes R M' ⊆ associatedPrimes R M ∪ associatedPrimes R M'' := by
rintro p ⟨_, x, hx⟩
by_cases h : ∃ a ∈ p.primeCompl, ∃ y : M, f y = a • x
· obtain ⟨a, ha, y, h⟩ := h
left
refine ⟨‹_›, y, le_antisymm (fun b hb ↦ ?_) (fun b hb ↦ ?_)⟩
· rw [hx] at hb
rw [LinearMap.mem_ker, LinearMap.toSpanSingleton_apply] at hb ⊢
apply_fun _ using hf
rw [map_smul, map_zero, h, smul_comm, hb, smul_zero]
· rw [LinearMap.mem_ker, LinearMap.toSpanSingleton_apply] at hb
apply_fun f at hb
rw [map_smul, map_zero, h, ← mul_smul, ← LinearMap.toSpanSingleton_apply,
← LinearMap.mem_ker, ← hx] at hb
contrapose! hb
exact p.primeCompl.mul_mem hb ha
· push_neg at h
right
refine ⟨‹_›, g x, le_antisymm (fun b hb ↦ ?_) (fun b hb ↦ ?_)⟩
· rw [hx] at hb
rw [LinearMap.mem_ker, LinearMap.toSpanSingleton_apply] at hb ⊢
rw [← map_smul, hb, map_zero]
· rw [LinearMap.mem_ker, LinearMap.toSpanSingleton_apply, ← map_smul, ← LinearMap.mem_ker,
hfg.linearMap_ker_eq] at hb
obtain ⟨y, hy⟩ := hb
by_contra! H
exact h b H y hy
variable (R M M') in | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Noetherian.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean | subset_union_of_exact | If `0 → M → M' → M''` is an exact sequence, then the set of associated primes of `M'` is
contained in the union of those of `M` and `M''`. |
@[stacks 02M3 "third part"]
prod : associatedPrimes R (M × M') = associatedPrimes R M ∪ associatedPrimes R M' :=
(subset_union_of_exact LinearMap.inl_injective .inl_snd).antisymm (Set.union_subset_iff.2
⟨subset_of_injective LinearMap.inl_injective, subset_of_injective LinearMap.inr_injective⟩) | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Noetherian.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean | prod | The set of associated primes of the product of two modules is equal to
the union of those of the two modules. |
LinearEquiv.AssociatedPrimes.eq (l : M ≃ₗ[R] M') :
associatedPrimes R M = associatedPrimes R M' :=
le_antisymm (associatedPrimes.subset_of_injective l.injective)
(associatedPrimes.subset_of_injective l.symm.injective) | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Noetherian.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean | LinearEquiv.AssociatedPrimes.eq | null |
associatedPrimes.eq_empty_of_subsingleton [Subsingleton M] : associatedPrimes R M = ∅ := by
ext; simp only [Set.mem_empty_iff_false, iff_false]
apply not_isAssociatedPrime_of_subsingleton
variable (R M) | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Noetherian.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean | associatedPrimes.eq_empty_of_subsingleton | null |
associatedPrimes.nonempty [IsNoetherianRing R] [Nontrivial M] :
(associatedPrimes R M).Nonempty := by
obtain ⟨x, hx⟩ := exists_ne (0 : M)
obtain ⟨P, hP, _⟩ := exists_le_isAssociatedPrime_of_isNoetherianRing R x hx
exact ⟨P, hP⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Noetherian.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean | associatedPrimes.nonempty | null |
biUnion_associatedPrimes_eq_zero_divisors [IsNoetherianRing R] :
⋃ p ∈ associatedPrimes R M, p = { r : R | ∃ x : M, x ≠ 0 ∧ r • x = 0 } := by
refine subset_antisymm (Set.iUnion₂_subset ?_) ?_
· rintro _ ⟨h, x, ⟨⟩⟩ r h'
refine ⟨x, ne_of_eq_of_ne (one_smul R x).symm ?_, h'⟩
exact (Ideal.ne_top_iff_one _).mp h.ne_top
· intro r ⟨x, h, h'⟩
obtain ⟨P, hP, hx⟩ := exists_le_isAssociatedPrime_of_isNoetherianRing R x h
exact Set.mem_biUnion hP (hx h')
variable {R M} | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Noetherian.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean | biUnion_associatedPrimes_eq_zero_divisors | null |
IsAssociatedPrime.annihilator_le (h : IsAssociatedPrime I M) :
(⊤ : Submodule R M).annihilator ≤ I := by
obtain ⟨hI, x, rfl⟩ := h
rw [← Submodule.annihilator_span_singleton]
exact Submodule.annihilator_mono le_top | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Noetherian.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean | IsAssociatedPrime.annihilator_le | null |
IsAssociatedPrime.eq_radical (hI : I.IsPrimary) (h : IsAssociatedPrime J (R ⧸ I)) :
J = I.radical := by
obtain ⟨hJ, x, e⟩ := h
have : x ≠ 0 := by
rintro rfl
apply hJ.1
rwa [toSpanSingleton_zero, ker_zero] at e
obtain ⟨x, rfl⟩ := Ideal.Quotient.mkₐ_surjective R _ x
replace e : ∀ {y}, y ∈ J ↔ x * y ∈ I := by
intro y
rw [e, mem_ker, toSpanSingleton_apply, ← map_smul, smul_eq_mul, mul_comm,
Ideal.Quotient.mkₐ_eq_mk, ← Ideal.Quotient.mk_eq_mk, Submodule.Quotient.mk_eq_zero]
apply le_antisymm
· intro y hy
exact ((Ideal.isPrimary_iff.1 hI).2 <| e.mp hy).resolve_left
((Submodule.Quotient.mk_eq_zero I).not.mp this)
· rw [hJ.radical_le_iff]
intro y hy
exact e.mpr (I.mul_mem_left x hy) | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Noetherian.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean | IsAssociatedPrime.eq_radical | null |
associatedPrimes.eq_singleton_of_isPrimary [IsNoetherianRing R] (hI : I.IsPrimary) :
associatedPrimes R (R ⧸ I) = {I.radical} := by
ext J
rw [Set.mem_singleton_iff]
refine ⟨IsAssociatedPrime.eq_radical hI, ?_⟩
rintro rfl
haveI : Nontrivial (R ⧸ I) := by
refine ⟨(Ideal.Quotient.mk I :) 1, (Ideal.Quotient.mk I :) 0, ?_⟩
rw [Ne, Ideal.Quotient.eq, sub_zero, ← Ideal.eq_top_iff_one]
exact hI.1
obtain ⟨a, ha⟩ := associatedPrimes.nonempty R (R ⧸ I)
exact ha.eq_radical hI ▸ ha | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Noetherian.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean | associatedPrimes.eq_singleton_of_isPrimary | null |
Submodule.IsQuotientEquivQuotientPrime (N₁ N₂ : Submodule A M) :=
N₁ ≤ N₂ ∧ ∃ (p : PrimeSpectrum A), Nonempty ((↥N₂ ⧸ N₁.submoduleOf N₂) ≃ₗ[A] A ⧸ p.1)
open LinearMap in | def | RingTheory | [
"Mathlib.Order.RelSeries",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.Noetherian.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Finiteness.lean | Submodule.IsQuotientEquivQuotientPrime | A `Prop` asserting that two submodules `N₁, N₂` satisfy `N₁ ≤ N₂` and
`N₂ / N₁` is isomorphic to `A / p` for some prime ideal `p` of `A`. |
Submodule.isQuotientEquivQuotientPrime_iff {N₁ N₂ : Submodule A M} :
N₁.IsQuotientEquivQuotientPrime N₂ ↔
∃ x, Ideal.IsPrime (ker (toSpanSingleton A _ (N₁.mkQ x))) ∧ N₂ = N₁ ⊔ span A {x} := by
let f := mapQ (N₁.submoduleOf N₂) N₁ N₂.subtype le_rfl
have hf₁ : ker f = ⊥ := ker_liftQ_eq_bot _ _ _ (by simp [ker_comp, submoduleOf])
have hf₂ : range f = N₂.map N₁.mkQ := by simp [f, mapQ, range_liftQ, range_comp]
refine ⟨fun ⟨h, p, ⟨e⟩⟩ ↦ ?_, fun ⟨x, hx, hx'⟩ ↦ ⟨le_sup_left.trans_eq hx'.symm, ⟨_, hx⟩, ?_⟩⟩
· obtain ⟨⟨x, hx⟩, hx'⟩ := Submodule.mkQ_surjective _ (e.symm 1)
have hx'' : N₁.mkQ x = f (e.symm 1) := by simp [f, ← hx']
refine ⟨x, ?_, ?_⟩
· convert p.2
ext r
simp [hx'', ← map_smul, Algebra.smul_def, show f _ = 0 ↔ _ from congr(_ ∈ $hf₁),
Ideal.Quotient.eq_zero_iff_mem]
· refine le_antisymm ?_ (sup_le h ((span_singleton_le_iff_mem _ _).mpr hx))
have : (span A {x}).map N₁.mkQ = ((span A {1}).map e.symm).map f := by
simp only [map_span, Set.image_singleton, hx'']
rw [← N₁.ker_mkQ, sup_comm, ← comap_map_eq, ← map_le_iff_le_comap, this]
simp [hf₂, Ideal.Quotient.span_singleton_one]
· have hxN₂ : x ∈ N₂ := (le_sup_right.trans_eq hx'.symm) (mem_span_singleton_self x)
refine ⟨.symm (.ofBijective (Submodule.mapQ _ _ (toSpanSingleton A _ ⟨x, hxN₂⟩) ?_) ⟨?_, ?_⟩)⟩
· simp [SetLike.le_def, ← Quotient.mk_smul, submoduleOf]
· refine ker_eq_bot.mp (ker_liftQ_eq_bot _ _ _ ?_)
simp [← Quotient.mk_smul, SetLike.le_def, submoduleOf]
· rw [mapQ, ← range_eq_top, range_liftQ, range_comp]
have := congr($(hx').submoduleOf N₂)
rw [submoduleOf_self, submoduleOf_sup_of_le (by simp_all) (by simp_all),
submoduleOf_span_singleton_of_mem _ hxN₂] at this
simpa [← span_singleton_eq_range, LinearMap.range_toSpanSingleton] using this.symm
variable (A M) [IsNoetherianRing A] [Module.Finite A M] | theorem | RingTheory | [
"Mathlib.Order.RelSeries",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.Noetherian.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Finiteness.lean | Submodule.isQuotientEquivQuotientPrime_iff | null |
@[stacks 00L0]
IsNoetherianRing.exists_relSeries_isQuotientEquivQuotientPrime :
∃ s : RelSeries {(N₁, N₂) | Submodule.IsQuotientEquivQuotientPrime (A := A) (M := M) N₁ N₂},
s.head = ⊥ ∧ s.last = ⊤ := by
refine WellFoundedGT.induction_top ⟨⊥, .singleton _ ⊥, rfl, rfl⟩ ?_
rintro N hN ⟨s, hs₁, hs₂⟩
have := Submodule.Quotient.nontrivial_of_lt_top _ hN.lt_top
obtain ⟨p, hp, x, rfl⟩ := associatedPrimes.nonempty A (M ⧸ N)
obtain ⟨x, rfl⟩ := Submodule.mkQ_surjective _ x
have hxN : x ∉ N := fun h ↦ hp.ne_top (by rw [show N.mkQ x = 0 by simpa]; simp)
have := Submodule.isQuotientEquivQuotientPrime_iff.mpr ⟨x, hp, rfl⟩
refine ⟨_, by simpa [hs₂], s.snoc _ (hs₂ ▸ this), by simpa, rfl⟩ | theorem | RingTheory | [
"Mathlib.Order.RelSeries",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.Noetherian.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Finiteness.lean | IsNoetherianRing.exists_relSeries_isQuotientEquivQuotientPrime | If `A` is a Noetherian ring and `M` is a finitely generated `A`-module, then there exists
a chain of submodules `0 = M₀ ≤ M₁ ≤ M₂ ≤ ... ≤ Mₙ = M` of `M`, such that for each `0 ≤ i < n`,
`Mᵢ₊₁ / Mᵢ` is isomorphic to `A / pᵢ` for some prime ideal `pᵢ` of `A`. |
@[elab_as_elim]
IsNoetherianRing.induction_on_isQuotientEquivQuotientPrime
⦃M : Type v⦄ [AddCommGroup M] [Module A M] (_ : Module.Finite A M)
{motive : (N : Type v) → [AddCommGroup N] → [Module A N] → [Module.Finite A N] → Prop}
(subsingleton : (N : Type v) → [AddCommGroup N] → [Module A N] → [Module.Finite A N] →
[Subsingleton N] → motive N)
(quotient : (N : Type v) → [AddCommGroup N] → [Module A N] → [Module.Finite A N] →
(p : PrimeSpectrum A) → (N ≃ₗ[A] A ⧸ p.1) → motive N)
(exact : (N₁ : Type v) → [AddCommGroup N₁] → [Module A N₁] → [Module.Finite A N₁] →
(N₂ : Type v) → [AddCommGroup N₂] → [Module A N₂] → [Module.Finite A N₂] →
(N₃ : Type v) → [AddCommGroup N₃] → [Module A N₃] → [Module.Finite A N₃] →
(f : N₁ →ₗ[A] N₂) → (g : N₂ →ₗ[A] N₃) →
Function.Injective f → Function.Surjective g → Function.Exact f g →
motive N₁ → motive N₃ → motive N₂) : motive M := by
have equiv (N₁ : Type v) [AddCommGroup N₁] [Module A N₁] [Module.Finite A N₁]
(N₂ : Type v) [AddCommGroup N₂] [Module A N₂] [Module.Finite A N₂]
(f : N₁ ≃ₗ[A] N₂) (h : motive N₁) : motive N₂ :=
exact N₁ N₂ PUnit.{v + 1} f 0 f.injective (Function.surjective_to_subsingleton _)
((f.exact_zero_iff_surjective _).2 f.surjective) h (subsingleton _)
obtain ⟨s, hs1, hs2⟩ := IsNoetherianRing.exists_relSeries_isQuotientEquivQuotientPrime A M
suffices H : ∀ n, (h : n < s.length + 1) → motive (s ⟨n, h⟩) by
replace H : motive s.last := H s.length s.length.lt_add_one
rw [hs2] at H
exact equiv _ _ Submodule.topEquiv H
intro n h
induction n with
| zero =>
change motive s.head
rw [hs1]
exact subsingleton _
| succ n ih =>
specialize ih (n.lt_add_one.trans h)
obtain ⟨hle, p, ⟨f⟩⟩ := s.step ⟨n, (add_lt_add_iff_right _).1 h⟩
replace ih := equiv _ _ (Submodule.submoduleOfEquivOfLe hle).symm ih
exact exact _ _ _ _ _ (Submodule.injective_subtype _) (Submodule.mkQ_surjective _)
(LinearMap.exact_subtype_mkQ _) ih (quotient _ p f) | theorem | RingTheory | [
"Mathlib.Order.RelSeries",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.Noetherian.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Finiteness.lean | IsNoetherianRing.induction_on_isQuotientEquivQuotientPrime | If a property on finitely generated modules over a Noetherian ring satisfies that:
- it holds for zero module (it's formalized as it holds for any module which is subsingleton),
- it holds for `A ⧸ p` for every prime ideal `p` of `A` (to avoid universe problem,
it's formalized as it holds for any module isomorphic to `A ⧸ p`),
- it is stable by short exact sequences,
then the property holds for every finitely generated modules.
NOTE: This should be the induction principle for `M`, but due to the bug
https://github.com/leanprover/lean4/issues/4246
currently it is induction for `Module.Finite A M`. |
@[stacks 00LC]
associatedPrimes.finite : (associatedPrimes A M).Finite := by
induction ‹Module.Finite A M› using
IsNoetherianRing.induction_on_isQuotientEquivQuotientPrime A with
| subsingleton N => simp [associatedPrimes.eq_empty_of_subsingleton]
| quotient N p f =>
have := associatedPrimes.eq_singleton_of_isPrimary p.2.isPrimary
simp [LinearEquiv.AssociatedPrimes.eq f, this]
| exact N₁ N₂ N₃ f g hf _ hfg h₁ h₃ =>
exact (h₁.union h₃).subset (associatedPrimes.subset_union_of_exact hf hfg) | theorem | RingTheory | [
"Mathlib.Order.RelSeries",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.Noetherian.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Defs"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Finiteness.lean | associatedPrimes.finite | There are only finitely many associated primes of a finitely generated module
over a Noetherian ring. |
mem_associatePrimes_of_comap_mem_associatePrimes_isLocalizedModule
(p : Ideal R') [p.IsPrime]
(ass : p.comap (algebraMap R R') ∈ associatedPrimes R M) :
p ∈ associatedPrimes R' M' := by
rcases ass with ⟨hp, x, hx⟩
constructor
· /- use the following to remove `p.IsPrime`
exact (IsLocalization.isPrime_iff_isPrime_disjoint S _ _).mpr
⟨hp, (IsLocalization.disjoint_comap_iff S R' p).mpr (p ≠ ⊤)⟩ -/
assumption
· use f x
ext t
rcases IsLocalization.mk'_surjective S t with ⟨r, s, hrs⟩
rw [← IsLocalizedModule.mk'_one S, ← hrs, mem_ker, toSpanSingleton_apply,
IsLocalizedModule.mk'_smul_mk', mul_one, IsLocalizedModule.mk'_eq_zero']
refine ⟨fun h ↦ ?_, fun ⟨t, ht⟩ ↦ ?_⟩
· use 1
simp only [← toSpanSingleton_apply, one_smul, ← mem_ker, ← hx, Ideal.mem_comap]
have : (algebraMap R R') r =
IsLocalization.mk' R' r s * IsLocalization.mk' R' s.1 (1 : S) := by
rw [← IsLocalization.mk'_one (M := S) R', ← sub_eq_zero, ← IsLocalization.mk'_mul,
← IsLocalization.mk'_sub]
simp
rw [this]
exact Ideal.IsTwoSided.mul_mem_of_left _ h
· have : t • r • x = (t.1 * r) • x := smul_smul t.1 r x
rw [this, ← LinearMap.toSpanSingleton_apply, ← LinearMap.mem_ker, ← hx, Ideal.mem_comap,
← IsLocalization.mk'_one (M := S) R'] at ht
have : IsLocalization.mk' R' r s =
IsLocalization.mk' (M := S) R' (t.1 * r) 1 * IsLocalization.mk' R' 1 (t * s) := by
rw [← IsLocalization.mk'_mul, mul_one, one_mul, ← sub_eq_zero, ← IsLocalization.mk'_sub,
Submonoid.coe_mul]
simp [← mul_assoc, mul_comm r t.1, IsLocalization.mk'_zero]
simpa [this] using Ideal.IsTwoSided.mul_mem_of_left _ ht | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Localization.lean | mem_associatePrimes_of_comap_mem_associatePrimes_isLocalizedModule | null |
mem_associatePrimes_localizedModule_atPrime_of_mem_associated_primes
{p : Ideal R} [p.IsPrime] (ass : p ∈ associatedPrimes R M) :
maximalIdeal (Localization.AtPrime p) ∈
associatedPrimes (Localization.AtPrime p) (LocalizedModule p.primeCompl M) := by
apply mem_associatePrimes_of_comap_mem_associatePrimes_isLocalizedModule
p.primeCompl (Localization.AtPrime p) (LocalizedModule.mkLinearMap p.primeCompl M)
simpa [Localization.AtPrime.comap_maximalIdeal] using ass | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Basic",
"Mathlib.RingTheory.Ideal.AssociatedPrime.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/Ideal/AssociatedPrime/Localization.lean | mem_associatePrimes_localizedModule_atPrime_of_mem_associated_primes | null |
protected Ideal.minimalPrimes : Set (Ideal R) :=
{p | Minimal (fun q ↦ q.IsPrime ∧ I ≤ q) p}
variable (R) in | def | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.Order.Minimal"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Basic.lean | Ideal.minimalPrimes | `I.minimalPrimes` is the set of ideals that are minimal primes over `I`. |
minimalPrimes : Set (Ideal R) :=
Ideal.minimalPrimes ⊥ | def | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.Order.Minimal"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Basic.lean | minimalPrimes | `minimalPrimes R` is the set of minimal primes of `R`.
This is defined as `Ideal.minimalPrimes ⊥`. |
minimalPrimes_eq_minimals : minimalPrimes R = {x | Minimal Ideal.IsPrime x} :=
congr_arg Minimal (by simp)
variable {I J} | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.Order.Minimal"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Basic.lean | minimalPrimes_eq_minimals | null |
Ideal.minimalPrimes_isPrime {p : Ideal R} (h : p ∈ I.minimalPrimes) : p.IsPrime :=
h.1.1 | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.Order.Minimal"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Basic.lean | Ideal.minimalPrimes_isPrime | null |
Ideal.exists_minimalPrimes_le [J.IsPrime] (e : I ≤ J) : ∃ p ∈ I.minimalPrimes, p ≤ J := by
set S := { p : (Ideal R)ᵒᵈ | Ideal.IsPrime p ∧ I ≤ OrderDual.ofDual p }
suffices h : ∃ m, OrderDual.toDual J ≤ m ∧ Maximal (· ∈ S) m by
obtain ⟨p, hJp, hp⟩ := h
exact ⟨p, ⟨hp.prop, fun q hq hle ↦ hp.le_of_ge hq hle⟩, hJp⟩
apply zorn_le_nonempty₀
swap
· refine ⟨show J.IsPrime by infer_instance, e⟩
rintro (c : Set (Ideal R)) hc hc' J' hJ'
refine
⟨OrderDual.toDual (sInf c),
⟨Ideal.sInf_isPrime_of_isChain ⟨J', hJ'⟩ hc'.symm fun x hx => (hc hx).1, ?_⟩, ?_⟩
· rw [OrderDual.ofDual_toDual, le_sInf_iff]
exact fun _ hx => (hc hx).2
· rintro z hz
rw [OrderDual.le_toDual]
exact sInf_le hz | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.Order.Minimal"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Basic.lean | Ideal.exists_minimalPrimes_le | null |
Ideal.nonempty_minimalPrimes (h : I ≠ ⊤) : Nonempty I.minimalPrimes := by
obtain ⟨m, hm, hle⟩ := Ideal.exists_le_maximal I h
obtain ⟨p, hp, -⟩ := Ideal.exists_minimalPrimes_le hle
exact ⟨p, hp⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.Order.Minimal"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Basic.lean | Ideal.nonempty_minimalPrimes | null |
Ideal.eq_bot_of_minimalPrimes_eq_empty (h : I.minimalPrimes = ∅) : I = ⊤ := by
by_contra hI
obtain ⟨p, hp⟩ := Ideal.nonempty_minimalPrimes hI
exact Set.notMem_empty p (h ▸ hp)
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.Order.Minimal"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Basic.lean | Ideal.eq_bot_of_minimalPrimes_eq_empty | null |
Ideal.radical_minimalPrimes : I.radical.minimalPrimes = I.minimalPrimes := by
rw [Ideal.minimalPrimes, Ideal.minimalPrimes]
ext p
refine ⟨?_, ?_⟩ <;> rintro ⟨⟨a, ha⟩, b⟩
· refine ⟨⟨a, a.radical_le_iff.1 ha⟩, ?_⟩
simp only [and_imp] at *
exact fun _ h2 h3 h4 => b h2 (h2.radical_le_iff.2 h3) h4
· refine ⟨⟨a, a.radical_le_iff.2 ha⟩, ?_⟩
simp only [and_imp] at *
exact fun _ h2 h3 h4 => b h2 (h2.radical_le_iff.1 h3) h4
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.Order.Minimal"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Basic.lean | Ideal.radical_minimalPrimes | null |
Ideal.sInf_minimalPrimes : sInf I.minimalPrimes = I.radical := by
rw [I.radical_eq_sInf]
apply le_antisymm
· intro x hx
rw [Ideal.mem_sInf] at hx ⊢
rintro J ⟨e, hJ⟩
obtain ⟨p, hp, hp'⟩ := Ideal.exists_minimalPrimes_le e
exact hp' (hx hp)
· apply sInf_le_sInf _
intro I hI
exact hI.1.symm | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.Order.Minimal"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Basic.lean | Ideal.sInf_minimalPrimes | null |
Ideal.minimalPrimes_eq_subsingleton (hI : I.IsPrimary) : I.minimalPrimes = {I.radical} := by
ext J
constructor
· exact fun H =>
let e := H.1.1.radical_le_iff.mpr H.1.2
(H.2 ⟨Ideal.isPrime_radical hI, Ideal.le_radical⟩ e).antisymm e
· rintro (rfl : J = I.radical)
exact ⟨⟨Ideal.isPrime_radical hI, Ideal.le_radical⟩, fun _ H _ => H.1.radical_le_iff.mpr H.2⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.Order.Minimal"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Basic.lean | Ideal.minimalPrimes_eq_subsingleton | null |
Ideal.minimalPrimes_eq_subsingleton_self [I.IsPrime] : I.minimalPrimes = {I} := by
ext J
constructor
· exact fun H => (H.2 ⟨inferInstance, rfl.le⟩ H.1.2).antisymm H.1.2
· rintro (rfl : J = I)
exact ⟨⟨inferInstance, rfl.le⟩, fun _ h _ => h.2⟩
variable (R) in | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.Order.Minimal"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Basic.lean | Ideal.minimalPrimes_eq_subsingleton_self | null |
IsDomain.minimalPrimes_eq_singleton_bot [IsDomain R] :
minimalPrimes R = {⊥} :=
have := Ideal.bot_prime (α := R)
Ideal.minimalPrimes_eq_subsingleton_self | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.Order.Minimal"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Basic.lean | IsDomain.minimalPrimes_eq_singleton_bot | null |
Ideal.minimalPrimes_top : (⊤ : Ideal R).minimalPrimes = ∅ := by
ext p
simp only [Set.notMem_empty, iff_false]
intro h
exact h.1.1.ne_top (top_le_iff.mp h.1.2) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.Order.Minimal"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Basic.lean | Ideal.minimalPrimes_top | null |
Ideal.minimalPrimes_eq_empty_iff (I : Ideal R) :
I.minimalPrimes = ∅ ↔ I = ⊤ := by
constructor
· intro e
by_contra h
have ⟨M, hM, hM'⟩ := Ideal.exists_le_maximal I h
have ⟨p, hp⟩ := Ideal.exists_minimalPrimes_le hM'
rw [e] at hp
apply Set.notMem_empty _ hp.1
· rintro rfl
exact Ideal.minimalPrimes_top | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.Order.Minimal"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Basic.lean | Ideal.minimalPrimes_eq_empty_iff | null |
Ideal.iUnion_minimalPrimes :
⋃ p ∈ I.minimalPrimes, p = { x | ∃ y ∉ I.radical, x * y ∈ I.radical } := by
classical
ext x
simp only [Set.mem_iUnion, SetLike.mem_coe, exists_prop, Set.mem_setOf_eq]
constructor
· rintro ⟨p, ⟨⟨hp₁, hp₂⟩, hp₃⟩, hxp⟩
have : p.map (algebraMap R (Localization.AtPrime p)) ≤ (I.map (algebraMap _ _)).radical := by
rw [Ideal.radical_eq_sInf, le_sInf_iff]
rintro q ⟨hq', hq⟩
obtain ⟨h₁, h₂⟩ := ((IsLocalization.AtPrime.orderIsoOfPrime _ p) ⟨q, hq⟩).2
rw [Ideal.map_le_iff_le_comap] at hq' ⊢
exact hp₃ ⟨h₁, hq'⟩ h₂
obtain ⟨n, hn⟩ := this (Ideal.mem_map_of_mem _ hxp)
rw [IsLocalization.mem_map_algebraMap_iff (M := p.primeCompl)] at hn
obtain ⟨⟨a, b⟩, hn⟩ := hn
rw [← map_pow, ← map_mul, IsLocalization.eq_iff_exists p.primeCompl] at hn
obtain ⟨t, ht⟩ := hn
refine ⟨t * b, fun h ↦ (t * b).2 (hp₁.radical_le_iff.mpr hp₂ h), n + 1, ?_⟩
simp only at ht
have : (x * (t.1 * b.1)) ^ (n + 1) = (t.1 ^ n * b.1 ^ n * x * t.1) * a := by
rw [mul_assoc, ← ht]; ring
rw [this]
exact I.mul_mem_left _ a.2
· rintro ⟨y, hy, hx⟩
obtain ⟨p, hp, hyp⟩ : ∃ p ∈ I.minimalPrimes, y ∉ p := by
simpa [← Ideal.sInf_minimalPrimes] using hy
refine ⟨p, hp, (hp.1.1.mem_or_mem ?_).resolve_right hyp⟩
exact hp.1.1.radical_le_iff.mpr hp.1.2 hx | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Localization.lean | Ideal.iUnion_minimalPrimes | null |
Ideal.exists_mul_mem_of_mem_minimalPrimes
{p : Ideal R} (hp : p ∈ I.minimalPrimes) {x : R} (hx : x ∈ p) :
∃ y ∉ I, x * y ∈ I := by
classical
obtain ⟨y, hy, n, hx⟩ := Ideal.iUnion_minimalPrimes.subset (Set.mem_biUnion hp hx)
have H : ∃ m, x ^ m * y ^ n ∈ I := ⟨n, mul_pow x y n ▸ hx⟩
have : Nat.find H ≠ 0 :=
fun h ↦ hy ⟨n, by simpa only [h, pow_zero, one_mul] using Nat.find_spec H⟩
refine ⟨x ^ (Nat.find H - 1) * y ^ n, Nat.find_min H (Nat.sub_one_lt this), ?_⟩
rw [← mul_assoc, ← pow_succ', tsub_add_cancel_of_le (Nat.one_le_iff_ne_zero.mpr this)]
exact Nat.find_spec H | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Localization.lean | Ideal.exists_mul_mem_of_mem_minimalPrimes | null |
Ideal.disjoint_nonZeroDivisors_of_mem_minimalPrimes {p : Ideal R} (hp : p ∈ minimalPrimes R) :
Disjoint (p : Set R) (nonZeroDivisors R) := by
simp_rw [Set.disjoint_left, SetLike.mem_coe, mem_nonZeroDivisors_iff_right, not_forall,
exists_prop, @and_comm (_ * _ = _), ← mul_comm]
exact fun _ ↦ Ideal.exists_mul_mem_of_mem_minimalPrimes hp | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Localization.lean | Ideal.disjoint_nonZeroDivisors_of_mem_minimalPrimes | minimal primes are contained in zero divisors. |
Ideal.exists_comap_eq_of_mem_minimalPrimes {I : Ideal S} (f : R →+* S) (p)
(H : p ∈ (I.comap f).minimalPrimes) : ∃ p' : Ideal S, p'.IsPrime ∧ I ≤ p' ∧ p'.comap f = p :=
have := H.1.1
have ⟨p', hIp', hp', le⟩ := exists_ideal_comap_le_prime p I H.1.2
⟨p', hp', hIp', le.antisymm (H.2 ⟨inferInstance, comap_mono hIp'⟩ le)⟩
@[stacks 00FK] theorem Ideal.exists_comap_eq_of_mem_minimalPrimes_of_injective {f : R →+* S}
(hf : Function.Injective f) (p) (H : p ∈ minimalPrimes R) :
∃ p' : Ideal S, p'.IsPrime ∧ p'.comap f = p :=
have ⟨p', hp', _, eq⟩ := exists_comap_eq_of_mem_minimalPrimes f (I := ⊥) p <| by
rwa [comap_bot_of_injective f hf]
⟨p', hp', eq⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Localization.lean | Ideal.exists_comap_eq_of_mem_minimalPrimes | null |
Ideal.exists_minimalPrimes_comap_eq {I : Ideal S} (f : R →+* S) (p)
(H : p ∈ (I.comap f).minimalPrimes) : ∃ p' ∈ I.minimalPrimes, Ideal.comap f p' = p := by
obtain ⟨p', h₁, h₂, h₃⟩ := Ideal.exists_comap_eq_of_mem_minimalPrimes f p H
obtain ⟨q, hq, hq'⟩ := Ideal.exists_minimalPrimes_le h₂
refine ⟨q, hq, Eq.symm ?_⟩
have := hq.1.1
have := (Ideal.comap_mono hq').trans_eq h₃
exact (H.2 ⟨inferInstance, Ideal.comap_mono hq.1.2⟩ this).antisymm this | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Localization.lean | Ideal.exists_minimalPrimes_comap_eq | null |
Ideal.minimalPrimes_comap_subset (f : R →+* S) (J : Ideal S) :
(J.comap f).minimalPrimes ⊆ Ideal.comap f '' J.minimalPrimes :=
fun p hp ↦ Ideal.exists_minimalPrimes_comap_eq f p hp | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Localization.lean | Ideal.minimalPrimes_comap_subset | null |
Ideal.minimal_primes_comap_of_surjective {f : R →+* S} (hf : Function.Surjective f)
{I J : Ideal S} (h : J ∈ I.minimalPrimes) : J.comap f ∈ (I.comap f).minimalPrimes := by
have := h.1.1
refine ⟨⟨inferInstance, Ideal.comap_mono h.1.2⟩, ?_⟩
rintro K ⟨hK, e₁⟩ e₂
have : RingHom.ker f ≤ K := (Ideal.comap_mono bot_le).trans e₁
rw [← sup_eq_left.mpr this, RingHom.ker_eq_comap_bot, ← Ideal.comap_map_of_surjective f hf]
apply Ideal.comap_mono _
apply h.2 _ _
· exact ⟨Ideal.map_isPrime_of_surjective hf this, Ideal.le_map_of_comap_le_of_surjective f hf e₁⟩
· exact Ideal.map_le_of_le_comap e₂ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Localization.lean | Ideal.minimal_primes_comap_of_surjective | null |
Ideal.comap_minimalPrimes_eq_of_surjective {f : R →+* S} (hf : Function.Surjective f)
(I : Ideal S) : (I.comap f).minimalPrimes = Ideal.comap f '' I.minimalPrimes := by
ext J
constructor
· intro H
obtain ⟨p, h, rfl⟩ := Ideal.exists_minimalPrimes_comap_eq f J H
exact ⟨p, h, rfl⟩
· rintro ⟨J, hJ, rfl⟩
exact Ideal.minimal_primes_comap_of_surjective hf hJ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/Ideal/MinimalPrime/Localization.lean | Ideal.comap_minimalPrimes_eq_of_surjective | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.