Theorem: Ideal.isPrime_map_C_iff_isPrime
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: constructor
state_before: R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
⊢ (map C P).IsPrime ↔ P.IsPrime
state_after: case mp
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
⊢ (map C P).IsPrime → P.IsPrime

case mpr
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
⊢ P.IsPrime → (map C P).IsPrime

tactic: intro H
state_before: case mp
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
⊢ (map C P).IsPrime → P.IsPrime
state_after: case mp
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
H : (map C P).IsPrime
⊢ P.IsPrime

tactic: have := comap_isPrime C (map C P)
state_before: case mp
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
H : (map C P).IsPrime
⊢ P.IsPrime
state_after: case mp
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
H : (map C P).IsPrime
this : (comap C (map C P)).IsPrime
⊢ P.IsPrime

tactic: convert this using 1
state_before: case mp
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
H : (map C P).IsPrime
this : (comap C (map C P)).IsPrime
⊢ P.IsPrime
state_after: case h.e'_3
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
H : (map C P).IsPrime
this : (comap C (map C P)).IsPrime
⊢ P = comap C (map C P)

tactic: ext x
state_before: case h.e'_3
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
H : (map C P).IsPrime
this : (comap C (map C P)).IsPrime
⊢ P = comap C (map C P)
state_after: case h.e'_3.h
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
H : (map C P).IsPrime
this : (comap C (map C P)).IsPrime
x : R
⊢ x ∈ P ↔ x ∈ comap C (map C P)

tactic: simp only [mem_comap, mem_map_C_iff]
state_before: case h.e'_3.h
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
H : (map C P).IsPrime
this : (comap C (map C P)).IsPrime
x : R
⊢ x ∈ P ↔ x ∈ comap C (map C P)
state_after: case h.e'_3.h
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
H : (map C P).IsPrime
this : (comap C (map C P)).IsPrime
x : R
⊢ x ∈ P ↔ ∀ (n : ℕ), (C x).coeff n ∈ P

tactic: constructor
state_before: case h.e'_3.h
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
H : (map C P).IsPrime
this : (comap C (map C P)).IsPrime
x : R
⊢ x ∈ P ↔ ∀ (n : ℕ), (C x).coeff n ∈ P
state_after: case h.e'_3.h.mp
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
H : (map C P).IsPrime
this : (comap C (map C P)).IsPrime
x : R
⊢ x ∈ P → ∀ (n : ℕ), (C x).coeff n ∈ P

case h.e'_3.h.mpr
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
H : (map C P).IsPrime
this : (comap C (map C P)).IsPrime
x : R
⊢ (∀ (n : ℕ), (C x).coeff n ∈ P) → x ∈ P

tactic: rintro h (- | n)
state_before: case h.e'_3.h.mp
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
H : (map C P).IsPrime
this : (comap C (map C P)).IsPrime
x : R
⊢ x ∈ P → ∀ (n : ℕ), (C x).coeff n ∈ P
state_after: case h.e'_3.h.mp.zero
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
H : (map C P).IsPrime
this : (comap C (map C P)).IsPrime
x : R
h : x ∈ P
⊢ (C x).coeff 0 ∈ P

case h.e'_3.h.mp.succ
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
H : (map C P).IsPrime
this : (comap C (map C P)).IsPrime
x : R
h : x ∈ P
n : ℕ
⊢ (C x).coeff (n + 1) ∈ P

tactic: rwa [coeff_C_zero]
state_before: case h.e'_3.h.mp.zero
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
H : (map C P).IsPrime
this : (comap C (map C P)).IsPrime
x : R
h : x ∈ P
⊢ (C x).coeff 0 ∈ P
state_after: no goals

tactic: simp only [coeff_C_ne_zero (Nat.succ_ne_zero _), Submodule.zero_mem]
state_before: case h.e'_3.h.mp.succ
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
H : (map C P).IsPrime
this : (comap C (map C P)).IsPrime
x : R
h : x ∈ P
n : ℕ
⊢ (C x).coeff (n + 1) ∈ P
state_after: no goals

