[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
⊢ IsJacobson R ↔ ∀ (P : Ideal R), IsPrime P → jacobson P = P
[PROOFSTEP]
refine' isJacobson_iff.trans ⟨fun h I hI => h I hI.isRadical, _⟩
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
⊢ (∀ (P : Ideal R), IsPrime P → jacobson P = P) → ∀ (I : Ideal R), IsRadical I → jacobson I = I
[PROOFSTEP]
refine fun h I hI ↦ le_antisymm (fun x hx ↦ ?_) (fun x hx ↦ mem_sInf.mpr fun _ hJ ↦ hJ.left hx)
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I✝ : Ideal R
h : ∀ (P : Ideal R), IsPrime P → jacobson P = P
I : Ideal R
hI : IsRadical I
x : R
hx : x ∈ jacobson I
⊢ x ∈ I
[PROOFSTEP]
rw [← hI.radical, radical_eq_sInf I, mem_sInf]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I✝ : Ideal R
h : ∀ (P : Ideal R), IsPrime P → jacobson P = P
I : Ideal R
hI : IsRadical I
x : R
hx : x ∈ jacobson I
⊢ ∀ ⦃I_1 : Ideal R⦄, I_1 ∈ {J | I ≤ J ∧ IsPrime J} → x ∈ I_1
[PROOFSTEP]
intro P hP
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I✝ : Ideal R
h : ∀ (P : Ideal R), IsPrime P → jacobson P = P
I : Ideal R
hI : IsRadical I
x : R
hx : x ∈ jacobson I
P : Ideal R
hP : P ∈ {J | I ≤ J ∧ IsPrime J}
⊢ x ∈ P
[PROOFSTEP]
rw [Set.mem_setOf_eq] at hP
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I✝ : Ideal R
h : ∀ (P : Ideal R), IsPrime P → jacobson P = P
I : Ideal R
hI : IsRadical I
x : R
hx : x ∈ jacobson I
P : Ideal R
hP : I ≤ P ∧ IsPrime P
⊢ x ∈ P
[PROOFSTEP]
erw [mem_sInf] at hx
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I✝ : Ideal R
h : ∀ (P : Ideal R), IsPrime P → jacobson P = P
I : Ideal R
hI : IsRadical I
x : R
hx : ∀ ⦃I_1 : Ideal R⦄, I_1 ∈ {J | I ≤ J ∧ IsMaximal J} → x ∈ I_1
P : Ideal R
hP : I ≤ P ∧ IsPrime P
⊢ x ∈ P
[PROOFSTEP]
erw [← h P hP.right, mem_sInf]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I✝ : Ideal R
h : ∀ (P : Ideal R), IsPrime P → jacobson P = P
I : Ideal R
hI : IsRadical I
x : R
hx : ∀ ⦃I_1 : Ideal R⦄, I_1 ∈ {J | I ≤ J ∧ IsMaximal J} → x ∈ I_1
P : Ideal R
hP : I ≤ P ∧ IsPrime P
⊢ ∀ ⦃I : Ideal R⦄, I ∈ {J | P ≤ J ∧ IsMaximal J} → x ∈ I
[PROOFSTEP]
exact fun J hJ => hx ⟨le_trans hP.left hJ.left, hJ.right⟩
[GOAL]
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I✝ : Ideal R
K : Type u_3
inst✝ : Field K
I : Ideal K
x✝ : IsRadical I
h : I = ⊤
⊢ jacobson I = I
[PROOFSTEP]
rw [h, jacobson_eq_top_iff]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
H : IsJacobson R
⊢ (∃ f, Function.Surjective ↑f) → IsJacobson S
[PROOFSTEP]
rintro ⟨f, hf⟩
[GOAL]
case intro
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
H : IsJacobson R
f : R →+* S
hf : Function.Surjective ↑f
⊢ IsJacobson S
[PROOFSTEP]
rw [isJacobson_iff_sInf_maximal]
[GOAL]
case intro
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
H : IsJacobson R
f : R →+* S
hf : Function.Surjective ↑f
⊢ ∀ {I : Ideal S}, IsPrime I → ∃ M, (∀ (J : Ideal S), J ∈ M → IsMaximal J ∨ J = ⊤) ∧ I = sInf M
[PROOFSTEP]
intro p hp
[GOAL]
case intro
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
H : IsJacobson R
f : R →+* S
hf : Function.Surjective ↑f
p : Ideal S
hp : IsPrime p
⊢ ∃ M, (∀ (J : Ideal S), J ∈ M → IsMaximal J ∨ J = ⊤) ∧ p = sInf M
[PROOFSTEP]
use map f '' {J : Ideal R | comap f p ≤ J ∧ J.IsMaximal}
[GOAL]
case h
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
H : IsJacobson R
f : R →+* S
hf : Function.Surjective ↑f
p : Ideal S
hp : IsPrime p
⊢ (∀ (J : Ideal S), J ∈ map f '' {J | comap f p ≤ J ∧ IsMaximal J} → IsMaximal J ∨ J = ⊤) ∧
    p = sInf (map f '' {J | comap f p ≤ J ∧ IsMaximal J})
[PROOFSTEP]
use fun j ⟨J, hJ, hmap⟩ => hmap ▸ (map_eq_top_or_isMaximal_of_surjective f hf hJ.right).symm
[GOAL]
case right
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
H : IsJacobson R
f : R →+* S
hf : Function.Surjective ↑f
p : Ideal S
hp : IsPrime p
⊢ p = sInf (map f '' {J | comap f p ≤ J ∧ IsMaximal J})
[PROOFSTEP]
have : p = map f (comap f p).jacobson :=
  (IsJacobson.out' _ <| hp.isRadical.comap f).symm ▸ (map_comap_of_surjective f hf p).symm
[GOAL]
case right
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
H : IsJacobson R
f : R →+* S
hf : Function.Surjective ↑f
p : Ideal S
hp : IsPrime p
this : p = map f (jacobson (comap f p))
⊢ p = sInf (map f '' {J | comap f p ≤ J ∧ IsMaximal J})
[PROOFSTEP]
exact this.trans (map_sInf hf fun J ⟨hJ, _⟩ => le_trans (Ideal.ker_le_comap f) hJ)
[GOAL]
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I : Ideal R
inst✝ : IsJacobson R
⊢ Function.Surjective ↑(Quotient.mk I)
[PROOFSTEP]
rintro ⟨x⟩
[GOAL]
case mk
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I : Ideal R
inst✝ : IsJacobson R
b✝ : R ⧸ I
x : R
⊢ ∃ a, ↑(Quotient.mk I) a = Quot.mk Setoid.r x
[PROOFSTEP]
use x
[GOAL]
case h
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I : Ideal R
inst✝ : IsJacobson R
b✝ : R ⧸ I
x : R
⊢ ↑(Quotient.mk I) x = Quot.mk Setoid.r x
[PROOFSTEP]
rfl
[GOAL]
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I : Ideal R
inst✝ : Algebra R S
hRS : Algebra.IsIntegral R S
hR : IsJacobson R
⊢ IsJacobson S
[PROOFSTEP]
rw [isJacobson_iff_prime_eq]
[GOAL]
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I : Ideal R
inst✝ : Algebra R S
hRS : Algebra.IsIntegral R S
hR : IsJacobson R
⊢ ∀ (P : Ideal S), IsPrime P → jacobson P = P
[PROOFSTEP]
intro P hP
[GOAL]
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I : Ideal R
inst✝ : Algebra R S
hRS : Algebra.IsIntegral R S
hR : IsJacobson R
P : Ideal S
hP : IsPrime P
⊢ jacobson P = P
[PROOFSTEP]
by_cases hP_top : comap (algebraMap R S) P = ⊤
[GOAL]
case pos
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I : Ideal R
inst✝ : Algebra R S
hRS : Algebra.IsIntegral R S
hR : IsJacobson R
P : Ideal S
hP : IsPrime P
hP_top : comap (algebraMap R S) P = ⊤
⊢ jacobson P = P
[PROOFSTEP]
simp [comap_eq_top_iff.1 hP_top]
[GOAL]
case neg
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I : Ideal R
inst✝ : Algebra R S
hRS : Algebra.IsIntegral R S
hR : IsJacobson R
P : Ideal S
hP : IsPrime P
hP_top : ¬comap (algebraMap R S) P = ⊤
⊢ jacobson P = P
[PROOFSTEP]
haveI : Nontrivial (R ⧸ comap (algebraMap R S) P) := Quotient.nontrivial hP_top
[GOAL]
case neg
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I : Ideal R
inst✝ : Algebra R S
hRS : Algebra.IsIntegral R S
hR : IsJacobson R
P : Ideal S
hP : IsPrime P
hP_top : ¬comap (algebraMap R S) P = ⊤
this : Nontrivial (R ⧸ comap (algebraMap R S) P)
⊢ jacobson P = P
[PROOFSTEP]
rw [jacobson_eq_iff_jacobson_quotient_eq_bot]
[GOAL]
case neg
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I : Ideal R
inst✝ : Algebra R S
hRS : Algebra.IsIntegral R S
hR : IsJacobson R
P : Ideal S
hP : IsPrime P
hP_top : ¬comap (algebraMap R S) P = ⊤
this : Nontrivial (R ⧸ comap (algebraMap R S) P)
⊢ jacobson ⊥ = ⊥
[PROOFSTEP]
refine' eq_bot_of_comap_eq_bot (isIntegral_quotient_of_isIntegral hRS) _
[GOAL]
case neg
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I : Ideal R
inst✝ : Algebra R S
hRS : Algebra.IsIntegral R S
hR : IsJacobson R
P : Ideal S
hP : IsPrime P
hP_top : ¬comap (algebraMap R S) P = ⊤
this : Nontrivial (R ⧸ comap (algebraMap R S) P)
⊢ comap (algebraMap (R ⧸ comap (algebraMap R S) P) (S ⧸ P)) (jacobson ⊥) = ⊥
[PROOFSTEP]
rw [eq_bot_iff, ←
  jacobson_eq_iff_jacobson_quotient_eq_bot.1
    ((isJacobson_iff_prime_eq.1 hR) (comap (algebraMap R S) P) (comap_isPrime _ _)),
  comap_jacobson]
[GOAL]
case neg
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I : Ideal R
inst✝ : Algebra R S
hRS : Algebra.IsIntegral R S
hR : IsJacobson R
P : Ideal S
hP : IsPrime P
hP_top : ¬comap (algebraMap R S) P = ⊤
this : Nontrivial (R ⧸ comap (algebraMap R S) P)
⊢ sInf (comap (algebraMap (R ⧸ comap (algebraMap R S) P) (S ⧸ P)) '' {J | ⊥ ≤ J ∧ IsMaximal J}) ≤ jacobson ⊥
[PROOFSTEP]
refine' sInf_le_sInf fun J hJ => _
[GOAL]
case neg
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I : Ideal R
inst✝ : Algebra R S
hRS : Algebra.IsIntegral R S
hR : IsJacobson R
P : Ideal S
hP : IsPrime P
hP_top : ¬comap (algebraMap R S) P = ⊤
this : Nontrivial (R ⧸ comap (algebraMap R S) P)
J : Ideal (R ⧸ comap (algebraMap R S) P)
hJ : J ∈ {J | ⊥ ≤ J ∧ IsMaximal J}
⊢ J ∈ comap (algebraMap (R ⧸ comap (algebraMap R S) P) (S ⧸ P)) '' {J | ⊥ ≤ J ∧ IsMaximal J}
[PROOFSTEP]
simp only [true_and_iff, Set.mem_image, bot_le, Set.mem_setOf_eq]
[GOAL]
case neg
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I : Ideal R
inst✝ : Algebra R S
hRS : Algebra.IsIntegral R S
hR : IsJacobson R
P : Ideal S
hP : IsPrime P
hP_top : ¬comap (algebraMap R S) P = ⊤
this : Nontrivial (R ⧸ comap (algebraMap R S) P)
J : Ideal (R ⧸ comap (algebraMap R S) P)
hJ : J ∈ {J | ⊥ ≤ J ∧ IsMaximal J}
⊢ ∃ x, IsMaximal x ∧ comap (algebraMap (R ⧸ comap (algebraMap R S) P) (S ⧸ P)) x = J
[PROOFSTEP]
have : J.IsMaximal := by simpa using hJ
[GOAL]
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I : Ideal R
inst✝ : Algebra R S
hRS : Algebra.IsIntegral R S
hR : IsJacobson R
P : Ideal S
hP : IsPrime P
hP_top : ¬comap (algebraMap R S) P = ⊤
this : Nontrivial (R ⧸ comap (algebraMap R S) P)
J : Ideal (R ⧸ comap (algebraMap R S) P)
hJ : J ∈ {J | ⊥ ≤ J ∧ IsMaximal J}
⊢ IsMaximal J
[PROOFSTEP]
simpa using hJ
[GOAL]
case neg
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I : Ideal R
inst✝ : Algebra R S
hRS : Algebra.IsIntegral R S
hR : IsJacobson R
P : Ideal S
hP : IsPrime P
hP_top : ¬comap (algebraMap R S) P = ⊤
this✝ : Nontrivial (R ⧸ comap (algebraMap R S) P)
J : Ideal (R ⧸ comap (algebraMap R S) P)
hJ : J ∈ {J | ⊥ ≤ J ∧ IsMaximal J}
this : IsMaximal J
⊢ ∃ x, IsMaximal x ∧ comap (algebraMap (R ⧸ comap (algebraMap R S) P) (S ⧸ P)) x = J
[PROOFSTEP]
exact
  exists_ideal_over_maximal_of_isIntegral (isIntegral_quotient_of_isIntegral hRS) J
    (comap_bot_le_of_injective _ algebraMap_quotient_injective)
[GOAL]
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
hI : IsRadical I
⊢ Disjoint ↑(powers y) ↑I ↔ ¬y ∈ I.toAddSubmonoid
[PROOFSTEP]
refine' ⟨fun h => Set.disjoint_left.1 h (mem_powers _), fun h => disjoint_iff.mpr (eq_bot_iff.mpr _)⟩
[GOAL]
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
hI : IsRadical I
h : ¬y ∈ I.toAddSubmonoid
⊢ ↑(powers y) ⊓ ↑I ≤ ⊥
[PROOFSTEP]
rintro x ⟨⟨n, rfl⟩, hx'⟩
[GOAL]
case intro.intro
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
hI : IsRadical I
h : ¬y ∈ I.toAddSubmonoid
n : ℕ
hx' : (fun x x_1 => x ^ x_1) y n ∈ ↑I
⊢ (fun x x_1 => x ^ x_1) y n ∈ ⊥
[PROOFSTEP]
exact h (hI <| mem_radical_of_pow_mem <| le_radical hx')
[GOAL]
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
⊢ IsMaximal J ↔ IsMaximal (comap (algebraMap R S) J) ∧ ¬y ∈ comap (algebraMap R S) J
[PROOFSTEP]
constructor
[GOAL]
case mp
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
⊢ IsMaximal J → IsMaximal (comap (algebraMap R S) J) ∧ ¬y ∈ comap (algebraMap R S) J
[PROOFSTEP]
refine' fun h => ⟨_, fun hy => h.ne_top (Ideal.eq_top_of_isUnit_mem _ hy (map_units _ ⟨y, Submonoid.mem_powers _⟩))⟩
[GOAL]
case mp
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal J
⊢ IsMaximal (comap (algebraMap R S) J)
[PROOFSTEP]
have hJ : J.IsPrime := IsMaximal.isPrime h
[GOAL]
case mp
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal J
hJ : IsPrime J
⊢ IsMaximal (comap (algebraMap R S) J)
[PROOFSTEP]
rw [isPrime_iff_isPrime_disjoint (Submonoid.powers y)] at hJ
[GOAL]
case mp
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal J
hJ : IsPrime (comap (algebraMap R S) J) ∧ Disjoint ↑(powers y) ↑(comap (algebraMap R S) J)
⊢ IsMaximal (comap (algebraMap R S) J)
[PROOFSTEP]
have : y ∉ (comap (algebraMap R S) J).1 := Set.disjoint_left.1 hJ.right (Submonoid.mem_powers _)
[GOAL]
case mp
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal J
hJ : IsPrime (comap (algebraMap R S) J) ∧ Disjoint ↑(powers y) ↑(comap (algebraMap R S) J)
this : ¬y ∈ (comap (algebraMap R S) J).toAddSubmonoid
⊢ IsMaximal (comap (algebraMap R S) J)
[PROOFSTEP]
erw [← H.out hJ.left.isRadical, mem_sInf] at this
[GOAL]
case mp
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal J
hJ : IsPrime (comap (algebraMap R S) J) ∧ Disjoint ↑(powers y) ↑(comap (algebraMap R S) J)
this : ¬∀ ⦃I : Ideal R⦄, I ∈ {J_1 | comap (algebraMap R S) J ≤ J_1 ∧ IsMaximal J_1} → y ∈ I
⊢ IsMaximal (comap (algebraMap R S) J)
[PROOFSTEP]
push_neg at this
[GOAL]
case mp
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal J
hJ : IsPrime (comap (algebraMap R S) J) ∧ Disjoint ↑(powers y) ↑(comap (algebraMap R S) J)
this : Exists fun ⦃I⦄ => I ∈ {J_1 | comap (algebraMap R S) J ≤ J_1 ∧ IsMaximal J_1} ∧ ¬y ∈ I
⊢ IsMaximal (comap (algebraMap R S) J)
[PROOFSTEP]
rcases this with ⟨I, hI, hI'⟩
[GOAL]
case mp.intro.intro
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I✝ : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal J
hJ : IsPrime (comap (algebraMap R S) J) ∧ Disjoint ↑(powers y) ↑(comap (algebraMap R S) J)
I : Ideal R
hI : I ∈ {J_1 | comap (algebraMap R S) J ≤ J_1 ∧ IsMaximal J_1}
hI' : ¬y ∈ I
⊢ IsMaximal (comap (algebraMap R S) J)
[PROOFSTEP]
convert hI.right
[GOAL]
case h.e'_3.h
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I✝ : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal J
hJ : IsPrime (comap (algebraMap R S) J) ∧ Disjoint ↑(powers y) ↑(comap (algebraMap R S) J)
I : Ideal R
hI : I ∈ {J_1 | comap (algebraMap R S) J ≤ J_1 ∧ IsMaximal J_1}
hI' : ¬y ∈ I
e_2✝ : CommSemiring.toSemiring = Ring.toSemiring
⊢ comap (algebraMap R S) J = I
[PROOFSTEP]
by_cases hJ : J = map (algebraMap R S) I
[GOAL]
case pos
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I✝ : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal J
hJ✝ : IsPrime (comap (algebraMap R S) J) ∧ Disjoint ↑(powers y) ↑(comap (algebraMap R S) J)
I : Ideal R
hI : I ∈ {J_1 | comap (algebraMap R S) J ≤ J_1 ∧ IsMaximal J_1}
hI' : ¬y ∈ I
e_2✝ : CommSemiring.toSemiring = Ring.toSemiring
hJ : J = map (algebraMap R S) I
⊢ comap (algebraMap R S) J = I
[PROOFSTEP]
rw [hJ, comap_map_of_isPrime_disjoint (powers y) S I (IsMaximal.isPrime hI.right)]
[GOAL]
case pos
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I✝ : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal J
hJ✝ : IsPrime (comap (algebraMap R S) J) ∧ Disjoint ↑(powers y) ↑(comap (algebraMap R S) J)
I : Ideal R
hI : I ∈ {J_1 | comap (algebraMap R S) J ≤ J_1 ∧ IsMaximal J_1}
hI' : ¬y ∈ I
e_2✝ : CommSemiring.toSemiring = Ring.toSemiring
hJ : J = map (algebraMap R S) I
⊢ Disjoint ↑(powers y) ↑I
[PROOFSTEP]
rwa [disjoint_powers_iff_not_mem y hI.right.isPrime.isRadical]
[GOAL]
case neg
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I✝ : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal J
hJ✝ : IsPrime (comap (algebraMap R S) J) ∧ Disjoint ↑(powers y) ↑(comap (algebraMap R S) J)
I : Ideal R
hI : I ∈ {J_1 | comap (algebraMap R S) J ≤ J_1 ∧ IsMaximal J_1}
hI' : ¬y ∈ I
e_2✝ : CommSemiring.toSemiring = Ring.toSemiring
hJ : ¬J = map (algebraMap R S) I
⊢ comap (algebraMap R S) J = I
[PROOFSTEP]
have hI_p : (map (algebraMap R S) I).IsPrime :=
  by
  refine' isPrime_of_isPrime_disjoint (powers y) _ I hI.right.isPrime _
  rwa [disjoint_powers_iff_not_mem y hI.right.isPrime.isRadical]
[GOAL]
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I✝ : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal J
hJ✝ : IsPrime (comap (algebraMap R S) J) ∧ Disjoint ↑(powers y) ↑(comap (algebraMap R S) J)
I : Ideal R
hI : I ∈ {J_1 | comap (algebraMap R S) J ≤ J_1 ∧ IsMaximal J_1}
hI' : ¬y ∈ I
e_2✝ : CommSemiring.toSemiring = Ring.toSemiring
hJ : ¬J = map (algebraMap R S) I
⊢ IsPrime (map (algebraMap R S) I)
[PROOFSTEP]
refine' isPrime_of_isPrime_disjoint (powers y) _ I hI.right.isPrime _
[GOAL]
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I✝ : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal J
hJ✝ : IsPrime (comap (algebraMap R S) J) ∧ Disjoint ↑(powers y) ↑(comap (algebraMap R S) J)
I : Ideal R
hI : I ∈ {J_1 | comap (algebraMap R S) J ≤ J_1 ∧ IsMaximal J_1}
hI' : ¬y ∈ I
e_2✝ : CommSemiring.toSemiring = Ring.toSemiring
hJ : ¬J = map (algebraMap R S) I
⊢ Disjoint ↑(powers y) ↑I
[PROOFSTEP]
rwa [disjoint_powers_iff_not_mem y hI.right.isPrime.isRadical]
[GOAL]
case neg
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I✝ : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal J
hJ✝ : IsPrime (comap (algebraMap R S) J) ∧ Disjoint ↑(powers y) ↑(comap (algebraMap R S) J)
I : Ideal R
hI : I ∈ {J_1 | comap (algebraMap R S) J ≤ J_1 ∧ IsMaximal J_1}
hI' : ¬y ∈ I
e_2✝ : CommSemiring.toSemiring = Ring.toSemiring
hJ : ¬J = map (algebraMap R S) I
hI_p : IsPrime (map (algebraMap R S) I)
⊢ comap (algebraMap R S) J = I
[PROOFSTEP]
have : J ≤ map (algebraMap R S) I := map_comap (Submonoid.powers y) S J ▸ map_mono hI.left
[GOAL]
case neg
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I✝ : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal J
hJ✝ : IsPrime (comap (algebraMap R S) J) ∧ Disjoint ↑(powers y) ↑(comap (algebraMap R S) J)
I : Ideal R
hI : I ∈ {J_1 | comap (algebraMap R S) J ≤ J_1 ∧ IsMaximal J_1}
hI' : ¬y ∈ I
e_2✝ : CommSemiring.toSemiring = Ring.toSemiring
hJ : ¬J = map (algebraMap R S) I
hI_p : IsPrime (map (algebraMap R S) I)
this : J ≤ map (algebraMap R S) I
⊢ comap (algebraMap R S) J = I
[PROOFSTEP]
exact absurd (h.1.2 _ (lt_of_le_of_ne this hJ)) hI_p.1
[GOAL]
case mpr
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
⊢ IsMaximal (comap (algebraMap R S) J) ∧ ¬y ∈ comap (algebraMap R S) J → IsMaximal J
[PROOFSTEP]
refine' fun h => ⟨⟨fun hJ => h.1.ne_top (eq_top_iff.2 _), fun I hI => _⟩⟩
[GOAL]
case mpr.refine'_1
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal (comap (algebraMap R S) J) ∧ ¬y ∈ comap (algebraMap R S) J
hJ : J = ⊤
⊢ ⊤ ≤ comap (algebraMap R S) J
[PROOFSTEP]
rwa [eq_top_iff, ← (IsLocalization.orderEmbedding (powers y) S).le_iff_le] at hJ
[GOAL]
case mpr.refine'_2
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I✝ : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal (comap (algebraMap R S) J) ∧ ¬y ∈ comap (algebraMap R S) J
I : Ideal S
hI : J < I
⊢ I = ⊤
[PROOFSTEP]
have := congr_arg (map (algebraMap R S)) (h.1.1.2 _ ⟨comap_mono (le_of_lt hI), ?_⟩)
[GOAL]
case mpr.refine'_2.refine_2
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I✝ : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal (comap (algebraMap R S) J) ∧ ¬y ∈ comap (algebraMap R S) J
I : Ideal S
hI : J < I
this : map (algebraMap R S) (comap (algebraMap R S) I) = map (algebraMap R S) ⊤
⊢ I = ⊤
case mpr.refine'_2.refine_1
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I✝ : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal (comap (algebraMap R S) J) ∧ ¬y ∈ comap (algebraMap R S) J
I : Ideal S
hI : J < I
⊢ ¬↑(comap (algebraMap R S) I) ⊆ ↑(comap (algebraMap R S) J)
[PROOFSTEP]
rwa [map_comap (powers y) S I, map_top] at this
[GOAL]
case mpr.refine'_2.refine_1
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I✝ : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal (comap (algebraMap R S) J) ∧ ¬y ∈ comap (algebraMap R S) J
I : Ideal S
hI : J < I
⊢ ¬↑(comap (algebraMap R S) I) ⊆ ↑(comap (algebraMap R S) J)
[PROOFSTEP]
refine' fun hI' => hI.right _
[GOAL]
case mpr.refine'_2.refine_1
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I✝ : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal (comap (algebraMap R S) J) ∧ ¬y ∈ comap (algebraMap R S) J
I : Ideal S
hI : J < I
hI' : ↑(comap (algebraMap R S) I) ⊆ ↑(comap (algebraMap R S) J)
⊢ ↑I ⊆ ↑J
[PROOFSTEP]
rw [← map_comap (powers y) S I, ← map_comap (powers y) S J]
[GOAL]
case mpr.refine'_2.refine_1
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I✝ : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
J : Ideal S
h : IsMaximal (comap (algebraMap R S) J) ∧ ¬y ∈ comap (algebraMap R S) J
I : Ideal S
hI : J < I
hI' : ↑(comap (algebraMap R S) I) ⊆ ↑(comap (algebraMap R S) J)
⊢ ↑(map (algebraMap R S) (comap (algebraMap R S) I)) ⊆ ↑(map (algebraMap R S) (comap (algebraMap R S) J))
[PROOFSTEP]
exact map_mono hI'
[GOAL]
R : Type u_1
S : Type u_2
inst✝⁴ : CommRing R
inst✝³ : CommRing S
I✝ : Ideal R
y : R
inst✝² : Algebra R S
inst✝¹ : Away y S
inst✝ : IsJacobson R
I : Ideal R
hI : IsMaximal I
hy : ¬y ∈ I
⊢ IsMaximal (map (algebraMap R S) I)
[PROOFSTEP]
rw [isMaximal_iff_isMaximal_disjoint S y,
  comap_map_of_isPrime_disjoint (powers y) S I (IsMaximal.isPrime hI)
    ((disjoint_powers_iff_not_mem y hI.isPrime.isRadical).2 hy)]
[GOAL]
R : Type u_1
S : Type u_2
inst✝⁴ : CommRing R
inst✝³ : CommRing S
I✝ : Ideal R
y : R
inst✝² : Algebra R S
inst✝¹ : Away y S
inst✝ : IsJacobson R
I : Ideal R
hI : IsMaximal I
hy : ¬y ∈ I
⊢ IsMaximal I ∧ ¬y ∈ I
[PROOFSTEP]
exact ⟨hI, hy⟩
[GOAL]
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
⊢ IsJacobson S
[PROOFSTEP]
rw [isJacobson_iff_prime_eq]
[GOAL]
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
⊢ ∀ (P : Ideal S), IsPrime P → jacobson P = P
[PROOFSTEP]
refine' fun P' hP' => le_antisymm _ le_jacobson
[GOAL]
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
P' : Ideal S
hP' : IsPrime P'
⊢ jacobson P' ≤ P'
[PROOFSTEP]
obtain ⟨hP', hPM⟩ := (IsLocalization.isPrime_iff_isPrime_disjoint (powers y) S P').mp hP'
[GOAL]
case intro
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
P' : Ideal S
hP'✝ : IsPrime P'
hP' : IsPrime (comap (algebraMap R S) P')
hPM : Disjoint ↑(powers y) ↑(comap (algebraMap R S) P')
⊢ jacobson P' ≤ P'
[PROOFSTEP]
have hP := H.out hP'.isRadical
[GOAL]
case intro
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
P' : Ideal S
hP'✝ : IsPrime P'
hP' : IsPrime (comap (algebraMap R S) P')
hPM : Disjoint ↑(powers y) ↑(comap (algebraMap R S) P')
hP : jacobson (comap (algebraMap R S) P') = comap (algebraMap R S) P'
⊢ jacobson P' ≤ P'
[PROOFSTEP]
refine'
  (IsLocalization.map_comap (powers y) S P'.jacobson).ge.trans
    ((map_mono _).trans (IsLocalization.map_comap (powers y) S P').le)
[GOAL]
case intro
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
P' : Ideal S
hP'✝ : IsPrime P'
hP' : IsPrime (comap (algebraMap R S) P')
hPM : Disjoint ↑(powers y) ↑(comap (algebraMap R S) P')
hP : jacobson (comap (algebraMap R S) P') = comap (algebraMap R S) P'
⊢ comap (algebraMap R S) (jacobson P') ≤ comap (algebraMap R S) P'
[PROOFSTEP]
have : sInf {I : Ideal R | comap (algebraMap R S) P' ≤ I ∧ I.IsMaximal ∧ y ∉ I} ≤ comap (algebraMap R S) P' :=
  by
  intro x hx
  have hxy : x * y ∈ (comap (algebraMap R S) P').jacobson :=
    by
    rw [Ideal.jacobson, mem_sInf]
    intro J hJ
    by_cases y ∈ J
    · exact J.mul_mem_left x h
    · exact J.mul_mem_right y ((mem_sInf.1 hx) ⟨hJ.left, ⟨hJ.right, h⟩⟩)
  rw [hP] at hxy
  cases' hP'.mem_or_mem hxy with hxy hxy
  · exact hxy
  · exact (hPM.le_bot ⟨Submonoid.mem_powers _, hxy⟩).elim
[GOAL]
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
P' : Ideal S
hP'✝ : IsPrime P'
hP' : IsPrime (comap (algebraMap R S) P')
hPM : Disjoint ↑(powers y) ↑(comap (algebraMap R S) P')
hP : jacobson (comap (algebraMap R S) P') = comap (algebraMap R S) P'
⊢ sInf {I | comap (algebraMap R S) P' ≤ I ∧ IsMaximal I ∧ ¬y ∈ I} ≤ comap (algebraMap R S) P'
[PROOFSTEP]
intro x hx
[GOAL]
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
P' : Ideal S
hP'✝ : IsPrime P'
hP' : IsPrime (comap (algebraMap R S) P')
hPM : Disjoint ↑(powers y) ↑(comap (algebraMap R S) P')
hP : jacobson (comap (algebraMap R S) P') = comap (algebraMap R S) P'
x : R
hx : x ∈ sInf {I | comap (algebraMap R S) P' ≤ I ∧ IsMaximal I ∧ ¬y ∈ I}
⊢ x ∈ comap (algebraMap R S) P'
[PROOFSTEP]
have hxy : x * y ∈ (comap (algebraMap R S) P').jacobson :=
  by
  rw [Ideal.jacobson, mem_sInf]
  intro J hJ
  by_cases y ∈ J
  · exact J.mul_mem_left x h
  · exact J.mul_mem_right y ((mem_sInf.1 hx) ⟨hJ.left, ⟨hJ.right, h⟩⟩)
[GOAL]
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
P' : Ideal S
hP'✝ : IsPrime P'
hP' : IsPrime (comap (algebraMap R S) P')
hPM : Disjoint ↑(powers y) ↑(comap (algebraMap R S) P')
hP : jacobson (comap (algebraMap R S) P') = comap (algebraMap R S) P'
x : R
hx : x ∈ sInf {I | comap (algebraMap R S) P' ≤ I ∧ IsMaximal I ∧ ¬y ∈ I}
⊢ x * y ∈ jacobson (comap (algebraMap R S) P')
[PROOFSTEP]
rw [Ideal.jacobson, mem_sInf]
[GOAL]
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
P' : Ideal S
hP'✝ : IsPrime P'
hP' : IsPrime (comap (algebraMap R S) P')
hPM : Disjoint ↑(powers y) ↑(comap (algebraMap R S) P')
hP : jacobson (comap (algebraMap R S) P') = comap (algebraMap R S) P'
x : R
hx : x ∈ sInf {I | comap (algebraMap R S) P' ≤ I ∧ IsMaximal I ∧ ¬y ∈ I}
⊢ ∀ ⦃I : Ideal R⦄, I ∈ {J | comap (algebraMap R S) P' ≤ J ∧ IsMaximal J} → x * y ∈ I
[PROOFSTEP]
intro J hJ
[GOAL]
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
P' : Ideal S
hP'✝ : IsPrime P'
hP' : IsPrime (comap (algebraMap R S) P')
hPM : Disjoint ↑(powers y) ↑(comap (algebraMap R S) P')
hP : jacobson (comap (algebraMap R S) P') = comap (algebraMap R S) P'
x : R
hx : x ∈ sInf {I | comap (algebraMap R S) P' ≤ I ∧ IsMaximal I ∧ ¬y ∈ I}
J : Ideal R
hJ : J ∈ {J | comap (algebraMap R S) P' ≤ J ∧ IsMaximal J}
⊢ x * y ∈ J
[PROOFSTEP]
by_cases y ∈ J
[GOAL]
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
P' : Ideal S
hP'✝ : IsPrime P'
hP' : IsPrime (comap (algebraMap R S) P')
hPM : Disjoint ↑(powers y) ↑(comap (algebraMap R S) P')
hP : jacobson (comap (algebraMap R S) P') = comap (algebraMap R S) P'
x : R
hx : x ∈ sInf {I | comap (algebraMap R S) P' ≤ I ∧ IsMaximal I ∧ ¬y ∈ I}
J : Ideal R
hJ : J ∈ {J | comap (algebraMap R S) P' ≤ J ∧ IsMaximal J}
⊢ x * y ∈ J
[PROOFSTEP]
by_cases y ∈ J
[GOAL]
case pos
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
P' : Ideal S
hP'✝ : IsPrime P'
hP' : IsPrime (comap (algebraMap R S) P')
hPM : Disjoint ↑(powers y) ↑(comap (algebraMap R S) P')
hP : jacobson (comap (algebraMap R S) P') = comap (algebraMap R S) P'
x : R
hx : x ∈ sInf {I | comap (algebraMap R S) P' ≤ I ∧ IsMaximal I ∧ ¬y ∈ I}
J : Ideal R
hJ : J ∈ {J | comap (algebraMap R S) P' ≤ J ∧ IsMaximal J}
h : y ∈ J
⊢ x * y ∈ J
[PROOFSTEP]
exact J.mul_mem_left x h
[GOAL]
case neg
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
P' : Ideal S
hP'✝ : IsPrime P'
hP' : IsPrime (comap (algebraMap R S) P')
hPM : Disjoint ↑(powers y) ↑(comap (algebraMap R S) P')
hP : jacobson (comap (algebraMap R S) P') = comap (algebraMap R S) P'
x : R
hx : x ∈ sInf {I | comap (algebraMap R S) P' ≤ I ∧ IsMaximal I ∧ ¬y ∈ I}
J : Ideal R
hJ : J ∈ {J | comap (algebraMap R S) P' ≤ J ∧ IsMaximal J}
h : ¬y ∈ J
⊢ x * y ∈ J
[PROOFSTEP]
exact J.mul_mem_right y ((mem_sInf.1 hx) ⟨hJ.left, ⟨hJ.right, h⟩⟩)
[GOAL]
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
P' : Ideal S
hP'✝ : IsPrime P'
hP' : IsPrime (comap (algebraMap R S) P')
hPM : Disjoint ↑(powers y) ↑(comap (algebraMap R S) P')
hP : jacobson (comap (algebraMap R S) P') = comap (algebraMap R S) P'
x : R
hx : x ∈ sInf {I | comap (algebraMap R S) P' ≤ I ∧ IsMaximal I ∧ ¬y ∈ I}
hxy : x * y ∈ jacobson (comap (algebraMap R S) P')
⊢ x ∈ comap (algebraMap R S) P'
[PROOFSTEP]
rw [hP] at hxy
[GOAL]
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
P' : Ideal S
hP'✝ : IsPrime P'
hP' : IsPrime (comap (algebraMap R S) P')
hPM : Disjoint ↑(powers y) ↑(comap (algebraMap R S) P')
hP : jacobson (comap (algebraMap R S) P') = comap (algebraMap R S) P'
x : R
hx : x ∈ sInf {I | comap (algebraMap R S) P' ≤ I ∧ IsMaximal I ∧ ¬y ∈ I}
hxy : x * y ∈ comap (algebraMap R S) P'
⊢ x ∈ comap (algebraMap R S) P'
[PROOFSTEP]
cases' hP'.mem_or_mem hxy with hxy hxy
[GOAL]
case inl
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
P' : Ideal S
hP'✝ : IsPrime P'
hP' : IsPrime (comap (algebraMap R S) P')
hPM : Disjoint ↑(powers y) ↑(comap (algebraMap R S) P')
hP : jacobson (comap (algebraMap R S) P') = comap (algebraMap R S) P'
x : R
hx : x ∈ sInf {I | comap (algebraMap R S) P' ≤ I ∧ IsMaximal I ∧ ¬y ∈ I}
hxy✝ : x * y ∈ comap (algebraMap R S) P'
hxy : x ∈ comap (algebraMap R S) P'
⊢ x ∈ comap (algebraMap R S) P'
[PROOFSTEP]
exact hxy
[GOAL]
case inr
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
P' : Ideal S
hP'✝ : IsPrime P'
hP' : IsPrime (comap (algebraMap R S) P')
hPM : Disjoint ↑(powers y) ↑(comap (algebraMap R S) P')
hP : jacobson (comap (algebraMap R S) P') = comap (algebraMap R S) P'
x : R
hx : x ∈ sInf {I | comap (algebraMap R S) P' ≤ I ∧ IsMaximal I ∧ ¬y ∈ I}
hxy✝ : x * y ∈ comap (algebraMap R S) P'
hxy : y ∈ comap (algebraMap R S) P'
⊢ x ∈ comap (algebraMap R S) P'
[PROOFSTEP]
exact (hPM.le_bot ⟨Submonoid.mem_powers _, hxy⟩).elim
[GOAL]
case intro
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
P' : Ideal S
hP'✝ : IsPrime P'
hP' : IsPrime (comap (algebraMap R S) P')
hPM : Disjoint ↑(powers y) ↑(comap (algebraMap R S) P')
hP : jacobson (comap (algebraMap R S) P') = comap (algebraMap R S) P'
this : sInf {I | comap (algebraMap R S) P' ≤ I ∧ IsMaximal I ∧ ¬y ∈ I} ≤ comap (algebraMap R S) P'
⊢ comap (algebraMap R S) (jacobson P') ≤ comap (algebraMap R S) P'
[PROOFSTEP]
refine' le_trans _ this
[GOAL]
case intro
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
P' : Ideal S
hP'✝ : IsPrime P'
hP' : IsPrime (comap (algebraMap R S) P')
hPM : Disjoint ↑(powers y) ↑(comap (algebraMap R S) P')
hP : jacobson (comap (algebraMap R S) P') = comap (algebraMap R S) P'
this : sInf {I | comap (algebraMap R S) P' ≤ I ∧ IsMaximal I ∧ ¬y ∈ I} ≤ comap (algebraMap R S) P'
⊢ comap (algebraMap R S) (jacobson P') ≤ sInf {I | comap (algebraMap R S) P' ≤ I ∧ IsMaximal I ∧ ¬y ∈ I}
[PROOFSTEP]
rw [Ideal.jacobson, comap_sInf', sInf_eq_iInf]
[GOAL]
case intro
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
P' : Ideal S
hP'✝ : IsPrime P'
hP' : IsPrime (comap (algebraMap R S) P')
hPM : Disjoint ↑(powers y) ↑(comap (algebraMap R S) P')
hP : jacobson (comap (algebraMap R S) P') = comap (algebraMap R S) P'
this : sInf {I | comap (algebraMap R S) P' ≤ I ∧ IsMaximal I ∧ ¬y ∈ I} ≤ comap (algebraMap R S) P'
⊢ ⨅ (I : Ideal R) (_ : I ∈ comap (algebraMap R S) '' {J | P' ≤ J ∧ IsMaximal J}), I ≤
    ⨅ (a : Ideal R) (_ : a ∈ {I | comap (algebraMap R S) P' ≤ I ∧ IsMaximal I ∧ ¬y ∈ I}), a
[PROOFSTEP]
refine' iInf_le_iInf_of_subset fun I hI => ⟨map (algebraMap R S) I, ⟨_, _⟩⟩
[GOAL]
case intro.refine'_1
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I✝ : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
P' : Ideal S
hP'✝ : IsPrime P'
hP' : IsPrime (comap (algebraMap R S) P')
hPM : Disjoint ↑(powers y) ↑(comap (algebraMap R S) P')
hP : jacobson (comap (algebraMap R S) P') = comap (algebraMap R S) P'
this : sInf {I | comap (algebraMap R S) P' ≤ I ∧ IsMaximal I ∧ ¬y ∈ I} ≤ comap (algebraMap R S) P'
I : Ideal R
hI : I ∈ {I | comap (algebraMap R S) P' ≤ I ∧ IsMaximal I ∧ ¬y ∈ I}
⊢ map (algebraMap R S) I ∈ {J | P' ≤ J ∧ IsMaximal J}
[PROOFSTEP]
exact
  ⟨le_trans (le_of_eq (IsLocalization.map_comap (powers y) S P').symm) (map_mono hI.1),
    isMaximal_of_isMaximal_disjoint y _ hI.2.1 hI.2.2⟩
[GOAL]
case intro.refine'_2
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I✝ : Ideal R
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobson R
P' : Ideal S
hP'✝ : IsPrime P'
hP' : IsPrime (comap (algebraMap R S) P')
hPM : Disjoint ↑(powers y) ↑(comap (algebraMap R S) P')
hP : jacobson (comap (algebraMap R S) P') = comap (algebraMap R S) P'
this : sInf {I | comap (algebraMap R S) P' ≤ I ∧ IsMaximal I ∧ ¬y ∈ I} ≤ comap (algebraMap R S) P'
I : Ideal R
hI : I ∈ {I | comap (algebraMap R S) P' ≤ I ∧ IsMaximal I ∧ ¬y ∈ I}
⊢ comap (algebraMap R S) (map (algebraMap R S) I) = I
[PROOFSTEP]
exact
  IsLocalization.comap_map_of_isPrime_disjoint _ S I (IsMaximal.isPrime hI.2.1)
    ((disjoint_powers_iff_not_mem y hI.2.1.isPrime.isRadical).2 hI.2.2)
[GOAL]
S : Type u_1
T : Type u_2
inst✝¹ : CommRing S
inst✝ : CommRing T
g : S →+* T
u : Set S
x : S
hx : x ∈ Subring.closure u
⊢ ↑g x ∈ Subring.closure (↑g '' u)
[PROOFSTEP]
rw [Subring.mem_closure] at hx ⊢
[GOAL]
S : Type u_1
T : Type u_2
inst✝¹ : CommRing S
inst✝ : CommRing T
g : S →+* T
u : Set S
x : S
hx : ∀ (S_1 : Subring S), u ⊆ ↑S_1 → x ∈ S_1
⊢ ∀ (S_1 : Subring ((fun x => T) x)), ↑g '' u ⊆ ↑S_1 → ↑g x ∈ S_1
[PROOFSTEP]
intro T₁ h₁
[GOAL]
S : Type u_1
T : Type u_2
inst✝¹ : CommRing S
inst✝ : CommRing T
g : S →+* T
u : Set S
x : S
hx : ∀ (S_1 : Subring S), u ⊆ ↑S_1 → x ∈ S_1
T₁ : Subring ((fun x => T) x)
h₁ : ↑g '' u ⊆ ↑T₁
⊢ ↑g x ∈ T₁
[PROOFSTEP]
rw [← Subring.mem_comap]
[GOAL]
S : Type u_1
T : Type u_2
inst✝¹ : CommRing S
inst✝ : CommRing T
g : S →+* T
u : Set S
x : S
hx : ∀ (S_1 : Subring S), u ⊆ ↑S_1 → x ∈ S_1
T₁ : Subring ((fun x => T) x)
h₁ : ↑g '' u ⊆ ↑T₁
⊢ x ∈ Subring.comap g T₁
[PROOFSTEP]
apply hx
[GOAL]
case a
S : Type u_1
T : Type u_2
inst✝¹ : CommRing S
inst✝ : CommRing T
g : S →+* T
u : Set S
x : S
hx : ∀ (S_1 : Subring S), u ⊆ ↑S_1 → x ∈ S_1
T₁ : Subring ((fun x => T) x)
h₁ : ↑g '' u ⊆ ↑T₁
⊢ u ⊆ ↑(Subring.comap g T₁)
[PROOFSTEP]
simp only [Subring.coe_comap, ← Set.image_subset_iff, SetLike.mem_coe]
[GOAL]
case a
S : Type u_1
T : Type u_2
inst✝¹ : CommRing S
inst✝ : CommRing T
g : S →+* T
u : Set S
x : S
hx : ∀ (S_1 : Subring S), u ⊆ ↑S_1 → x ∈ S_1
T₁ : Subring ((fun x => T) x)
h₁ : ↑g '' u ⊆ ↑T₁
⊢ ↑g '' u ⊆ ↑T₁
[PROOFSTEP]
exact h₁
[GOAL]
R : Type u_1
inst✝ : Ring R
p : R[X]
⊢ p ∈ Subring.closure (insert X {f | degree f ≤ 0})
[PROOFSTEP]
refine' Polynomial.induction_on p _ _ _
[GOAL]
case refine'_1
R : Type u_1
inst✝ : Ring R
p : R[X]
⊢ ∀ (a : R), ↑C a ∈ Subring.closure (insert X {f | degree f ≤ 0})
[PROOFSTEP]
intro r
[GOAL]
case refine'_1
R : Type u_1
inst✝ : Ring R
p : R[X]
r : R
⊢ ↑C r ∈ Subring.closure (insert X {f | degree f ≤ 0})
[PROOFSTEP]
apply Subring.subset_closure
[GOAL]
case refine'_1.a
R : Type u_1
inst✝ : Ring R
p : R[X]
r : R
⊢ ↑C r ∈ insert X {f | degree f ≤ 0}
[PROOFSTEP]
apply Set.mem_insert_of_mem
[GOAL]
case refine'_1.a.a
R : Type u_1
inst✝ : Ring R
p : R[X]
r : R
⊢ ↑C r ∈ {f | degree f ≤ 0}
[PROOFSTEP]
exact degree_C_le
[GOAL]
case refine'_2
R : Type u_1
inst✝ : Ring R
p : R[X]
⊢ ∀ (p q : R[X]),
    p ∈ Subring.closure (insert X {f | degree f ≤ 0}) →
      q ∈ Subring.closure (insert X {f | degree f ≤ 0}) → p + q ∈ Subring.closure (insert X {f | degree f ≤ 0})
[PROOFSTEP]
intros p1 p2 h1 h2
[GOAL]
case refine'_2
R : Type u_1
inst✝ : Ring R
p p1 p2 : R[X]
h1 : p1 ∈ Subring.closure (insert X {f | degree f ≤ 0})
h2 : p2 ∈ Subring.closure (insert X {f | degree f ≤ 0})
⊢ p1 + p2 ∈ Subring.closure (insert X {f | degree f ≤ 0})
[PROOFSTEP]
exact Subring.add_mem _ h1 h2
[GOAL]
case refine'_3
R : Type u_1
inst✝ : Ring R
p : R[X]
⊢ ∀ (n : ℕ) (a : R),
    ↑C a * X ^ n ∈ Subring.closure (insert X {f | degree f ≤ 0}) →
      ↑C a * X ^ (n + 1) ∈ Subring.closure (insert X {f | degree f ≤ 0})
[PROOFSTEP]
intros n r hr
[GOAL]
case refine'_3
R : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
r : R
hr : ↑C r * X ^ n ∈ Subring.closure (insert X {f | degree f ≤ 0})
⊢ ↑C r * X ^ (n + 1) ∈ Subring.closure (insert X {f | degree f ≤ 0})
[PROOFSTEP]
rw [pow_succ', ← mul_assoc]
[GOAL]
case refine'_3
R : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
r : R
hr : ↑C r * X ^ n ∈ Subring.closure (insert X {f | degree f ≤ 0})
⊢ ↑C r * X ^ n * X ∈ Subring.closure (insert X {f | degree f ≤ 0})
[PROOFSTEP]
apply Subring.mul_mem _ hr
[GOAL]
case refine'_3
R : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
r : R
hr : ↑C r * X ^ n ∈ Subring.closure (insert X {f | degree f ≤ 0})
⊢ X ∈ Subring.closure (insert X {f | degree f ≤ 0})
[PROOFSTEP]
apply Subring.subset_closure
[GOAL]
case refine'_3.a
R : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
r : R
hr : ↑C r * X ^ n ∈ Subring.closure (insert X {f | degree f ≤ 0})
⊢ X ∈ insert X {f | degree f ≤ 0}
[PROOFSTEP]
apply Set.mem_insert
[GOAL]
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
⊢ RingHom.IsIntegral
    (IsLocalization.map Sₘ (quotientMap P C (_ : comap C P ≤ comap C P))
      (_ :
        Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) ≤
          Submonoid.comap (quotientMap P C (_ : comap C P ≤ comap C P))
            (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
              (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))))
[PROOFSTEP]
let P' : Ideal R := P.comap C
[GOAL]
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
⊢ RingHom.IsIntegral
    (IsLocalization.map Sₘ (quotientMap P C (_ : comap C P ≤ comap C P))
      (_ :
        Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) ≤
          Submonoid.comap (quotientMap P C (_ : comap C P ≤ comap C P))
            (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
              (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))))
[PROOFSTEP]
let M : Submonoid (R ⧸ P') := Submonoid.powers (pX.map (Quotient.mk (P.comap (C : R →+* R[X])))).leadingCoeff
[GOAL]
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
⊢ RingHom.IsIntegral
    (IsLocalization.map Sₘ (quotientMap P C (_ : comap C P ≤ comap C P))
      (_ :
        Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) ≤
          Submonoid.comap (quotientMap P C (_ : comap C P ≤ comap C P))
            (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
              (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))))
[PROOFSTEP]
let M' : Submonoid (R[X] ⧸ P) :=
  (Submonoid.powers (pX.map (Quotient.mk (P.comap (C : R →+* R[X])))).leadingCoeff).map (quotientMap P C le_rfl)
[GOAL]
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
⊢ RingHom.IsIntegral
    (IsLocalization.map Sₘ (quotientMap P C (_ : comap C P ≤ comap C P))
      (_ :
        Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) ≤
          Submonoid.comap (quotientMap P C (_ : comap C P ≤ comap C P))
            (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
              (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))))
[PROOFSTEP]
let φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C le_rfl
[GOAL]
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
⊢ RingHom.IsIntegral
    (IsLocalization.map Sₘ (quotientMap P C (_ : comap C P ≤ comap C P))
      (_ :
        Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) ≤
          Submonoid.comap (quotientMap P C (_ : comap C P ≤ comap C P))
            (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
              (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))))
[PROOFSTEP]
let φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ M.le_comap_map
[GOAL]
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
⊢ RingHom.IsIntegral
    (IsLocalization.map Sₘ (quotientMap P C (_ : comap C P ≤ comap C P))
      (_ :
        Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) ≤
          Submonoid.comap (quotientMap P C (_ : comap C P ≤ comap C P))
            (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
              (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))))
[PROOFSTEP]
have hφ' : φ.comp (Quotient.mk P') = (Quotient.mk P).comp C := rfl
[GOAL]
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
⊢ RingHom.IsIntegral
    (IsLocalization.map Sₘ (quotientMap P C (_ : comap C P ≤ comap C P))
      (_ :
        Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) ≤
          Submonoid.comap (quotientMap P C (_ : comap C P ≤ comap C P))
            (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
              (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))))
[PROOFSTEP]
intro p
[GOAL]
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p : Sₘ
⊢ RingHom.IsIntegralElem
    (IsLocalization.map Sₘ (quotientMap P C (_ : comap C P ≤ comap C P))
      (_ :
        Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) ≤
          Submonoid.comap (quotientMap P C (_ : comap C P ≤ comap C P))
            (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
              (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))))
    p
[PROOFSTEP]
obtain ⟨⟨p', ⟨q, hq⟩⟩, hp⟩ := IsLocalization.surj M' p
[GOAL]
case intro.mk.mk
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp :
  p * ↑(algebraMap (R[X] ⧸ P) Sₘ) ↑(p', { val := q, property := hq }).snd =
    ↑(algebraMap (R[X] ⧸ P) Sₘ) (p', { val := q, property := hq }).fst
⊢ RingHom.IsIntegralElem
    (IsLocalization.map Sₘ (quotientMap P C (_ : comap C P ≤ comap C P))
      (_ :
        Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) ≤
          Submonoid.comap (quotientMap P C (_ : comap C P ≤ comap C P))
            (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
              (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))))
    p
[PROOFSTEP]
suffices φ'.IsIntegralElem (algebraMap (R[X] ⧸ P) Sₘ p')
  by
  obtain ⟨q', hq', rfl⟩ := hq
  obtain ⟨q'', hq''⟩ := isUnit_iff_exists_inv'.1 (IsLocalization.map_units Rₘ (⟨q', hq'⟩ : M))
  refine' φ'.isIntegral_of_isIntegral_mul_unit p (algebraMap (R[X] ⧸ P) Sₘ (φ q')) q'' _ (hp.symm ▸ this)
  rw [← φ'.map_one, ← congr_arg φ' hq'', φ'.map_mul, ← φ'.comp_apply]
  simp only [IsLocalization.map_comp _]
  rw [RingHom.comp_apply]
[GOAL]
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp :
  p * ↑(algebraMap (R[X] ⧸ P) Sₘ) ↑(p', { val := q, property := hq }).snd =
    ↑(algebraMap (R[X] ⧸ P) Sₘ) (p', { val := q, property := hq }).fst
this : RingHom.IsIntegralElem φ' (↑(algebraMap (R[X] ⧸ P) Sₘ) p')
⊢ RingHom.IsIntegralElem
    (IsLocalization.map Sₘ (quotientMap P C (_ : comap C P ≤ comap C P))
      (_ :
        Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) ≤
          Submonoid.comap (quotientMap P C (_ : comap C P ≤ comap C P))
            (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
              (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))))
    p
[PROOFSTEP]
obtain ⟨q', hq', rfl⟩ := hq
[GOAL]
case 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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p : Sₘ
p' : R[X] ⧸ P
this : RingHom.IsIntegralElem φ' (↑(algebraMap (R[X] ⧸ P) Sₘ) p')
q' : R ⧸ comap C P
hq' : q' ∈ ↑(Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
hp :
  p *
      ↑(algebraMap (R[X] ⧸ P) Sₘ)
        ↑(p',
              { val := ↑(quotientMap P C (_ : comap C P ≤ comap C P)) q',
                property :=
                  (_ :
                    ∃ a,
                      a ∈ ↑(Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))) ∧
                        ↑(quotientMap P C (_ : comap C P ≤ comap C P)) a =
                          ↑(quotientMap P C (_ : comap C P ≤ comap C P)) q') }).snd =
    ↑(algebraMap (R[X] ⧸ P) Sₘ)
      (p',
          { val := ↑(quotientMap P C (_ : comap C P ≤ comap C P)) q',
            property :=
              (_ :
                ∃ a,
                  a ∈ ↑(Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))) ∧
                    ↑(quotientMap P C (_ : comap C P ≤ comap C P)) a =
                      ↑(quotientMap P C (_ : comap C P ≤ comap C P)) q') }).fst
⊢ RingHom.IsIntegralElem
    (IsLocalization.map Sₘ (quotientMap P C (_ : comap C P ≤ comap C P))
      (_ :
        Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) ≤
          Submonoid.comap (quotientMap P C (_ : comap C P ≤ comap C P))
            (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
              (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))))
    p
[PROOFSTEP]
obtain ⟨q'', hq''⟩ := isUnit_iff_exists_inv'.1 (IsLocalization.map_units Rₘ (⟨q', hq'⟩ : M))
[GOAL]
case intro.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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p : Sₘ
p' : R[X] ⧸ P
this : RingHom.IsIntegralElem φ' (↑(algebraMap (R[X] ⧸ P) Sₘ) p')
q' : R ⧸ comap C P
hq' : q' ∈ ↑(Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
hp :
  p *
      ↑(algebraMap (R[X] ⧸ P) Sₘ)
        ↑(p',
              { val := ↑(quotientMap P C (_ : comap C P ≤ comap C P)) q',
                property :=
                  (_ :
                    ∃ a,
                      a ∈ ↑(Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))) ∧
                        ↑(quotientMap P C (_ : comap C P ≤ comap C P)) a =
                          ↑(quotientMap P C (_ : comap C P ≤ comap C P)) q') }).snd =
    ↑(algebraMap (R[X] ⧸ P) Sₘ)
      (p',
          { val := ↑(quotientMap P C (_ : comap C P ≤ comap C P)) q',
            property :=
              (_ :
                ∃ a,
                  a ∈ ↑(Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))) ∧
                    ↑(quotientMap P C (_ : comap C P ≤ comap C P)) a =
                      ↑(quotientMap P C (_ : comap C P ≤ comap C P)) q') }).fst
q'' : Rₘ
hq'' : q'' * ↑(algebraMap (R ⧸ P') Rₘ) ↑{ val := q', property := hq' } = 1
⊢ RingHom.IsIntegralElem
    (IsLocalization.map Sₘ (quotientMap P C (_ : comap C P ≤ comap C P))
      (_ :
        Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) ≤
          Submonoid.comap (quotientMap P C (_ : comap C P ≤ comap C P))
            (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
              (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))))
    p
[PROOFSTEP]
refine' φ'.isIntegral_of_isIntegral_mul_unit p (algebraMap (R[X] ⧸ P) Sₘ (φ q')) q'' _ (hp.symm ▸ this)
[GOAL]
case intro.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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p : Sₘ
p' : R[X] ⧸ P
this : RingHom.IsIntegralElem φ' (↑(algebraMap (R[X] ⧸ P) Sₘ) p')
q' : R ⧸ comap C P
hq' : q' ∈ ↑(Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
hp :
  p *
      ↑(algebraMap (R[X] ⧸ P) Sₘ)
        ↑(p',
              { val := ↑(quotientMap P C (_ : comap C P ≤ comap C P)) q',
                property :=
                  (_ :
                    ∃ a,
                      a ∈ ↑(Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))) ∧
                        ↑(quotientMap P C (_ : comap C P ≤ comap C P)) a =
                          ↑(quotientMap P C (_ : comap C P ≤ comap C P)) q') }).snd =
    ↑(algebraMap (R[X] ⧸ P) Sₘ)
      (p',
          { val := ↑(quotientMap P C (_ : comap C P ≤ comap C P)) q',
            property :=
              (_ :
                ∃ a,
                  a ∈ ↑(Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))) ∧
                    ↑(quotientMap P C (_ : comap C P ≤ comap C P)) a =
                      ↑(quotientMap P C (_ : comap C P ≤ comap C P)) q') }).fst
q'' : Rₘ
hq'' : q'' * ↑(algebraMap (R ⧸ P') Rₘ) ↑{ val := q', property := hq' } = 1
⊢ ↑φ' q'' * ↑(algebraMap (R[X] ⧸ P) Sₘ) (↑φ q') = 1
[PROOFSTEP]
rw [← φ'.map_one, ← congr_arg φ' hq'', φ'.map_mul, ← φ'.comp_apply]
[GOAL]
case intro.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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p : Sₘ
p' : R[X] ⧸ P
this : RingHom.IsIntegralElem φ' (↑(algebraMap (R[X] ⧸ P) Sₘ) p')
q' : R ⧸ comap C P
hq' : q' ∈ ↑(Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
hp :
  p *
      ↑(algebraMap (R[X] ⧸ P) Sₘ)
        ↑(p',
              { val := ↑(quotientMap P C (_ : comap C P ≤ comap C P)) q',
                property :=
                  (_ :
                    ∃ a,
                      a ∈ ↑(Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))) ∧
                        ↑(quotientMap P C (_ : comap C P ≤ comap C P)) a =
                          ↑(quotientMap P C (_ : comap C P ≤ comap C P)) q') }).snd =
    ↑(algebraMap (R[X] ⧸ P) Sₘ)
      (p',
          { val := ↑(quotientMap P C (_ : comap C P ≤ comap C P)) q',
            property :=
              (_ :
                ∃ a,
                  a ∈ ↑(Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))) ∧
                    ↑(quotientMap P C (_ : comap C P ≤ comap C P)) a =
                      ↑(quotientMap P C (_ : comap C P ≤ comap C P)) q') }).fst
q'' : Rₘ
hq'' : q'' * ↑(algebraMap (R ⧸ P') Rₘ) ↑{ val := q', property := hq' } = 1
⊢ ↑φ' q'' * ↑(algebraMap (R[X] ⧸ P) Sₘ) (↑φ q') =
    ↑φ' q'' * ↑(RingHom.comp φ' (algebraMap (R ⧸ P') Rₘ)) ↑{ val := q', property := hq' }
[PROOFSTEP]
simp only [IsLocalization.map_comp _]
[GOAL]
case intro.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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p : Sₘ
p' : R[X] ⧸ P
this : RingHom.IsIntegralElem φ' (↑(algebraMap (R[X] ⧸ P) Sₘ) p')
q' : R ⧸ comap C P
hq' : q' ∈ ↑(Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
hp :
  p *
      ↑(algebraMap (R[X] ⧸ P) Sₘ)
        ↑(p',
              { val := ↑(quotientMap P C (_ : comap C P ≤ comap C P)) q',
                property :=
                  (_ :
                    ∃ a,
                      a ∈ ↑(Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))) ∧
                        ↑(quotientMap P C (_ : comap C P ≤ comap C P)) a =
                          ↑(quotientMap P C (_ : comap C P ≤ comap C P)) q') }).snd =
    ↑(algebraMap (R[X] ⧸ P) Sₘ)
      (p',
          { val := ↑(quotientMap P C (_ : comap C P ≤ comap C P)) q',
            property :=
              (_ :
                ∃ a,
                  a ∈ ↑(Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))) ∧
                    ↑(quotientMap P C (_ : comap C P ≤ comap C P)) a =
                      ↑(quotientMap P C (_ : comap C P ≤ comap C P)) q') }).fst
q'' : Rₘ
hq'' : q'' * ↑(algebraMap (R ⧸ P') Rₘ) ↑{ val := q', property := hq' } = 1
⊢ ↑(IsLocalization.map Sₘ (quotientMap P C (_ : P' ≤ P')) (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))) q'' *
      ↑(algebraMap (R[X] ⧸ P) Sₘ) (↑(quotientMap P C (_ : P' ≤ P')) q') =
    ↑(IsLocalization.map Sₘ (quotientMap P C (_ : P' ≤ P')) (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))) q'' *
      ↑(RingHom.comp (algebraMap (R[X] ⧸ P) Sₘ) (quotientMap P C (_ : P' ≤ P'))) q'
[PROOFSTEP]
rw [RingHom.comp_apply]
[GOAL]
case intro.mk.mk
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp :
  p * ↑(algebraMap (R[X] ⧸ P) Sₘ) ↑(p', { val := q, property := hq }).snd =
    ↑(algebraMap (R[X] ⧸ P) Sₘ) (p', { val := q, property := hq }).fst
⊢ RingHom.IsIntegralElem φ' (↑(algebraMap (R[X] ⧸ P) Sₘ) p')
[PROOFSTEP]
dsimp at hp
[GOAL]
case intro.mk.mk
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp : p * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) p'
⊢ RingHom.IsIntegralElem φ' (↑(algebraMap (R[X] ⧸ P) Sₘ) p')
[PROOFSTEP]
refine'
  @isIntegral_of_mem_closure'' Rₘ _ Sₘ _ φ'
    ((algebraMap (R[X] ⧸ P) Sₘ).comp (Quotient.mk P) '' insert X {p | p.degree ≤ 0}) _ ((algebraMap (R[X] ⧸ P) Sₘ) p') _
[GOAL]
case intro.mk.mk.refine'_1
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp : p * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) p'
⊢ ∀ (x : Sₘ),
    x ∈ ↑(RingHom.comp (algebraMap (R[X] ⧸ P) Sₘ) (Quotient.mk P)) '' insert X {p | degree p ≤ 0} →
      RingHom.IsIntegralElem φ' x
[PROOFSTEP]
rintro x ⟨p, hp, rfl⟩
[GOAL]
case intro.mk.mk.refine'_1.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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p✝ : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp✝ : p✝ * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) p'
p : R[X]
hp : p ∈ insert X {p | degree p ≤ 0}
⊢ RingHom.IsIntegralElem φ' (↑(RingHom.comp (algebraMap (R[X] ⧸ P) Sₘ) (Quotient.mk P)) p)
[PROOFSTEP]
simp only [Set.mem_insert_iff] at hp
[GOAL]
case intro.mk.mk.refine'_1.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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p✝ : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp✝ : p✝ * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) p'
p : R[X]
hp : p = X ∨ p ∈ {p | degree p ≤ 0}
⊢ RingHom.IsIntegralElem φ' (↑(RingHom.comp (algebraMap (R[X] ⧸ P) Sₘ) (Quotient.mk P)) p)
[PROOFSTEP]
cases' hp with hy hy
[GOAL]
case intro.mk.mk.refine'_1.intro.intro.inl
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p✝ : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp : p✝ * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) p'
p : R[X]
hy : p = X
⊢ RingHom.IsIntegralElem φ' (↑(RingHom.comp (algebraMap (R[X] ⧸ P) Sₘ) (Quotient.mk P)) p)
[PROOFSTEP]
rw [hy]
[GOAL]
case intro.mk.mk.refine'_1.intro.intro.inl
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p✝ : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp : p✝ * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) p'
p : R[X]
hy : p = X
⊢ RingHom.IsIntegralElem φ' (↑(RingHom.comp (algebraMap (R[X] ⧸ P) Sₘ) (Quotient.mk P)) X)
[PROOFSTEP]
refine' φ.isIntegralElem_localization_at_leadingCoeff ((Quotient.mk P) X) (pX.map (Quotient.mk P')) _ M _
[GOAL]
case intro.mk.mk.refine'_1.intro.intro.inl.refine'_1
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p✝ : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp : p✝ * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) p'
p : R[X]
hy : p = X
⊢ eval₂ φ (↑(Quotient.mk P) X) (Polynomial.map (Quotient.mk P') pX) = 0
[PROOFSTEP]
rwa [eval₂_map, hφ', ← hom_eval₂, Quotient.eq_zero_iff_mem, eval₂_C_X]
[GOAL]
case intro.mk.mk.refine'_1.intro.intro.inl.refine'_2
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p✝ : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp : p✝ * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) p'
p : R[X]
hy : p = X
⊢ Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') pX) ∈ M
[PROOFSTEP]
use 1
[GOAL]
case h
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p✝ : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp : p✝ * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) p'
p : R[X]
hy : p = X
⊢ (fun x x_1 => x ^ x_1) (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) 1 =
    Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') pX)
[PROOFSTEP]
simp only [pow_one]
[GOAL]
case intro.mk.mk.refine'_1.intro.intro.inr
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p✝ : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp : p✝ * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) p'
p : R[X]
hy : p ∈ {p | degree p ≤ 0}
⊢ RingHom.IsIntegralElem φ' (↑(RingHom.comp (algebraMap (R[X] ⧸ P) Sₘ) (Quotient.mk P)) p)
[PROOFSTEP]
rw [Set.mem_setOf_eq, degree_le_zero_iff] at hy
[GOAL]
case intro.mk.mk.refine'_1.intro.intro.inr
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p✝ : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp : p✝ * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) p'
p : R[X]
hy : p = ↑C (coeff p 0)
⊢ RingHom.IsIntegralElem φ' (↑(RingHom.comp (algebraMap (R[X] ⧸ P) Sₘ) (Quotient.mk P)) p)
[PROOFSTEP]
rw [hy]
[GOAL]
case intro.mk.mk.refine'_1.intro.intro.inr
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p✝ : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp : p✝ * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) p'
p : R[X]
hy : p = ↑C (coeff p 0)
⊢ RingHom.IsIntegralElem φ' (↑(RingHom.comp (algebraMap (R[X] ⧸ P) Sₘ) (Quotient.mk P)) (↑C (coeff p 0)))
[PROOFSTEP]
use X - C (algebraMap (R ⧸ P') Rₘ ((Quotient.mk P') (p.coeff 0)))
[GOAL]
case h
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p✝ : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp : p✝ * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) p'
p : R[X]
hy : p = ↑C (coeff p 0)
⊢ Monic (X - ↑C (↑(algebraMap (R ⧸ P') Rₘ) (↑(Quotient.mk P') (coeff p 0)))) ∧
    eval₂ φ' (↑(RingHom.comp (algebraMap (R[X] ⧸ P) Sₘ) (Quotient.mk P)) (↑C (coeff p 0)))
        (X - ↑C (↑(algebraMap (R ⧸ P') Rₘ) (↑(Quotient.mk P') (coeff p 0)))) =
      0
[PROOFSTEP]
constructor
[GOAL]
case h.left
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p✝ : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp : p✝ * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) p'
p : R[X]
hy : p = ↑C (coeff p 0)
⊢ Monic (X - ↑C (↑(algebraMap (R ⧸ P') Rₘ) (↑(Quotient.mk P') (coeff p 0))))
[PROOFSTEP]
apply monic_X_sub_C
[GOAL]
case h.right
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p✝ : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp : p✝ * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) p'
p : R[X]
hy : p = ↑C (coeff p 0)
⊢ eval₂ φ' (↑(RingHom.comp (algebraMap (R[X] ⧸ P) Sₘ) (Quotient.mk P)) (↑C (coeff p 0)))
      (X - ↑C (↑(algebraMap (R ⧸ P') Rₘ) (↑(Quotient.mk P') (coeff p 0)))) =
    0
[PROOFSTEP]
simp only [eval₂_sub, eval₂_X, eval₂_C]
[GOAL]
case h.right
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p✝ : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp : p✝ * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) p'
p : R[X]
hy : p = ↑C (coeff p 0)
⊢ ↑(RingHom.comp (algebraMap (R[X] ⧸ P) Sₘ) (Quotient.mk P)) (↑C (coeff p 0)) -
      ↑(IsLocalization.map Sₘ (quotientMap P C (_ : P' ≤ P')) (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M)))
        (↑(algebraMap (R ⧸ comap C P) Rₘ) (↑(Quotient.mk (comap C P)) (coeff p 0))) =
    0
[PROOFSTEP]
rw [sub_eq_zero, ← φ'.comp_apply]
[GOAL]
case h.right
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p✝ : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp : p✝ * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) p'
p : R[X]
hy : p = ↑C (coeff p 0)
⊢ ↑(RingHom.comp (algebraMap (R[X] ⧸ P) Sₘ) (Quotient.mk P)) (↑C (coeff p 0)) =
    ↑(RingHom.comp φ' (algebraMap (R ⧸ comap C P) Rₘ)) (↑(Quotient.mk (comap C P)) (coeff p 0))
[PROOFSTEP]
simp only [IsLocalization.map_comp _]
[GOAL]
case h.right
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p✝ : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp : p✝ * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) p'
p : R[X]
hy : p = ↑C (coeff p 0)
⊢ ↑(RingHom.comp (algebraMap (R[X] ⧸ P) Sₘ) (Quotient.mk P)) (↑C (coeff p 0)) =
    ↑(RingHom.comp (algebraMap (R[X] ⧸ P) Sₘ) (quotientMap P C (_ : P' ≤ P'))) (↑(Quotient.mk (comap C P)) (coeff p 0))
[PROOFSTEP]
rfl
[GOAL]
case intro.mk.mk.refine'_2
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p : Sₘ
p' q : R[X] ⧸ P
hq : q ∈ M'
hp : p * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) p'
⊢ ↑(algebraMap (R[X] ⧸ P) Sₘ) p' ∈
    Subring.closure (↑(RingHom.comp (algebraMap (R[X] ⧸ P) Sₘ) (Quotient.mk P)) '' insert X {p | degree p ≤ 0})
[PROOFSTEP]
obtain ⟨p, rfl⟩ := Quotient.mk_surjective p'
[GOAL]
case intro.mk.mk.refine'_2.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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p✝ : Sₘ
q : R[X] ⧸ P
hq : q ∈ M'
p : R[X]
hp : p✝ * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) (↑(Quotient.mk P) p)
⊢ ↑(algebraMap (R[X] ⧸ P) Sₘ) (↑(Quotient.mk P) p) ∈
    Subring.closure (↑(RingHom.comp (algebraMap (R[X] ⧸ P) Sₘ) (Quotient.mk P)) '' insert X {p | degree p ≤ 0})
[PROOFSTEP]
rw [← RingHom.comp_apply]
[GOAL]
case intro.mk.mk.refine'_2.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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p✝ : Sₘ
q : R[X] ⧸ P
hq : q ∈ M'
p : R[X]
hp : p✝ * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) (↑(Quotient.mk P) p)
⊢ ↑(RingHom.comp (algebraMap (R[X] ⧸ P) Sₘ) (Quotient.mk P)) p ∈
    Subring.closure (↑(RingHom.comp (algebraMap (R[X] ⧸ P) Sₘ) (Quotient.mk P)) '' insert X {p | degree p ≤ 0})
[PROOFSTEP]
apply Subring.mem_closure_image_of
[GOAL]
case intro.mk.mk.refine'_2.intro.hx
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ₘ
P : Ideal R[X]
pX : R[X]
hpX : pX ∈ P
inst✝³ : Algebra (R ⧸ comap C P) Rₘ
inst✝² : IsLocalization.Away (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)) Rₘ
inst✝¹ : Algebra (R[X] ⧸ P) Sₘ
inst✝ :
  IsLocalization
    (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
      (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))))
    Sₘ
P' : Ideal R := comap C P
M : Submonoid (R ⧸ P') := Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX))
M' : Submonoid (R[X] ⧸ P) :=
  Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P))
    (Submonoid.powers (Polynomial.leadingCoeff (Polynomial.map (Quotient.mk (comap C P)) pX)))
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M))
hφ' : RingHom.comp φ (Quotient.mk P') = RingHom.comp (Quotient.mk P) C
p✝ : Sₘ
q : R[X] ⧸ P
hq : q ∈ M'
p : R[X]
hp : p✝ * ↑(algebraMap (R[X] ⧸ P) Sₘ) q = ↑(algebraMap (R[X] ⧸ P) Sₘ) (↑(Quotient.mk P) p)
⊢ p ∈ Subring.closure (insert X {p | degree p ≤ 0})
[PROOFSTEP]
apply Polynomial.mem_closure_X_union_C
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
⊢ jacobson ⊥ = ⊥
[PROOFSTEP]
have hM : ((Submonoid.powers x).map φ : Submonoid S) ≤ nonZeroDivisors S :=
  map_le_nonZeroDivisors_of_injective φ hφ (powers_le_nonZeroDivisors_of_noZeroDivisors hx)
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
⊢ jacobson ⊥ = ⊥
[PROOFSTEP]
letI : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors _ hM
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
⊢ jacobson ⊥ = ⊥
[PROOFSTEP]
let φ' : Rₘ →+* Sₘ := IsLocalization.map _ φ (Submonoid.powers x).le_comap_map
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
⊢ jacobson ⊥ = ⊥
[PROOFSTEP]
suffices ∀ I : Ideal Sₘ, I.IsMaximal → (I.comap (algebraMap S Sₘ)).IsMaximal
  by
  have hϕ' : comap (algebraMap S Sₘ) (⊥ : Ideal Sₘ) = (⊥ : Ideal S) :=
    by
    rw [← RingHom.ker_eq_comap_bot, ← RingHom.injective_iff_ker_eq_bot]
    exact IsLocalization.injective Sₘ hM
  have hSₘ : IsJacobson Sₘ := isJacobson_of_isIntegral' φ' hφ' (isJacobson_localization x)
  refine' eq_bot_iff.mpr (le_trans _ (le_of_eq hϕ'))
  rw [← hSₘ.out isRadical_bot_of_noZeroDivisors, comap_jacobson]
  exact
    sInf_le_sInf fun j hj =>
      ⟨bot_le,
        let ⟨J, hJ⟩ := hj
        hJ.2 ▸ this J hJ.1.2⟩
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this✝ : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
this : ∀ (I : Ideal Sₘ), IsMaximal I → IsMaximal (comap (algebraMap S Sₘ) I)
⊢ jacobson ⊥ = ⊥
[PROOFSTEP]
have hϕ' : comap (algebraMap S Sₘ) (⊥ : Ideal Sₘ) = (⊥ : Ideal S) :=
  by
  rw [← RingHom.ker_eq_comap_bot, ← RingHom.injective_iff_ker_eq_bot]
  exact IsLocalization.injective Sₘ hM
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this✝ : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
this : ∀ (I : Ideal Sₘ), IsMaximal I → IsMaximal (comap (algebraMap S Sₘ) I)
⊢ comap (algebraMap S Sₘ) ⊥ = ⊥
[PROOFSTEP]
rw [← RingHom.ker_eq_comap_bot, ← RingHom.injective_iff_ker_eq_bot]
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this✝ : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
this : ∀ (I : Ideal Sₘ), IsMaximal I → IsMaximal (comap (algebraMap S Sₘ) I)
⊢ Function.Injective ↑(algebraMap S Sₘ)
[PROOFSTEP]
exact IsLocalization.injective Sₘ hM
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this✝ : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
this : ∀ (I : Ideal Sₘ), IsMaximal I → IsMaximal (comap (algebraMap S Sₘ) I)
hϕ' : comap (algebraMap S Sₘ) ⊥ = ⊥
⊢ jacobson ⊥ = ⊥
[PROOFSTEP]
have hSₘ : IsJacobson Sₘ := isJacobson_of_isIntegral' φ' hφ' (isJacobson_localization x)
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this✝ : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
this : ∀ (I : Ideal Sₘ), IsMaximal I → IsMaximal (comap (algebraMap S Sₘ) I)
hϕ' : comap (algebraMap S Sₘ) ⊥ = ⊥
hSₘ : IsJacobson Sₘ
⊢ jacobson ⊥ = ⊥
[PROOFSTEP]
refine' eq_bot_iff.mpr (le_trans _ (le_of_eq hϕ'))
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this✝ : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
this : ∀ (I : Ideal Sₘ), IsMaximal I → IsMaximal (comap (algebraMap S Sₘ) I)
hϕ' : comap (algebraMap S Sₘ) ⊥ = ⊥
hSₘ : IsJacobson Sₘ
⊢ jacobson ⊥ ≤ comap (algebraMap S Sₘ) ⊥
[PROOFSTEP]
rw [← hSₘ.out isRadical_bot_of_noZeroDivisors, comap_jacobson]
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this✝ : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
this : ∀ (I : Ideal Sₘ), IsMaximal I → IsMaximal (comap (algebraMap S Sₘ) I)
hϕ' : comap (algebraMap S Sₘ) ⊥ = ⊥
hSₘ : IsJacobson Sₘ
⊢ jacobson ⊥ ≤ sInf (comap (algebraMap S Sₘ) '' {J | ⊥ ≤ J ∧ IsMaximal J})
[PROOFSTEP]
exact
  sInf_le_sInf fun j hj =>
    ⟨bot_le,
      let ⟨J, hJ⟩ := hj
      hJ.2 ▸ this J hJ.1.2⟩
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
⊢ ∀ (I : Ideal Sₘ), IsMaximal I → IsMaximal (comap (algebraMap S Sₘ) I)
[PROOFSTEP]
intro I hI
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
I : Ideal Sₘ
hI : IsMaximal I
⊢ IsMaximal (comap (algebraMap S Sₘ) I)
[PROOFSTEP]
haveI : (I.comap (algebraMap S Sₘ)).IsPrime := comap_isPrime _ I
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this✝ : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
I : Ideal Sₘ
hI : IsMaximal I
this : IsPrime (comap (algebraMap S Sₘ) I)
⊢ IsMaximal (comap (algebraMap S Sₘ) I)
[PROOFSTEP]
haveI : (I.comap φ').IsPrime := comap_isPrime φ' I
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this✝¹ : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
I : Ideal Sₘ
hI : IsMaximal I
this✝ : IsPrime (comap (algebraMap S Sₘ) I)
this : IsPrime (comap φ' I)
⊢ IsMaximal (comap (algebraMap S Sₘ) I)
[PROOFSTEP]
haveI : (⊥ : Ideal (S ⧸ I.comap (algebraMap S Sₘ))).IsPrime := bot_prime
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this✝² : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
I : Ideal Sₘ
hI : IsMaximal I
this✝¹ : IsPrime (comap (algebraMap S Sₘ) I)
this✝ : IsPrime (comap φ' I)
this : IsPrime ⊥
⊢ IsMaximal (comap (algebraMap S Sₘ) I)
[PROOFSTEP]
have hcomm : φ'.comp (algebraMap R Rₘ) = (algebraMap S Sₘ).comp φ := IsLocalization.map_comp _
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this✝² : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
I : Ideal Sₘ
hI : IsMaximal I
this✝¹ : IsPrime (comap (algebraMap S Sₘ) I)
this✝ : IsPrime (comap φ' I)
this : IsPrime ⊥
hcomm : RingHom.comp φ' (algebraMap R Rₘ) = RingHom.comp (algebraMap S Sₘ) φ
⊢ IsMaximal (comap (algebraMap S Sₘ) I)
[PROOFSTEP]
let f := quotientMap (I.comap (algebraMap S Sₘ)) φ le_rfl
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this✝² : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
I : Ideal Sₘ
hI : IsMaximal I
this✝¹ : IsPrime (comap (algebraMap S Sₘ) I)
this✝ : IsPrime (comap φ' I)
this : IsPrime ⊥
hcomm : RingHom.comp φ' (algebraMap R Rₘ) = RingHom.comp (algebraMap S Sₘ) φ
f : R ⧸ comap φ (comap (algebraMap S Sₘ) I) →+* S ⧸ comap (algebraMap S Sₘ) I :=
  quotientMap (comap (algebraMap S Sₘ) I) φ
    (_ : comap φ (comap (algebraMap S Sₘ) I) ≤ comap φ (comap (algebraMap S Sₘ) I))
⊢ IsMaximal (comap (algebraMap S Sₘ) I)
[PROOFSTEP]
let g := quotientMap I (algebraMap S Sₘ) le_rfl
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this✝² : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
I : Ideal Sₘ
hI : IsMaximal I
this✝¹ : IsPrime (comap (algebraMap S Sₘ) I)
this✝ : IsPrime (comap φ' I)
this : IsPrime ⊥
hcomm : RingHom.comp φ' (algebraMap R Rₘ) = RingHom.comp (algebraMap S Sₘ) φ
f : R ⧸ comap φ (comap (algebraMap S Sₘ) I) →+* S ⧸ comap (algebraMap S Sₘ) I :=
  quotientMap (comap (algebraMap S Sₘ) I) φ
    (_ : comap φ (comap (algebraMap S Sₘ) I) ≤ comap φ (comap (algebraMap S Sₘ) I))
g : S ⧸ comap (algebraMap S Sₘ) I →+* Sₘ ⧸ I :=
  quotientMap I (algebraMap S Sₘ) (_ : comap (algebraMap S Sₘ) I ≤ comap (algebraMap S Sₘ) I)
⊢ IsMaximal (comap (algebraMap S Sₘ) I)
[PROOFSTEP]
have := isMaximal_comap_of_isIntegral_of_isMaximal' φ' hφ' I hI
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this✝³ : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
I : Ideal Sₘ
hI : IsMaximal I
this✝² : IsPrime (comap (algebraMap S Sₘ) I)
this✝¹ : IsPrime (comap φ' I)
this✝ : IsPrime ⊥
hcomm : RingHom.comp φ' (algebraMap R Rₘ) = RingHom.comp (algebraMap S Sₘ) φ
f : R ⧸ comap φ (comap (algebraMap S Sₘ) I) →+* S ⧸ comap (algebraMap S Sₘ) I :=
  quotientMap (comap (algebraMap S Sₘ) I) φ
    (_ : comap φ (comap (algebraMap S Sₘ) I) ≤ comap φ (comap (algebraMap S Sₘ) I))
g : S ⧸ comap (algebraMap S Sₘ) I →+* Sₘ ⧸ I :=
  quotientMap I (algebraMap S Sₘ) (_ : comap (algebraMap S Sₘ) I ≤ comap (algebraMap S Sₘ) I)
this : IsMaximal (comap φ' I)
⊢ IsMaximal (comap (algebraMap S Sₘ) I)
[PROOFSTEP]
have := ((isMaximal_iff_isMaximal_disjoint Rₘ x _).1 this).left
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this✝⁴ : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
I : Ideal Sₘ
hI : IsMaximal I
this✝³ : IsPrime (comap (algebraMap S Sₘ) I)
this✝² : IsPrime (comap φ' I)
this✝¹ : IsPrime ⊥
hcomm : RingHom.comp φ' (algebraMap R Rₘ) = RingHom.comp (algebraMap S Sₘ) φ
f : R ⧸ comap φ (comap (algebraMap S Sₘ) I) →+* S ⧸ comap (algebraMap S Sₘ) I :=
  quotientMap (comap (algebraMap S Sₘ) I) φ
    (_ : comap φ (comap (algebraMap S Sₘ) I) ≤ comap φ (comap (algebraMap S Sₘ) I))
g : S ⧸ comap (algebraMap S Sₘ) I →+* Sₘ ⧸ I :=
  quotientMap I (algebraMap S Sₘ) (_ : comap (algebraMap S Sₘ) I ≤ comap (algebraMap S Sₘ) I)
this✝ : IsMaximal (comap φ' I)
this : IsMaximal (comap (algebraMap R Rₘ) (comap φ' I))
⊢ IsMaximal (comap (algebraMap S Sₘ) I)
[PROOFSTEP]
have : ((I.comap (algebraMap S Sₘ)).comap φ).IsMaximal := by rwa [comap_comap, hcomm, ← comap_comap] at this
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this✝⁴ : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
I : Ideal Sₘ
hI : IsMaximal I
this✝³ : IsPrime (comap (algebraMap S Sₘ) I)
this✝² : IsPrime (comap φ' I)
this✝¹ : IsPrime ⊥
hcomm : RingHom.comp φ' (algebraMap R Rₘ) = RingHom.comp (algebraMap S Sₘ) φ
f : R ⧸ comap φ (comap (algebraMap S Sₘ) I) →+* S ⧸ comap (algebraMap S Sₘ) I :=
  quotientMap (comap (algebraMap S Sₘ) I) φ
    (_ : comap φ (comap (algebraMap S Sₘ) I) ≤ comap φ (comap (algebraMap S Sₘ) I))
g : S ⧸ comap (algebraMap S Sₘ) I →+* Sₘ ⧸ I :=
  quotientMap I (algebraMap S Sₘ) (_ : comap (algebraMap S Sₘ) I ≤ comap (algebraMap S Sₘ) I)
this✝ : IsMaximal (comap φ' I)
this : IsMaximal (comap (algebraMap R Rₘ) (comap φ' I))
⊢ IsMaximal (comap φ (comap (algebraMap S Sₘ) I))
[PROOFSTEP]
rwa [comap_comap, hcomm, ← comap_comap] at this
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this✝⁵ : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
I : Ideal Sₘ
hI : IsMaximal I
this✝⁴ : IsPrime (comap (algebraMap S Sₘ) I)
this✝³ : IsPrime (comap φ' I)
this✝² : IsPrime ⊥
hcomm : RingHom.comp φ' (algebraMap R Rₘ) = RingHom.comp (algebraMap S Sₘ) φ
f : R ⧸ comap φ (comap (algebraMap S Sₘ) I) →+* S ⧸ comap (algebraMap S Sₘ) I :=
  quotientMap (comap (algebraMap S Sₘ) I) φ
    (_ : comap φ (comap (algebraMap S Sₘ) I) ≤ comap φ (comap (algebraMap S Sₘ) I))
g : S ⧸ comap (algebraMap S Sₘ) I →+* Sₘ ⧸ I :=
  quotientMap I (algebraMap S Sₘ) (_ : comap (algebraMap S Sₘ) I ≤ comap (algebraMap S Sₘ) I)
this✝¹ : IsMaximal (comap φ' I)
this✝ : IsMaximal (comap (algebraMap R Rₘ) (comap φ' I))
this : IsMaximal (comap φ (comap (algebraMap S Sₘ) I))
⊢ IsMaximal (comap (algebraMap S Sₘ) I)
[PROOFSTEP]
rw [← bot_quotient_isMaximal_iff] at this ⊢
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this✝⁵ : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
I : Ideal Sₘ
hI : IsMaximal I
this✝⁴ : IsPrime (comap (algebraMap S Sₘ) I)
this✝³ : IsPrime (comap φ' I)
this✝² : IsPrime ⊥
hcomm : RingHom.comp φ' (algebraMap R Rₘ) = RingHom.comp (algebraMap S Sₘ) φ
f : R ⧸ comap φ (comap (algebraMap S Sₘ) I) →+* S ⧸ comap (algebraMap S Sₘ) I :=
  quotientMap (comap (algebraMap S Sₘ) I) φ
    (_ : comap φ (comap (algebraMap S Sₘ) I) ≤ comap φ (comap (algebraMap S Sₘ) I))
g : S ⧸ comap (algebraMap S Sₘ) I →+* Sₘ ⧸ I :=
  quotientMap I (algebraMap S Sₘ) (_ : comap (algebraMap S Sₘ) I ≤ comap (algebraMap S Sₘ) I)
this✝¹ : IsMaximal (comap φ' I)
this✝ : IsMaximal (comap (algebraMap R Rₘ) (comap φ' I))
this : IsMaximal ⊥
⊢ IsMaximal ⊥
[PROOFSTEP]
refine'
  isMaximal_of_isIntegral_of_isMaximal_comap' f _ ⊥
    ((eq_bot_iff.2 (comap_bot_le_of_injective f quotientMap_injective)).symm ▸ this)
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this✝⁵ : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
I : Ideal Sₘ
hI : IsMaximal I
this✝⁴ : IsPrime (comap (algebraMap S Sₘ) I)
this✝³ : IsPrime (comap φ' I)
this✝² : IsPrime ⊥
hcomm : RingHom.comp φ' (algebraMap R Rₘ) = RingHom.comp (algebraMap S Sₘ) φ
f : R ⧸ comap φ (comap (algebraMap S Sₘ) I) →+* S ⧸ comap (algebraMap S Sₘ) I :=
  quotientMap (comap (algebraMap S Sₘ) I) φ
    (_ : comap φ (comap (algebraMap S Sₘ) I) ≤ comap φ (comap (algebraMap S Sₘ) I))
g : S ⧸ comap (algebraMap S Sₘ) I →+* Sₘ ⧸ I :=
  quotientMap I (algebraMap S Sₘ) (_ : comap (algebraMap S Sₘ) I ≤ comap (algebraMap S Sₘ) I)
this✝¹ : IsMaximal (comap φ' I)
this✝ : IsMaximal (comap (algebraMap R Rₘ) (comap φ' I))
this : IsMaximal ⊥
⊢ RingHom.IsIntegral f
[PROOFSTEP]
exact
  f.isIntegral_tower_bot_of_isIntegral g quotientMap_injective
    ((comp_quotientMap_eq_of_comp_eq hcomm I).symm ▸
      RingHom.isIntegral_trans _ _
        (RingHom.isIntegral_of_surjective _
          (IsLocalization.surjective_quotientMap_of_maximal_of_localization (Submonoid.powers x) Rₘ
            (by rwa [comap_comap, hcomm, ← bot_quotient_isMaximal_iff])))
        (RingHom.isIntegral_quotient_of_isIntegral _ hφ'))
[GOAL]
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
inst✝⁶ : IsJacobson R
Rₘ : Type u_6
Sₘ : Type u_7
inst✝⁵ : CommRing Rₘ
inst✝⁴ : CommRing Sₘ
φ : R →+* S
hφ : Function.Injective ↑φ
x : R
hx : x ≠ 0
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization.Away x Rₘ
inst✝¹ : Algebra S Sₘ
inst✝ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ
hφ' :
  RingHom.IsIntegral
    (IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x))))
hM : Submonoid.map φ (Submonoid.powers x) ≤ nonZeroDivisors S
this✝⁵ : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors S hM
φ' : Rₘ →+* Sₘ :=
  IsLocalization.map Sₘ φ (_ : Submonoid.powers x ≤ Submonoid.comap φ (Submonoid.map φ (Submonoid.powers x)))
I : Ideal Sₘ
hI : IsMaximal I
this✝⁴ : IsPrime (comap (algebraMap S Sₘ) I)
this✝³ : IsPrime (comap φ' I)
this✝² : IsPrime ⊥
hcomm : RingHom.comp φ' (algebraMap R Rₘ) = RingHom.comp (algebraMap S Sₘ) φ
f : R ⧸ comap φ (comap (algebraMap S Sₘ) I) →+* S ⧸ comap (algebraMap S Sₘ) I :=
  quotientMap (comap (algebraMap S Sₘ) I) φ
    (_ : comap φ (comap (algebraMap S Sₘ) I) ≤ comap φ (comap (algebraMap S Sₘ) I))
g : S ⧸ comap (algebraMap S Sₘ) I →+* Sₘ ⧸ I :=
  quotientMap I (algebraMap S Sₘ) (_ : comap (algebraMap S Sₘ) I ≤ comap (algebraMap S Sₘ) I)
this✝¹ : IsMaximal (comap φ' I)
this✝ : IsMaximal (comap (algebraMap R Rₘ) (comap φ' I))
this : IsMaximal ⊥
⊢ IsMaximal (comap (algebraMap R Rₘ) (comap φ' I))
[PROOFSTEP]
rwa [comap_comap, hcomm, ← bot_quotient_isMaximal_iff]
[GOAL]
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
⊢ jacobson P = P
[PROOFSTEP]
by_cases Pb : P = ⊥
[GOAL]
case pos
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 = ⊥
⊢ jacobson P = P
[PROOFSTEP]
exact Pb.symm ▸ jacobson_bot_polynomial_of_jacobson_bot (hR.out isRadical_bot_of_noZeroDivisors)
[GOAL]
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 = ⊥
⊢ jacobson P = P
[PROOFSTEP]
rw [jacobson_eq_iff_jacobson_quotient_eq_bot]
[GOAL]
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 = ⊥
⊢ jacobson ⊥ = ⊥
[PROOFSTEP]
let P' := P.comap (C : R →+* R[X])
[GOAL]
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
⊢ jacobson ⊥ = ⊥
[PROOFSTEP]
haveI : P'.IsPrime := comap_isPrime C P
[GOAL]
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 ⊥ = ⊥
[PROOFSTEP]
haveI hR' : IsJacobson (R ⧸ P') := by infer_instance
[GOAL]
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')
[PROOFSTEP]
infer_instance
[GOAL]
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 ⊥ = ⊥
[PROOFSTEP]
obtain ⟨p, pP, p0⟩ := exists_nonzero_mem_of_ne_bot Pb hP
[GOAL]
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 ⊥ = ⊥
[PROOFSTEP]
let x := (Polynomial.map (Quotient.mk P') p).leadingCoeff
[GOAL]
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 ⊥ = ⊥
[PROOFSTEP]
have hx : x ≠ 0 := by rwa [Ne.def, leadingCoeff_eq_zero]
[GOAL]
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
[PROOFSTEP]
rwa [Ne.def, leadingCoeff_eq_zero]
[GOAL]
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 ⊥ = ⊥
[PROOFSTEP]
let φ : R ⧸ P' →+* R[X] ⧸ P := Ideal.quotientMap P (C : R →+* R[X]) le_rfl
[GOAL]
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 ⊥ = ⊥
[PROOFSTEP]
let hφ : Function.Injective ↑φ := quotientMap_injective
[GOAL]
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 ⊥ = ⊥
[PROOFSTEP]
let Rₘ := Localization.Away x
[GOAL]
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 ⊥ = ⊥
[PROOFSTEP]
let Sₘ := (Localization ((Submonoid.powers x).map φ : Submonoid (R[X] ⧸ P)))
[GOAL]
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 ⊥ = ⊥
[PROOFSTEP]
refine' jacobson_bot_of_integral_localization (S := R[X] ⧸ P) (R := R ⧸ P') Rₘ Sₘ _ hφ _ hx _
[GOAL]
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))))
[PROOFSTEP]
haveI islocSₘ : IsLocalization (Submonoid.map φ (Submonoid.powers x)) Sₘ := by infer_instance
[GOAL]
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ₘ
[PROOFSTEP]
infer_instance
[GOAL]
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))))
[PROOFSTEP]
exact @isIntegral_isLocalization_polynomial_quotient R _ Rₘ Sₘ _ _ P p pP _ _ _ islocSₘ
[GOAL]
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]
[PROOFSTEP]
rw [isJacobson_iff_prime_eq]
[GOAL]
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
[PROOFSTEP]
intro I hI
[GOAL]
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
[PROOFSTEP]
let R' : Subring (R[X] ⧸ I) := ((Quotient.mk I).comp C).range
[GOAL]
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
R' : Subring (R[X] ⧸ I) := RingHom.range (RingHom.comp (Quotient.mk I) C)
⊢ jacobson I = I
[PROOFSTEP]
let i : R →+* R' := ((Quotient.mk I).comp C).rangeRestrict
[GOAL]
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
R' : Subring (R[X] ⧸ I) := RingHom.range (RingHom.comp (Quotient.mk I) C)
i : R →+* { x // x ∈ R' } := RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)
⊢ jacobson I = I
[PROOFSTEP]
have hi : Function.Surjective ↑i := ((Quotient.mk I).comp C).rangeRestrict_surjective
[GOAL]
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
R' : Subring (R[X] ⧸ I) := RingHom.range (RingHom.comp (Quotient.mk I) C)
i : R →+* { x // x ∈ R' } := RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)
hi : Function.Surjective ↑i
⊢ jacobson I = I
[PROOFSTEP]
have hi' : RingHom.ker (mapRingHom i) ≤ I
[GOAL]
case hi'
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
R' : Subring (R[X] ⧸ I) := RingHom.range (RingHom.comp (Quotient.mk I) C)
i : R →+* { x // x ∈ R' } := RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)
hi : Function.Surjective ↑i
⊢ RingHom.ker (mapRingHom i) ≤ I
[PROOFSTEP]
intro f hf
[GOAL]
case hi'
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
R' : Subring (R[X] ⧸ I) := RingHom.range (RingHom.comp (Quotient.mk I) C)
i : R →+* { x // x ∈ R' } := RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)
hi : Function.Surjective ↑i
f : R[X]
hf : f ∈ RingHom.ker (mapRingHom i)
⊢ f ∈ I
[PROOFSTEP]
apply polynomial_mem_ideal_of_coeff_mem_ideal I f
[GOAL]
case hi'
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
R' : Subring (R[X] ⧸ I) := RingHom.range (RingHom.comp (Quotient.mk I) C)
i : R →+* { x // x ∈ R' } := RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)
hi : Function.Surjective ↑i
f : R[X]
hf : f ∈ RingHom.ker (mapRingHom i)
⊢ ∀ (n : ℕ), coeff f n ∈ comap C I
[PROOFSTEP]
intro n
[GOAL]
case hi'
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
R' : Subring (R[X] ⧸ I) := RingHom.range (RingHom.comp (Quotient.mk I) C)
i : R →+* { x // x ∈ R' } := RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)
hi : Function.Surjective ↑i
f : R[X]
hf : f ∈ RingHom.ker (mapRingHom i)
n : ℕ
⊢ coeff f n ∈ comap C I
[PROOFSTEP]
replace hf := congrArg (fun g : Polynomial ((Quotient.mk I).comp C).range => g.coeff n) hf
[GOAL]
case hi'
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
R' : Subring (R[X] ⧸ I) := RingHom.range (RingHom.comp (Quotient.mk I) C)
i : R →+* { x // x ∈ R' } := RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)
hi : Function.Surjective ↑i
f : R[X]
n : ℕ
hf : (fun g => coeff g n) (↑(mapRingHom i) f) = (fun g => coeff g n) 0
⊢ coeff f n ∈ comap C I
[PROOFSTEP]
change (Polynomial.map ((Quotient.mk I).comp C).rangeRestrict f).coeff n = 0 at hf
[GOAL]
case hi'
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
R' : Subring (R[X] ⧸ I) := RingHom.range (RingHom.comp (Quotient.mk I) C)
i : R →+* { x // x ∈ R' } := RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)
hi : Function.Surjective ↑i
f : R[X]
n : ℕ
hf : coeff (Polynomial.map (RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)) f) n = 0
⊢ coeff f n ∈ comap C I
[PROOFSTEP]
rw [coeff_map, Subtype.ext_iff] at hf
[GOAL]
case hi'
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
R' : Subring (R[X] ⧸ I) := RingHom.range (RingHom.comp (Quotient.mk I) C)
i : R →+* { x // x ∈ R' } := RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)
hi : Function.Surjective ↑i
f : R[X]
n : ℕ
hf : ↑(↑(RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)) (coeff f n)) = ↑0
⊢ coeff f n ∈ comap C I
[PROOFSTEP]
rwa [mem_comap, ← Quotient.eq_zero_iff_mem, ← RingHom.comp_apply]
[GOAL]
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
R' : Subring (R[X] ⧸ I) := RingHom.range (RingHom.comp (Quotient.mk I) C)
i : R →+* { x // x ∈ R' } := RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)
hi : Function.Surjective ↑i
hi' : RingHom.ker (mapRingHom i) ≤ I
⊢ jacobson I = I
[PROOFSTEP]
have R'_jacob : IsJacobson R' := isJacobson_of_surjective ⟨i, hi⟩
[GOAL]
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
R' : Subring (R[X] ⧸ I) := RingHom.range (RingHom.comp (Quotient.mk I) C)
i : R →+* { x // x ∈ R' } := RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)
hi : Function.Surjective ↑i
hi' : RingHom.ker (mapRingHom i) ≤ I
R'_jacob : IsJacobson { x // x ∈ R' }
⊢ jacobson I = I
[PROOFSTEP]
let J := map (mapRingHom i) I
[GOAL]
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
R' : Subring (R[X] ⧸ I) := RingHom.range (RingHom.comp (Quotient.mk I) C)
i : R →+* { x // x ∈ R' } := RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)
hi : Function.Surjective ↑i
hi' : RingHom.ker (mapRingHom i) ≤ I
R'_jacob : IsJacobson { x // x ∈ R' }
J : Ideal { x // x ∈ R' }[X] := map (mapRingHom i) I
⊢ jacobson I = I
[PROOFSTEP]
have h_surj : Function.Surjective (mapRingHom i) := Polynomial.map_surjective i hi
[GOAL]
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
R' : Subring (R[X] ⧸ I) := RingHom.range (RingHom.comp (Quotient.mk I) C)
i : R →+* { x // x ∈ R' } := RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)
hi : Function.Surjective ↑i
hi' : RingHom.ker (mapRingHom i) ≤ I
R'_jacob : IsJacobson { x // x ∈ R' }
J : Ideal { x // x ∈ R' }[X] := map (mapRingHom i) I
h_surj : Function.Surjective ↑(mapRingHom i)
⊢ jacobson I = I
[PROOFSTEP]
have : IsPrime J := map_isPrime_of_surjective h_surj hi'
[GOAL]
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
R' : Subring (R[X] ⧸ I) := RingHom.range (RingHom.comp (Quotient.mk I) C)
i : R →+* { x // x ∈ R' } := RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)
hi : Function.Surjective ↑i
hi' : RingHom.ker (mapRingHom i) ≤ I
R'_jacob : IsJacobson { x // x ∈ R' }
J : Ideal { x // x ∈ R' }[X] := map (mapRingHom i) I
h_surj : Function.Surjective ↑(mapRingHom i)
this : IsPrime J
⊢ jacobson I = I
[PROOFSTEP]
suffices h : J.jacobson = J
[GOAL]
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
R' : Subring (R[X] ⧸ I) := RingHom.range (RingHom.comp (Quotient.mk I) C)
i : R →+* { x // x ∈ R' } := RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)
hi : Function.Surjective ↑i
hi' : RingHom.ker (mapRingHom i) ≤ I
R'_jacob : IsJacobson { x // x ∈ R' }
J : Ideal { x // x ∈ R' }[X] := map (mapRingHom i) I
h_surj : Function.Surjective ↑(mapRingHom i)
this : IsPrime J
h : jacobson J = J
⊢ jacobson I = I
[PROOFSTEP]
replace h := congrArg (comap (Polynomial.mapRingHom i)) h
[GOAL]
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
R' : Subring (R[X] ⧸ I) := RingHom.range (RingHom.comp (Quotient.mk I) C)
i : R →+* { x // x ∈ R' } := RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)
hi : Function.Surjective ↑i
hi' : RingHom.ker (mapRingHom i) ≤ I
R'_jacob : IsJacobson { x // x ∈ R' }
J : Ideal { x // x ∈ R' }[X] := map (mapRingHom i) I
h_surj : Function.Surjective ↑(mapRingHom i)
this : IsPrime J
h : comap (mapRingHom i) (jacobson J) = comap (mapRingHom i) J
⊢ jacobson I = I
[PROOFSTEP]
rw [← map_jacobson_of_surjective h_surj hi', comap_map_of_surjective _ h_surj, comap_map_of_surjective _ h_surj] at h
[GOAL]
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
R' : Subring (R[X] ⧸ I) := RingHom.range (RingHom.comp (Quotient.mk I) C)
i : R →+* { x // x ∈ R' } := RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)
hi : Function.Surjective ↑i
hi' : RingHom.ker (mapRingHom i) ≤ I
R'_jacob : IsJacobson { x // x ∈ R' }
J : Ideal { x // x ∈ R' }[X] := map (mapRingHom i) I
h_surj : Function.Surjective ↑(mapRingHom i)
this : IsPrime J
h : jacobson I ⊔ comap (mapRingHom i) ⊥ = I ⊔ comap (mapRingHom i) ⊥
⊢ jacobson I = I
[PROOFSTEP]
refine le_antisymm ?_ le_jacobson
[GOAL]
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
R' : Subring (R[X] ⧸ I) := RingHom.range (RingHom.comp (Quotient.mk I) C)
i : R →+* { x // x ∈ R' } := RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)
hi : Function.Surjective ↑i
hi' : RingHom.ker (mapRingHom i) ≤ I
R'_jacob : IsJacobson { x // x ∈ R' }
J : Ideal { x // x ∈ R' }[X] := map (mapRingHom i) I
h_surj : Function.Surjective ↑(mapRingHom i)
this : IsPrime J
h : jacobson I ⊔ comap (mapRingHom i) ⊥ = I ⊔ comap (mapRingHom i) ⊥
⊢ jacobson I ≤ I
[PROOFSTEP]
exact le_trans (le_sup_of_le_left le_rfl) (le_trans (le_of_eq h) (sup_le le_rfl hi'))
[GOAL]
case h
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
R' : Subring (R[X] ⧸ I) := RingHom.range (RingHom.comp (Quotient.mk I) C)
i : R →+* { x // x ∈ R' } := RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)
hi : Function.Surjective ↑i
hi' : RingHom.ker (mapRingHom i) ≤ I
R'_jacob : IsJacobson { x // x ∈ R' }
J : Ideal { x // x ∈ R' }[X] := map (mapRingHom i) I
h_surj : Function.Surjective ↑(mapRingHom i)
this : IsPrime J
⊢ jacobson J = J
[PROOFSTEP]
apply isJacobson_polynomial_of_domain R' J
[GOAL]
case h
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
R' : Subring (R[X] ⧸ I) := RingHom.range (RingHom.comp (Quotient.mk I) C)
i : R →+* { x // x ∈ R' } := RingHom.rangeRestrict (RingHom.comp (Quotient.mk I) C)
hi : Function.Surjective ↑i
hi' : RingHom.ker (mapRingHom i) ≤ I
R'_jacob : IsJacobson { x // x ∈ R' }
J : Ideal { x // x ∈ R' }[X] := map (mapRingHom i) I
h_surj : Function.Surjective ↑(mapRingHom i)
this : IsPrime J
⊢ ∀ (x : { x // x ∈ R' }), ↑C x ∈ J → x = 0
[PROOFSTEP]
exact (eq_zero_of_polynomial_mem_map_range I)
[GOAL]
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ₘ
⊢ IsJacobson R[X] ↔ IsJacobson R
[PROOFSTEP]
refine' ⟨_, isJacobson_polynomial_of_isJacobson⟩
[GOAL]
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ₘ
⊢ IsJacobson R[X] → IsJacobson R
[PROOFSTEP]
intro H
[GOAL]
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ₘ
H : IsJacobson R[X]
⊢ IsJacobson R
[PROOFSTEP]
exact
  isJacobson_of_surjective
    ⟨eval₂RingHom (RingHom.id _) 1, fun x => ⟨C x, by simp only [coe_eval₂RingHom, RingHom.id_apply, eval₂_C]⟩⟩
[GOAL]
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ₘ
H : IsJacobson R[X]
x : R
⊢ ↑(eval₂RingHom (RingHom.id R) 1) (↑C x) = x
[PROOFSTEP]
simp only [coe_eval₂RingHom, RingHom.id_apply, eval₂_C]
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
⊢ IsMaximal (comap C P)
[PROOFSTEP]
let P' := comap (C : R →+* R[X]) P
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
⊢ IsMaximal (comap C P)
[PROOFSTEP]
haveI hP'_prime : P'.IsPrime := comap_isPrime C P
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
⊢ IsMaximal (comap C P)
[PROOFSTEP]
obtain ⟨⟨m, hmem_P⟩, hm⟩ := Submodule.nonzero_mem_of_bot_lt (bot_lt_of_maximal P polynomial_not_isField)
[GOAL]
case intro.mk
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
⊢ IsMaximal (comap C P)
[PROOFSTEP]
have hm' : m ≠ 0 := by simpa [Submodule.coe_eq_zero] using hm
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
⊢ m ≠ 0
[PROOFSTEP]
simpa [Submodule.coe_eq_zero] using hm
[GOAL]
case intro.mk
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
⊢ IsMaximal (comap C P)
[PROOFSTEP]
let φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P (C : R →+* R[X]) le_rfl
[GOAL]
case intro.mk
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
⊢ IsMaximal (comap C P)
[PROOFSTEP]
let a : R ⧸ P' := (m.map (Quotient.mk P')).leadingCoeff
[GOAL]
case intro.mk
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
⊢ IsMaximal (comap C P)
[PROOFSTEP]
let M : Submonoid (R ⧸ P') := Submonoid.powers a
[GOAL]
case intro.mk
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
⊢ IsMaximal (comap C P)
[PROOFSTEP]
rw [← bot_quotient_isMaximal_iff]
[GOAL]
case intro.mk
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
⊢ IsMaximal ⊥
[PROOFSTEP]
have hp0 : a ≠ 0 := fun hp0' =>
  hm' <|
    map_injective (Quotient.mk (P.comap (C : R →+* R[X]) : Ideal R))
      ((injective_iff_map_eq_zero (Quotient.mk (P.comap (C : R →+* R[X]) : Ideal R))).2 fun x hx => by
        rwa [Quotient.eq_zero_iff_mem, (by rwa [eq_bot_iff] : (P.comap C : Ideal R) = ⊥)] at hx )
      (by simpa only [leadingCoeff_eq_zero, Polynomial.map_zero] using hp0')
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0' : a = 0
x : R
hx : ↑(Quotient.mk (comap C P)) x = 0
⊢ x = 0
[PROOFSTEP]
rwa [Quotient.eq_zero_iff_mem, (by rwa [eq_bot_iff] : (P.comap C : Ideal R) = ⊥)] at hx
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0' : a = 0
x : R
hx : x ∈ comap C P
⊢ comap C P = ⊥
[PROOFSTEP]
rwa [eq_bot_iff]
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0' : a = 0
⊢ Polynomial.map (Quotient.mk (comap C P)) m = Polynomial.map (Quotient.mk (comap C P)) 0
[PROOFSTEP]
simpa only [leadingCoeff_eq_zero, Polynomial.map_zero] using hp0'
[GOAL]
case intro.mk
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0 : a ≠ 0
⊢ IsMaximal ⊥
[PROOFSTEP]
have hM : (0 : R ⧸ P') ∉ M := fun ⟨n, hn⟩ => hp0 (pow_eq_zero hn)
[GOAL]
case intro.mk
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0 : a ≠ 0
hM : ¬0 ∈ M
⊢ IsMaximal ⊥
[PROOFSTEP]
suffices (⊥ : Ideal (Localization M)).IsMaximal
  by
  rw [←
    IsLocalization.comap_map_of_isPrime_disjoint M (Localization M) ⊥ bot_prime
      (disjoint_iff_inf_le.mpr fun x hx => hM (hx.2 ▸ hx.1))]
  refine' ((isMaximal_iff_isMaximal_disjoint (Localization M) _ _).mp (by rwa [map_bot])).1
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0 : a ≠ 0
hM : ¬0 ∈ M
this : IsMaximal ⊥
⊢ IsMaximal ⊥
[PROOFSTEP]
rw [←
  IsLocalization.comap_map_of_isPrime_disjoint M (Localization M) ⊥ bot_prime
    (disjoint_iff_inf_le.mpr fun x hx => hM (hx.2 ▸ hx.1))]
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0 : a ≠ 0
hM : ¬0 ∈ M
this : IsMaximal ⊥
⊢ IsMaximal (comap (algebraMap (R ⧸ P') (Localization M)) (map (algebraMap (R ⧸ P') (Localization M)) ⊥))
[PROOFSTEP]
refine' ((isMaximal_iff_isMaximal_disjoint (Localization M) _ _).mp (by rwa [map_bot])).1
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0 : a ≠ 0
hM : ¬0 ∈ M
this : IsMaximal ⊥
⊢ IsMaximal (map (algebraMap (R ⧸ P') (Localization M)) ⊥)
[PROOFSTEP]
rwa [map_bot]
[GOAL]
case intro.mk
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0 : a ≠ 0
hM : ¬0 ∈ M
⊢ IsMaximal ⊥
[PROOFSTEP]
let M' : Submonoid (R[X] ⧸ P) := M.map φ
[GOAL]
case intro.mk
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0 : a ≠ 0
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
⊢ IsMaximal ⊥
[PROOFSTEP]
have hM' : (0 : R[X] ⧸ P) ∉ M' := fun ⟨z, hz⟩ => hM (quotientMap_injective (_root_.trans hz.2 φ.map_zero.symm) ▸ hz.1)
[GOAL]
case intro.mk
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0 : a ≠ 0
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
hM' : ¬0 ∈ M'
⊢ IsMaximal ⊥
[PROOFSTEP]
haveI : IsDomain (Localization M') := IsLocalization.isDomain_localization (le_nonZeroDivisors_of_noZeroDivisors hM')
[GOAL]
case intro.mk
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0 : a ≠ 0
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
hM' : ¬0 ∈ M'
this : IsDomain (Localization M')
⊢ IsMaximal ⊥
[PROOFSTEP]
suffices (⊥ : Ideal (Localization M')).IsMaximal
  by
  rw [le_antisymm bot_le
      (comap_bot_le_of_injective _
        (IsLocalization.map_injective_of_injective M (Localization M) (Localization M') quotientMap_injective))]
  refine' isMaximal_comap_of_isIntegral_of_isMaximal' _ _ ⊥ this
  have isloc : IsLocalization (Submonoid.map φ M) (Localization M') := by infer_instance
  exact @isIntegral_isLocalization_polynomial_quotient R _ (Localization M) (Localization M') _ _ P m hmem_P _ _ _ isloc
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0 : a ≠ 0
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
hM' : ¬0 ∈ M'
this✝ : IsDomain (Localization M')
this : IsMaximal ⊥
⊢ IsMaximal ⊥
[PROOFSTEP]
rw [le_antisymm bot_le
    (comap_bot_le_of_injective _
      (IsLocalization.map_injective_of_injective M (Localization M) (Localization M') quotientMap_injective))]
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0 : a ≠ 0
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
hM' : ¬0 ∈ M'
this✝ : IsDomain (Localization M')
this : IsMaximal ⊥
⊢ IsMaximal
    (comap
      (IsLocalization.map (Localization M') (quotientMap P C (_ : comap C P ≤ comap C P))
        (_ :
          M ≤
            Submonoid.comap (quotientMap P C (_ : comap C P ≤ comap C P))
              (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P)) M)))
      ⊥)
[PROOFSTEP]
refine' isMaximal_comap_of_isIntegral_of_isMaximal' _ _ ⊥ this
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0 : a ≠ 0
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
hM' : ¬0 ∈ M'
this✝ : IsDomain (Localization M')
this : IsMaximal ⊥
⊢ RingHom.IsIntegral
    (IsLocalization.map (Localization M') (quotientMap P C (_ : comap C P ≤ comap C P))
      (_ :
        M ≤
          Submonoid.comap (quotientMap P C (_ : comap C P ≤ comap C P))
            (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P)) M)))
[PROOFSTEP]
have isloc : IsLocalization (Submonoid.map φ M) (Localization M') := by infer_instance
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0 : a ≠ 0
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
hM' : ¬0 ∈ M'
this✝ : IsDomain (Localization M')
this : IsMaximal ⊥
⊢ IsLocalization (Submonoid.map φ M) (Localization M')
[PROOFSTEP]
infer_instance
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0 : a ≠ 0
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
hM' : ¬0 ∈ M'
this✝ : IsDomain (Localization M')
this : IsMaximal ⊥
isloc : IsLocalization (Submonoid.map φ M) (Localization M')
⊢ RingHom.IsIntegral
    (IsLocalization.map (Localization M') (quotientMap P C (_ : comap C P ≤ comap C P))
      (_ :
        M ≤
          Submonoid.comap (quotientMap P C (_ : comap C P ≤ comap C P))
            (Submonoid.map (quotientMap P C (_ : comap C P ≤ comap C P)) M)))
[PROOFSTEP]
exact @isIntegral_isLocalization_polynomial_quotient R _ (Localization M) (Localization M') _ _ P m hmem_P _ _ _ isloc
[GOAL]
case intro.mk
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0 : a ≠ 0
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
hM' : ¬0 ∈ M'
this : IsDomain (Localization M')
⊢ IsMaximal ⊥
[PROOFSTEP]
rw [(map_bot.symm : (⊥ : Ideal (Localization M')) = map (algebraMap (R[X] ⧸ P) (Localization M')) ⊥)]
[GOAL]
case intro.mk
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0 : a ≠ 0
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
hM' : ¬0 ∈ M'
this : IsDomain (Localization M')
⊢ IsMaximal (map (algebraMap (R[X] ⧸ P) (Localization M')) ⊥)
[PROOFSTEP]
let bot_maximal := (bot_quotient_isMaximal_iff _).mpr hP
[GOAL]
case intro.mk
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0 : a ≠ 0
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
hM' : ¬0 ∈ M'
this : IsDomain (Localization M')
bot_maximal : IsMaximal ⊥ := Iff.mpr (bot_quotient_isMaximal_iff P) hP
⊢ IsMaximal (map (algebraMap (R[X] ⧸ P) (Localization M')) ⊥)
[PROOFSTEP]
refine' map.isMaximal (algebraMap (R[X] ⧸ P) (Localization M')) _ bot_maximal
[GOAL]
case intro.mk
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0 : a ≠ 0
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
hM' : ¬0 ∈ M'
this : IsDomain (Localization M')
bot_maximal : IsMaximal ⊥ := Iff.mpr (bot_quotient_isMaximal_iff P) hP
⊢ Function.Bijective ↑(algebraMap (R[X] ⧸ P) (Localization M'))
[PROOFSTEP]
apply IsField.localization_map_bijective hM'
[GOAL]
case intro.mk.hR
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
hP'_prime : IsPrime P'
m : R[X]
hmem_P : m ∈ P
hm : { val := m, property := hmem_P } ≠ 0
hm' : m ≠ 0
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') m)
M : Submonoid (R ⧸ P') := Submonoid.powers a
hp0 : a ≠ 0
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
hM' : ¬0 ∈ M'
this : IsDomain (Localization M')
bot_maximal : IsMaximal ⊥ := Iff.mpr (bot_quotient_isMaximal_iff P) hP
⊢ IsField (R[X] ⧸ P)
[PROOFSTEP]
rwa [← Quotient.maximal_ideal_iff_isField_quotient, ← bot_quotient_isMaximal_iff]
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
⊢ RingHom.IsIntegral (RingHom.comp (Quotient.mk P) C)
[PROOFSTEP]
refine' (isIntegral_quotientMap_iff _).mp _
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
⊢ RingHom.IsIntegral (quotientMap P C (_ : comap C P ≤ comap C P))
[PROOFSTEP]
let P' : Ideal R := P.comap C
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
⊢ RingHom.IsIntegral (quotientMap P C (_ : comap C P ≤ comap C P))
[PROOFSTEP]
obtain ⟨pX, hpX, hp0⟩ := exists_nonzero_mem_of_ne_bot (ne_of_lt (bot_lt_of_maximal P polynomial_not_isField)).symm hP'
[GOAL]
case intro.intro
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
pX : R[X]
hpX : pX ∈ P
hp0 : Polynomial.map (Quotient.mk (comap C P)) pX ≠ 0
⊢ RingHom.IsIntegral (quotientMap P C (_ : comap C P ≤ comap C P))
[PROOFSTEP]
let a : R ⧸ P' := (pX.map (Quotient.mk P')).leadingCoeff
[GOAL]
case intro.intro
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
pX : R[X]
hpX : pX ∈ P
hp0 : Polynomial.map (Quotient.mk (comap C P)) pX ≠ 0
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') pX)
⊢ RingHom.IsIntegral (quotientMap P C (_ : comap C P ≤ comap C P))
[PROOFSTEP]
let M : Submonoid (R ⧸ P') := Submonoid.powers a
[GOAL]
case intro.intro
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
pX : R[X]
hpX : pX ∈ P
hp0 : Polynomial.map (Quotient.mk (comap C P)) pX ≠ 0
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') pX)
M : Submonoid (R ⧸ P') := Submonoid.powers a
⊢ RingHom.IsIntegral (quotientMap P C (_ : comap C P ≤ comap C P))
[PROOFSTEP]
let φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C le_rfl
[GOAL]
case intro.intro
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
pX : R[X]
hpX : pX ∈ P
hp0 : Polynomial.map (Quotient.mk (comap C P)) pX ≠ 0
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') pX)
M : Submonoid (R ⧸ P') := Submonoid.powers a
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
⊢ RingHom.IsIntegral (quotientMap P C (_ : comap C P ≤ comap C P))
[PROOFSTEP]
haveI hP'_prime : P'.IsPrime := comap_isPrime C P
[GOAL]
case intro.intro
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
pX : R[X]
hpX : pX ∈ P
hp0 : Polynomial.map (Quotient.mk (comap C P)) pX ≠ 0
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') pX)
M : Submonoid (R ⧸ P') := Submonoid.powers a
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
hP'_prime : IsPrime P'
⊢ RingHom.IsIntegral (quotientMap P C (_ : comap C P ≤ comap C P))
[PROOFSTEP]
have hM : (0 : R ⧸ P') ∉ M := fun ⟨n, hn⟩ => hp0 <| leadingCoeff_eq_zero.mp (pow_eq_zero hn)
[GOAL]
case intro.intro
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
pX : R[X]
hpX : pX ∈ P
hp0 : Polynomial.map (Quotient.mk (comap C P)) pX ≠ 0
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') pX)
M : Submonoid (R ⧸ P') := Submonoid.powers a
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
hP'_prime : IsPrime P'
hM : ¬0 ∈ M
⊢ RingHom.IsIntegral (quotientMap P C (_ : comap C P ≤ comap C P))
[PROOFSTEP]
let M' : Submonoid (R[X] ⧸ P) := M.map φ
[GOAL]
case intro.intro
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
pX : R[X]
hpX : pX ∈ P
hp0 : Polynomial.map (Quotient.mk (comap C P)) pX ≠ 0
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') pX)
M : Submonoid (R ⧸ P') := Submonoid.powers a
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
hP'_prime : IsPrime P'
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
⊢ RingHom.IsIntegral (quotientMap P C (_ : comap C P ≤ comap C P))
[PROOFSTEP]
refine' φ.isIntegral_tower_bot_of_isIntegral (algebraMap _ (Localization M')) _ _
[GOAL]
case intro.intro.refine'_1
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
pX : R[X]
hpX : pX ∈ P
hp0 : Polynomial.map (Quotient.mk (comap C P)) pX ≠ 0
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') pX)
M : Submonoid (R ⧸ P') := Submonoid.powers a
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
hP'_prime : IsPrime P'
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
⊢ Function.Injective ↑(algebraMap (R[X] ⧸ P) (Localization M'))
[PROOFSTEP]
refine'
  IsLocalization.injective (Localization M') (show M' ≤ _ from le_nonZeroDivisors_of_noZeroDivisors fun hM' => hM _)
[GOAL]
case intro.intro.refine'_1
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
pX : R[X]
hpX : pX ∈ P
hp0 : Polynomial.map (Quotient.mk (comap C P)) pX ≠ 0
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') pX)
M : Submonoid (R ⧸ P') := Submonoid.powers a
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
hP'_prime : IsPrime P'
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
hM' : 0 ∈ M'
⊢ 0 ∈ M
[PROOFSTEP]
exact
  let ⟨z, zM, z0⟩ := hM'
  quotientMap_injective (_root_.trans z0 φ.map_zero.symm) ▸ zM
[GOAL]
case intro.intro.refine'_2
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
pX : R[X]
hpX : pX ∈ P
hp0 : Polynomial.map (Quotient.mk (comap C P)) pX ≠ 0
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') pX)
M : Submonoid (R ⧸ P') := Submonoid.powers a
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
hP'_prime : IsPrime P'
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
⊢ RingHom.IsIntegral (RingHom.comp (algebraMap (R[X] ⧸ P) (Localization M')) φ)
[PROOFSTEP]
suffices :
  RingHom.comp (algebraMap (R[X] ⧸ P) (Localization M')) φ =
    (IsLocalization.map (Localization M') φ M.le_comap_map).comp (algebraMap (R ⧸ P') (Localization M))
[GOAL]
case intro.intro.refine'_2
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
pX : R[X]
hpX : pX ∈ P
hp0 : Polynomial.map (Quotient.mk (comap C P)) pX ≠ 0
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') pX)
M : Submonoid (R ⧸ P') := Submonoid.powers a
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
hP'_prime : IsPrime P'
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
this :
  RingHom.comp (algebraMap (R[X] ⧸ P) (Localization M')) φ =
    RingHom.comp (IsLocalization.map (Localization M') φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M)))
      (algebraMap (R ⧸ P') (Localization M))
⊢ RingHom.IsIntegral (RingHom.comp (algebraMap (R[X] ⧸ P) (Localization M')) φ)
case this
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
pX : R[X]
hpX : pX ∈ P
hp0 : Polynomial.map (Quotient.mk (comap C P)) pX ≠ 0
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') pX)
M : Submonoid (R ⧸ P') := Submonoid.powers a
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
hP'_prime : IsPrime P'
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
⊢ RingHom.comp (algebraMap (R[X] ⧸ P) (Localization M')) φ =
    RingHom.comp (IsLocalization.map (Localization M') φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M)))
      (algebraMap (R ⧸ P') (Localization M))
[PROOFSTEP]
rw [this]
[GOAL]
case intro.intro.refine'_2
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
pX : R[X]
hpX : pX ∈ P
hp0 : Polynomial.map (Quotient.mk (comap C P)) pX ≠ 0
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') pX)
M : Submonoid (R ⧸ P') := Submonoid.powers a
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
hP'_prime : IsPrime P'
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
this :
  RingHom.comp (algebraMap (R[X] ⧸ P) (Localization M')) φ =
    RingHom.comp (IsLocalization.map (Localization M') φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M)))
      (algebraMap (R ⧸ P') (Localization M))
⊢ RingHom.IsIntegral
    (RingHom.comp (IsLocalization.map (Localization M') φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M)))
      (algebraMap (R ⧸ P') (Localization M)))
case this
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
pX : R[X]
hpX : pX ∈ P
hp0 : Polynomial.map (Quotient.mk (comap C P)) pX ≠ 0
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') pX)
M : Submonoid (R ⧸ P') := Submonoid.powers a
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
hP'_prime : IsPrime P'
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
⊢ RingHom.comp (algebraMap (R[X] ⧸ P) (Localization M')) φ =
    RingHom.comp (IsLocalization.map (Localization M') φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M)))
      (algebraMap (R ⧸ P') (Localization M))
[PROOFSTEP]
refine'
  RingHom.isIntegral_trans (algebraMap (R ⧸ P') (Localization M))
    (IsLocalization.map (Localization M') φ M.le_comap_map) _ _
[GOAL]
case intro.intro.refine'_2.refine'_1
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
pX : R[X]
hpX : pX ∈ P
hp0 : Polynomial.map (Quotient.mk (comap C P)) pX ≠ 0
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') pX)
M : Submonoid (R ⧸ P') := Submonoid.powers a
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
hP'_prime : IsPrime P'
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
this :
  RingHom.comp (algebraMap (R[X] ⧸ P) (Localization M')) φ =
    RingHom.comp (IsLocalization.map (Localization M') φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M)))
      (algebraMap (R ⧸ P') (Localization M))
⊢ RingHom.IsIntegral (algebraMap (R ⧸ P') (Localization M))
[PROOFSTEP]
exact
  (algebraMap (R ⧸ P') (Localization M)).isIntegral_of_surjective
    (IsField.localization_map_bijective hM
        ((Quotient.maximal_ideal_iff_isField_quotient _).mp (isMaximal_comap_C_of_isMaximal P hP'))).2
[GOAL]
case intro.intro.refine'_2.refine'_2
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
pX : R[X]
hpX : pX ∈ P
hp0 : Polynomial.map (Quotient.mk (comap C P)) pX ≠ 0
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') pX)
M : Submonoid (R ⧸ P') := Submonoid.powers a
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
hP'_prime : IsPrime P'
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
this :
  RingHom.comp (algebraMap (R[X] ⧸ P) (Localization M')) φ =
    RingHom.comp (IsLocalization.map (Localization M') φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M)))
      (algebraMap (R ⧸ P') (Localization M))
⊢ RingHom.IsIntegral (IsLocalization.map (Localization M') φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M)))
[PROOFSTEP]
have isloc : IsLocalization M' (Localization M') := by infer_instance
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
pX : R[X]
hpX : pX ∈ P
hp0 : Polynomial.map (Quotient.mk (comap C P)) pX ≠ 0
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') pX)
M : Submonoid (R ⧸ P') := Submonoid.powers a
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
hP'_prime : IsPrime P'
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
this :
  RingHom.comp (algebraMap (R[X] ⧸ P) (Localization M')) φ =
    RingHom.comp (IsLocalization.map (Localization M') φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M)))
      (algebraMap (R ⧸ P') (Localization M))
⊢ IsLocalization M' (Localization M')
[PROOFSTEP]
infer_instance
[GOAL]
case intro.intro.refine'_2.refine'_2
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
pX : R[X]
hpX : pX ∈ P
hp0 : Polynomial.map (Quotient.mk (comap C P)) pX ≠ 0
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') pX)
M : Submonoid (R ⧸ P') := Submonoid.powers a
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
hP'_prime : IsPrime P'
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
this :
  RingHom.comp (algebraMap (R[X] ⧸ P) (Localization M')) φ =
    RingHom.comp (IsLocalization.map (Localization M') φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M)))
      (algebraMap (R ⧸ P') (Localization M))
isloc : IsLocalization M' (Localization M')
⊢ RingHom.IsIntegral (IsLocalization.map (Localization M') φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M)))
[PROOFSTEP]
exact @isIntegral_isLocalization_polynomial_quotient R _ (Localization M) (Localization M') _ _ P pX hpX _ _ _ isloc
[GOAL]
case this
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
inst✝ : Nontrivial R
hR : IsJacobson R
hP' : ∀ (x : R), ↑C x ∈ P → x = 0
P' : Ideal R := comap C P
pX : R[X]
hpX : pX ∈ P
hp0 : Polynomial.map (Quotient.mk (comap C P)) pX ≠ 0
a : R ⧸ P' := Polynomial.leadingCoeff (Polynomial.map (Quotient.mk P') pX)
M : Submonoid (R ⧸ P') := Submonoid.powers a
φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C (_ : P' ≤ P')
hP'_prime : IsPrime P'
hM : ¬0 ∈ M
M' : Submonoid (R[X] ⧸ P) := Submonoid.map φ M
⊢ RingHom.comp (algebraMap (R[X] ⧸ P) (Localization M')) φ =
    RingHom.comp (IsLocalization.map (Localization M') φ (_ : M ≤ Submonoid.comap φ (Submonoid.map φ M)))
      (algebraMap (R ⧸ P') (Localization M))
[PROOFSTEP]
rw [IsLocalization.map_comp M.le_comap_map]
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
⊢ RingHom.IsIntegral (RingHom.comp (Quotient.mk P) C)
[PROOFSTEP]
let P' : Ideal R := P.comap C
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
P' : Ideal R := comap C P
⊢ RingHom.IsIntegral (RingHom.comp (Quotient.mk P) C)
[PROOFSTEP]
haveI : P'.IsPrime := comap_isPrime C P
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
P' : Ideal R := comap C P
this : IsPrime P'
⊢ RingHom.IsIntegral (RingHom.comp (Quotient.mk P) C)
[PROOFSTEP]
let f : R[X] →+* Polynomial (R ⧸ P') := Polynomial.mapRingHom (Quotient.mk P')
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
P' : Ideal R := comap C P
this : IsPrime P'
f : R[X] →+* (R ⧸ P')[X] := mapRingHom (Quotient.mk P')
⊢ RingHom.IsIntegral (RingHom.comp (Quotient.mk P) C)
[PROOFSTEP]
have hf : Function.Surjective ↑f := map_surjective (Quotient.mk P') Quotient.mk_surjective
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
P' : Ideal R := comap C P
this : IsPrime P'
f : R[X] →+* (R ⧸ P')[X] := mapRingHom (Quotient.mk P')
hf : Function.Surjective ↑f
⊢ RingHom.IsIntegral (RingHom.comp (Quotient.mk P) C)
[PROOFSTEP]
have hPJ : P = (P.map f).comap f := by
  rw [comap_map_of_surjective _ hf]
  refine' le_antisymm (le_sup_of_le_left le_rfl) (sup_le le_rfl _)
  refine' fun p hp => polynomial_mem_ideal_of_coeff_mem_ideal P p fun n => Quotient.eq_zero_iff_mem.mp _
  simpa only [coeff_map, coe_mapRingHom] using (Polynomial.ext_iff.mp hp) n
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
P' : Ideal R := comap C P
this : IsPrime P'
f : R[X] →+* (R ⧸ P')[X] := mapRingHom (Quotient.mk P')
hf : Function.Surjective ↑f
⊢ P = comap f (map f P)
[PROOFSTEP]
rw [comap_map_of_surjective _ hf]
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
P' : Ideal R := comap C P
this : IsPrime P'
f : R[X] →+* (R ⧸ P')[X] := mapRingHom (Quotient.mk P')
hf : Function.Surjective ↑f
⊢ P = P ⊔ comap f ⊥
[PROOFSTEP]
refine' le_antisymm (le_sup_of_le_left le_rfl) (sup_le le_rfl _)
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
P' : Ideal R := comap C P
this : IsPrime P'
f : R[X] →+* (R ⧸ P')[X] := mapRingHom (Quotient.mk P')
hf : Function.Surjective ↑f
⊢ comap f ⊥ ≤ P
[PROOFSTEP]
refine' fun p hp => polynomial_mem_ideal_of_coeff_mem_ideal P p fun n => Quotient.eq_zero_iff_mem.mp _
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
P' : Ideal R := comap C P
this : IsPrime P'
f : R[X] →+* (R ⧸ P')[X] := mapRingHom (Quotient.mk P')
hf : Function.Surjective ↑f
p : R[X]
hp : p ∈ comap f ⊥
n : ℕ
⊢ ↑(Quotient.mk (comap C P)) (coeff p n) = 0
[PROOFSTEP]
simpa only [coeff_map, coe_mapRingHom] using (Polynomial.ext_iff.mp hp) n
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
P' : Ideal R := comap C P
this : IsPrime P'
f : R[X] →+* (R ⧸ P')[X] := mapRingHom (Quotient.mk P')
hf : Function.Surjective ↑f
hPJ : P = comap f (map f P)
⊢ RingHom.IsIntegral (RingHom.comp (Quotient.mk P) C)
[PROOFSTEP]
refine' RingHom.isIntegral_tower_bot_of_isIntegral _ _ (injective_quotient_le_comap_map P) _
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
P' : Ideal R := comap C P
this : IsPrime P'
f : R[X] →+* (R ⧸ P')[X] := mapRingHom (Quotient.mk P')
hf : Function.Surjective ↑f
hPJ : P = comap f (map f P)
⊢ RingHom.IsIntegral
    (RingHom.comp
      (quotientMap (map (mapRingHom (Quotient.mk (comap C P))) P) (mapRingHom (Quotient.mk (comap C P)))
        (_ : P ≤ comap (mapRingHom (Quotient.mk (comap C P))) (map (mapRingHom (Quotient.mk (comap C P))) P)))
      (RingHom.comp (Quotient.mk P) C))
[PROOFSTEP]
rw [← quotient_mk_maps_eq]
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
P' : Ideal R := comap C P
this : IsPrime P'
f : R[X] →+* (R ⧸ P')[X] := mapRingHom (Quotient.mk P')
hf : Function.Surjective ↑f
hPJ : P = comap f (map f P)
⊢ RingHom.IsIntegral
    (RingHom.comp (RingHom.comp (Quotient.mk (map (mapRingHom (Quotient.mk (comap C P))) P)) C)
      (Quotient.mk (comap C P)))
[PROOFSTEP]
refine RingHom.isIntegral_trans _ _ ((Quotient.mk P').isIntegral_of_surjective Quotient.mk_surjective) ?_
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
P' : Ideal R := comap C P
this : IsPrime P'
f : R[X] →+* (R ⧸ P')[X] := mapRingHom (Quotient.mk P')
hf : Function.Surjective ↑f
hPJ : P = comap f (map f P)
⊢ RingHom.IsIntegral (RingHom.comp (Quotient.mk (map (mapRingHom (Quotient.mk (comap C P))) P)) C)
[PROOFSTEP]
have : IsMaximal (map (mapRingHom (Quotient.mk (comap C P))) P)
[GOAL]
case this
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
P' : Ideal R := comap C P
this : IsPrime P'
f : R[X] →+* (R ⧸ P')[X] := mapRingHom (Quotient.mk P')
hf : Function.Surjective ↑f
hPJ : P = comap f (map f P)
⊢ IsMaximal (map (mapRingHom (Quotient.mk (comap C P))) P)
[PROOFSTEP]
exact
  Or.recOn (map_eq_top_or_isMaximal_of_surjective f hf hP)
    (fun h => absurd (_root_.trans (h ▸ hPJ : P = comap f ⊤) comap_top : P = ⊤) hP.ne_top) id
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
P' : Ideal R := comap C P
this✝ : IsPrime P'
f : R[X] →+* (R ⧸ P')[X] := mapRingHom (Quotient.mk P')
hf : Function.Surjective ↑f
hPJ : P = comap f (map f P)
this : IsMaximal (map (mapRingHom (Quotient.mk (comap C P))) P)
⊢ RingHom.IsIntegral (RingHom.comp (Quotient.mk (map (mapRingHom (Quotient.mk (comap C P))) P)) C)
[PROOFSTEP]
apply quotient_mk_comp_C_isIntegral_of_jacobson' _ ?_ (fun x hx => ?_)
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
P' : Ideal R := comap C P
this✝ : IsPrime P'
f : R[X] →+* (R ⧸ P')[X] := mapRingHom (Quotient.mk P')
hf : Function.Surjective ↑f
hPJ : P = comap f (map f P)
this : IsMaximal (map (mapRingHom (Quotient.mk (comap C P))) P)
⊢ IsJacobson (R ⧸ comap C P)
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
P' : Ideal R := comap C P
this✝ : IsPrime P'
f : R[X] →+* (R ⧸ P')[X] := mapRingHom (Quotient.mk P')
hf : Function.Surjective ↑f
hPJ : P = comap f (map f P)
this : IsMaximal (map (mapRingHom (Quotient.mk (comap C P))) P)
x : R ⧸ comap C P
hx : ↑C x ∈ map (mapRingHom (Quotient.mk (comap C P))) P
⊢ x = 0
[PROOFSTEP]
any_goals exact Ideal.isJacobson_quotient
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
P' : Ideal R := comap C P
this✝ : IsPrime P'
f : R[X] →+* (R ⧸ P')[X] := mapRingHom (Quotient.mk P')
hf : Function.Surjective ↑f
hPJ : P = comap f (map f P)
this : IsMaximal (map (mapRingHom (Quotient.mk (comap C P))) P)
⊢ IsJacobson (R ⧸ comap C P)
[PROOFSTEP]
exact Ideal.isJacobson_quotient
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
P' : Ideal R := comap C P
this✝ : IsPrime P'
f : R[X] →+* (R ⧸ P')[X] := mapRingHom (Quotient.mk P')
hf : Function.Surjective ↑f
hPJ : P = comap f (map f P)
this : IsMaximal (map (mapRingHom (Quotient.mk (comap C P))) P)
x : R ⧸ comap C P
hx : ↑C x ∈ map (mapRingHom (Quotient.mk (comap C P))) P
⊢ x = 0
[PROOFSTEP]
exact Ideal.isJacobson_quotient
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
P' : Ideal R := comap C P
this✝ : IsPrime P'
f : R[X] →+* (R ⧸ P')[X] := mapRingHom (Quotient.mk P')
hf : Function.Surjective ↑f
hPJ : P = comap f (map f P)
this : IsMaximal (map (mapRingHom (Quotient.mk (comap C P))) P)
x : R ⧸ comap C P
hx : ↑C x ∈ map (mapRingHom (Quotient.mk (comap C P))) P
⊢ x = 0
[PROOFSTEP]
obtain ⟨z, rfl⟩ := Quotient.mk_surjective x
[GOAL]
case intro
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
P' : Ideal R := comap C P
this✝ : IsPrime P'
f : R[X] →+* (R ⧸ P')[X] := mapRingHom (Quotient.mk P')
hf : Function.Surjective ↑f
hPJ : P = comap f (map f P)
this : IsMaximal (map (mapRingHom (Quotient.mk (comap C P))) P)
z : R
hx : ↑C (↑(Quotient.mk (comap C P)) z) ∈ map (mapRingHom (Quotient.mk (comap C P))) P
⊢ ↑(Quotient.mk (comap C P)) z = 0
[PROOFSTEP]
rwa [Quotient.eq_zero_iff_mem, mem_comap, hPJ, mem_comap, coe_mapRingHom, map_C]
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
⊢ IsMaximal (comap C P)
[PROOFSTEP]
rw [← @mk_ker _ _ P, RingHom.ker_eq_comap_bot, comap_comap]
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
⊢ IsMaximal (comap (RingHom.comp (Quotient.mk P) C) ⊥)
[PROOFSTEP]
exact
  isMaximal_comap_of_isIntegral_of_isMaximal' _ (quotient_mk_comp_C_isIntegral_of_jacobson P) ⊥
    ((bot_quotient_isMaximal_iff _).mpr hP)
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P✝ : Ideal R[X]
hP✝ : IsMaximal P✝
P : Ideal R[X]
hP : IsMaximal P
⊢ IsMaximal (comap C P)
[PROOFSTEP]
haveI := hP
[GOAL]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P✝ : Ideal R[X]
hP✝ : IsMaximal P✝
P : Ideal R[X]
hP this : IsMaximal P
⊢ IsMaximal (comap C P)
[PROOFSTEP]
exact isMaximal_comap_C_of_isJacobson P
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
S : Type u_2
inst✝ : Field S
f : R[X] →+* S
hf : Function.Surjective ↑f
⊢ RingHom.IsIntegral (RingHom.comp f C)
[PROOFSTEP]
haveI : f.ker.IsMaximal := RingHom.ker_isMaximal_of_surjective f hf
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
S : Type u_2
inst✝ : Field S
f : R[X] →+* S
hf : Function.Surjective ↑f
this : IsMaximal (RingHom.ker f)
⊢ RingHom.IsIntegral (RingHom.comp f C)
[PROOFSTEP]
let g : R[X] ⧸ (RingHom.ker f) →+* S := Ideal.Quotient.lift (RingHom.ker f) f fun _ h => h
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
S : Type u_2
inst✝ : Field S
f : R[X] →+* S
hf : Function.Surjective ↑f
this : IsMaximal (RingHom.ker f)
g : R[X] ⧸ RingHom.ker f →+* S :=
  Quotient.lift (RingHom.ker f) f (_ : ∀ (x : R[X]), x ∈ RingHom.ker f → x ∈ RingHom.ker f)
⊢ RingHom.IsIntegral (RingHom.comp f C)
[PROOFSTEP]
have hfg : g.comp (Quotient.mk (RingHom.ker f)) = f := ringHom_ext' rfl rfl
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
S : Type u_2
inst✝ : Field S
f : R[X] →+* S
hf : Function.Surjective ↑f
this : IsMaximal (RingHom.ker f)
g : R[X] ⧸ RingHom.ker f →+* S :=
  Quotient.lift (RingHom.ker f) f (_ : ∀ (x : R[X]), x ∈ RingHom.ker f → x ∈ RingHom.ker f)
hfg : RingHom.comp g (Quotient.mk (RingHom.ker f)) = f
⊢ RingHom.IsIntegral (RingHom.comp f C)
[PROOFSTEP]
rw [← hfg, RingHom.comp_assoc]
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
S : Type u_2
inst✝ : Field S
f : R[X] →+* S
hf : Function.Surjective ↑f
this : IsMaximal (RingHom.ker f)
g : R[X] ⧸ RingHom.ker f →+* S :=
  Quotient.lift (RingHom.ker f) f (_ : ∀ (x : R[X]), x ∈ RingHom.ker f → x ∈ RingHom.ker f)
hfg : RingHom.comp g (Quotient.mk (RingHom.ker f)) = f
⊢ RingHom.IsIntegral (RingHom.comp g (RingHom.comp (Quotient.mk (RingHom.ker f)) C))
[PROOFSTEP]
refine
  RingHom.isIntegral_trans _ g (quotient_mk_comp_C_isIntegral_of_jacobson (RingHom.ker f))
    (g.isIntegral_of_surjective ?_)
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
S : Type u_2
inst✝ : Field S
f : R[X] →+* S
hf : Function.Surjective ↑f
this : IsMaximal (RingHom.ker f)
g : R[X] ⧸ RingHom.ker f →+* S :=
  Quotient.lift (RingHom.ker f) f (_ : ∀ (x : R[X]), x ∈ RingHom.ker f → x ∈ RingHom.ker f)
hfg : RingHom.comp g (Quotient.mk (RingHom.ker f)) = f
⊢ Function.Surjective ↑g
[PROOFSTEP]
rw [← hfg] at hf
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
S : Type u_2
inst✝ : Field S
f : R[X] →+* S
this : IsMaximal (RingHom.ker f)
g : R[X] ⧸ RingHom.ker f →+* S :=
  Quotient.lift (RingHom.ker f) f (_ : ∀ (x : R[X]), x ∈ RingHom.ker f → x ∈ RingHom.ker f)
hf : Function.Surjective ↑(RingHom.comp g (Quotient.mk (RingHom.ker f)))
hfg : RingHom.comp g (Quotient.mk (RingHom.ker f)) = f
⊢ Function.Surjective ↑g
[PROOFSTEP]
norm_num at hf
[GOAL]
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsJacobson R
P : Ideal R[X]
hP : IsMaximal P
S : Type u_2
inst✝ : Field S
f : R[X] →+* S
this : IsMaximal (RingHom.ker f)
g : R[X] ⧸ RingHom.ker f →+* S :=
  Quotient.lift (RingHom.ker f) f (_ : ∀ (x : R[X]), x ∈ RingHom.ker f → x ∈ RingHom.ker f)
hf :
  Function.Surjective
    (↑(Quotient.lift (RingHom.ker f) f (_ : ∀ (x : R[X]), x ∈ RingHom.ker f → x ∈ RingHom.ker f)) ∘
      ↑(Quotient.mk (RingHom.ker f)))
hfg : RingHom.comp g (Quotient.mk (RingHom.ker f)) = f
⊢ Function.Surjective ↑g
[PROOFSTEP]
exact Function.Surjective.of_comp hf
[GOAL]
R : Type u_1
inst✝² : CommRing R
ι : Type u_2
inst✝¹ : _root_.Finite ι
inst✝ : IsJacobson R
⊢ IsJacobson (MvPolynomial ι R)
[PROOFSTEP]
cases nonempty_fintype ι
[GOAL]
case intro
R : Type u_1
inst✝² : CommRing R
ι : Type u_2
inst✝¹ : _root_.Finite ι
inst✝ : IsJacobson R
val✝ : Fintype ι
⊢ IsJacobson (MvPolynomial ι R)
[PROOFSTEP]
haveI := Classical.decEq ι
[GOAL]
case intro
R : Type u_1
inst✝² : CommRing R
ι : Type u_2
inst✝¹ : _root_.Finite ι
inst✝ : IsJacobson R
val✝ : Fintype ι
this : DecidableEq ι
⊢ IsJacobson (MvPolynomial ι R)
[PROOFSTEP]
let e := Fintype.equivFin ι
[GOAL]
case intro
R : Type u_1
inst✝² : CommRing R
ι : Type u_2
inst✝¹ : _root_.Finite ι
inst✝ : IsJacobson R
val✝ : Fintype ι
this : DecidableEq ι
e : ι ≃ Fin (Fintype.card ι) := Fintype.equivFin ι
⊢ IsJacobson (MvPolynomial ι R)
[PROOFSTEP]
rw [isJacobson_iso (renameEquiv R e).toRingEquiv]
[GOAL]
case intro
R : Type u_1
inst✝² : CommRing R
ι : Type u_2
inst✝¹ : _root_.Finite ι
inst✝ : IsJacobson R
val✝ : Fintype ι
this : DecidableEq ι
e : ι ≃ Fin (Fintype.card ι) := Fintype.equivFin ι
⊢ IsJacobson (MvPolynomial (Fin (Fintype.card ι)) R)
[PROOFSTEP]
exact isJacobson_MvPolynomial_fin _
[GOAL]
n : ℕ
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
src✝ : S →+* S[X] := Polynomial.C
r : R
⊢ OneHom.toFun
      (↑↑{ toMonoidHom := ↑src✝, map_zero' := (_ : OneHom.toFun (↑↑src✝) 0 = 0),
            map_add' :=
              (_ : ∀ (x y : S), OneHom.toFun (↑↑src✝) (x + y) = OneHom.toFun (↑↑src✝) x + OneHom.toFun (↑↑src✝) y) })
      (↑(algebraMap R S) r) =
    ↑(algebraMap R S[X]) r
[PROOFSTEP]
rfl
[GOAL]
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
⊢ RingHom.IsIntegral (algebraMap R (T ⧸ P))
[PROOFSTEP]
let Q := P.comap v.toAlgHom.toRingHom
[GOAL]
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
⊢ RingHom.IsIntegral (algebraMap R (T ⧸ P))
[PROOFSTEP]
have hw : Ideal.map v Q = P := map_comap_of_surjective v v.surjective P
[GOAL]
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
hw : map v Q = P
⊢ RingHom.IsIntegral (algebraMap R (T ⧸ P))
[PROOFSTEP]
haveI hQ : IsMaximal Q := comap_isMaximal_of_surjective _ v.surjective
[GOAL]
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
hw : map v Q = P
hQ : IsMaximal Q
⊢ RingHom.IsIntegral (algebraMap R (T ⧸ P))
[PROOFSTEP]
let w : (S[X] ⧸ Q) ≃ₐ[R] (T ⧸ P) := Ideal.quotientEquivAlg Q P v hw.symm
[GOAL]
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
hw : map v Q = P
hQ : IsMaximal Q
w : (S[X] ⧸ Q) ≃ₐ[R] T ⧸ P := quotientEquivAlg Q P v (_ : P = map v Q)
⊢ RingHom.IsIntegral (algebraMap R (T ⧸ P))
[PROOFSTEP]
let Q' := Q.comap (Polynomial.C)
[GOAL]
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
hw : map v Q = P
hQ : IsMaximal Q
w : (S[X] ⧸ Q) ≃ₐ[R] T ⧸ P := quotientEquivAlg Q P v (_ : P = map v Q)
Q' : Ideal S := comap Polynomial.C Q
⊢ RingHom.IsIntegral (algebraMap R (T ⧸ P))
[PROOFSTEP]
let w' : (S ⧸ Q') →ₐ[R] (S[X] ⧸ Q) := Ideal.quotientMapₐ Q (Cₐ R S) le_rfl
[GOAL]
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
hw : map v Q = P
hQ : IsMaximal Q
w : (S[X] ⧸ Q) ≃ₐ[R] T ⧸ P := quotientEquivAlg Q P v (_ : P = map v Q)
Q' : Ideal S := comap Polynomial.C Q
w' : S ⧸ Q' →ₐ[R] S[X] ⧸ Q := quotientMapₐ Q (Ideal.MvPolynomial.Cₐ R S) (_ : Q' ≤ Q')
⊢ RingHom.IsIntegral (algebraMap R (T ⧸ P))
[PROOFSTEP]
have h_eq : algebraMap R (T ⧸ P) = w.toRingEquiv.toRingHom.comp (w'.toRingHom.comp (algebraMap R (S ⧸ Q'))) :=
  by
  ext r
  simp only [AlgEquiv.toAlgHom_eq_coe, AlgHom.toRingHom_eq_coe, AlgEquiv.toRingEquiv_eq_coe, RingEquiv.toRingHom_eq_coe,
    AlgHom.comp_algebraMap_of_tower, coe_comp, coe_coe, AlgEquiv.coe_ringEquiv, Function.comp_apply, AlgEquiv.commutes]
[GOAL]
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
hw : map v Q = P
hQ : IsMaximal Q
w : (S[X] ⧸ Q) ≃ₐ[R] T ⧸ P := quotientEquivAlg Q P v (_ : P = map v Q)
Q' : Ideal S := comap Polynomial.C Q
w' : S ⧸ Q' →ₐ[R] S[X] ⧸ Q := quotientMapₐ Q (Ideal.MvPolynomial.Cₐ R S) (_ : Q' ≤ Q')
⊢ algebraMap R (T ⧸ P) =
    RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv w)) (RingHom.comp (↑w') (algebraMap R (S ⧸ Q')))
[PROOFSTEP]
ext r
[GOAL]
case a
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
hw : map v Q = P
hQ : IsMaximal Q
w : (S[X] ⧸ Q) ≃ₐ[R] T ⧸ P := quotientEquivAlg Q P v (_ : P = map v Q)
Q' : Ideal S := comap Polynomial.C Q
w' : S ⧸ Q' →ₐ[R] S[X] ⧸ Q := quotientMapₐ Q (Ideal.MvPolynomial.Cₐ R S) (_ : Q' ≤ Q')
r : R
⊢ ↑(algebraMap R (T ⧸ P)) r =
    ↑(RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv w)) (RingHom.comp (↑w') (algebraMap R (S ⧸ Q')))) r
[PROOFSTEP]
simp only [AlgEquiv.toAlgHom_eq_coe, AlgHom.toRingHom_eq_coe, AlgEquiv.toRingEquiv_eq_coe, RingEquiv.toRingHom_eq_coe,
  AlgHom.comp_algebraMap_of_tower, coe_comp, coe_coe, AlgEquiv.coe_ringEquiv, Function.comp_apply, AlgEquiv.commutes]
[GOAL]
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
hw : map v Q = P
hQ : IsMaximal Q
w : (S[X] ⧸ Q) ≃ₐ[R] T ⧸ P := quotientEquivAlg Q P v (_ : P = map v Q)
Q' : Ideal S := comap Polynomial.C Q
w' : S ⧸ Q' →ₐ[R] S[X] ⧸ Q := quotientMapₐ Q (Ideal.MvPolynomial.Cₐ R S) (_ : Q' ≤ Q')
h_eq :
  algebraMap R (T ⧸ P) =
    RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv w)) (RingHom.comp (↑w') (algebraMap R (S ⧸ Q')))
⊢ RingHom.IsIntegral (algebraMap R (T ⧸ P))
[PROOFSTEP]
rw [h_eq]
[GOAL]
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
hw : map v Q = P
hQ : IsMaximal Q
w : (S[X] ⧸ Q) ≃ₐ[R] T ⧸ P := quotientEquivAlg Q P v (_ : P = map v Q)
Q' : Ideal S := comap Polynomial.C Q
w' : S ⧸ Q' →ₐ[R] S[X] ⧸ Q := quotientMapₐ Q (Ideal.MvPolynomial.Cₐ R S) (_ : Q' ≤ Q')
h_eq :
  algebraMap R (T ⧸ P) =
    RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv w)) (RingHom.comp (↑w') (algebraMap R (S ⧸ Q')))
⊢ RingHom.IsIntegral
    (RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv w)) (RingHom.comp (↑w') (algebraMap R (S ⧸ Q'))))
[PROOFSTEP]
apply RingHom.isIntegral_trans
[GOAL]
case hf
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
hw : map v Q = P
hQ : IsMaximal Q
w : (S[X] ⧸ Q) ≃ₐ[R] T ⧸ P := quotientEquivAlg Q P v (_ : P = map v Q)
Q' : Ideal S := comap Polynomial.C Q
w' : S ⧸ Q' →ₐ[R] S[X] ⧸ Q := quotientMapₐ Q (Ideal.MvPolynomial.Cₐ R S) (_ : Q' ≤ Q')
h_eq :
  algebraMap R (T ⧸ P) =
    RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv w)) (RingHom.comp (↑w') (algebraMap R (S ⧸ Q')))
⊢ RingHom.IsIntegral (RingHom.comp (↑w') (algebraMap R (S ⧸ Q')))
case hg
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
hw : map v Q = P
hQ : IsMaximal Q
w : (S[X] ⧸ Q) ≃ₐ[R] T ⧸ P := quotientEquivAlg Q P v (_ : P = map v Q)
Q' : Ideal S := comap Polynomial.C Q
w' : S ⧸ Q' →ₐ[R] S[X] ⧸ Q := quotientMapₐ Q (Ideal.MvPolynomial.Cₐ R S) (_ : Q' ≤ Q')
h_eq :
  algebraMap R (T ⧸ P) =
    RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv w)) (RingHom.comp (↑w') (algebraMap R (S ⧸ Q')))
⊢ RingHom.IsIntegral (RingEquiv.toRingHom (AlgEquiv.toRingEquiv w))
[PROOFSTEP]
apply RingHom.isIntegral_trans
[GOAL]
case hf.hf
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
hw : map v Q = P
hQ : IsMaximal Q
w : (S[X] ⧸ Q) ≃ₐ[R] T ⧸ P := quotientEquivAlg Q P v (_ : P = map v Q)
Q' : Ideal S := comap Polynomial.C Q
w' : S ⧸ Q' →ₐ[R] S[X] ⧸ Q := quotientMapₐ Q (Ideal.MvPolynomial.Cₐ R S) (_ : Q' ≤ Q')
h_eq :
  algebraMap R (T ⧸ P) =
    RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv w)) (RingHom.comp (↑w') (algebraMap R (S ⧸ Q')))
⊢ RingHom.IsIntegral (algebraMap R (S ⧸ Q'))
[PROOFSTEP]
apply IH
[GOAL]
case hf.hf.a
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
hw : map v Q = P
hQ : IsMaximal Q
w : (S[X] ⧸ Q) ≃ₐ[R] T ⧸ P := quotientEquivAlg Q P v (_ : P = map v Q)
Q' : Ideal S := comap Polynomial.C Q
w' : S ⧸ Q' →ₐ[R] S[X] ⧸ Q := quotientMapₐ Q (Ideal.MvPolynomial.Cₐ R S) (_ : Q' ≤ Q')
h_eq :
  algebraMap R (T ⧸ P) =
    RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv w)) (RingHom.comp (↑w') (algebraMap R (S ⧸ Q')))
⊢ IsMaximal Q'
[PROOFSTEP]
apply Polynomial.isMaximal_comap_C_of_isJacobson'
[GOAL]
case hf.hf.a.hP
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
hw : map v Q = P
hQ : IsMaximal Q
w : (S[X] ⧸ Q) ≃ₐ[R] T ⧸ P := quotientEquivAlg Q P v (_ : P = map v Q)
Q' : Ideal S := comap Polynomial.C Q
w' : S ⧸ Q' →ₐ[R] S[X] ⧸ Q := quotientMapₐ Q (Ideal.MvPolynomial.Cₐ R S) (_ : Q' ≤ Q')
h_eq :
  algebraMap R (T ⧸ P) =
    RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv w)) (RingHom.comp (↑w') (algebraMap R (S ⧸ Q')))
⊢ IsMaximal Q
[PROOFSTEP]
exact hQ
[GOAL]
case hf.hg
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
hw : map v Q = P
hQ : IsMaximal Q
w : (S[X] ⧸ Q) ≃ₐ[R] T ⧸ P := quotientEquivAlg Q P v (_ : P = map v Q)
Q' : Ideal S := comap Polynomial.C Q
w' : S ⧸ Q' →ₐ[R] S[X] ⧸ Q := quotientMapₐ Q (Ideal.MvPolynomial.Cₐ R S) (_ : Q' ≤ Q')
h_eq :
  algebraMap R (T ⧸ P) =
    RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv w)) (RingHom.comp (↑w') (algebraMap R (S ⧸ Q')))
⊢ RingHom.IsIntegral ↑w'
[PROOFSTEP]
suffices : w'.toRingHom = Ideal.quotientMap Q (Polynomial.C) le_rfl
[GOAL]
case hf.hg
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
hw : map v Q = P
hQ : IsMaximal Q
w : (S[X] ⧸ Q) ≃ₐ[R] T ⧸ P := quotientEquivAlg Q P v (_ : P = map v Q)
Q' : Ideal S := comap Polynomial.C Q
w' : S ⧸ Q' →ₐ[R] S[X] ⧸ Q := quotientMapₐ Q (Ideal.MvPolynomial.Cₐ R S) (_ : Q' ≤ Q')
h_eq :
  algebraMap R (T ⧸ P) =
    RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv w)) (RingHom.comp (↑w') (algebraMap R (S ⧸ Q')))
this : ↑w' = quotientMap Q Polynomial.C (_ : comap Polynomial.C Q ≤ comap Polynomial.C Q)
⊢ RingHom.IsIntegral ↑w'
[PROOFSTEP]
rw [this]
[GOAL]
case hf.hg
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
hw : map v Q = P
hQ : IsMaximal Q
w : (S[X] ⧸ Q) ≃ₐ[R] T ⧸ P := quotientEquivAlg Q P v (_ : P = map v Q)
Q' : Ideal S := comap Polynomial.C Q
w' : S ⧸ Q' →ₐ[R] S[X] ⧸ Q := quotientMapₐ Q (Ideal.MvPolynomial.Cₐ R S) (_ : Q' ≤ Q')
h_eq :
  algebraMap R (T ⧸ P) =
    RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv w)) (RingHom.comp (↑w') (algebraMap R (S ⧸ Q')))
this : ↑w' = quotientMap Q Polynomial.C (_ : comap Polynomial.C Q ≤ comap Polynomial.C Q)
⊢ RingHom.IsIntegral (quotientMap Q Polynomial.C (_ : comap Polynomial.C Q ≤ comap Polynomial.C Q))
[PROOFSTEP]
rw [isIntegral_quotientMap_iff _]
[GOAL]
case hf.hg
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
hw : map v Q = P
hQ : IsMaximal Q
w : (S[X] ⧸ Q) ≃ₐ[R] T ⧸ P := quotientEquivAlg Q P v (_ : P = map v Q)
Q' : Ideal S := comap Polynomial.C Q
w' : S ⧸ Q' →ₐ[R] S[X] ⧸ Q := quotientMapₐ Q (Ideal.MvPolynomial.Cₐ R S) (_ : Q' ≤ Q')
h_eq :
  algebraMap R (T ⧸ P) =
    RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv w)) (RingHom.comp (↑w') (algebraMap R (S ⧸ Q')))
this : ↑w' = quotientMap Q Polynomial.C (_ : comap Polynomial.C Q ≤ comap Polynomial.C Q)
⊢ RingHom.IsIntegral (RingHom.comp (Quotient.mk Q) Polynomial.C)
[PROOFSTEP]
apply Polynomial.quotient_mk_comp_C_isIntegral_of_jacobson
[GOAL]
case this
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
hw : map v Q = P
hQ : IsMaximal Q
w : (S[X] ⧸ Q) ≃ₐ[R] T ⧸ P := quotientEquivAlg Q P v (_ : P = map v Q)
Q' : Ideal S := comap Polynomial.C Q
w' : S ⧸ Q' →ₐ[R] S[X] ⧸ Q := quotientMapₐ Q (Ideal.MvPolynomial.Cₐ R S) (_ : Q' ≤ Q')
h_eq :
  algebraMap R (T ⧸ P) =
    RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv w)) (RingHom.comp (↑w') (algebraMap R (S ⧸ Q')))
⊢ ↑w' = quotientMap Q Polynomial.C (_ : comap Polynomial.C Q ≤ comap Polynomial.C Q)
[PROOFSTEP]
rfl
[GOAL]
case hg
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
hw : map v Q = P
hQ : IsMaximal Q
w : (S[X] ⧸ Q) ≃ₐ[R] T ⧸ P := quotientEquivAlg Q P v (_ : P = map v Q)
Q' : Ideal S := comap Polynomial.C Q
w' : S ⧸ Q' →ₐ[R] S[X] ⧸ Q := quotientMapₐ Q (Ideal.MvPolynomial.Cₐ R S) (_ : Q' ≤ Q')
h_eq :
  algebraMap R (T ⧸ P) =
    RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv w)) (RingHom.comp (↑w') (algebraMap R (S ⧸ Q')))
⊢ RingHom.IsIntegral (RingEquiv.toRingHom (AlgEquiv.toRingEquiv w))
[PROOFSTEP]
apply RingHom.isIntegral_of_surjective
[GOAL]
case hg.hf
n : ℕ
R : Type u
S : Type v
T : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : CommRing T
inst✝² : IsJacobson S
inst✝¹ : Algebra R S
inst✝ : Algebra R T
IH : ∀ (Q : Ideal S), IsMaximal Q → RingHom.IsIntegral (algebraMap R (S ⧸ Q))
v : S[X] ≃ₐ[R] T
P : Ideal T
hP : IsMaximal P
Q : Ideal S[X] := comap (↑↑v) P
hw : map v Q = P
hQ : IsMaximal Q
w : (S[X] ⧸ Q) ≃ₐ[R] T ⧸ P := quotientEquivAlg Q P v (_ : P = map v Q)
Q' : Ideal S := comap Polynomial.C Q
w' : S ⧸ Q' →ₐ[R] S[X] ⧸ Q := quotientMapₐ Q (Ideal.MvPolynomial.Cₐ R S) (_ : Q' ≤ Q')
h_eq :
  algebraMap R (T ⧸ P) =
    RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv w)) (RingHom.comp (↑w') (algebraMap R (S ⧸ Q')))
⊢ Function.Surjective ↑(RingEquiv.toRingHom (AlgEquiv.toRingEquiv w))
[PROOFSTEP]
exact w.surjective
[GOAL]
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal (MvPolynomial (Fin n) R)
hP : IsMaximal P
⊢ RingHom.IsIntegral (algebraMap R (MvPolynomial (Fin n) R ⧸ P))
[PROOFSTEP]
induction' n with n IH
[GOAL]
case zero
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P✝ : Ideal (MvPolynomial (Fin n) R)
hP✝ : IsMaximal P✝
P : Ideal (MvPolynomial (Fin Nat.zero) R)
hP : IsMaximal P
⊢ RingHom.IsIntegral (algebraMap R (MvPolynomial (Fin Nat.zero) R ⧸ P))
[PROOFSTEP]
apply RingHom.isIntegral_of_surjective
[GOAL]
case zero.hf
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P✝ : Ideal (MvPolynomial (Fin n) R)
hP✝ : IsMaximal P✝
P : Ideal (MvPolynomial (Fin Nat.zero) R)
hP : IsMaximal P
⊢ Function.Surjective ↑(algebraMap R (MvPolynomial (Fin Nat.zero) R ⧸ P))
[PROOFSTEP]
apply Function.Surjective.comp Quotient.mk_surjective
[GOAL]
case zero.hf
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P✝ : Ideal (MvPolynomial (Fin n) R)
hP✝ : IsMaximal P✝
P : Ideal (MvPolynomial (Fin Nat.zero) R)
hP : IsMaximal P
⊢ Function.Surjective fun x => ↑(algebraMap R (MvPolynomial (Fin Nat.zero) R)) x
[PROOFSTEP]
exact C_surjective (Fin 0)
[GOAL]
case succ
n✝ : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P✝ : Ideal (MvPolynomial (Fin n✝) R)
hP✝ : IsMaximal P✝
n : ℕ
IH :
  ∀ (P : Ideal (MvPolynomial (Fin n) R)), IsMaximal P → RingHom.IsIntegral (algebraMap R (MvPolynomial (Fin n) R ⧸ P))
P : Ideal (MvPolynomial (Fin (Nat.succ n)) R)
hP : IsMaximal P
⊢ RingHom.IsIntegral (algebraMap R (MvPolynomial (Fin (Nat.succ n)) R ⧸ P))
[PROOFSTEP]
apply aux_IH IH (finSuccEquiv R n).symm P hP
[GOAL]
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal (MvPolynomial (Fin n) R)
hP : IsMaximal P
⊢ RingHom.IsIntegral (RingHom.comp (Quotient.mk P) MvPolynomial.C)
[PROOFSTEP]
change RingHom.IsIntegral (algebraMap R (MvPolynomial (Fin n) R ⧸ P))
[GOAL]
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal (MvPolynomial (Fin n) R)
hP : IsMaximal P
⊢ RingHom.IsIntegral (algebraMap R (MvPolynomial (Fin n) R ⧸ P))
[PROOFSTEP]
apply quotient_mk_comp_C_isIntegral_of_jacobson'
[GOAL]
case hP
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal (MvPolynomial (Fin n) R)
hP : IsMaximal P
⊢ IsMaximal P
[PROOFSTEP]
infer_instance
[GOAL]
n : ℕ
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsJacobson R
σ : Type u_2
inst✝¹ : _root_.Finite σ
S : Type u_3
inst✝ : Field S
f : MvPolynomial σ R →+* S
hf : Function.Surjective ↑f
⊢ RingHom.IsIntegral (RingHom.comp f MvPolynomial.C)
[PROOFSTEP]
cases nonempty_fintype σ
[GOAL]
case intro
n : ℕ
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsJacobson R
σ : Type u_2
inst✝¹ : _root_.Finite σ
S : Type u_3
inst✝ : Field S
f : MvPolynomial σ R →+* S
hf : Function.Surjective ↑f
val✝ : Fintype σ
⊢ RingHom.IsIntegral (RingHom.comp f MvPolynomial.C)
[PROOFSTEP]
have e := (Fintype.equivFin σ).symm
[GOAL]
case intro
n : ℕ
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsJacobson R
σ : Type u_2
inst✝¹ : _root_.Finite σ
S : Type u_3
inst✝ : Field S
f : MvPolynomial σ R →+* S
hf : Function.Surjective ↑f
val✝ : Fintype σ
e : Fin (Fintype.card σ) ≃ σ
⊢ RingHom.IsIntegral (RingHom.comp f MvPolynomial.C)
[PROOFSTEP]
let f' : MvPolynomial (Fin _) R →+* S := f.comp (renameEquiv R e).toRingEquiv.toRingHom
[GOAL]
case intro
n : ℕ
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsJacobson R
σ : Type u_2
inst✝¹ : _root_.Finite σ
S : Type u_3
inst✝ : Field S
f : MvPolynomial σ R →+* S
hf : Function.Surjective ↑f
val✝ : Fintype σ
e : Fin (Fintype.card σ) ≃ σ
f' : MvPolynomial (Fin (Fintype.card σ)) R →+* S :=
  RingHom.comp f (RingEquiv.toRingHom (AlgEquiv.toRingEquiv (renameEquiv R e)))
⊢ RingHom.IsIntegral (RingHom.comp f MvPolynomial.C)
[PROOFSTEP]
have hf' := Function.Surjective.comp hf (renameEquiv R e).surjective
[GOAL]
case intro
n : ℕ
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsJacobson R
σ : Type u_2
inst✝¹ : _root_.Finite σ
S : Type u_3
inst✝ : Field S
f : MvPolynomial σ R →+* S
hf : Function.Surjective ↑f
val✝ : Fintype σ
e : Fin (Fintype.card σ) ≃ σ
f' : MvPolynomial (Fin (Fintype.card σ)) R →+* S :=
  RingHom.comp f (RingEquiv.toRingHom (AlgEquiv.toRingEquiv (renameEquiv R e)))
hf' : Function.Surjective (↑f ∘ ↑(renameEquiv R e))
⊢ RingHom.IsIntegral (RingHom.comp f MvPolynomial.C)
[PROOFSTEP]
change Function.Surjective ↑f' at hf'
[GOAL]
case intro
n : ℕ
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsJacobson R
σ : Type u_2
inst✝¹ : _root_.Finite σ
S : Type u_3
inst✝ : Field S
f : MvPolynomial σ R →+* S
hf : Function.Surjective ↑f
val✝ : Fintype σ
e : Fin (Fintype.card σ) ≃ σ
f' : MvPolynomial (Fin (Fintype.card σ)) R →+* S :=
  RingHom.comp f (RingEquiv.toRingHom (AlgEquiv.toRingEquiv (renameEquiv R e)))
hf' : Function.Surjective ↑f'
⊢ RingHom.IsIntegral (RingHom.comp f MvPolynomial.C)
[PROOFSTEP]
have : (f'.comp C).IsIntegral :=
  by
  haveI : f'.ker.IsMaximal := ker_isMaximal_of_surjective f' hf'
  let g : MvPolynomial _ R ⧸ (RingHom.ker f') →+* S := Ideal.Quotient.lift (RingHom.ker f') f' fun _ h => h
  have hfg : g.comp (Quotient.mk (RingHom.ker f')) = f' := ringHom_ext (fun r => rfl) fun i => rfl
  rw [← hfg, RingHom.comp_assoc]
  refine'
    RingHom.isIntegral_trans _ g (quotient_mk_comp_C_isIntegral_of_jacobson (RingHom.ker f'))
      (g.isIntegral_of_surjective _)
  rw [← hfg] at hf'
  norm_num at hf'
  exact Function.Surjective.of_comp hf'
[GOAL]
n : ℕ
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsJacobson R
σ : Type u_2
inst✝¹ : _root_.Finite σ
S : Type u_3
inst✝ : Field S
f : MvPolynomial σ R →+* S
hf : Function.Surjective ↑f
val✝ : Fintype σ
e : Fin (Fintype.card σ) ≃ σ
f' : MvPolynomial (Fin (Fintype.card σ)) R →+* S :=
  RingHom.comp f (RingEquiv.toRingHom (AlgEquiv.toRingEquiv (renameEquiv R e)))
hf' : Function.Surjective ↑f'
⊢ RingHom.IsIntegral (RingHom.comp f' MvPolynomial.C)
[PROOFSTEP]
haveI : f'.ker.IsMaximal := ker_isMaximal_of_surjective f' hf'
[GOAL]
n : ℕ
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsJacobson R
σ : Type u_2
inst✝¹ : _root_.Finite σ
S : Type u_3
inst✝ : Field S
f : MvPolynomial σ R →+* S
hf : Function.Surjective ↑f
val✝ : Fintype σ
e : Fin (Fintype.card σ) ≃ σ
f' : MvPolynomial (Fin (Fintype.card σ)) R →+* S :=
  RingHom.comp f (RingEquiv.toRingHom (AlgEquiv.toRingEquiv (renameEquiv R e)))
hf' : Function.Surjective ↑f'
this : IsMaximal (ker f')
⊢ RingHom.IsIntegral (RingHom.comp f' MvPolynomial.C)
[PROOFSTEP]
let g : MvPolynomial _ R ⧸ (RingHom.ker f') →+* S := Ideal.Quotient.lift (RingHom.ker f') f' fun _ h => h
[GOAL]
n : ℕ
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsJacobson R
σ : Type u_2
inst✝¹ : _root_.Finite σ
S : Type u_3
inst✝ : Field S
f : MvPolynomial σ R →+* S
hf : Function.Surjective ↑f
val✝ : Fintype σ
e : Fin (Fintype.card σ) ≃ σ
f' : MvPolynomial (Fin (Fintype.card σ)) R →+* S :=
  RingHom.comp f (RingEquiv.toRingHom (AlgEquiv.toRingEquiv (renameEquiv R e)))
hf' : Function.Surjective ↑f'
this : IsMaximal (ker f')
g : MvPolynomial (Fin (Fintype.card σ)) R ⧸ ker f' →+* S :=
  Quotient.lift (ker f') f' (_ : ∀ (x : MvPolynomial (Fin (Fintype.card σ)) R), x ∈ ker f' → x ∈ ker f')
⊢ RingHom.IsIntegral (RingHom.comp f' MvPolynomial.C)
[PROOFSTEP]
have hfg : g.comp (Quotient.mk (RingHom.ker f')) = f' := ringHom_ext (fun r => rfl) fun i => rfl
[GOAL]
n : ℕ
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsJacobson R
σ : Type u_2
inst✝¹ : _root_.Finite σ
S : Type u_3
inst✝ : Field S
f : MvPolynomial σ R →+* S
hf : Function.Surjective ↑f
val✝ : Fintype σ
e : Fin (Fintype.card σ) ≃ σ
f' : MvPolynomial (Fin (Fintype.card σ)) R →+* S :=
  RingHom.comp f (RingEquiv.toRingHom (AlgEquiv.toRingEquiv (renameEquiv R e)))
hf' : Function.Surjective ↑f'
this : IsMaximal (ker f')
g : MvPolynomial (Fin (Fintype.card σ)) R ⧸ ker f' →+* S :=
  Quotient.lift (ker f') f' (_ : ∀ (x : MvPolynomial (Fin (Fintype.card σ)) R), x ∈ ker f' → x ∈ ker f')
hfg : RingHom.comp g (Quotient.mk (ker f')) = f'
⊢ RingHom.IsIntegral (RingHom.comp f' MvPolynomial.C)
[PROOFSTEP]
rw [← hfg, RingHom.comp_assoc]
[GOAL]
n : ℕ
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsJacobson R
σ : Type u_2
inst✝¹ : _root_.Finite σ
S : Type u_3
inst✝ : Field S
f : MvPolynomial σ R →+* S
hf : Function.Surjective ↑f
val✝ : Fintype σ
e : Fin (Fintype.card σ) ≃ σ
f' : MvPolynomial (Fin (Fintype.card σ)) R →+* S :=
  RingHom.comp f (RingEquiv.toRingHom (AlgEquiv.toRingEquiv (renameEquiv R e)))
hf' : Function.Surjective ↑f'
this : IsMaximal (ker f')
g : MvPolynomial (Fin (Fintype.card σ)) R ⧸ ker f' →+* S :=
  Quotient.lift (ker f') f' (_ : ∀ (x : MvPolynomial (Fin (Fintype.card σ)) R), x ∈ ker f' → x ∈ ker f')
hfg : RingHom.comp g (Quotient.mk (ker f')) = f'
⊢ RingHom.IsIntegral (RingHom.comp g (RingHom.comp (Quotient.mk (ker f')) MvPolynomial.C))
[PROOFSTEP]
refine'
  RingHom.isIntegral_trans _ g (quotient_mk_comp_C_isIntegral_of_jacobson (RingHom.ker f'))
    (g.isIntegral_of_surjective _)
[GOAL]
n : ℕ
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsJacobson R
σ : Type u_2
inst✝¹ : _root_.Finite σ
S : Type u_3
inst✝ : Field S
f : MvPolynomial σ R →+* S
hf : Function.Surjective ↑f
val✝ : Fintype σ
e : Fin (Fintype.card σ) ≃ σ
f' : MvPolynomial (Fin (Fintype.card σ)) R →+* S :=
  RingHom.comp f (RingEquiv.toRingHom (AlgEquiv.toRingEquiv (renameEquiv R e)))
hf' : Function.Surjective ↑f'
this : IsMaximal (ker f')
g : MvPolynomial (Fin (Fintype.card σ)) R ⧸ ker f' →+* S :=
  Quotient.lift (ker f') f' (_ : ∀ (x : MvPolynomial (Fin (Fintype.card σ)) R), x ∈ ker f' → x ∈ ker f')
hfg : RingHom.comp g (Quotient.mk (ker f')) = f'
⊢ Function.Surjective ↑g
[PROOFSTEP]
rw [← hfg] at hf'
[GOAL]
n : ℕ
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsJacobson R
σ : Type u_2
inst✝¹ : _root_.Finite σ
S : Type u_3
inst✝ : Field S
f : MvPolynomial σ R →+* S
hf : Function.Surjective ↑f
val✝ : Fintype σ
e : Fin (Fintype.card σ) ≃ σ
f' : MvPolynomial (Fin (Fintype.card σ)) R →+* S :=
  RingHom.comp f (RingEquiv.toRingHom (AlgEquiv.toRingEquiv (renameEquiv R e)))
this : IsMaximal (ker f')
g : MvPolynomial (Fin (Fintype.card σ)) R ⧸ ker f' →+* S :=
  Quotient.lift (ker f') f' (_ : ∀ (x : MvPolynomial (Fin (Fintype.card σ)) R), x ∈ ker f' → x ∈ ker f')
hf' : Function.Surjective ↑(RingHom.comp g (Quotient.mk (ker f')))
hfg : RingHom.comp g (Quotient.mk (ker f')) = f'
⊢ Function.Surjective ↑g
[PROOFSTEP]
norm_num at hf'
[GOAL]
n : ℕ
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsJacobson R
σ : Type u_2
inst✝¹ : _root_.Finite σ
S : Type u_3
inst✝ : Field S
f : MvPolynomial σ R →+* S
hf : Function.Surjective ↑f
val✝ : Fintype σ
e : Fin (Fintype.card σ) ≃ σ
f' : MvPolynomial (Fin (Fintype.card σ)) R →+* S :=
  RingHom.comp f (RingEquiv.toRingHom (AlgEquiv.toRingEquiv (renameEquiv R e)))
this : IsMaximal (ker f')
g : MvPolynomial (Fin (Fintype.card σ)) R ⧸ ker f' →+* S :=
  Quotient.lift (ker f') f' (_ : ∀ (x : MvPolynomial (Fin (Fintype.card σ)) R), x ∈ ker f' → x ∈ ker f')
hf' :
  Function.Surjective
    (↑(Quotient.lift (ker f') (RingHom.comp f ↑↑(renameEquiv R e))
          (_ :
            ∀ (a : MvPolynomial (Fin (Fintype.card σ)) R), a ∈ ker f' → ↑(RingHom.comp f ↑↑(renameEquiv R e)) a = 0)) ∘
      ↑(Quotient.mk (ker (RingHom.comp f ↑↑(renameEquiv R e)))))
hfg : RingHom.comp g (Quotient.mk (ker f')) = f'
⊢ Function.Surjective ↑g
[PROOFSTEP]
exact Function.Surjective.of_comp hf'
[GOAL]
case intro
n : ℕ
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsJacobson R
σ : Type u_2
inst✝¹ : _root_.Finite σ
S : Type u_3
inst✝ : Field S
f : MvPolynomial σ R →+* S
hf : Function.Surjective ↑f
val✝ : Fintype σ
e : Fin (Fintype.card σ) ≃ σ
f' : MvPolynomial (Fin (Fintype.card σ)) R →+* S :=
  RingHom.comp f (RingEquiv.toRingHom (AlgEquiv.toRingEquiv (renameEquiv R e)))
hf' : Function.Surjective ↑f'
this : RingHom.IsIntegral (RingHom.comp f' MvPolynomial.C)
⊢ RingHom.IsIntegral (RingHom.comp f MvPolynomial.C)
[PROOFSTEP]
rw [RingHom.comp_assoc] at this
[GOAL]
case intro
n : ℕ
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsJacobson R
σ : Type u_2
inst✝¹ : _root_.Finite σ
S : Type u_3
inst✝ : Field S
f : MvPolynomial σ R →+* S
hf : Function.Surjective ↑f
val✝ : Fintype σ
e : Fin (Fintype.card σ) ≃ σ
f' : MvPolynomial (Fin (Fintype.card σ)) R →+* S :=
  RingHom.comp f (RingEquiv.toRingHom (AlgEquiv.toRingEquiv (renameEquiv R e)))
hf' : Function.Surjective ↑f'
this :
  RingHom.IsIntegral
    (RingHom.comp f (RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv (renameEquiv R e))) MvPolynomial.C))
⊢ RingHom.IsIntegral (RingHom.comp f MvPolynomial.C)
[PROOFSTEP]
convert this
[GOAL]
case h.e'_5.h.e'_8
n : ℕ
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsJacobson R
σ : Type u_2
inst✝¹ : _root_.Finite σ
S : Type u_3
inst✝ : Field S
f : MvPolynomial σ R →+* S
hf : Function.Surjective ↑f
val✝ : Fintype σ
e : Fin (Fintype.card σ) ≃ σ
f' : MvPolynomial (Fin (Fintype.card σ)) R →+* S :=
  RingHom.comp f (RingEquiv.toRingHom (AlgEquiv.toRingEquiv (renameEquiv R e)))
hf' : Function.Surjective ↑f'
this :
  RingHom.IsIntegral
    (RingHom.comp f (RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv (renameEquiv R e))) MvPolynomial.C))
⊢ MvPolynomial.C = RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv (renameEquiv R e))) MvPolynomial.C
[PROOFSTEP]
refine' RingHom.ext fun x => _
[GOAL]
case h.e'_5.h.e'_8
n : ℕ
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsJacobson R
σ : Type u_2
inst✝¹ : _root_.Finite σ
S : Type u_3
inst✝ : Field S
f : MvPolynomial σ R →+* S
hf : Function.Surjective ↑f
val✝ : Fintype σ
e : Fin (Fintype.card σ) ≃ σ
f' : MvPolynomial (Fin (Fintype.card σ)) R →+* S :=
  RingHom.comp f (RingEquiv.toRingHom (AlgEquiv.toRingEquiv (renameEquiv R e)))
hf' : Function.Surjective ↑f'
this :
  RingHom.IsIntegral
    (RingHom.comp f (RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv (renameEquiv R e))) MvPolynomial.C))
x : R
⊢ ↑MvPolynomial.C x = ↑(RingHom.comp (RingEquiv.toRingHom (AlgEquiv.toRingEquiv (renameEquiv R e))) MvPolynomial.C) x
[PROOFSTEP]
exact ((renameEquiv R e).commutes' x).symm