Theorem: IsPrincipalIdealRing.of_prime
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

tactic: rw [← nonPrincipals_eq_empty_iff, Set.eq_empty_iff_forall_not_mem]
state_before: R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
⊢ IsPrincipalIdealRing R

tactic: intro J hJ
state_before: R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
⊢ ∀ (x : Ideal R), ¬x ∈ nonPrincipals R

tactic: obtain ⟨I, Ibad, -, Imax⟩ := zorn_nonempty_partialOrder₀ (nonPrincipals R) nonPrincipals_zorn _ hJ
state_before: R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
⊢ False

tactic: have Imax' : ∀ {J}, I < J → J.IsPrincipal := by
  intro J hJ
  by_contra He
  exact hJ.ne (Imax _ ((nonPrincipals_def R).2 He) hJ.le).symm
state_before: case intro.intro.intro
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
⊢ False

tactic: by_cases hI1 : I = ⊤
state_before: case intro.intro.intro
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
⊢ False

tactic: refine' Ibad (H I ⟨hI1, fun {x y} hxy => or_iff_not_imp_right.mpr fun hy => _⟩)
state_before: case neg
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
⊢ False

tactic: obtain ⟨a, ha⟩ : (I ⊔ span {y}).IsPrincipal :=
  Imax' (left_lt_sup.mpr (mt I.span_singleton_le_iff_mem.mp hy))
state_before: case neg
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
x y : R
hxy : x * y ∈ I
hy : ¬y ∈ I
⊢ x ∈ I

tactic: suffices He : ¬(I.colon (span {y})).IsPrincipal
state_before: case neg.mk.intro
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
x y : R
hxy : x * y ∈ I
hy : ¬y ∈ I
a : R
ha : I ⊔ Ideal.span {y} = Submodule.span R {a}
⊢ x ∈ I

tactic: rintro ⟨b, hb⟩
state_before: case He
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
x y : R
hxy : x * y ∈ I
hy : ¬y ∈ I
a : R
ha : I ⊔ Ideal.span {y} = Submodule.span R {a}
⊢ ¬IsPrincipal (colon I (Ideal.span {y}))

tactic: refine (nonPrincipals_def _).1 Ibad ⟨a * b, ?_⟩
state_before: case He.mk.intro
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
x y : R
hxy : x * y ∈ I
hy : ¬y ∈ I
a : R
ha : I ⊔ Ideal.span {y} = Submodule.span R {a}
b : R
hb : colon I (Ideal.span {y}) = Submodule.span R {b}
⊢ False

tactic: refine'
  le_antisymm (α := Ideal R) (fun i hi => _) <| (span_singleton_mul_span_singleton a b).ge.trans _
state_before: case He.mk.intro
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
x y : R
hxy : x * y ∈ I
hy : ¬y ∈ I
a : R
ha : I ⊔ Ideal.span {y} = Submodule.span R {a}
b : R
hb : colon I (Ideal.span {y}) = Submodule.span R {b}
⊢ I = Submodule.span R {a * b}

tactic: intro J hJ
state_before: R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
⊢ ∀ {J : Ideal R}, I < J → IsPrincipal J

tactic: by_contra He
state_before: R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J✝ : Ideal R
hJ✝ : J✝ ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
J : Ideal R
hJ : I < J
⊢ IsPrincipal J

tactic: exact hJ.ne (Imax _ ((nonPrincipals_def R).2 He) hJ.le).symm
state_before: R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J✝ : Ideal R
hJ✝ : J✝ ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
J : Ideal R
hJ : I < J
He : ¬IsPrincipal J
⊢ False

tactic: subst hI1
state_before: case pos
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : I = ⊤
⊢ False

tactic: exact Ibad top_isPrincipal
state_before: case pos
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
Ibad : ⊤ ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → ⊤ ≤ z → z = ⊤
Imax' : ∀ {J : Ideal R}, ⊤ < J → IsPrincipal J
⊢ False

tactic: rw [← Imax _ ((nonPrincipals_def R).2 He) fun a ha =>
    Ideal.mem_colon_singleton.2 (mul_mem_right _ _ ha)]