tactic: intro h
state_before: case h.e'_3.h.mpr
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
H : (map C P).IsPrime
this : (comap C (map C P)).IsPrime
x : R
⊢ (∀ (n : ℕ), (C x).coeff n ∈ P) → x ∈ P
state_after: case h.e'_3.h.mpr
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
H : (map C P).IsPrime
this : (comap C (map C P)).IsPrime
x : R
h : ∀ (n : ℕ), (C x).coeff n ∈ P
⊢ x ∈ P

tactic: simpa only [coeff_C_zero] using h 0
state_before: case h.e'_3.h.mpr
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
H : (map C P).IsPrime
this : (comap C (map C P)).IsPrime
x : R
h : ∀ (n : ℕ), (C x).coeff n ∈ P
⊢ x ∈ P
state_after: no goals

tactic: intro h
state_before: case mpr
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
⊢ P.IsPrime → (map C P).IsPrime
state_after: case mpr
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
⊢ (map C P).IsPrime

tactic: constructor
state_before: case mpr
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
⊢ (map C P).IsPrime
state_after: case mpr.ne_top'
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
⊢ map C P ≠ ⊤

case mpr.mem_or_mem'
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
⊢ ∀ {x y : R[X]}, x * y ∈ map C P → x ∈ map C P ∨ y ∈ map C P

tactic: rw [Ne, eq_top_iff_one, mem_map_C_iff, not_forall]
state_before: case mpr.ne_top'
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
⊢ map C P ≠ ⊤
state_after: case mpr.ne_top'
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
⊢ ∃ x, coeff 1 x ∉ P

tactic: use 0
state_before: case mpr.ne_top'
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
⊢ ∃ x, coeff 1 x ∉ P
state_after: case h
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
⊢ coeff 1 0 ∉ P

tactic: rw [coeff_one_zero, ← eq_top_iff_one]
state_before: case h
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
⊢ coeff 1 0 ∉ P
state_after: case h
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
⊢ ¬P = ⊤

tactic: exact h.1
state_before: case h
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
⊢ ¬P = ⊤
state_after: no goals

tactic: intro f g
state_before: case mpr.mem_or_mem'
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
⊢ ∀ {x y : R[X]}, x * y ∈ map C P → x ∈ map C P ∨ y ∈ map C P
state_after: case mpr.mem_or_mem'
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
⊢ f * g ∈ map C P → f ∈ map C P ∨ g ∈ map C P

tactic: simp only [mem_map_C_iff]
state_before: case mpr.mem_or_mem'
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
⊢ f * g ∈ map C P → f ∈ map C P ∨ g ∈ map C P
state_after: case mpr.mem_or_mem'
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
⊢ (∀ (n : ℕ), (f * g).coeff n ∈ P) → (∀ (n : ℕ), f.coeff n ∈ P) ∨ ∀ (n : ℕ), g.coeff n ∈ P

tactic: contrapose!
state_before: case mpr.mem_or_mem'
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
⊢ (∀ (n : ℕ), (f * g).coeff n ∈ P) → (∀ (n : ℕ), f.coeff n ∈ P) ∨ ∀ (n : ℕ), g.coeff n ∈ P
state_after: case mpr.mem_or_mem'
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
⊢ ((∃ n, f.coeff n ∉ P) ∧ ∃ n, g.coeff n ∉ P) → ∃ n, (f * g).coeff n ∉ P

tactic: rintro ⟨hf, hg⟩
state_before: case mpr.mem_or_mem'
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
⊢ ((∃ n, f.coeff n ∉ P) ∧ ∃ n, g.coeff n ∉ P) → ∃ n, (f * g).coeff n ∉ P
state_after: case mpr.mem_or_mem'.intro
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
⊢ ∃ n, (f * g).coeff n ∉ P

tactic: let m := Nat.find hf
state_before: case mpr.mem_or_mem'.intro
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
⊢ ∃ n, (f * g).coeff n ∉ P
state_after: case mpr.mem_or_mem'.intro
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
⊢ ∃ n, (f * g).coeff n ∉ P

