l3lab/ntp-mathlib huggingface dataset:
/-- 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 := by
  by_cases Pb : P = ⊥
  · exact Pb.symm ▸
      jacobson_bot_polynomial_of_jacobson_bot (hR.out isRadical_bot_of_noZeroDivisors)
  · rw [jacobson_eq_iff_jacobson_quotient_eq_bot]
    let P' := P.comap (C : R →+* R[X])
    haveI : P'.IsPrime := comap_isPrime C P
    

Proof state:
case neg
R✝ : Type u_1
S : Type u_2
inst✝⁷ : CommRing R✝
inst✝⁶ : CommRing S
inst✝⁵ : IsDomain S
Rₘ : Type u_3
Sₘ : Type u_4
inst✝⁴ : CommRing Rₘ
inst✝³ : CommRing Sₘ
R : Type u_5
inst✝² : CommRing R
inst✝¹ : IsDomain R
hR : IsJacobson R
P : Ideal R[X]
inst✝ : IsPrime P
hP : ∀ (x : R), C x ∈ P → x = 0
Pb : ¬P = ⊥
P' : Ideal R := comap C P
this : IsPrime P'
⊢ jacobson ⊥ = ⊥

Next tactic:
haveI hR' : IsJacobson (R ⧸ P') := by infer_instance
/-- 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 := by
  by_cases Pb : P = ⊥
  · exact Pb.symm ▸
      jacobson_bot_polynomial_of_jacobson_bot (hR.out isRadical_bot_of_noZeroDivisors)
  · rw [jacobson_eq_iff_jacobson_quotient_eq_bot]
    let P' := P.comap (C : R →+* R[X])
    haveI : P'.IsPrime := comap_isPrime C P
    haveI hR' : IsJacobson (R ⧸ P') := by 

Proof state:
R✝ : Type u_1
S : Type u_2
inst✝⁷ : CommRing R✝
inst✝⁶ : CommRing S
inst✝⁵ : IsDomain S
Rₘ : Type u_3
Sₘ : Type u_4
inst✝⁴ : CommRing Rₘ
inst✝³ : CommRing Sₘ
R : Type u_5
inst✝² : CommRing R
inst✝¹ : IsDomain R
hR : IsJacobson R
P : Ideal R[X]
inst✝ : IsPrime P
hP : ∀ (x : R), C x ∈ P → x = 0
Pb : ¬P = ⊥
P' : Ideal R := comap C P
this : IsPrime P'
⊢ IsJacobson (R ⧸ P')

Next tactic:
infer_instance
/-- 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 := by
  by_cases Pb : P = ⊥
  · exact Pb.symm ▸
      jacobson_bot_polynomial_of_jacobson_bot (hR.out isRadical_bot_of_noZeroDivisors)
  · rw [jacobson_eq_iff_jacobson_quotient_eq_bot]
    let P' := P.comap (C : R →+* R[X])
    haveI : P'.IsPrime := comap_isPrime C P
    haveI hR' : IsJacobson (R ⧸ P') := by infer_instance
    

Proof state:
case neg
R✝ : Type u_1
S : Type u_2
inst✝⁷ : CommRing R✝
inst✝⁶ : CommRing S
inst✝⁵ : IsDomain S
Rₘ : Type u_3
Sₘ : Type u_4
inst✝⁴ : CommRing Rₘ
inst✝³ : CommRing Sₘ
R : Type u_5
inst✝² : CommRing R
inst✝¹ : IsDomain R
hR : IsJacobson R
P : Ideal R[X]
inst✝ : IsPrime P
hP : ∀ (x : R), C x ∈ P → x = 0
Pb : ¬P = ⊥
P' : Ideal R := comap C P
this : IsPrime P'
hR' : IsJacobson (R ⧸ P')
⊢ jacobson ⊥ = ⊥

Next tactic:
obtain ⟨p, pP, p0⟩ := exists_nonzero_mem_of_ne_bot Pb hP
/-- 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 := by
  by_cases Pb : P = ⊥
  · exact Pb.symm ▸
      jacobson_bot_polynomial_of_jacobson_bot (hR.out isRadical_bot_of_noZeroDivisors)
  · rw [jacobson_eq_iff_jacobson_quotient_eq_bot]
    let P' := P.comap (C : R →+* R[X])
    haveI : P'.IsPrime := comap_isPrime C P
    haveI hR' : IsJacobson (R ⧸ P') := by infer_instance
    obtain ⟨p, pP, p0⟩ := exists_nonzero_mem_of_ne_bot Pb hP
    