state_before: case neg.mk.intro
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
x y : R
hxy : x * y ∈ I
hy : ¬y ∈ I
a : R
ha : I ⊔ Ideal.span {y} = Submodule.span R {a}
He : ¬IsPrincipal (colon I (Ideal.span {y}))
⊢ x ∈ I

tactic: exact Ideal.mem_colon_singleton.2 hxy
state_before: case neg.mk.intro
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
x y : R
hxy : x * y ∈ I
hy : ¬y ∈ I
a : R
ha : I ⊔ Ideal.span {y} = Submodule.span R {a}
He : ¬IsPrincipal (colon I (Ideal.span {y}))
⊢ x ∈ colon I (Ideal.span {y})

tactic: have hisup : i ∈ I ⊔ span {y} := Ideal.mem_sup_left hi
state_before: case He.mk.intro.refine'_1
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
x y : R
hxy : x * y ∈ I
hy : ¬y ∈ I
a : R
ha : I ⊔ Ideal.span {y} = Submodule.span R {a}
b : R
hb : colon I (Ideal.span {y}) = Submodule.span R {b}
i : R
hi : i ∈ I
⊢ i ∈ Submodule.span R {a * b}

tactic: have : y ∈ I ⊔ span {y} := Ideal.mem_sup_right (Ideal.mem_span_singleton_self y)
state_before: case He.mk.intro.refine'_1
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
x y : R
hxy : x * y ∈ I
hy : ¬y ∈ I
a : R
ha : I ⊔ Ideal.span {y} = Submodule.span R {a}
b : R
hb : colon I (Ideal.span {y}) = Submodule.span R {b}
i : R
hi : i ∈ I
hisup : i ∈ I ⊔ Ideal.span {y}
⊢ i ∈ Submodule.span R {a * b}

