File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

full_name: Ideal.IsHomogeneous
code: /-- An `I : Ideal A` is homogeneous if for every `r ∈ I`, all homogeneous components
  of `r` are in `I`. -/
def Ideal.IsHomogeneous : Prop 
goal: Prop

full_name: Ideal.IsHomogeneous.mem_iff
code: theorem Ideal.IsHomogeneous.mem_iff {I} (hI : Ideal.IsHomogeneous 𝒜 I) {x} :
    x ∈ I ↔ ∀ i, (decompose 𝒜 x i : A) ∈ I 
goal: x ∈ I ↔ ∀ (i : ι), ↑(((DirectSum.decompose 𝒜) x) i) ∈ I

full_name: HomogeneousIdeal
code: /-- For any `Semiring A`, we collect the homogeneous ideals of `A` into a type. -/
structure HomogeneousIdeal extends Submodule A A where
  is_homogeneous' : Ideal.IsHomogeneous 𝒜 toSubmodule
goal: Type u_4

full_name: HomogeneousIdeal.is_homogeneous'
code: /-- For any `Semiring A`, we collect the homogeneous ideals of `A` into a type. -/
structure HomogeneousIdeal extends Submodule A A where
  is_homogeneous' : Ideal.IsHomogeneous 𝒜 toSubmodule
goal: Ideal.IsHomogeneous 𝒜 self.toSubmodule

full_name: HomogeneousIdeal.toIdeal
code: /-- Converting a homogeneous ideal to an ideal. -/
def HomogeneousIdeal.toIdeal (I : HomogeneousIdeal 𝒜) : Ideal A 
goal: Ideal A

full_name: HomogeneousIdeal.isHomogeneous
code: theorem HomogeneousIdeal.isHomogeneous (I : HomogeneousIdeal 𝒜) : I.toIdeal.IsHomogeneous 𝒜 
goal: Ideal.IsHomogeneous 𝒜 I.toIdeal

full_name: HomogeneousIdeal.toIdeal_injective
code: theorem HomogeneousIdeal.toIdeal_injective :
    Function.Injective (HomogeneousIdeal.toIdeal : HomogeneousIdeal 𝒜 → Ideal A) 
goal: Function.Injective HomogeneousIdeal.toIdeal

full_name: HomogeneousIdeal.setLike
code: instance HomogeneousIdeal.setLike : SetLike (HomogeneousIdeal 𝒜) A 
goal: SetLike (HomogeneousIdeal 𝒜) A

full_name: HomogeneousIdeal.ext
code: @[ext]
theorem HomogeneousIdeal.ext {I J : HomogeneousIdeal 𝒜} (h : I.toIdeal = J.toIdeal) : I = J 
goal: I = J

full_name: HomogeneousIdeal.ext'
code: theorem HomogeneousIdeal.ext' {I J : HomogeneousIdeal 𝒜} (h : ∀ i, ∀ x ∈ 𝒜 i, x ∈ I ↔ x ∈ J) :
    I = J 
goal: I = J

full_name: HomogeneousIdeal.mem_iff
code: @[simp]
theorem HomogeneousIdeal.mem_iff {I : HomogeneousIdeal 𝒜} {x : A} : x ∈ I.toIdeal ↔ x ∈ I 
goal: x ∈ I.toIdeal ↔ x ∈ I

full_name: Ideal.homogeneousCore'
code: /-- For any `I : Ideal A`, not necessarily homogeneous, `I.homogeneousCore' 𝒜`
is the largest homogeneous ideal of `A` contained in `I`, as an ideal. -/
def Ideal.homogeneousCore' (I : Ideal A) : Ideal A 
goal: Ideal A

