File: Mathlib/RingTheory/Jacobson.lean

full_name: Ideal.IsJacobson
code: /-- A ring is a Jacobson ring if for every radical ideal `I`,
 the Jacobson radical of `I` is equal to `I`.
 See `isJacobson_iff_prime_eq` and `isJacobson_iff_sInf_maximal` for equivalent definitions. -/
class IsJacobson (R : Type*) [CommRing R] : Prop where
  out' : ∀ I : Ideal R, I.IsRadical → I.jacobson = I
goal: Prop

full_name: Ideal.IsJacobson.out'
code: /-- A ring is a Jacobson ring if for every radical ideal `I`,
 the Jacobson radical of `I` is equal to `I`.
 See `isJacobson_iff_prime_eq` and `isJacobson_iff_sInf_maximal` for equivalent definitions. -/
class IsJacobson (R : Type*) [CommRing R] : Prop where
  out' : ∀ I : Ideal R, I.IsRadical → I.jacobson = I
goal: I.IsRadical → I.jacobson = I

full_name: Ideal.isJacobson_iff
code: theorem isJacobson_iff {R} [CommRing R] :
    IsJacobson R ↔ ∀ I : Ideal R, I.IsRadical → I.jacobson = I 
goal: Ideal.IsJacobson R ↔ ∀ (I : Ideal R), I.IsRadical → I.jacobson = I

full_name: Ideal.IsJacobson.out
code: theorem IsJacobson.out {R} [CommRing R] :
    IsJacobson R → ∀ {I : Ideal R}, I.IsRadical → I.jacobson = I 
goal: Ideal.IsJacobson R → ∀ {I : Ideal R}, I.IsRadical → I.jacobson = I

full_name: Ideal.isJacobson_iff_prime_eq
code: /-- A ring is a Jacobson ring if and only if for all prime ideals `P`,
 the Jacobson radical of `P` is equal to `P`. -/
theorem isJacobson_iff_prime_eq : IsJacobson R ↔ ∀ P : Ideal R, IsPrime P → P.jacobson = P 
goal: Ideal.IsJacobson R ↔ ∀ (P : Ideal R), P.IsPrime → P.jacobson = P

full_name: Ideal.isJacobson_iff_sInf_maximal
code: /-- A ring `R` is Jacobson if and only if for every prime ideal `I`,
 `I` can be written as the infimum of some collection of maximal ideals.
 Allowing ⊤ in the set `M` of maximal ideals is equivalent, but makes some proofs cleaner. -/
theorem isJacobson_iff_sInf_maximal : IsJacobson R ↔ ∀ {I : Ideal R}, I.IsPrime →
    ∃ M : Set (Ideal R), (∀ J ∈ M, IsMaximal J ∨ J = ⊤) ∧ I = sInf M 
goal: Ideal.IsJacobson R ↔ ∀ {I : Ideal R}, I.IsPrime → ∃ M, (∀ J ∈ M, J.IsMaximal ∨ J = ⊤) ∧ I = sInf M

full_name: Ideal.isJacobson_iff_sInf_maximal'
code: theorem isJacobson_iff_sInf_maximal' : IsJacobson R ↔ ∀ {I : Ideal R}, I.IsPrime →
    ∃ M : Set (Ideal R), (∀ J ∈ M, ∀ (K : Ideal R), J < K → K = ⊤) ∧ I = sInf M 
goal: Ideal.IsJacobson R ↔ ∀ {I : Ideal R}, I.IsPrime → ∃ M, (∀ J ∈ M, ∀ (K : Ideal R), J < K → K = ⊤) ∧ I = sInf M

full_name: Ideal.radical_eq_jacobson
code: theorem radical_eq_jacobson [H : IsJacobson R] (I : Ideal R) : I.radical = I.jacobson 
goal: I.radical = I.jacobson

full_name: Ideal.isJacobson_field
code: /-- Fields have only two ideals, and the condition holds for both of them. -/
instance (priority := 100) isJacobson_field {K : Type*} [Field K] : IsJacobson K 
goal: Ideal.IsJacobson K

full_name: Ideal.isJacobson_of_surjective
code: theorem isJacobson_of_surjective [H : IsJacobson R] :
    (∃ f : R →+* S, Function.Surjective ↑f) → IsJacobson S 
goal: (∃ f, Function.Surjective ⇑f) → Ideal.IsJacobson S

full_name: Ideal.isJacobson_quotient
code: instance (priority := 100) isJacobson_quotient [IsJacobson R] : IsJacobson (R ⧸ I) 
goal: Ideal.IsJacobson (R ⧸ I)

