Theorem: PrimeSpectrum.exists_primeSpectrum_prod_le_and_ne_bot_of_domain
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Noetherian.lean

tactic: revert h_nzI
state_before: R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I : Ideal A
h_nzI : I ≠ ⊥
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥

tactic: refine' IsNoetherian.induction (P := fun I => I ≠ ⊥ → ∃ Z : Multiset (PrimeSpectrum A),
    Multiset.prod (Z.map asIdeal) ≤ I ∧ Multiset.prod (Z.map asIdeal) ≠ ⊥)
  (fun (M : Ideal A) hgt => _) I
state_before: R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I : Ideal A
⊢ I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥

tactic: intro h_nzM
state_before: R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
⊢ (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) M

tactic: have hA_nont : Nontrivial A
state_before: R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥

tactic: apply IsDomain.toNontrivial
state_before: case hA_nont
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
⊢ Nontrivial A

R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥

tactic: by_cases h_topM : M = ⊤
state_before: R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥

tactic: by_cases h_prM : M.IsPrime
state_before: case neg
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥

tactic: obtain ⟨x, hx, y, hy, h_xy⟩ := (Ideal.not_isPrime_iff.mp h_prM).resolve_left h_topM
state_before: case neg
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥

tactic: have lt_add : ∀ (z) (_ : z ∉ M), M < M + span A {z} := by
  intro z hz
  refine' lt_of_le_of_ne le_sup_left fun m_eq => hz _
  rw [m_eq]
  exact mem_sup_right (mem_span_singleton_self z)
state_before: case neg.intro.intro.intro.intro
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥

tactic: obtain ⟨Wx, h_Wx_le, h_Wx_ne⟩ := hgt (M + span A {x}) (lt_add _ hx) (ne_bot_of_gt (lt_add _ hx))
state_before: case neg.intro.intro.intro.intro
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥

tactic: obtain ⟨Wy, h_Wy_le, h_Wx_ne⟩ := hgt (M + span A {y}) (lt_add _ hy) (ne_bot_of_gt (lt_add _ hy))
state_before: case neg.intro.intro.intro.intro.intro.intro
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥

tactic: use Wx + Wy
state_before: case neg.intro.intro.intro.intro.intro.intro.intro.intro
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne✝ : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
Wy : Multiset (PrimeSpectrum A)
h_Wy_le : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span A {y}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥

tactic: rw [Multiset.map_add, Multiset.prod_add]
state_before: case neg.intro.intro.intro.intro.intro.intro.intro.intro
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne✝ : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
Wy : Multiset (PrimeSpectrum A)
h_Wy_le : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span A {y}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥
⊢ Multiset.prod (Multiset.map asIdeal (Wx + Wy)) ≤ M ∧ Multiset.prod (Multiset.map asIdeal (Wx + Wy)) ≠ ⊥

tactic: refine' ⟨le_trans (Submodule.mul_le_mul h_Wx_le h_Wy_le) _, mt Ideal.mul_eq_bot.mp _⟩
state_before: case neg.intro.intro.intro.intro.intro.intro.intro.intro
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne✝ : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
Wy : Multiset (PrimeSpectrum A)
h_Wy_le : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span A {y}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥
⊢ Multiset.prod (Multiset.map asIdeal Wx) * Multiset.prod (Multiset.map asIdeal Wy) ≤ M ∧
    Multiset.prod (Multiset.map asIdeal Wx) * Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥

tactic: rcases h_topM with rfl
state_before: case pos
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : M = ⊤
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥

tactic: obtain ⟨p_id, h_nzp, h_pp⟩ : ∃ p : Ideal A, p ≠ ⊥ ∧ p.IsPrime := by
  apply Ring.not_isField_iff_exists_prime.mp h_fA
state_before: case pos
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I : Ideal A
hA_nont : Nontrivial A
hgt :
  ∀ (J : Submodule A A),
    J > ⊤ →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : ⊤ ≠ ⊥
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ ⊤ ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥

tactic: use ({⟨p_id, h_pp⟩} : Multiset (PrimeSpectrum A)), le_top
state_before: case pos.intro.intro
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I : Ideal A
hA_nont : Nontrivial A
hgt :
  ∀ (J : Submodule A A),
    J > ⊤ →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : ⊤ ≠ ⊥
p_id : Ideal A
h_nzp : p_id ≠ ⊥
h_pp : Ideal.IsPrime p_id
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ ⊤ ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥

tactic: rwa [Multiset.map_singleton, Multiset.prod_singleton]
state_before: case pos.intro.intro
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I : Ideal A
hA_nont : Nontrivial A
hgt :
  ∀ (J : Submodule A A),
    J > ⊤ →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : ⊤ ≠ ⊥
p_id : Ideal A
h_nzp : p_id ≠ ⊥
h_pp : Ideal.IsPrime p_id
⊢ Multiset.prod (Multiset.map asIdeal {{ asIdeal := p_id, IsPrime := h_pp }}) ≠ ⊥

tactic: apply Ring.not_isField_iff_exists_prime.mp h_fA
state_before: R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I : Ideal A
hA_nont : Nontrivial A
hgt :
  ∀ (J : Submodule A A),
    J > ⊤ →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : ⊤ ≠ ⊥
⊢ ∃ p, p ≠ ⊥ ∧ Ideal.IsPrime p

tactic: use ({⟨M, h_prM⟩} : Multiset (PrimeSpectrum A))
state_before: case pos
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : Ideal.IsPrime M
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥

tactic: rw [Multiset.map_singleton, Multiset.prod_singleton]
state_before: case pos
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : Ideal.IsPrime M
⊢ Multiset.prod (Multiset.map asIdeal {{ asIdeal := M, IsPrime := h_prM }}) ≤ M ∧
    Multiset.prod (Multiset.map asIdeal {{ asIdeal := M, IsPrime := h_prM }}) ≠ ⊥

tactic: exact ⟨le_rfl, h_nzM⟩
state_before: case pos
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : Ideal.IsPrime M
⊢ { asIdeal := M, IsPrime := h_prM }.asIdeal ≤ M ∧ { asIdeal := M, IsPrime := h_prM }.asIdeal ≠ ⊥

tactic: intro z hz
state_before: R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
⊢ ∀ (z : A), ¬z ∈ M → M < M + span A {z}

tactic: refine' lt_of_le_of_ne le_sup_left fun m_eq => hz _
state_before: R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
z : A
hz : ¬z ∈ M
⊢ M < M + span A {z}

tactic: rw [m_eq]
state_before: R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
z : A
hz : ¬z ∈ M
m_eq : M = M + span A {z}
⊢ z ∈ M

tactic: exact mem_sup_right (mem_span_singleton_self z)
state_before: R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
z : A
hz : ¬z ∈ M
m_eq : M = M + span A {z}
⊢ z ∈ M + span A {z}

tactic: rw [add_mul]
state_before: case neg.intro.intro.intro.intro.intro.intro.intro.intro.refine'_1
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne✝ : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
Wy : Multiset (PrimeSpectrum A)
h_Wy_le : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span A {y}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥
⊢ (M + span A {x}) * (M + span A {y}) ≤ M

tactic: apply sup_le (show M * (M + span A {y}) ≤ M from Ideal.mul_le_right)
state_before: case neg.intro.intro.intro.intro.intro.intro.intro.intro.refine'_1
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne✝ : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
Wy : Multiset (PrimeSpectrum A)
h_Wy_le : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span A {y}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥
⊢ M * (M + span A {y}) + span A {x} * (M + span A {y}) ≤ M

tactic: rw [mul_add]
state_before: case neg.intro.intro.intro.intro.intro.intro.intro.intro.refine'_1
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne✝ : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
Wy : Multiset (PrimeSpectrum A)
h_Wy_le : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span A {y}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥
⊢ span A {x} * (M + span A {y}) ≤ M

tactic: apply sup_le (show span A {x} * M ≤ M from Ideal.mul_le_left)
state_before: case neg.intro.intro.intro.intro.intro.intro.intro.intro.refine'_1
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne✝ : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
Wy : Multiset (PrimeSpectrum A)
h_Wy_le : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span A {y}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥
⊢ span A {x} * M + span A {x} * span A {y} ≤ M

tactic: rwa [span_mul_span, Set.singleton_mul_singleton, span_singleton_le_iff_mem]
state_before: case neg.intro.intro.intro.intro.intro.intro.intro.intro.refine'_1
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne✝ : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
Wy : Multiset (PrimeSpectrum A)
h_Wy_le : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span A {y}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥
⊢ span A {x} * span A {y} ≤ M

tactic: rintro (hx | hy) <;> contradiction
state_before: case neg.intro.intro.intro.intro.intro.intro.intro.intro.refine'_2
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne✝ : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
Wy : Multiset (PrimeSpectrum A)
h_Wy_le : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span A {y}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥
⊢ ¬(Multiset.prod (Multiset.map asIdeal Wx) = ⊥ ∨ Multiset.prod (Multiset.map asIdeal Wy) = ⊥)