Proof state:
case neg.intro.intro
R✝ : Type u_1
S : Type u_2
inst✝⁷ : CommRing R✝
inst✝⁶ : CommRing S
inst✝⁵ : IsDomain S
Rₘ : Type u_3
Sₘ : Type u_4
inst✝⁴ : CommRing Rₘ
inst✝³ : CommRing Sₘ
R : Type u_5
inst✝² : CommRing R
inst✝¹ : IsDomain R
hR : IsJacobson R
P : Ideal R[X]
inst✝ : IsPrime P
hP : ∀ (x : R), C x ∈ P → x = 0
Pb : ¬P = ⊥
P' : Ideal R := comap C P
this : IsPrime P'
hR' : IsJacobson (R ⧸ P')
p : R[X]
pP : p ∈ P
p0 : Polynomial.map (Quotient.mk (comap C P)) p ≠ 0
⊢ jacobson ⊥ = ⊥

Next tactic:
let x := (Polynomial.map (Quotient.mk P') p).leadingCoeff
/-- 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 := by
  by_cases Pb : P = ⊥
  · exact Pb.symm ▸
      jacobson_bot_polynomial_of_jacobson_bot (hR.out isRadical_bot_of_noZeroDivisors)
  · rw [jacobson_eq_iff_jacobson_quotient_eq_bot]
    let P' := P.comap (C : R →+* R[X])
    haveI : P'.IsPrime := comap_isPrime C P
    haveI hR' : IsJacobson (R ⧸ P') := by infer_instance
    obtain ⟨p, pP, p0⟩ := exists_nonzero_mem_of_ne_bot Pb hP
    let x := (Polynomial.map (Quotient.mk P') p).leadingCoeff
    

Proof state:
case neg.intro.intro
R✝ : Type u_1
S : Type u_2
inst✝⁷ : CommRing R✝
inst✝⁶ : CommRing S
inst✝⁵ : IsDomain S
Rₘ : Type u_3
Sₘ : Type u_4
inst✝⁴ : CommRing Rₘ
inst✝³ : CommRing Sₘ
R : Type u_5
inst✝² : CommRing R
inst✝¹ : IsDomain R
hR : IsJacobson R
P : Ideal R[X]
inst✝ : IsPrime P
hP : ∀ (x : R), C x ∈ P → x = 0
Pb : ¬P = ⊥
P' : Ideal R := comap C P
this : IsPrime P'
hR' : IsJacobson (R ⧸ P')
p : R[X]
pP : p ∈ P
p0 : Polynomial.map (Quotient.mk (comap C P)) p ≠ 0
x : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') p)
⊢ jacobson ⊥ = ⊥

Next tactic:
have hx : x ≠ 0 := by rwa [Ne.def, leadingCoeff_eq_zero]
/-- 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 := by
  by_cases Pb : P = ⊥
  · exact Pb.symm ▸
      jacobson_bot_polynomial_of_jacobson_bot (hR.out isRadical_bot_of_noZeroDivisors)
  · rw [jacobson_eq_iff_jacobson_quotient_eq_bot]
    let P' := P.comap (C : R →+* R[X])
    haveI : P'.IsPrime := comap_isPrime C P
    haveI hR' : IsJacobson (R ⧸ P') := by infer_instance
    obtain ⟨p, pP, p0⟩ := exists_nonzero_mem_of_ne_bot Pb hP
    let x := (Polynomial.map (Quotient.mk P') p).leadingCoeff
    have hx : x ≠ 0 := by 

Proof state:
R✝ : Type u_1
S : Type u_2
inst✝⁷ : CommRing R✝
inst✝⁶ : CommRing S
inst✝⁵ : IsDomain S
Rₘ : Type u_3
Sₘ : Type u_4
inst✝⁴ : CommRing Rₘ
inst✝³ : CommRing Sₘ
R : Type u_5
inst✝² : CommRing R
inst✝¹ : IsDomain R
hR : IsJacobson R
P : Ideal R[X]
inst✝ : IsPrime P
hP : ∀ (x : R), C x ∈ P → x = 0
Pb : ¬P = ⊥
P' : Ideal R := comap C P
this : IsPrime P'
hR' : IsJacobson (R ⧸ P')
p : R[X]
pP : p ∈ P
p0 : Polynomial.map (Quotient.mk (comap C P)) p ≠ 0
x : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') p)
⊢ x ≠ 0

Next tactic:
rwa [Ne.def, leadingCoeff_eq_zero]
/-- 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 := by
  by_cases Pb : P = ⊥
  · exact Pb.symm ▸
      jacobson_bot_polynomial_of_jacobson_bot (hR.out isRadical_bot_of_noZeroDivisors)
  · rw [jacobson_eq_iff_jacobson_quotient_eq_bot]
    let P' := P.comap (C : R →+* R[X])
    haveI : P'.IsPrime := comap_isPrime C P
    haveI hR' : IsJacobson (R ⧸ P') := by infer_instance
    obtain ⟨p, pP, p0⟩ := exists_nonzero_mem_of_ne_bot Pb hP
    let x := (Polynomial.map (Quotient.mk P') p).leadingCoeff
    have hx : x ≠ 0 := by rwa [Ne.def, leadingCoeff_eq_zero]
    

Proof state:
case neg.intro.intro
R✝ : Type u_1
S : Type u_2
inst✝⁷ : CommRing R✝
inst✝⁶ : CommRing S
inst✝⁵ : IsDomain S
Rₘ : Type u_3
Sₘ : Type u_4
inst✝⁴ : CommRing Rₘ
inst✝³ : CommRing Sₘ
R : Type u_5
inst✝² : CommRing R
inst✝¹ : IsDomain R
hR : IsJacobson R
P : Ideal R[X]
inst✝ : IsPrime P
hP : ∀ (x : R), C x ∈ P → x = 0
Pb : ¬P = ⊥
P' : Ideal R := comap C P
this : IsPrime P'
hR' : IsJacobson (R ⧸ P')
p : R[X]
pP : p ∈ P
p0 : Polynomial.map (Quotient.mk (comap C P)) p ≠ 0
x : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') p)
hx : x ≠ 0
⊢ jacobson ⊥ = ⊥

Next tactic:
let φ : R ⧸ P' →+* R[X] ⧸ P := Ideal.quotientMap P (C : R →+* R[X]) le_rfl
/-- 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 := by
  by_cases Pb : P = ⊥
  · exact Pb.symm ▸
      jacobson_bot_polynomial_of_jacobson_bot (hR.out isRadical_bot_of_noZeroDivisors)
  · rw [jacobson_eq_iff_jacobson_quotient_eq_bot]
    let P' := P.comap (C : R →+* R[X])
    haveI : P'.IsPrime := comap_isPrime C P
    haveI hR' : IsJacobson (R ⧸ P') := by infer_instance
    obtain ⟨p, pP, p0⟩ := exists_nonzero_mem_of_ne_bot Pb hP
    let x := (Polynomial.map (Quotient.mk P') p).leadingCoeff
    have hx : x ≠ 0 := by rwa [Ne.def, leadingCoeff_eq_zero]
    let φ : R ⧸ P' →+* R[X] ⧸ P := Ideal.quotientMap P (C : R →+* R[X]) le_rfl
    

Proof state:
case neg.intro.intro
R✝ : Type u_1
S : Type u_2
inst✝⁷ : CommRing R✝
inst✝⁶ : CommRing S
inst✝⁵ : IsDomain S
Rₘ : Type u_3
Sₘ : Type u_4
inst✝⁴ : CommRing Rₘ
inst✝³ : CommRing Sₘ
R : Type u_5
inst✝² : CommRing R
inst✝¹ : IsDomain R
hR : IsJacobson R
P : Ideal R[X]
inst✝ : IsPrime P
hP : ∀ (x : R), C x ∈ P → x = 0
Pb : ¬P = ⊥
P' : Ideal R := comap C P
this : IsPrime P'
hR' : IsJacobson (R ⧸ P')
p : R[X]
pP : p ∈ P
p0 : Polynomial.map (Quotient.mk (comap C P)) p ≠ 0
x : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') p)
hx : x ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
⊢ jacobson ⊥ = ⊥

Next tactic:
let hφ : Function.Injective ↑φ := quotientMap_injective
/-- 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 := by
  by_cases Pb : P = ⊥
  · exact Pb.symm ▸
      jacobson_bot_polynomial_of_jacobson_bot (hR.out isRadical_bot_of_noZeroDivisors)
  · rw [jacobson_eq_iff_jacobson_quotient_eq_bot]
    let P' := P.comap (C : R →+* R[X])
    haveI : P'.IsPrime := comap_isPrime C P
    haveI hR' : IsJacobson (R ⧸ P') := by infer_instance
    obtain ⟨p, pP, p0⟩ := exists_nonzero_mem_of_ne_bot Pb hP
    let x := (Polynomial.map (Quotient.mk P') p).leadingCoeff
    have hx : x ≠ 0 := by rwa [Ne.def, leadingCoeff_eq_zero]
    let φ : R ⧸ P' →+* R[X] ⧸ P := Ideal.quotientMap P (C : R →+* R[X]) le_rfl
    let hφ : Function.Injective ↑φ := quotientMap_injective
    

Proof state:
case neg.intro.intro
R✝ : Type u_1
S : Type u_2
inst✝⁷ : CommRing R✝
inst✝⁶ : CommRing S
inst✝⁵ : IsDomain S
Rₘ : Type u_3
Sₘ : Type u_4
inst✝⁴ : CommRing Rₘ
inst✝³ : CommRing Sₘ
R : Type u_5
inst✝² : CommRing R
inst✝¹ : IsDomain R
hR : IsJacobson R
P : Ideal R[X]
inst✝ : IsPrime P
hP : ∀ (x : R), C x ∈ P → x = 0
Pb : ¬P = ⊥
P' : Ideal R := comap C P
this : IsPrime P'
hR' : IsJacobson (R ⧸ P')
p : R[X]
pP : p ∈ P
p0 : Polynomial.map (Quotient.mk (comap C P)) p ≠ 0
x : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') p)
hx : x ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
hφ : Function.Injective ⇑φ := quotientMap_injective
⊢ jacobson ⊥ = ⊥

Next tactic:
let Rₘ := Localization.Away x
/-- 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 := by
  by_cases Pb : P = ⊥
  · exact Pb.symm ▸
      jacobson_bot_polynomial_of_jacobson_bot (hR.out isRadical_bot_of_noZeroDivisors)
  · rw [jacobson_eq_iff_jacobson_quotient_eq_bot]
    let P' := P.comap (C : R →+* R[X])
    haveI : P'.IsPrime := comap_isPrime C P
    haveI hR' : IsJacobson (R ⧸ P') := by infer_instance
    obtain ⟨p, pP, p0⟩ := exists_nonzero_mem_of_ne_bot Pb hP
    let x := (Polynomial.map (Quotient.mk P') p).leadingCoeff
    have hx : x ≠ 0 := by rwa [Ne.def, leadingCoeff_eq_zero]
    let φ : R ⧸ P' →+* R[X] ⧸ P := Ideal.quotientMap P (C : R →+* R[X]) le_rfl
    let hφ : Function.Injective ↑φ := quotientMap_injective
    let Rₘ := Localization.Away x
    

Proof state:
case neg.intro.intro
R✝ : Type u_1
S : Type u_2
inst✝⁷ : CommRing R✝
inst✝⁶ : CommRing S
inst✝⁵ : IsDomain S
Rₘ✝ : Type u_3
Sₘ : Type u_4
inst✝⁴ : CommRing Rₘ✝
inst✝³ : CommRing Sₘ
R : Type u_5
inst✝² : CommRing R
inst✝¹ : IsDomain R
hR : IsJacobson R
P : Ideal R[X]
inst✝ : IsPrime P
hP : ∀ (x : R), C x ∈ P → x = 0
Pb : ¬P = ⊥
P' : Ideal R := comap C P
this : IsPrime P'
hR' : IsJacobson (R ⧸ P')
p : R[X]
pP : p ∈ P
p0 : Polynomial.map (Quotient.mk (comap C P)) p ≠ 0
x : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') p)
hx : x ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
hφ : Function.Injective ⇑φ := quotientMap_injective
Rₘ : Type u_5 := Localization.Away x
⊢ jacobson ⊥ = ⊥

Next tactic:
let Sₘ := (Localization ((Submonoid.powers x).map φ : Submonoid (R[X] ⧸ P)))
/-- 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 := by
  by_cases Pb : P = ⊥
  · exact Pb.symm ▸
      jacobson_bot_polynomial_of_jacobson_bot (hR.out isRadical_bot_of_noZeroDivisors)
  · rw [jacobson_eq_iff_jacobson_quotient_eq_bot]
    let P' := P.comap (C : R →+* R[X])
    haveI : P'.IsPrime := comap_isPrime C P
    haveI hR' : IsJacobson (R ⧸ P') := by infer_instance
    obtain ⟨p, pP, p0⟩ := exists_nonzero_mem_of_ne_bot Pb hP
    let x := (Polynomial.map (Quotient.mk P') p).leadingCoeff
    have hx : x ≠ 0 := by rwa [Ne.def, leadingCoeff_eq_zero]
    let φ : R ⧸ P' →+* R[X] ⧸ P := Ideal.quotientMap P (C : R →+* R[X]) le_rfl
    let hφ : Function.Injective ↑φ := quotientMap_injective
    let Rₘ := Localization.Away x
    let Sₘ := (Localization ((Submonoid.powers x).map φ : Submonoid (R[X] ⧸ P)))
    

Proof state:
case neg.intro.intro
R✝ : Type u_1
S : Type u_2
inst✝⁷ : CommRing R✝
inst✝⁶ : CommRing S
inst✝⁵ : IsDomain S
Rₘ✝ : Type u_3
Sₘ✝ : Type u_4
inst✝⁴ : CommRing Rₘ✝
inst✝³ : CommRing Sₘ✝
R : Type u_5
inst✝² : CommRing R
inst✝¹ : IsDomain R
hR : IsJacobson R
P : Ideal R[X]
inst✝ : IsPrime P
hP : ∀ (x : R), C x ∈ P → x = 0
Pb : ¬P = ⊥
P' : Ideal R := comap C P
this : IsPrime P'
hR' : IsJacobson (R ⧸ P')
p : R[X]
pP : p ∈ P
p0 : Polynomial.map (Quotient.mk (comap C P)) p ≠ 0
x : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') p)
hx : x ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
hφ : Function.Injective ⇑φ := quotientMap_injective
Rₘ : Type u_5 := Localization.Away x
Sₘ : Type u_5 := Localization (Submonoid.map φ (Submonoid.powers x))
⊢ jacobson ⊥ = ⊥

Next tactic:
refine' jacobson_bot_of_integral_localization (S := R[X] ⧸ P) (R := R ⧸ P') Rₘ Sₘ _ hφ _ hx _
/-- 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 := by
  by_cases Pb : P = ⊥
  · exact Pb.symm ▸
      jacobson_bot_polynomial_of_jacobson_bot (hR.out isRadical_bot_of_noZeroDivisors)
  · rw [jacobson_eq_iff_jacobson_quotient_eq_bot]
    let P' := P.comap (C : R →+* R[X])
    haveI : P'.IsPrime := comap_isPrime C P
    haveI hR' : IsJacobson (R ⧸ P') := by infer_instance
    obtain ⟨p, pP, p0⟩ := exists_nonzero_mem_of_ne_bot Pb hP
    let x := (Polynomial.map (Quotient.mk P') p).leadingCoeff
    have hx : x ≠ 0 := by rwa [Ne.def, leadingCoeff_eq_zero]
    let φ : R ⧸ P' →+* R[X] ⧸ P := Ideal.quotientMap P (C : R →+* R[X]) le_rfl
    let hφ : Function.Injective ↑φ := quotientMap_injective
    let Rₘ := Localization.Away x
    let Sₘ := (Localization ((Submonoid.powers x).map φ : Submonoid (R[X] ⧸ P)))
    refine' jacobson_bot_of_integral_localization (S := R[X] ⧸ P) (R := R ⧸ P') Rₘ Sₘ _ hφ _ hx _
    

Proof state:
case neg.intro.intro
R✝ : Type u_1
S : Type u_2
inst✝⁷ : CommRing R✝
inst✝⁶ : CommRing S
inst✝⁵ : IsDomain S
Rₘ✝ : Type u_3
Sₘ✝ : Type u_4
inst✝⁴ : CommRing Rₘ✝
inst✝³ : CommRing Sₘ✝
R : Type u_5
inst✝² : CommRing R
inst✝¹ : IsDomain R
hR : IsJacobson R
P : Ideal R[X]
inst✝ : IsPrime P
hP : ∀ (x : R), C x ∈ P → x = 0
Pb : ¬P = ⊥
P' : Ideal R := comap C P
this : IsPrime P'
hR' : IsJacobson (R ⧸ P')
p : R[X]
pP : p ∈ P
p0 : Polynomial.map (Quotient.mk (comap C P)) p ≠ 0
x : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') p)
hx : x ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
hφ : Function.Injective ⇑φ := quotientMap_injective
Rₘ : Type u_5 := Localization.Away x
Sₘ : Type u_5 := Localization (Submonoid.map φ (Submonoid.powers x))
⊢ RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))