full_name: Ideal.isJacobson_iso
code: theorem isJacobson_iso (e : R ≃+* S) : IsJacobson R ↔ IsJacobson S 
goal: Ideal.IsJacobson R ↔ Ideal.IsJacobson S

full_name: Ideal.isJacobson_of_isIntegral
code: theorem isJacobson_of_isIntegral [Algebra R S] [Algebra.IsIntegral R S] (hR : IsJacobson R) :
    IsJacobson S 
goal: Ideal.IsJacobson S

full_name: Ideal.isJacobson_of_isIntegral'
code: theorem isJacobson_of_isIntegral' (f : R →+* S) (hf : f.IsIntegral) (hR : IsJacobson R) :
    IsJacobson S 
goal: Ideal.IsJacobson S

full_name: Ideal.isMaximal_iff_isMaximal_disjoint
code: /-- If `R` is a Jacobson ring, then maximal ideals in the localization at `y`
correspond to maximal ideals in the original ring `R` that don't contain `y`.
This lemma gives the correspondence in the particular case of an ideal and its comap.
See `le_relIso_of_maximal` for the more general relation isomorphism -/
theorem isMaximal_iff_isMaximal_disjoint [H : IsJacobson R] (J : Ideal S) :
    J.IsMaximal ↔ (comap (algebraMap R S) J).IsMaximal ∧ y ∉ Ideal.comap (algebraMap R S) J 
goal: J.IsMaximal ↔ (Ideal.comap (algebraMap R S) J).IsMaximal ∧ y ∉ Ideal.comap (algebraMap R S) J

full_name: Ideal.isMaximal_of_isMaximal_disjoint
code: /-- If `R` is a Jacobson ring, then maximal ideals in the localization at `y`
correspond to maximal ideals in the original ring `R` that don't contain `y`.
This lemma gives the correspondence in the particular case of an ideal and its map.
See `le_relIso_of_maximal` for the more general statement, and the reverse of this implication -/
theorem isMaximal_of_isMaximal_disjoint [IsJacobson R] (I : Ideal R) (hI : I.IsMaximal)
    (hy : y ∉ I) : (map (algebraMap R S) I).IsMaximal 
goal: (Ideal.map (algebraMap R S) I).IsMaximal