tactic: erw [ha, mem_span_singleton'] at hisup this
state_before: case He.mk.intro.refine'_1
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
x y : R
hxy : x * y ∈ I
hy : ¬y ∈ I
a : R
ha : I ⊔ Ideal.span {y} = Submodule.span R {a}
b : R
hb : colon I (Ideal.span {y}) = Submodule.span R {b}
i : R
hi : i ∈ I
hisup : i ∈ I ⊔ Ideal.span {y}
this : y ∈ I ⊔ Ideal.span {y}
⊢ i ∈ Submodule.span R {a * b}

tactic: obtain ⟨v, rfl⟩ := this
state_before: case He.mk.intro.refine'_1
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
x y : R
hxy : x * y ∈ I
hy : ¬y ∈ I
a : R
ha : I ⊔ Ideal.span {y} = Submodule.span R {a}
b : R
hb : colon I (Ideal.span {y}) = Submodule.span R {b}
i : R
hi : i ∈ I
hisup : ∃ a_1, a_1 * a = i
this : ∃ a_1, a_1 * a = y
⊢ i ∈ Submodule.span R {a * b}

tactic: obtain ⟨u, rfl⟩ := hisup
state_before: case He.mk.intro.refine'_1.intro
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
x a b i : R
hi : i ∈ I
hisup : ∃ a_1, a_1 * a = i
v : R
hxy : x * (v * a) ∈ I
hy : ¬v * a ∈ I
ha : I ⊔ Ideal.span {v * a} = Submodule.span R {a}
hb : colon I (Ideal.span {v * a}) = Submodule.span R {b}
⊢ i ∈ Submodule.span R {a * b}

tactic: have hucolon : u ∈ I.colon (span {v * a}) := by
  rw [Ideal.mem_colon_singleton, mul_comm v, ← mul_assoc]
  exact mul_mem_right _ _ hi
state_before: case He.mk.intro.refine'_1.intro.intro
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
x a b v : R
hxy : x * (v * a) ∈ I
hy : ¬v * a ∈ I
ha : I ⊔ Ideal.span {v * a} = Submodule.span R {a}
hb : colon I (Ideal.span {v * a}) = Submodule.span R {b}
u : R
hi : u * a ∈ I
⊢ u * a ∈ Submodule.span R {a * b}

tactic: erw [hb, mem_span_singleton'] at hucolon
state_before: case He.mk.intro.refine'_1.intro.intro
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
x a b v : R
hxy : x * (v * a) ∈ I
hy : ¬v * a ∈ I
ha : I ⊔ Ideal.span {v * a} = Submodule.span R {a}
hb : colon I (Ideal.span {v * a}) = Submodule.span R {b}
u : R
hi : u * a ∈ I
hucolon : u ∈ colon I (Ideal.span {v * a})
⊢ u * a ∈ Submodule.span R {a * b}

tactic: obtain ⟨z, rfl⟩ := hucolon
state_before: case He.mk.intro.refine'_1.intro.intro
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
x a b v : R
hxy : x * (v * a) ∈ I
hy : ¬v * a ∈ I
ha : I ⊔ Ideal.span {v * a} = Submodule.span R {a}
hb : colon I (Ideal.span {v * a}) = Submodule.span R {b}
u : R
hi : u * a ∈ I
hucolon : ∃ a, a * b = u
⊢ u * a ∈ Submodule.span R {a * b}

tactic: exact mem_span_singleton'.2 ⟨z, by ring⟩
state_before: case He.mk.intro.refine'_1.intro.intro.intro
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
x a b v : R
hxy : x * (v * a) ∈ I
hy : ¬v * a ∈ I
ha : I ⊔ Ideal.span {v * a} = Submodule.span R {a}
hb : colon I (Ideal.span {v * a}) = Submodule.span R {b}
z : R
hi : z * b * a ∈ I
⊢ z * b * a ∈ Submodule.span R {a * b}

tactic: rw [Ideal.mem_colon_singleton, mul_comm v, ← mul_assoc]
state_before: R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
x a b v : R
hxy : x * (v * a) ∈ I
hy : ¬v * a ∈ I
ha : I ⊔ Ideal.span {v * a} = Submodule.span R {a}
hb : colon I (Ideal.span {v * a}) = Submodule.span R {b}
u : R
hi : u * a ∈ I
⊢ u ∈ colon I (Ideal.span {v * a})

tactic: exact mul_mem_right _ _ hi
state_before: R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
x a b v : R
hxy : x * (v * a) ∈ I
hy : ¬v * a ∈ I
ha : I ⊔ Ideal.span {v * a} = Submodule.span R {a}
hb : colon I (Ideal.span {v * a}) = Submodule.span R {b}
u : R
hi : u * a ∈ I
⊢ u * a * v ∈ I

tactic: ring
state_before: R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
x a b v : R
hxy : x * (v * a) ∈ I
hy : ¬v * a ∈ I
ha : I ⊔ Ideal.span {v * a} = Submodule.span R {a}
hb : colon I (Ideal.span {v * a}) = Submodule.span R {b}
z : R
hi : z * b * a ∈ I
⊢ z * (a * b) = z * b * a

tactic: rw [← Ideal.submodule_span_eq, ← ha, Ideal.sup_mul, sup_le_iff,
  span_singleton_mul_span_singleton, mul_comm y, Ideal.span_singleton_le_iff_mem]
state_before: case He.mk.intro.refine'_2
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
x y : R
hxy : x * y ∈ I
hy : ¬y ∈ I
a : R
ha : I ⊔ Ideal.span {y} = Submodule.span R {a}
b : R
hb : colon I (Ideal.span {y}) = Submodule.span R {b}
⊢ Ideal.span {a} * Ideal.span {b} ≤ I

tactic: exact ⟨mul_le_right, Ideal.mem_colon_singleton.1 <| hb.symm ▸ Ideal.mem_span_singleton_self b⟩
state_before: case He.mk.intro.refine'_2
R : Type u
M : Type v
inst✝ : CommRing R
H : ∀ (P : Ideal R), IsPrime P → IsPrincipal P
J : Ideal R
hJ : J ∈ nonPrincipals R
I : Ideal R
Ibad : I ∈ nonPrincipals R
Imax : ∀ (z : Ideal R), z ∈ nonPrincipals R → I ≤ z → z = I
Imax' : ∀ {J : Ideal R}, I < J → IsPrincipal J
hI1 : ¬I = ⊤
x y : R
hxy : x * y ∈ I
hy : ¬y ∈ I
a : R
ha : I ⊔ Ideal.span {y} = Submodule.span R {a}
b : R
hb : colon I (Ideal.span {y}) = Submodule.span R {b}
⊢ I * Ideal.span {b} ≤ I ∧ b * y ∈ I