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

tactic: constructor
state_before: R : Type u
S : Type ?u.241035
inst✝ : CommRing R
P : Ideal R
⊢ IsPrime (map C P) ↔ IsPrime P

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

tactic: have := @comap_isPrime R R[X] (R →+* R[X]) _ _ _ C (map C P) H
state_before: case mp
R : Type u
S : Type ?u.241035
inst✝ : CommRing R
P : Ideal R
H : IsPrime (map C P)
⊢ IsPrime P

tactic: convert this using 1
state_before: case mp
R : Type u
S : Type ?u.241035
inst✝ : CommRing R
P : Ideal R
H : IsPrime (map C P)
this : IsPrime (comap C (map C P))
⊢ IsPrime P

tactic: ext x
state_before: case h.e'_3
R : Type u
S : Type ?u.241035
inst✝ : CommRing R
P : Ideal R
H : IsPrime (map C P)
this : IsPrime (comap C (map C P))
⊢ P = 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.241035
inst✝ : CommRing R
P : Ideal R
H : IsPrime (map C P)
this : IsPrime (comap C (map C P))
x : R
⊢ x ∈ P ↔ x ∈ comap C (map C P)

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

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

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

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.241035
inst✝ : CommRing R
P : Ideal R
H : IsPrime (map C P)
this : IsPrime (comap C (map C P))
x : R
h : x ∈ P
n : ℕ
⊢ coeff (↑C x) (Nat.succ n) ∈ P

tactic: intro h
state_before: case h.e'_3.h.mpr
R : Type u
S : Type ?u.241035
inst✝ : CommRing R
P : Ideal R
H : IsPrime (map C P)
this : IsPrime (comap C (map C P))
x : R
⊢ (∀ (n : ℕ), coeff (↑C x) 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.241035
inst✝ : CommRing R
P : Ideal R
H : IsPrime (map C P)
this : IsPrime (comap C (map C P))
x : R
h : ∀ (n : ℕ), coeff (↑C x) n ∈ P
⊢ x ∈ P

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

tactic: constructor
state_before: case mpr
R : Type u
S : Type ?u.241035
inst✝ : CommRing R
P : Ideal R
h : IsPrime P
⊢ IsPrime (map C P)

tactic: rw [Ne.def, eq_top_iff_one, mem_map_C_iff, not_forall]
state_before: case mpr.ne_top'
R : Type u
S : Type ?u.241035
inst✝ : CommRing R
P : Ideal R
h : IsPrime P
⊢ map C P ≠ ⊤

tactic: use 0
state_before: case mpr.ne_top'
R : Type u
S : Type ?u.241035
inst✝ : CommRing R
P : Ideal R
h : IsPrime P
⊢ ∃ x, ¬coeff 1 x ∈ P

tactic: rw [coeff_one_zero, ← eq_top_iff_one]
state_before: case mpr.ne_top'
R : Type u
S : Type ?u.241035
inst✝ : CommRing R
P : Ideal R
h : IsPrime P
⊢ ¬coeff 1 0 ∈ P

tactic: exact h.1
state_before: case mpr.ne_top'
R : Type u
S : Type ?u.241035
inst✝ : CommRing R
P : Ideal R
h : IsPrime P
⊢ ¬P = ⊤

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

tactic: simp only [mem_map_C_iff]
state_before: case mpr.mem_or_mem'
R : Type u
S : Type ?u.241035
inst✝ : CommRing R
P : Ideal R
h : IsPrime P
f g : R[X]
⊢ f * g ∈ map C P → f ∈ map C P ∨ g ∈ map C P

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

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

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

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

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

tactic: rw [coeff_mul, ← Finset.insert_erase ((@Finset.Nat.mem_antidiagonal _ (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.241035
inst✝ : CommRing R
P : Ideal R
h : IsPrime P
f g : R[X]
hf : ∃ n, ¬coeff f n ∈ P
hg : ∃ n, ¬coeff g n ∈ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
⊢ ¬coeff (f * g) (m + n) ∈ P

tactic: apply P.sum_mem
state_before: R : Type u
S : Type ?u.241035
inst✝ : CommRing R
P : Ideal R
h : IsPrime P
f g : R[X]
hf : ∃ n, ¬coeff f n ∈ P
hg : ∃ n, ¬coeff g n ∈ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
⊢ ∑ x in Finset.erase (Nat.antidiagonal ((m, n).fst + (m, n).snd)) (m, n), coeff f x.fst * coeff g x.snd ∈ P

tactic: rintro ⟨i, j⟩ hij
state_before: R : Type u
S : Type ?u.241035
inst✝ : CommRing R
P : Ideal R
h : IsPrime P
f g : R[X]
hf : ∃ n, ¬coeff f n ∈ P
hg : ∃ n, ¬coeff g n ∈ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
⊢ ∀ (c : ℕ × ℕ),
    c ∈ Finset.erase (Nat.antidiagonal ((m, n).fst + (m, n).snd)) (m, n) → coeff f c.fst * coeff g c.snd ∈ P

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

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

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

tactic: rw [not_or]
state_before: case mpr.mem_or_mem'.intro
R : Type u
S : Type ?u.241035
inst✝ : CommRing R
P : Ideal R
h : IsPrime P
f g : R[X]
hf : ∃ n, ¬coeff f n ∈ P
hg : ∃ n, ¬coeff g n ∈ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
⊢ ¬(coeff f (m, n).fst ∈ P ∨ coeff g (m, n).snd ∈ 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.241035
inst✝ : CommRing R
P : Ideal R
h : IsPrime P
f g : R[X]
hf : ∃ n, ¬coeff f n ∈ P
hg : ∃ n, ¬coeff g n ∈ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
⊢ ¬coeff f (m, n).fst ∈ P ∧ ¬coeff g (m, n).snd ∈ P

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

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

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

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

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.241035
inst✝ : CommRing R
P : Ideal R
h : IsPrime P
f g : R[X]
hf : ∃ n, ¬coeff f n ∈ P
hg : ∃ n, ¬coeff g n ∈ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
i j : ℕ
hij : (¬i = Nat.find hf ∨ ¬j = Nat.find hg) ∧ i + j = Nat.find hf + Nat.find hg
hmi : m < i
hnj : n ≤ j
⊢ False

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.241035
inst✝ : CommRing R
P : Ideal R
h : IsPrime P
f g : R[X]
hf : ∃ n, ¬coeff f n ∈ P
hg : ∃ n, ¬coeff g n ∈ P
m : ℕ := Nat.find hf
n : ℕ := Nat.find hg
j : ℕ
hij : (¬m = Nat.find hf ∨ ¬j = Nat.find hg) ∧ m + j = Nat.find hf + Nat.find hg
⊢ j < n

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

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

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

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

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