full_name: Ideal.orderIsoOfMaximal
code: /-- If `R` is a Jacobson ring, then maximal ideals in the localization at `y`
correspond to maximal ideals in the original ring `R` that don't contain `y` -/
def orderIsoOfMaximal [IsJacobson R] :
    { p : Ideal S // p.IsMaximal } ≃o { p : Ideal R // p.IsMaximal ∧ y ∉ p } 
goal: { p // p.IsMaximal } ≃o { p // p.IsMaximal ∧ y ∉ p }

full_name: Ideal.isJacobson_localization
code: /-- If `S` is the localization of the Jacobson ring `R` at the submonoid generated by `y : R`, then
`S` is Jacobson. -/
theorem isJacobson_localization [H : IsJacobson R] : IsJacobson S 
goal: Ideal.IsJacobson S

full_name: Ideal.Polynomial.Subring.mem_closure_image_of
code: lemma Subring.mem_closure_image_of {S T : Type*} [CommRing S] [CommRing T] (g : S →+* T)
    (u : Set S) (x : S) (hx : x ∈ Subring.closure u) : g x ∈ Subring.closure (g '' u) 
goal: g x ∈ Subring.closure (⇑g '' u)

full_name: Ideal.Polynomial.mem_closure_X_union_C
code: lemma mem_closure_X_union_C {R : Type*} [Ring R] (p : R[X]) :
    p ∈ Subring.closure (insert X {f | f.degree ≤ 0} : Set R[X]) 
goal: p ∈ Subring.closure (insert Polynomial.X {f | f.degree ≤ 0})

full_name: Ideal.Polynomial.isIntegral_isLocalization_polynomial_quotient
code: /-- If `I` is a prime ideal of `R[X]` and `pX ∈ I` is a non-constant polynomial,
  then the map `R →+* R[x]/I` descends to an integral map when localizing at `pX.leadingCoeff`.
  In particular `X` is integral because it satisfies `pX`, and constants are trivially integral,
  so integrality of the entire extension follows by closure under addition and multiplication. -/
theorem isIntegral_isLocalization_polynomial_quotient
    (P : Ideal R[X]) (pX : R[X]) (hpX : pX ∈ P) [Algebra (R ⧸ P.comap (C : R →+* R[X])) Rₘ]
    [IsLocalization.Away (pX.map (Quotient.mk (P.comap (C : R →+* R[X])))).leadingCoeff Rₘ]
    [Algebra (R[X] ⧸ P) Sₘ] [IsLocalization ((Submonoid.powers (pX.map (Quotient.mk (P.comap
      (C : R →+* R[X])))).leadingCoeff).map (quotientMap P C le_rfl) : Submonoid (R[X] ⧸ P)) Sₘ] :
    (IsLocalization.map Sₘ (quotientMap P C le_rfl) (Submonoid.powers (pX.map (Quotient.mk (P.comap
      (C : R →+* R[X])))).leadingCoeff).le_comap_map : Rₘ →+* Sₘ).IsIntegral 
goal: (IsLocalization.map Sₘ (Ideal.quotientMap P Polynomial.C ⋯) ⋯).IsIntegral

full_name: Ideal.Polynomial.jacobson_bot_of_integral_localization
code: /-- If `f : R → S` descends to an integral map in the localization at `x`,
  and `R` is a Jacobson ring, then the intersection of all maximal ideals in `S` is trivial -/
theorem jacobson_bot_of_integral_localization {R : Type*} [CommRing R] [IsDomain R] [IsJacobson R]
    (Rₘ Sₘ : Type*) [CommRing Rₘ] [CommRing Sₘ] (φ : R →+* S) (hφ : Function.Injective ↑φ) (x : R)
    (hx : x ≠ 0) [Algebra R Rₘ] [IsLocalization.Away x Rₘ] [Algebra S Sₘ]
    [IsLocalization ((Submonoid.powers x).map φ : Submonoid S) Sₘ]
    (hφ' :
      RingHom.IsIntegral (IsLocalization.map Sₘ φ (Submonoid.powers x).le_comap_map : Rₘ →+* Sₘ)) :
    (⊥ : Ideal S).jacobson = (⊥ : Ideal S) 
goal: ⊥.jacobson = ⊥

full_name: _private.Mathlib.RingTheory.Jacobson.0.Ideal.Polynomial.isJacobson_polynomial_of_domain
code: /-- Used to bootstrap the proof of `isJacobson_polynomial_iff_isJacobson`.
  That theorem is more general and should be used instead of this one. -/
private theorem isJacobson_polynomial_of_domain (R : Type*) [CommRing R] [IsDomain R]
    [hR : IsJacobson R] (P : Ideal R[X]) [IsPrime P] (hP : ∀ x : R, C x ∈ P → x = 0) :
    P.jacobson = P 
goal: P.jacobson = P

full_name: Ideal.Polynomial.isJacobson_polynomial_of_isJacobson
code: theorem isJacobson_polynomial_of_isJacobson (hR : IsJacobson R) : IsJacobson R[X] 
goal: Ideal.IsJacobson (Polynomial R)

full_name: Ideal.Polynomial.isJacobson_polynomial_iff_isJacobson
code: theorem isJacobson_polynomial_iff_isJacobson : IsJacobson R[X] ↔ IsJacobson R 
goal: Ideal.IsJacobson (Polynomial R) ↔ Ideal.IsJacobson R

full_name: Ideal.Polynomial.instIsJacobsonPolynomial
code: instance [IsJacobson R] : IsJacobson R[X] 
goal: Ideal.IsJacobson (Polynomial R)

full_name: Ideal.Polynomial.isMaximal_comap_C_of_isMaximal
code: theorem isMaximal_comap_C_of_isMaximal [Nontrivial R] (hP' : ∀ x : R, C x ∈ P → x = 0) :
    IsMaximal (comap (C : R →+* R[X]) P : Ideal R) 
goal: (Ideal.comap Polynomial.C P).IsMaximal

full_name: _private.Mathlib.RingTheory.Jacobson.0.Ideal.Polynomial.quotient_mk_comp_C_isIntegral_of_jacobson'
code: /-- Used to bootstrap the more general `quotient_mk_comp_C_isIntegral_of_jacobson` -/
private theorem quotient_mk_comp_C_isIntegral_of_jacobson' [Nontrivial R] (hR : IsJacobson R)
    (hP' : ∀ x : R, C x ∈ P → x = 0) : ((Quotient.mk P).comp C : R →+* R[X] ⧸ P).IsIntegral 
goal: ((Ideal.Quotient.mk P).comp Polynomial.C).IsIntegral

full_name: Ideal.Polynomial.quotient_mk_comp_C_isIntegral_of_jacobson
code: /-- If `R` is a Jacobson ring, and `P` is a maximal ideal of `R[X]`,
  then `R → R[X]/P` is an integral map. -/
theorem quotient_mk_comp_C_isIntegral_of_jacobson :
    ((Quotient.mk P).comp C : R →+* R[X] ⧸ P).IsIntegral 
goal: ((Ideal.Quotient.mk P).comp Polynomial.C).IsIntegral

full_name: Ideal.Polynomial.isMaximal_comap_C_of_isJacobson
code: theorem isMaximal_comap_C_of_isJacobson : (P.comap (C : R →+* R[X])).IsMaximal 
goal: (Ideal.comap Polynomial.C P).IsMaximal

full_name: Ideal.Polynomial.isMaximal_comap_C_of_isJacobson'
code: lemma isMaximal_comap_C_of_isJacobson' {P : Ideal R[X]} (hP : IsMaximal P) :
    (P.comap (C : R →+* R[X])).IsMaximal 
goal: (Ideal.comap Polynomial.C P).IsMaximal

full_name: Ideal.Polynomial.comp_C_integral_of_surjective_of_jacobson
code: theorem comp_C_integral_of_surjective_of_jacobson {S : Type*} [Field S] (f : R[X] →+* S)
    (hf : Function.Surjective ↑f) : (f.comp C).IsIntegral 
goal: (f.comp Polynomial.C).IsIntegral

full_name: Ideal.MvPolynomial.isJacobson_MvPolynomial_fin
code: theorem isJacobson_MvPolynomial_fin {R : Type u} [CommRing R] [H : IsJacobson R] :
    ∀ n : ℕ, IsJacobson (MvPolynomial (Fin n) R)
  
goal: Ideal.IsJacobson (MvPolynomial (Fin n) R)

full_name: Ideal.MvPolynomial.isJacobson
code: /-- General form of the Nullstellensatz for Jacobson rings, since in a Jacobson ring we have
  `Inf {P maximal | P ≥ I} = Inf {P prime | P ≥ I} = I.radical`. Fields are always Jacobson,
  and in that special case this is (most of) the classical Nullstellensatz,
  since `I(V(I))` is the intersection of maximal ideals containing `I`, which is then `I.radical` -/
instance isJacobson {R : Type*} [CommRing R] {ι : Type*} [Finite ι] [IsJacobson R] :
    IsJacobson (MvPolynomial ι R) 
goal: Ideal.IsJacobson (MvPolynomial ι R)

full_name: _private.Mathlib.RingTheory.Jacobson.0.Ideal.MvPolynomial.Cₐ
code: /-- The constant coefficient as an R-linear morphism -/
private noncomputable def Cₐ (R : Type u) (S : Type v)
    [CommRing R] [CommRing S] [Algebra R S] : S →ₐ[R] S[X] 
goal: S →ₐ[R] Polynomial S

full_name: _private.Mathlib.RingTheory.Jacobson.0.Ideal.MvPolynomial.aux_IH
code: private lemma aux_IH {R : Type u} {S : Type v} {T : Type w}
  [CommRing R] [CommRing S] [CommRing T] [IsJacobson S] [Algebra R S] [Algebra R T]
  (IH : ∀ (Q : Ideal S), (IsMaximal Q) → RingHom.IsIntegral (algebraMap R (S ⧸ Q)))
  (v : S[X] ≃ₐ[R] T) (P : Ideal T) (hP : P.IsMaximal) :
  RingHom.IsIntegral (algebraMap R (T ⧸ P)) 
goal: (algebraMap R (T ⧸ P)).IsIntegral

full_name: _private.Mathlib.RingTheory.Jacobson.0.Ideal.MvPolynomial.quotient_mk_comp_C_isIntegral_of_jacobson'
code: private theorem quotient_mk_comp_C_isIntegral_of_jacobson' {R : Type*} [CommRing R] [IsJacobson R]
    (P : Ideal (MvPolynomial (Fin n) R)) (hP : P.IsMaximal) :
    RingHom.IsIntegral (algebraMap R (MvPolynomial (Fin n) R ⧸ P)) 
goal: (algebraMap R (MvPolynomial (Fin n) R ⧸ P)).IsIntegral

full_name: Ideal.MvPolynomial.quotient_mk_comp_C_isIntegral_of_jacobson
code: theorem quotient_mk_comp_C_isIntegral_of_jacobson {R : Type*} [CommRing R] [IsJacobson R]
    (P : Ideal (MvPolynomial (Fin n) R)) [hP : P.IsMaximal] :
    RingHom.IsIntegral (RingHom.comp (Quotient.mk P) (MvPolynomial.C)) 
goal: ((Ideal.Quotient.mk P).comp MvPolynomial.C).IsIntegral

full_name: Ideal.MvPolynomial.comp_C_integral_of_surjective_of_jacobson
code: theorem comp_C_integral_of_surjective_of_jacobson {R : Type*} [CommRing R] [IsJacobson R]
    {σ : Type*} [Finite σ] {S : Type*} [Field S] (f : MvPolynomial σ R →+* S)
    (hf : Function.Surjective ↑f) : (f.comp C).IsIntegral 
goal: (f.comp MvPolynomial.C).IsIntegral