tactic: let n := Nat.find hg
state_before: case mpr.mem_or_mem'.intro
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
⊢ ∃ n, (f * g).coeff n ∉ P
state_after: case mpr.mem_or_mem'.intro
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
⊢ ∃ n, (f * g).coeff n ∉ P

tactic: refine ⟨m + n, ?_⟩
state_before: case mpr.mem_or_mem'.intro
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
⊢ ∃ n, (f * g).coeff n ∉ P
state_after: case mpr.mem_or_mem'.intro
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
⊢ (f * g).coeff (m + n) ∉ P

tactic: rw [coeff_mul, ← Finset.insert_erase ((Finset.mem_antidiagonal (a := (m,n))).mpr rfl),
  Finset.sum_insert (Finset.not_mem_erase _ _), (P.add_mem_iff_left _).not]
state_before: case mpr.mem_or_mem'.intro
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
⊢ (f * g).coeff (m + n) ∉ P
state_after: case mpr.mem_or_mem'.intro
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
⊢ f.coeff (m, n).1 * g.coeff (m, n).2 ∉ P

R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
⊢ ∑ x ∈ (antidiagonal ((m, n).1 + (m, n).2)).erase (m, n), f.coeff x.1 * g.coeff x.2 ∈ P

tactic: apply P.sum_mem
state_before: R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
⊢ ∑ x ∈ (antidiagonal ((m, n).1 + (m, n).2)).erase (m, n), f.coeff x.1 * g.coeff x.2 ∈ P
state_after: R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
⊢ ∀ c ∈ (antidiagonal ((m, n).1 + (m, n).2)).erase (m, n), f.coeff c.1 * g.coeff c.2 ∈ P

tactic: rintro ⟨i, j⟩ hij
state_before: R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
⊢ ∀ c ∈ (antidiagonal ((m, n).1 + (m, n).2)).erase (m, n), f.coeff c.1 * g.coeff c.2 ∈ P
state_after: case mk
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (i, j) ∈ (antidiagonal ((m, n).1 + (m, n).2)).erase (m, n)
⊢ f.coeff (i, j).1 * g.coeff (i, j).2 ∈ P

tactic: rw [Finset.mem_erase, Finset.mem_antidiagonal] at hij
state_before: case mk
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (i, j) ∈ (antidiagonal ((m, n).1 + (m, n).2)).erase (m, n)
⊢ f.coeff (i, j).1 * g.coeff (i, j).2 ∈ P
state_after: case mk
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (i, j) ≠ (m, n) ∧ (i, j).1 + (i, j).2 = (m, n).1 + (m, n).2
⊢ f.coeff (i, j).1 * g.coeff (i, j).2 ∈ P

tactic: simp only [Ne, Prod.mk.inj_iff, not_and_or] at hij
state_before: case mk
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (i, j) ≠ (m, n) ∧ (i, j).1 + (i, j).2 = (m, n).1 + (m, n).2
⊢ f.coeff (i, j).1 * g.coeff (i, j).2 ∈ P
state_after: case mk
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (¬i = m ∨ ¬j = n) ∧ i + j = m + n
⊢ f.coeff (i, j).1 * g.coeff (i, j).2 ∈ P

tactic: apply mt h.2
state_before: case mpr.mem_or_mem'.intro
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
⊢ f.coeff (m, n).1 * g.coeff (m, n).2 ∉ P
state_after: case mpr.mem_or_mem'.intro
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
⊢ ¬(f.coeff (m, n).1 ∈ P ∨ g.coeff (m, n).2 ∈ P)

tactic: rw [not_or]
state_before: case mpr.mem_or_mem'.intro
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
⊢ ¬(f.coeff (m, n).1 ∈ P ∨ g.coeff (m, n).2 ∈ P)
state_after: case mpr.mem_or_mem'.intro
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
⊢ f.coeff (m, n).1 ∉ P ∧ g.coeff (m, n).2 ∉ P

tactic: exact ⟨Nat.find_spec hf, Nat.find_spec hg⟩
state_before: case mpr.mem_or_mem'.intro
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
⊢ f.coeff (m, n).1 ∉ P ∧ g.coeff (m, n).2 ∉ P
state_after: no goals