Next tactic:
haveI islocSₘ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ := by infer_instance
/-- 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 := by
  by_cases Pb : P = ⊥
  · exact Pb.symm ▸
      jacobson_bot_polynomial_of_jacobson_bot (hR.out isRadical_bot_of_noZeroDivisors)
  · rw [jacobson_eq_iff_jacobson_quotient_eq_bot]
    let P' := P.comap (C : R →+* R[X])
    haveI : P'.IsPrime := comap_isPrime C P
    haveI hR' : IsJacobson (R ⧸ P') := by infer_instance
    obtain ⟨p, pP, p0⟩ := exists_nonzero_mem_of_ne_bot Pb hP
    let x := (Polynomial.map (Quotient.mk P') p).leadingCoeff
    have hx : x ≠ 0 := by rwa [Ne.def, leadingCoeff_eq_zero]
    let φ : R ⧸ P' →+* R[X] ⧸ P := Ideal.quotientMap P (C : R →+* R[X]) le_rfl
    let hφ : Function.Injective ↑φ := quotientMap_injective
    let Rₘ := Localization.Away x
    let Sₘ := (Localization ((Submonoid.powers x).map φ : Submonoid (R[X] ⧸ P)))
    refine' jacobson_bot_of_integral_localization (S := R[X] ⧸ P) (R := R ⧸ P') Rₘ Sₘ _ hφ _ hx _
    haveI islocSₘ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ := by 

Proof state:
R✝ : Type u_1
S : Type u_2
inst✝⁷ : CommRing R✝
inst✝⁶ : CommRing S
inst✝⁵ : IsDomain S
Rₘ✝ : Type u_3
Sₘ✝ : Type u_4
inst✝⁴ : CommRing Rₘ✝
inst✝³ : CommRing Sₘ✝
R : Type u_5
inst✝² : CommRing R
inst✝¹ : IsDomain R
hR : IsJacobson R
P : Ideal R[X]
inst✝ : IsPrime P
hP : ∀ (x : R), C x ∈ P → x = 0
Pb : ¬P = ⊥
P' : Ideal R := comap C P
this : IsPrime P'
hR' : IsJacobson (R ⧸ P')
p : R[X]
pP : p ∈ P
p0 : Polynomial.map (Quotient.mk (comap C P)) p ≠ 0
x : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') p)
hx : x ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
hφ : Function.Injective ⇑φ := quotientMap_injective
Rₘ : Type u_5 := Localization.Away x
Sₘ : Type u_5 := Localization (Submonoid.map φ (Submonoid.powers x))
⊢ IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ

Next tactic:
infer_instance
/-- 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 := by
  by_cases Pb : P = ⊥
  · exact Pb.symm ▸
      jacobson_bot_polynomial_of_jacobson_bot (hR.out isRadical_bot_of_noZeroDivisors)
  · rw [jacobson_eq_iff_jacobson_quotient_eq_bot]
    let P' := P.comap (C : R →+* R[X])
    haveI : P'.IsPrime := comap_isPrime C P
    haveI hR' : IsJacobson (R ⧸ P') := by infer_instance
    obtain ⟨p, pP, p0⟩ := exists_nonzero_mem_of_ne_bot Pb hP
    let x := (Polynomial.map (Quotient.mk P') p).leadingCoeff
    have hx : x ≠ 0 := by rwa [Ne.def, leadingCoeff_eq_zero]
    let φ : R ⧸ P' →+* R[X] ⧸ P := Ideal.quotientMap P (C : R →+* R[X]) le_rfl
    let hφ : Function.Injective ↑φ := quotientMap_injective
    let Rₘ := Localization.Away x
    let Sₘ := (Localization ((Submonoid.powers x).map φ : Submonoid (R[X] ⧸ P)))
    refine' jacobson_bot_of_integral_localization (S := R[X] ⧸ P) (R := R ⧸ P') Rₘ Sₘ _ hφ _ hx _
    haveI islocSₘ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ := by infer_instance
    

Proof state:
case neg.intro.intro
R✝ : Type u_1
S : Type u_2
inst✝⁷ : CommRing R✝
inst✝⁶ : CommRing S
inst✝⁵ : IsDomain S
Rₘ✝ : Type u_3
Sₘ✝ : Type u_4
inst✝⁴ : CommRing Rₘ✝
inst✝³ : CommRing Sₘ✝
R : Type u_5
inst✝² : CommRing R
inst✝¹ : IsDomain R
hR : IsJacobson R
P : Ideal R[X]
inst✝ : IsPrime P
hP : ∀ (x : R), C x ∈ P → x = 0
Pb : ¬P = ⊥
P' : Ideal R := comap C P
this : IsPrime P'
hR' : IsJacobson (R ⧸ P')
p : R[X]
pP : p ∈ P
p0 : Polynomial.map (Quotient.mk (comap C P)) p ≠ 0
x : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') p)
hx : x ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
hφ : Function.Injective ⇑φ := quotientMap_injective
Rₘ : Type u_5 := Localization.Away x
Sₘ : Type u_5 := Localization (Submonoid.map φ (Submonoid.powers x))
islocSₘ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
⊢ RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))

