File: Mathlib/RingTheory/JacobsonIdeal.lean

full_name: Ideal.jacobson
code: /-- The Jacobson radical of `I` is the infimum of all maximal (left) ideals containing `I`. -/
def jacobson (I : Ideal R) : Ideal R 
goal: Ideal R

full_name: Ideal.le_jacobson
code: theorem le_jacobson : I ≤ jacobson I 
goal: I ≤ I.jacobson

full_name: Ideal.jacobson_idem
code: @[simp]
theorem jacobson_idem : jacobson (jacobson I) = jacobson I 
goal: I.jacobson.jacobson = I.jacobson

full_name: Ideal.jacobson_top
code: @[simp]
theorem jacobson_top : jacobson (⊤ : Ideal R) = ⊤ 
goal: ⊤.jacobson = ⊤

full_name: Ideal.jacobson_eq_top_iff
code: @[simp]
theorem jacobson_eq_top_iff : jacobson I = ⊤ ↔ I = ⊤ 
goal: I.jacobson = ⊤ ↔ I = ⊤

full_name: Ideal.jacobson_eq_bot
code: theorem jacobson_eq_bot : jacobson I = ⊥ → I = ⊥ 
goal: I.jacobson = ⊥ → I = ⊥

full_name: Ideal.jacobson_eq_self_of_isMaximal
code: theorem jacobson_eq_self_of_isMaximal [H : IsMaximal I] : I.jacobson = I 
goal: I.jacobson = I

full_name: Ideal.jacobson.isMaximal
code: instance (priority := 100) jacobson.isMaximal [H : IsMaximal I] : IsMaximal (jacobson I) 
goal: I.jacobson.IsMaximal

full_name: Ideal.mem_jacobson_iff
code: theorem mem_jacobson_iff {x : R} : x ∈ jacobson I ↔ ∀ y, ∃ z, z * y * x + z - 1 ∈ I 
goal: x ∈ I.jacobson ↔ ∀ (y : R), ∃ z, z * y * x + z - 1 ∈ I

full_name: Ideal.exists_mul_sub_mem_of_sub_one_mem_jacobson
code: theorem exists_mul_sub_mem_of_sub_one_mem_jacobson {I : Ideal R} (r : R) (h : r - 1 ∈ jacobson I) :
    ∃ s, s * r - 1 ∈ I 
goal: ∃ s, s * r - 1 ∈ I

full_name: Ideal.eq_jacobson_iff_sInf_maximal
code: /-- An ideal equals its Jacobson radical iff it is the intersection of a set of maximal ideals.
Allowing the set to include ⊤ is equivalent, and is included only to simplify some proofs. -/
theorem eq_jacobson_iff_sInf_maximal :
    I.jacobson = I ↔ ∃ M : Set (Ideal R), (∀ J ∈ M, IsMaximal J ∨ J = ⊤) ∧ I = sInf M 
goal: I.jacobson = I ↔ ∃ M, (∀ J ∈ M, J.IsMaximal ∨ J = ⊤) ∧ I = sInf M

full_name: Ideal.eq_jacobson_iff_sInf_maximal'
code: theorem eq_jacobson_iff_sInf_maximal' :
    I.jacobson = I ↔ ∃ M : Set (Ideal R), (∀ J ∈ M, ∀ (K : Ideal R), J < K → K = ⊤) ∧ I = sInf M 
goal: I.jacobson = I ↔ ∃ M, (∀ J ∈ M, ∀ (K : Ideal R), J < K → K = ⊤) ∧ I = sInf M

full_name: Ideal.eq_jacobson_iff_not_mem
code: /-- An ideal `I` equals its Jacobson radical if and only if every element outside `I`
also lies outside of a maximal ideal containing `I`. -/
theorem eq_jacobson_iff_not_mem :
    I.jacobson = I ↔ ∀ (x) (_ : x ∉ I), ∃ M : Ideal R, (I ≤ M ∧ M.IsMaximal) ∧ x ∉ M 
goal: I.jacobson = I ↔ ∀ x ∉ I, ∃ M, (I ≤ M ∧ M.IsMaximal) ∧ x ∉ M

full_name: Ideal.map_jacobson_of_surjective
code: theorem map_jacobson_of_surjective {f : R →+* S} (hf : Function.Surjective f) :
    RingHom.ker f ≤ I → map f I.jacobson = (map f I).jacobson 
goal: RingHom.ker f ≤ I → Ideal.map f I.jacobson = (Ideal.map f I).jacobson

full_name: Ideal.map_jacobson_of_bijective
code: theorem map_jacobson_of_bijective {f : R →+* S} (hf : Function.Bijective f) :
    map f I.jacobson = (map f I).jacobson 
goal: Ideal.map f I.jacobson = (Ideal.map f I).jacobson

full_name: Ideal.comap_jacobson
code: theorem comap_jacobson {f : R →+* S} {K : Ideal S} :
    comap f K.jacobson = sInf (comap f '' { J : Ideal S | K ≤ J ∧ J.IsMaximal }) 
goal: Ideal.comap f K.jacobson = sInf (Ideal.comap f '' {J | K ≤ J ∧ J.IsMaximal})

full_name: Ideal.comap_jacobson_of_surjective
code: theorem comap_jacobson_of_surjective {f : R →+* S} (hf : Function.Surjective f) {K : Ideal S} :
    comap f K.jacobson = (comap f K).jacobson 
goal: Ideal.comap f K.jacobson = (Ideal.comap f K).jacobson