full_name: Ideal.homogeneousCore'_mono
code: theorem Ideal.homogeneousCore'_mono : Monotone (Ideal.homogeneousCore' 𝒜) 
goal: Monotone (Ideal.homogeneousCore' 𝒜)

full_name: Ideal.homogeneousCore'_le
code: theorem Ideal.homogeneousCore'_le : I.homogeneousCore' 𝒜 ≤ I 
goal: Ideal.homogeneousCore' 𝒜 I ≤ I

full_name: Ideal.isHomogeneous_iff_forall_subset
code: theorem Ideal.isHomogeneous_iff_forall_subset :
    I.IsHomogeneous 𝒜 ↔ ∀ i, (I : Set A) ⊆ GradedRing.proj 𝒜 i ⁻¹' I 
goal: Ideal.IsHomogeneous 𝒜 I ↔ ∀ (i : ι), ↑I ⊆ ⇑(GradedRing.proj 𝒜 i) ⁻¹' ↑I

full_name: Ideal.isHomogeneous_iff_subset_iInter
code: theorem Ideal.isHomogeneous_iff_subset_iInter :
    I.IsHomogeneous 𝒜 ↔ (I : Set A) ⊆ ⋂ i, GradedRing.proj 𝒜 i ⁻¹' ↑I 
goal: Ideal.IsHomogeneous 𝒜 I ↔ ↑I ⊆ ⋂ i, ⇑(GradedRing.proj 𝒜 i) ⁻¹' ↑I

full_name: Ideal.mul_homogeneous_element_mem_of_mem
code: theorem Ideal.mul_homogeneous_element_mem_of_mem {I : Ideal A} (r x : A) (hx₁ : Homogeneous 𝒜 x)
    (hx₂ : x ∈ I) (j : ι) : GradedRing.proj 𝒜 j (r * x) ∈ I 
goal: (GradedRing.proj 𝒜 j) (r * x) ∈ I

full_name: Ideal.homogeneous_span
code: theorem Ideal.homogeneous_span (s : Set A) (h : ∀ x ∈ s, Homogeneous 𝒜 x) :
    (Ideal.span s).IsHomogeneous 𝒜 
goal: Ideal.IsHomogeneous 𝒜 (Ideal.span s)

full_name: Ideal.homogeneousCore
code: /-- For any `I : Ideal A`, not necessarily homogeneous, `I.homogeneousCore' 𝒜`
is the largest homogeneous ideal of `A` contained in `I`. -/
def Ideal.homogeneousCore : HomogeneousIdeal 𝒜 
goal: HomogeneousIdeal 𝒜

full_name: Ideal.homogeneousCore_mono
code: theorem Ideal.homogeneousCore_mono : Monotone (Ideal.homogeneousCore 𝒜) 
goal: Monotone (Ideal.homogeneousCore 𝒜)

full_name: Ideal.toIdeal_homogeneousCore_le
code: theorem Ideal.toIdeal_homogeneousCore_le : (I.homogeneousCore 𝒜).toIdeal ≤ I 
goal: (Ideal.homogeneousCore 𝒜 I).toIdeal ≤ I

full_name: Ideal.mem_homogeneousCore_of_homogeneous_of_mem
code: theorem Ideal.mem_homogeneousCore_of_homogeneous_of_mem {x : A} (h : SetLike.Homogeneous 𝒜 x)
    (hmem : x ∈ I) : x ∈ I.homogeneousCore 𝒜 
goal: x ∈ Ideal.homogeneousCore 𝒜 I

full_name: Ideal.IsHomogeneous.toIdeal_homogeneousCore_eq_self
code: theorem Ideal.IsHomogeneous.toIdeal_homogeneousCore_eq_self (h : I.IsHomogeneous 𝒜) :
    (I.homogeneousCore 𝒜).toIdeal = I 
goal: (Ideal.homogeneousCore 𝒜 I).toIdeal = I

full_name: HomogeneousIdeal.toIdeal_homogeneousCore_eq_self
code: @[simp]
theorem HomogeneousIdeal.toIdeal_homogeneousCore_eq_self (I : HomogeneousIdeal 𝒜) :
    I.toIdeal.homogeneousCore 𝒜 = I 
goal: Ideal.homogeneousCore 𝒜 I.toIdeal = I

full_name: Ideal.IsHomogeneous.iff_eq
code: theorem Ideal.IsHomogeneous.iff_eq : I.IsHomogeneous 𝒜 ↔ (I.homogeneousCore 𝒜).toIdeal = I 
goal: Ideal.IsHomogeneous 𝒜 I ↔ (Ideal.homogeneousCore 𝒜 I).toIdeal = I

full_name: Ideal.IsHomogeneous.iff_exists
code: theorem Ideal.IsHomogeneous.iff_exists :
    I.IsHomogeneous 𝒜 ↔ ∃ S : Set (homogeneousSubmonoid 𝒜), I = Ideal.span ((↑) '' S) 
goal: Ideal.IsHomogeneous 𝒜 I ↔ ∃ S, I = Ideal.span (Subtype.val '' S)

full_name: Ideal.IsHomogeneous.bot
code: theorem bot : Ideal.IsHomogeneous 𝒜 ⊥ 
goal: Ideal.IsHomogeneous 𝒜 ⊥

full_name: Ideal.IsHomogeneous.top
code: theorem top : Ideal.IsHomogeneous 𝒜 ⊤ 
goal: Ideal.IsHomogeneous 𝒜 ⊤

full_name: Ideal.IsHomogeneous.inf
code: theorem inf {I J : Ideal A} (HI : I.IsHomogeneous 𝒜) (HJ : J.IsHomogeneous 𝒜) :
    (I ⊓ J).IsHomogeneous 𝒜 
goal: Ideal.IsHomogeneous 𝒜 (I ⊓ J)

full_name: Ideal.IsHomogeneous.sup
code: theorem sup {I J : Ideal A} (HI : I.IsHomogeneous 𝒜) (HJ : J.IsHomogeneous 𝒜) :
    (I ⊔ J).IsHomogeneous 𝒜 
goal: Ideal.IsHomogeneous 𝒜 (I ⊔ J)

full_name: Ideal.IsHomogeneous.iSup
code: protected theorem iSup {κ : Sort*} {f : κ → Ideal A} (h : ∀ i, (f i).IsHomogeneous 𝒜) :
    (⨆ i, f i).IsHomogeneous 𝒜 
goal: Ideal.IsHomogeneous 𝒜 (⨆ i, f i)

full_name: Ideal.IsHomogeneous.iInf
code: protected theorem iInf {κ : Sort*} {f : κ → Ideal A} (h : ∀ i, (f i).IsHomogeneous 𝒜) :
    (⨅ i, f i).IsHomogeneous 𝒜 
goal: Ideal.IsHomogeneous 𝒜 (⨅ i, f i)

full_name: Ideal.IsHomogeneous.iSup₂
code: theorem iSup₂ {κ : Sort*} {κ' : κ → Sort*} {f : ∀ i, κ' i → Ideal A}
    (h : ∀ i j, (f i j).IsHomogeneous 𝒜) : (⨆ (i) (j), f i j).IsHomogeneous 𝒜 
goal: Ideal.IsHomogeneous 𝒜 (⨆ i, ⨆ j, f i j)

full_name: Ideal.IsHomogeneous.iInf₂
code: theorem iInf₂ {κ : Sort*} {κ' : κ → Sort*} {f : ∀ i, κ' i → Ideal A}
    (h : ∀ i j, (f i j).IsHomogeneous 𝒜) : (⨅ (i) (j), f i j).IsHomogeneous 𝒜 
goal: Ideal.IsHomogeneous 𝒜 (⨅ i, ⨅ j, f i j)

full_name: Ideal.IsHomogeneous.sSup
code: theorem sSup {ℐ : Set (Ideal A)} (h : ∀ I ∈ ℐ, Ideal.IsHomogeneous 𝒜 I) :
    (sSup ℐ).IsHomogeneous 𝒜 
goal: Ideal.IsHomogeneous 𝒜 (sSup ℐ)

full_name: Ideal.IsHomogeneous.sInf
code: theorem sInf {ℐ : Set (Ideal A)} (h : ∀ I ∈ ℐ, Ideal.IsHomogeneous 𝒜 I) :
    (sInf ℐ).IsHomogeneous 𝒜 
goal: Ideal.IsHomogeneous 𝒜 (sInf ℐ)

full_name: HomogeneousIdeal.instPartialOrder
code: instance : PartialOrder (HomogeneousIdeal 𝒜) 
goal: PartialOrder (HomogeneousIdeal 𝒜)

full_name: HomogeneousIdeal.instTop
code: instance : Top (HomogeneousIdeal 𝒜) 
goal: Top (HomogeneousIdeal 𝒜)

full_name: HomogeneousIdeal.instBot
code: instance : Bot (HomogeneousIdeal 𝒜) 
goal: Bot (HomogeneousIdeal 𝒜)

full_name: HomogeneousIdeal.instSup
code: instance : Sup (HomogeneousIdeal 𝒜) 
goal: Sup (HomogeneousIdeal 𝒜)

full_name: HomogeneousIdeal.instInf
code: instance : Inf (HomogeneousIdeal 𝒜) 
goal: Inf (HomogeneousIdeal 𝒜)

full_name: HomogeneousIdeal.instSupSet
code: instance : SupSet (HomogeneousIdeal 𝒜) 
goal: SupSet (HomogeneousIdeal 𝒜)

full_name: HomogeneousIdeal.instInfSet
code: instance : InfSet (HomogeneousIdeal 𝒜) 
goal: InfSet (HomogeneousIdeal 𝒜)

full_name: HomogeneousIdeal.coe_top
code: @[simp]
theorem coe_top : ((⊤ : HomogeneousIdeal 𝒜) : Set A) = univ 
goal: ↑⊤ = Set.univ

full_name: HomogeneousIdeal.coe_bot
code: @[simp]
theorem coe_bot : ((⊥ : HomogeneousIdeal 𝒜) : Set A) = 0 
goal: ↑⊥ = 0

full_name: HomogeneousIdeal.coe_sup
code: @[simp]
theorem coe_sup (I J : HomogeneousIdeal 𝒜) : ↑(I ⊔ J) = (I + J : Set A) 
goal: ↑(I ⊔ J) = ↑I + ↑J

full_name: HomogeneousIdeal.coe_inf
code: @[simp]
theorem coe_inf (I J : HomogeneousIdeal 𝒜) : (↑(I ⊓ J) : Set A) = ↑I ∩ ↑J 
goal: ↑(I ⊓ J) = ↑I ∩ ↑J

full_name: HomogeneousIdeal.toIdeal_top
code: @[simp]
theorem toIdeal_top : (⊤ : HomogeneousIdeal 𝒜).toIdeal = (⊤ : Ideal A) 
goal: ⊤.toIdeal = ⊤

full_name: HomogeneousIdeal.toIdeal_bot
code: @[simp]
theorem toIdeal_bot : (⊥ : HomogeneousIdeal 𝒜).toIdeal = (⊥ : Ideal A) 
goal: ⊥.toIdeal = ⊥

full_name: HomogeneousIdeal.toIdeal_sup
code: @[simp]
theorem toIdeal_sup (I J : HomogeneousIdeal 𝒜) : (I ⊔ J).toIdeal = I.toIdeal ⊔ J.toIdeal 
goal: (I ⊔ J).toIdeal = I.toIdeal ⊔ J.toIdeal

full_name: HomogeneousIdeal.toIdeal_inf
code: @[simp]
theorem toIdeal_inf (I J : HomogeneousIdeal 𝒜) : (I ⊓ J).toIdeal = I.toIdeal ⊓ J.toIdeal 
goal: (I ⊓ J).toIdeal = I.toIdeal ⊓ J.toIdeal

full_name: HomogeneousIdeal.toIdeal_sSup
code: @[simp]
theorem toIdeal_sSup (ℐ : Set (HomogeneousIdeal 𝒜)) : (sSup ℐ).toIdeal = ⨆ s ∈ ℐ, toIdeal s 
goal: (sSup ℐ).toIdeal = ⨆ s ∈ ℐ, s.toIdeal

full_name: HomogeneousIdeal.toIdeal_sInf
code: @[simp]
theorem toIdeal_sInf (ℐ : Set (HomogeneousIdeal 𝒜)) : (sInf ℐ).toIdeal = ⨅ s ∈ ℐ, toIdeal s 
goal: (sInf ℐ).toIdeal = ⨅ s ∈ ℐ, s.toIdeal

full_name: HomogeneousIdeal.toIdeal_iSup
code: @[simp]
theorem toIdeal_iSup {κ : Sort*} (s : κ → HomogeneousIdeal 𝒜) :
    (⨆ i, s i).toIdeal = ⨆ i, (s i).toIdeal 
goal: (⨆ i, s i).toIdeal = ⨆ i, (s i).toIdeal

full_name: HomogeneousIdeal.toIdeal_iInf
code: @[simp]
theorem toIdeal_iInf {κ : Sort*} (s : κ → HomogeneousIdeal 𝒜) :
    (⨅ i, s i).toIdeal = ⨅ i, (s i).toIdeal 
goal: (⨅ i, s i).toIdeal = ⨅ i, (s i).toIdeal

full_name: HomogeneousIdeal.toIdeal_iSup₂
code: theorem toIdeal_iSup₂ {κ : Sort*} {κ' : κ → Sort*} (s : ∀ i, κ' i → HomogeneousIdeal 𝒜) :
    (⨆ (i) (j), s i j).toIdeal = ⨆ (i) (j), (s i j).toIdeal 
goal: (⨆ i, ⨆ j, s i j).toIdeal = ⨆ i, ⨆ j, (s i j).toIdeal

full_name: HomogeneousIdeal.toIdeal_iInf₂
code: theorem toIdeal_iInf₂ {κ : Sort*} {κ' : κ → Sort*} (s : ∀ i, κ' i → HomogeneousIdeal 𝒜) :
    (⨅ (i) (j), s i j).toIdeal = ⨅ (i) (j), (s i j).toIdeal 
goal: (⨅ i, ⨅ j, s i j).toIdeal = ⨅ i, ⨅ j, (s i j).toIdeal

full_name: HomogeneousIdeal.eq_top_iff
code: @[simp]
theorem eq_top_iff (I : HomogeneousIdeal 𝒜) : I = ⊤ ↔ I.toIdeal = ⊤ 
goal: I = ⊤ ↔ I.toIdeal = ⊤

full_name: HomogeneousIdeal.eq_bot_iff
code: @[simp]
theorem eq_bot_iff (I : HomogeneousIdeal 𝒜) : I = ⊥ ↔ I.toIdeal = ⊥ 
goal: I = ⊥ ↔ I.toIdeal = ⊥

full_name: HomogeneousIdeal.completeLattice
code: instance completeLattice : CompleteLattice (HomogeneousIdeal 𝒜) 
goal: CompleteLattice (HomogeneousIdeal 𝒜)

full_name: HomogeneousIdeal.instAdd
code: instance : Add (HomogeneousIdeal 𝒜) 
goal: Add (HomogeneousIdeal 𝒜)

full_name: HomogeneousIdeal.toIdeal_add
code: @[simp]
theorem toIdeal_add (I J : HomogeneousIdeal 𝒜) : (I + J).toIdeal = I.toIdeal + J.toIdeal 
goal: (I + J).toIdeal = I.toIdeal + J.toIdeal

full_name: HomogeneousIdeal.instInhabited
code: instance : Inhabited (HomogeneousIdeal 𝒜) 
goal: Inhabited (HomogeneousIdeal 𝒜)

full_name: Ideal.IsHomogeneous.mul
code: theorem Ideal.IsHomogeneous.mul {I J : Ideal A} (HI : I.IsHomogeneous 𝒜) (HJ : J.IsHomogeneous 𝒜) :
    (I * J).IsHomogeneous 𝒜 
goal: Ideal.IsHomogeneous 𝒜 (I * J)

full_name: instMulHomogeneousIdeal
code: instance : Mul (HomogeneousIdeal 𝒜) 
goal: Mul (HomogeneousIdeal 𝒜)

full_name: HomogeneousIdeal.toIdeal_mul
code: @[simp]
theorem HomogeneousIdeal.toIdeal_mul (I J : HomogeneousIdeal 𝒜) :
    (I * J).toIdeal = I.toIdeal * J.toIdeal 
goal: (I * J).toIdeal = I.toIdeal * J.toIdeal

full_name: Ideal.homogeneousCore.gc
code: theorem Ideal.homogeneousCore.gc : GaloisConnection toIdeal (Ideal.homogeneousCore 𝒜) 
goal: GaloisConnection HomogeneousIdeal.toIdeal (Ideal.homogeneousCore 𝒜)

full_name: Ideal.homogeneousCore.gi
code: /-- `toIdeal : HomogeneousIdeal 𝒜 → Ideal A` and `Ideal.homogeneousCore 𝒜` forms a galois
coinsertion. -/
def Ideal.homogeneousCore.gi : GaloisCoinsertion toIdeal (Ideal.homogeneousCore 𝒜) 
goal: GaloisCoinsertion HomogeneousIdeal.toIdeal (Ideal.homogeneousCore 𝒜)

full_name: Ideal.homogeneousCore_eq_sSup
code: theorem Ideal.homogeneousCore_eq_sSup :
    I.homogeneousCore 𝒜 = sSup { J : HomogeneousIdeal 𝒜 | J.toIdeal ≤ I } 
goal: Ideal.homogeneousCore 𝒜 I = sSup {J | J.toIdeal ≤ I}

full_name: Ideal.homogeneousCore'_eq_sSup
code: theorem Ideal.homogeneousCore'_eq_sSup :
    I.homogeneousCore' 𝒜 = sSup { J : Ideal A | J.IsHomogeneous 𝒜 ∧ J ≤ I } 
goal: Ideal.homogeneousCore' 𝒜 I = sSup {J | Ideal.IsHomogeneous 𝒜 J ∧ J ≤ I}

full_name: Ideal.homogeneousHull
code: /-- For any `I : Ideal A`, not necessarily homogeneous, `I.homogeneousHull 𝒜` is
the smallest homogeneous ideal containing `I`. -/
def Ideal.homogeneousHull : HomogeneousIdeal 𝒜 
goal: HomogeneousIdeal 𝒜

full_name: Ideal.le_toIdeal_homogeneousHull
code: theorem Ideal.le_toIdeal_homogeneousHull : I ≤ (Ideal.homogeneousHull 𝒜 I).toIdeal 
goal: I ≤ (Ideal.homogeneousHull 𝒜 I).toIdeal

full_name: Ideal.homogeneousHull_mono
code: theorem Ideal.homogeneousHull_mono : Monotone (Ideal.homogeneousHull 𝒜) 
goal: Monotone (Ideal.homogeneousHull 𝒜)

full_name: Ideal.IsHomogeneous.toIdeal_homogeneousHull_eq_self
code: theorem Ideal.IsHomogeneous.toIdeal_homogeneousHull_eq_self (h : I.IsHomogeneous 𝒜) :
    (Ideal.homogeneousHull 𝒜 I).toIdeal = I 
goal: (Ideal.homogeneousHull 𝒜 I).toIdeal = I

full_name: HomogeneousIdeal.homogeneousHull_toIdeal_eq_self
code: @[simp]
theorem HomogeneousIdeal.homogeneousHull_toIdeal_eq_self (I : HomogeneousIdeal 𝒜) :
    I.toIdeal.homogeneousHull 𝒜 = I 
goal: Ideal.homogeneousHull 𝒜 I.toIdeal = I

full_name: Ideal.toIdeal_homogeneousHull_eq_iSup
code: theorem Ideal.toIdeal_homogeneousHull_eq_iSup :
    (I.homogeneousHull 𝒜).toIdeal = ⨆ i, Ideal.span (GradedRing.proj 𝒜 i '' I) 
goal: (Ideal.homogeneousHull 𝒜 I).toIdeal = ⨆ i, Ideal.span (⇑(GradedRing.proj 𝒜 i) '' ↑I)

full_name: Ideal.homogeneousHull_eq_iSup
code: theorem Ideal.homogeneousHull_eq_iSup :
    I.homogeneousHull 𝒜 =
      ⨆ i, ⟨Ideal.span (GradedRing.proj 𝒜 i '' I), Ideal.homogeneous_span 𝒜 _ (by
        rintro _ ⟨x, -, rfl⟩
        apply SetLike.homogeneous_coe)⟩ 
goal: Ideal.homogeneousHull 𝒜 I = ⨆ i, { toSubmodule := Ideal.span (⇑(GradedRing.proj 𝒜 i) '' ↑I), is_homogeneous' := ⋯ }

full_name: Ideal.homogeneousHull.gc
code: theorem Ideal.homogeneousHull.gc : GaloisConnection (Ideal.homogeneousHull 𝒜) toIdeal 
goal: GaloisConnection (Ideal.homogeneousHull 𝒜) HomogeneousIdeal.toIdeal

full_name: Ideal.homogeneousHull.gi
code: /-- `Ideal.homogeneousHull 𝒜` and `toIdeal : HomogeneousIdeal 𝒜 → Ideal A` form a galois
insertion. -/
def Ideal.homogeneousHull.gi : GaloisInsertion (Ideal.homogeneousHull 𝒜) toIdeal 
goal: GaloisInsertion (Ideal.homogeneousHull 𝒜) HomogeneousIdeal.toIdeal

full_name: Ideal.homogeneousHull_eq_sInf
code: theorem Ideal.homogeneousHull_eq_sInf (I : Ideal A) :
    Ideal.homogeneousHull 𝒜 I = sInf { J : HomogeneousIdeal 𝒜 | I ≤ J.toIdeal } 
goal: Ideal.homogeneousHull 𝒜 I = sInf {J | I ≤ J.toIdeal}

full_name: HomogeneousIdeal.irrelevant
code: /-- 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}`.
-/
def HomogeneousIdeal.irrelevant : HomogeneousIdeal 𝒜 
goal: HomogeneousIdeal 𝒜

full_name: HomogeneousIdeal.mem_irrelevant_iff
code: @[simp]
theorem HomogeneousIdeal.mem_irrelevant_iff (a : A) :
    a ∈ HomogeneousIdeal.irrelevant 𝒜 ↔ proj 𝒜 0 a = 0 
goal: a ∈ HomogeneousIdeal.irrelevant 𝒜 ↔ (GradedRing.proj 𝒜 0) a = 0

full_name: HomogeneousIdeal.toIdeal_irrelevant
code: @[simp]
theorem HomogeneousIdeal.toIdeal_irrelevant :
    (HomogeneousIdeal.irrelevant 𝒜).toIdeal = RingHom.ker (GradedRing.projZeroRingHom 𝒜) 
goal: (HomogeneousIdeal.irrelevant 𝒜).toIdeal = RingHom.ker (GradedRing.projZeroRingHom 𝒜)