Next tactic:
exact @isIntegral_isLocalization_polynomial_quotient R _ Rₘ Sₘ _ _ P p pP _ _ _ islocSₘ
theorem isJacobson_polynomial_of_isJacobson (hR : IsJacobson R) : IsJacobson R[X] := by
  

Proof state:
R : Type u_1
S : Type u_2
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : IsDomain S
Rₘ : Type u_3
Sₘ : Type u_4
inst✝¹ : CommRing Rₘ
inst✝ : CommRing Sₘ
hR : IsJacobson R
⊢ IsJacobson R[X]

Next tactic:
rw [isJacobson_iff_prime_eq]
theorem isJacobson_polynomial_of_isJacobson (hR : IsJacobson R) : IsJacobson R[X] := by
  rw [isJacobson_iff_prime_eq]
  

Proof state:
R : Type u_1
S : Type u_2
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : IsDomain S
Rₘ : Type u_3
Sₘ : Type u_4
inst✝¹ : CommRing Rₘ
inst✝ : CommRing Sₘ
hR : IsJacobson R
⊢ ∀ (P : Ideal R[X]), IsPrime P → jacobson P = P

Next tactic:
intro I hI
theorem isJacobson_polynomial_of_isJacobson (hR : IsJacobson R) : IsJacobson R[X] := by
  rw [isJacobson_iff_prime_eq]
  intro I hI
  

Proof state:
R : Type u_1
S : Type u_2
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : IsDomain S
Rₘ : Type u_3
Sₘ : Type u_4
inst✝¹ : CommRing Rₘ
inst✝ : CommRing Sₘ
hR : IsJacobson R
I : Ideal R[X]
hI : IsPrime I
⊢ jacobson I = I

Next tactic:
let R' : Subring (R[X] ⧸ I) := ((Quotient.mk I).comp C).range