full_name: Ideal.jacobson_mono
code: @[mono]
theorem jacobson_mono {I J : Ideal R} : I ≤ J → I.jacobson ≤ J.jacobson 
goal: I ≤ J → I.jacobson ≤ J.jacobson

full_name: Ideal.radical_le_jacobson
code: theorem radical_le_jacobson : radical I ≤ jacobson I 
goal: I.radical ≤ I.jacobson

full_name: Ideal.isRadical_of_eq_jacobson
code: theorem isRadical_of_eq_jacobson (h : jacobson I = I) : I.IsRadical 
goal: I.IsRadical

full_name: Ideal.isUnit_of_sub_one_mem_jacobson_bot
code: theorem isUnit_of_sub_one_mem_jacobson_bot (r : R) (h : r - 1 ∈ jacobson (⊥ : Ideal R)) :
    IsUnit r 
goal: IsUnit r

full_name: Ideal.mem_jacobson_bot
code: theorem mem_jacobson_bot {x : R} : x ∈ jacobson (⊥ : Ideal R) ↔ ∀ y, IsUnit (x * y + 1) 
goal: x ∈ ⊥.jacobson ↔ ∀ (y : R), IsUnit (x * y + 1)

full_name: Ideal.jacobson_eq_iff_jacobson_quotient_eq_bot
code: /-- An ideal `I` of `R` is equal to its Jacobson radical if and only if
the Jacobson radical of the quotient ring `R/I` is the zero ideal -/
-- Porting note: changed `Quotient.mk'` to ``
theorem jacobson_eq_iff_jacobson_quotient_eq_bot :
    I.jacobson = I ↔ jacobson (⊥ : Ideal (R ⧸ I)) = ⊥ 
goal: I.jacobson = I ↔ ⊥.jacobson = ⊥

full_name: Ideal.radical_eq_jacobson_iff_radical_quotient_eq_jacobson_bot
code: /-- The standard radical and Jacobson radical of an ideal `I` of `R` are equal if and only if
the nilradical and Jacobson radical of the quotient ring `R/I` coincide -/
-- Porting note: changed `Quotient.mk'` to ``
theorem radical_eq_jacobson_iff_radical_quotient_eq_jacobson_bot :
    I.radical = I.jacobson ↔ radical (⊥ : Ideal (R ⧸ I)) = jacobson ⊥ 
goal: I.radical = I.jacobson ↔ ⊥.radical = ⊥.jacobson

full_name: Ideal.jacobson_radical_eq_jacobson
code: theorem jacobson_radical_eq_jacobson : I.radical.jacobson = I.jacobson 
goal: I.radical.jacobson = I.jacobson

full_name: Ideal.jacobson_bot_polynomial_le_sInf_map_maximal
code: theorem jacobson_bot_polynomial_le_sInf_map_maximal :
    jacobson (⊥ : Ideal R[X]) ≤ sInf (map (C : R →+* R[X]) '' { J : Ideal R | J.IsMaximal }) 
goal: ⊥.jacobson ≤ sInf (Ideal.map Polynomial.C '' {J | J.IsMaximal})

full_name: Ideal.jacobson_bot_polynomial_of_jacobson_bot
code: theorem jacobson_bot_polynomial_of_jacobson_bot (h : jacobson (⊥ : Ideal R) = ⊥) :
    jacobson (⊥ : Ideal R[X]) = ⊥ 
goal: ⊥.jacobson = ⊥

full_name: Ideal.IsLocal
code: /-- An ideal `I` is local iff its Jacobson radical is maximal. -/
class IsLocal (I : Ideal R) : Prop where
  /-- A ring `R` is local if and only if its jacobson radical is maximal -/
  out : IsMaximal (jacobson I)
goal: Prop

full_name: Ideal.IsLocal.out
code: /-- An ideal `I` is local iff its Jacobson radical is maximal. -/
class IsLocal (I : Ideal R) : Prop where
  /-- A ring `R` is local if and only if its jacobson radical is maximal -/
  out : IsMaximal (jacobson I)
goal: I.jacobson.IsMaximal

full_name: Ideal.isLocal_iff
code: theorem isLocal_iff {I : Ideal R} : IsLocal I ↔ IsMaximal (jacobson I) 
goal: I.IsLocal ↔ I.jacobson.IsMaximal

full_name: Ideal.isLocal_of_isMaximal_radical
code: theorem isLocal_of_isMaximal_radical {I : Ideal R} (hi : IsMaximal (radical I)) : IsLocal I 
goal: I.IsLocal

full_name: Ideal.IsLocal.le_jacobson
code: theorem IsLocal.le_jacobson {I J : Ideal R} (hi : IsLocal I) (hij : I ≤ J) (hj : J ≠ ⊤) :
    J ≤ jacobson I 
goal: J ≤ I.jacobson

full_name: Ideal.IsLocal.mem_jacobson_or_exists_inv
code: theorem IsLocal.mem_jacobson_or_exists_inv {I : Ideal R} (hi : IsLocal I) (x : R) :
    x ∈ jacobson I ∨ ∃ y, y * x - 1 ∈ I 
goal: x ∈ I.jacobson ∨ ∃ y, y * x - 1 ∈ I

full_name: Ideal.isPrimary_of_isMaximal_radical
code: theorem isPrimary_of_isMaximal_radical [CommRing R] {I : Ideal R} (hi : IsMaximal (radical I)) :
    IsPrimary I 
goal: I.IsPrimary