tactic: rw [or_iff_not_imp_left, not_lt, le_iff_lt_or_eq]
state_before: R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (¬i = m ∨ ¬j = n) ∧ i + j = m + n
⊢ i < m ∨ j < n
state_after: R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (¬i = m ∨ ¬j = n) ∧ i + j = m + n
⊢ m < i ∨ m = i → j < n

tactic: rintro (hmi | rfl)
state_before: R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (¬i = m ∨ ¬j = n) ∧ i + j = m + n
⊢ m < i ∨ m = i → j < n
state_after: case inl
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (¬i = m ∨ ¬j = n) ∧ i + j = m + n
hmi : m < i
⊢ j < n

case inr
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
j : ℕ
hij : (¬m = m ∨ ¬j = n) ∧ m + j = m + n
⊢ j < n

tactic: rw [← not_le]
state_before: case inl
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (¬i = m ∨ ¬j = n) ∧ i + j = m + n
hmi : m < i
⊢ j < n
state_after: case inl
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (¬i = m ∨ ¬j = n) ∧ i + j = m + n
hmi : m < i
⊢ ¬n ≤ j

tactic: intro hnj
state_before: case inl
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (¬i = m ∨ ¬j = n) ∧ i + j = m + n
hmi : m < i
⊢ ¬n ≤ j
state_after: case inl
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (¬i = m ∨ ¬j = n) ∧ i + j = m + n
hmi : m < i
hnj : n ≤ j
⊢ False

tactic: exact (add_lt_add_of_lt_of_le hmi hnj).ne hij.2.symm
state_before: case inl
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (¬i = m ∨ ¬j = n) ∧ i + j = m + n
hmi : m < i
hnj : n ≤ j
⊢ False
state_after: no goals

tactic: simp only [eq_self_iff_true, not_true, false_or_iff, add_right_inj,
  not_and_self_iff] at hij
state_before: case inr
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
j : ℕ
hij : (¬m = m ∨ ¬j = n) ∧ m + j = m + n
⊢ j < n
state_after: no goals

tactic: rw [mul_comm]
state_before: case mk.inl
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (¬i = m ∨ ¬j = n) ∧ i + j = m + n
hi : i < m
⊢ f.coeff (i, j).1 * g.coeff (i, j).2 ∈ P
state_after: case mk.inl
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (¬i = m ∨ ¬j = n) ∧ i + j = m + n
hi : i < m
⊢ g.coeff (i, j).2 * f.coeff (i, j).1 ∈ P

tactic: apply P.mul_mem_left
state_before: case mk.inl
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (¬i = m ∨ ¬j = n) ∧ i + j = m + n
hi : i < m
⊢ g.coeff (i, j).2 * f.coeff (i, j).1 ∈ P
state_after: case mk.inl.a
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (¬i = m ∨ ¬j = n) ∧ i + j = m + n
hi : i < m
⊢ f.coeff (i, j).1 ∈ P

tactic: exact Classical.not_not.1 (Nat.find_min hf hi)
state_before: case mk.inl.a
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (¬i = m ∨ ¬j = n) ∧ i + j = m + n
hi : i < m
⊢ f.coeff (i, j).1 ∈ P
state_after: no goals

tactic: apply P.mul_mem_left
state_before: case mk.inr
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (¬i = m ∨ ¬j = n) ∧ i + j = m + n
hj : j < n
⊢ f.coeff (i, j).1 * g.coeff (i, j).2 ∈ P
state_after: case mk.inr.a
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (¬i = m ∨ ¬j = n) ∧ i + j = m + n
hj : j < n
⊢ g.coeff (i, j).2 ∈ P

tactic: exact Classical.not_not.1 (Nat.find_min hg hj)
state_before: case mk.inr.a
R : Type u
S : Type u_1
inst✝ : CommRing R
P : Ideal R
h : P.IsPrime
f g : R[X]
hf : ∃ n, f.coeff n ∉ P
hg : ∃ n, g.coeff n ∉ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (¬i = m ∨ ¬j = n) ∧ i + j = m + n
hj : j < n
⊢ g.coeff (i, j).2 ∈ P
state_after: no goals