File: Mathlib/RingTheory/Ideal/MinimalPrime.lean

full_name: Ideal.minimalPrimes
code: /-- `I.minimalPrimes` is the set of ideals that are minimal primes over `I`. -/
protected def Ideal.minimalPrimes : Set (Ideal R) 
goal: Set (Ideal R)

full_name: minimalPrimes
code: /-- `minimalPrimes R` is the set of minimal primes of `R`.
This is defined as `Ideal.minimalPrimes ⊥`. -/
def minimalPrimes : Set (Ideal R) 
goal: Set (Ideal R)

full_name: minimalPrimes_eq_minimals
code: lemma minimalPrimes_eq_minimals : minimalPrimes R = minimals (· ≤ ·) (setOf Ideal.IsPrime) 
goal: minimalPrimes R = minimals (fun x x_1 => x ≤ x_1) (setOf Ideal.IsPrime)

full_name: Ideal.exists_minimalPrimes_le
code: theorem Ideal.exists_minimalPrimes_le [J.IsPrime] (e : I ≤ J) : ∃ p ∈ I.minimalPrimes, p ≤ J 
goal: ∃ p ∈ I.minimalPrimes, p ≤ J

full_name: Ideal.radical_minimalPrimes
code: @[simp]
theorem Ideal.radical_minimalPrimes : I.radical.minimalPrimes = I.minimalPrimes 
goal: I.radical.minimalPrimes = I.minimalPrimes

full_name: Ideal.sInf_minimalPrimes
code: @[simp]
theorem Ideal.sInf_minimalPrimes : sInf I.minimalPrimes = I.radical 
goal: sInf I.minimalPrimes = I.radical

full_name: Ideal.exists_comap_eq_of_mem_minimalPrimes_of_injective
code: 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 
goal: ∃ p', p'.IsPrime ∧ Ideal.comap f p' = p

full_name: Ideal.exists_comap_eq_of_mem_minimalPrimes
code: theorem 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 
goal: ∃ p', p'.IsPrime ∧ I ≤ p' ∧ Ideal.comap f p' = p

full_name: Ideal.exists_minimalPrimes_comap_eq
code: theorem 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 
goal: ∃ p' ∈ I.minimalPrimes, Ideal.comap f p' = p

full_name: Ideal.minimal_primes_comap_of_surjective
code: theorem 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 
goal: Ideal.comap f J ∈ (Ideal.comap f I).minimalPrimes

full_name: Ideal.comap_minimalPrimes_eq_of_surjective
code: theorem 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 
goal: (Ideal.comap f I).minimalPrimes = Ideal.comap f '' I.minimalPrimes

full_name: Ideal.minimalPrimes_eq_comap
code: theorem Ideal.minimalPrimes_eq_comap :
    I.minimalPrimes = Ideal.comap (Ideal.Quotient.mk I) '' minimalPrimes (R ⧸ I) 
goal: I.minimalPrimes = Ideal.comap (Ideal.Quotient.mk I) '' minimalPrimes (R ⧸ I)

full_name: Ideal.minimalPrimes_eq_subsingleton
code: theorem Ideal.minimalPrimes_eq_subsingleton (hI : I.IsPrimary) : I.minimalPrimes = {I.radical} 
goal: I.minimalPrimes = {I.radical}

full_name: Ideal.minimalPrimes_eq_subsingleton_self
code: theorem Ideal.minimalPrimes_eq_subsingleton_self [I.IsPrime] : I.minimalPrimes = {I} 
goal: I.minimalPrimes = {I}

full_name: IsLocalization.AtPrime.prime_unique_of_minimal
code: theorem _root_.IsLocalization.AtPrime.prime_unique_of_minimal {S} [CommSemiring S] [Algebra R S]
    [IsLocalization.AtPrime S I] {J K : Ideal S} [J.IsPrime] [K.IsPrime] : J = K 
goal: J = K

full_name: Localization.AtPrime.prime_unique_of_minimal
code: theorem prime_unique_of_minimal (J : Ideal (Localization I.primeCompl)) [J.IsPrime] :
    J = LocalRing.maximalIdeal (Localization I.primeCompl) 
goal: J = LocalRing.maximalIdeal (Localization I.primeCompl)

full_name: Localization.AtPrime.nilpotent_iff_mem_maximal_of_minimal
code: theorem nilpotent_iff_mem_maximal_of_minimal {x : _} :
    IsNilpotent x ↔ x ∈ LocalRing.maximalIdeal (Localization I.primeCompl) 
goal: IsNilpotent x ↔ x ∈ LocalRing.maximalIdeal (Localization I.primeCompl)

full_name: Localization.AtPrime.nilpotent_iff_not_unit_of_minimal
code: theorem nilpotent_iff_not_unit_of_minimal {x : Localization I.primeCompl} :
    IsNilpotent x ↔ x ∈ nonunits _ 
goal: IsNilpotent x ↔ x ∈ nonunits (Localization I.primeCompl)