Theorem: Ideal.IsHomogeneous.isPrime_of_homogeneous_mem_or_mem
File: Mathlib/RingTheory/GradedAlgebra/Radical.lean

tactic: intro x y hxy
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
⊢ ∀ {x y : A}, x * y ∈ I → x ∈ I ∨ y ∈ I

tactic: by_contra rid
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
hxy : x * y ∈ I
⊢ x ∈ I ∨ y ∈ I

tactic: push_neg at rid
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
hxy : x * y ∈ I
rid : ¬(x ∈ I ∨ y ∈ I)
⊢ False

tactic: obtain ⟨rid₁, rid₂⟩ := rid
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
hxy : x * y ∈ I
rid : ¬x ∈ I ∧ ¬y ∈ I
⊢ False

tactic: set set₁ := (decompose 𝒜 x).support.filter (fun i => proj 𝒜 i x ∉ I) with set₁_eq
state_before: case intro
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
hxy : x * y ∈ I
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
⊢ False

tactic: set set₂ := (decompose 𝒜 y).support.filter (fun i => proj 𝒜 i y ∉ I) with set₂_eq
state_before: case intro
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
hxy : x * y ∈ I
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
⊢ False

tactic: have nonempty :
  ∀ x : A, x ∉ I → ((decompose 𝒜 x).support.filter (fun i => proj 𝒜 i x ∉ I)).Nonempty := by
  intro x hx
  rw [filter_nonempty_iff]
  contrapose! hx
  simp_rw [proj_apply] at hx
  rw [← sum_support_decompose 𝒜 x]
  exact Ideal.sum_mem _ hx
state_before: case intro
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
hxy : x * y ∈ I
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
⊢ False

tactic: set max₁ := set₁.max' (nonempty x rid₁)
state_before: case intro
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
hxy : x * y ∈ I
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
⊢ False

tactic: set max₂ := set₂.max' (nonempty y rid₂)
state_before: case intro
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
hxy : x * y ∈ I
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
⊢ False

tactic: have mem_max₁ : max₁ ∈ set₁ := max'_mem set₁ (nonempty x rid₁)
state_before: case intro
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
hxy : x * y ∈ I
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
⊢ False

tactic: have mem_max₂ : max₂ ∈ set₂ := max'_mem set₂ (nonempty y rid₂)
state_before: case intro
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
hxy : x * y ∈ I
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
⊢ False

tactic: replace hxy : proj 𝒜 (max₁ + max₂) (x * y) ∈ I := hI _ hxy
state_before: case intro
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
hxy : x * y ∈ I
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
⊢ False

tactic: exact not_mem_I mem_I
state_before: case intro
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
mem_I : ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y ∈ I
not_mem_I : ¬↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y ∈ I
⊢ False

tactic: intro x hx
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
hxy : x * y ∈ I
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
⊢ ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))

tactic: rw [filter_nonempty_iff]
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x✝ y : A
hxy : x✝ * y ∈ I
rid₁ : ¬x✝ ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x✝ ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x✝))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x✝ ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x✝))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
x : A
hx : ¬x ∈ I
⊢ Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))

tactic: contrapose! hx
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x✝ y : A
hxy : x✝ * y ∈ I
rid₁ : ¬x✝ ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x✝ ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x✝))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x✝ ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x✝))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
x : A
hx : ¬x ∈ I
⊢ ∃ a, a ∈ Dfinsupp.support (↑(decompose 𝒜) x) ∧ ¬↑(proj 𝒜 a) x ∈ I

tactic: simp_rw [proj_apply] at hx
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x✝ y : A
hxy : x✝ * y ∈ I
rid₁ : ¬x✝ ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x✝ ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x✝))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x✝ ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x✝))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
x : A
hx : ∀ (a : ι), a ∈ Dfinsupp.support (↑(decompose 𝒜) x) → ↑(proj 𝒜 a) x ∈ I
⊢ x ∈ I

tactic: rw [← sum_support_decompose 𝒜 x]
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x✝ y : A
hxy : x✝ * y ∈ I
rid₁ : ¬x✝ ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x✝ ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x✝))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x✝ ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x✝))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
x : A
hx : ∀ (a : ι), a ∈ Dfinsupp.support (↑(decompose 𝒜) x) → ↑(↑(↑(decompose 𝒜) x) a) ∈ I
⊢ x ∈ I

tactic: exact Ideal.sum_mem _ hx
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x✝ y : A
hxy : x✝ * y ∈ I
rid₁ : ¬x✝ ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x✝ ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x✝))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x✝ ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x✝))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
x : A
hx : ∀ (a : ι), a ∈ Dfinsupp.support (↑(decompose 𝒜) x) → ↑(↑(↑(decompose 𝒜) x) a) ∈ I
⊢ ∑ i in Dfinsupp.support (↑(decompose 𝒜) x), ↑(↑(↑(decompose 𝒜) x) i) ∈ I

tactic: set antidiag :=
  ((decompose 𝒜 x).support ×ˢ (decompose 𝒜 y).support).filter (fun z : ι × ι =>
    z.1 + z.2 = max₁ + max₂) with ha
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
⊢ ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y ∈ I

tactic: have mem_antidiag : (max₁, max₂) ∈ antidiag := by
  simp only [add_sum_erase, mem_filter, mem_product]
  exact ⟨⟨mem_of_mem_filter _ mem_max₁, mem_of_mem_filter _ mem_max₂⟩, trivial⟩
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
⊢ ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y ∈ I

tactic: have eq_add_sum :=
  calc
    proj 𝒜 (max₁ + max₂) (x * y) = ∑ ij in antidiag, proj 𝒜 ij.1 x * proj 𝒜 ij.2 y := by
      simp_rw [ha, proj_apply, DirectSum.decompose_mul, DirectSum.coe_mul_apply 𝒜]
    _ =
        proj 𝒜 max₁ x * proj 𝒜 max₂ y +
          ∑ ij in antidiag.erase (max₁, max₂), proj 𝒜 ij.1 x * proj 𝒜 ij.2 y :=
      (add_sum_erase _ _ mem_antidiag).symm
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
⊢ ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y ∈ I

tactic: rw [eq_sub_of_add_eq eq_add_sum.symm]
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
eq_add_sum :
  ↑(proj 𝒜 (max₁ + max₂)) (x * y) =
    ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y + ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y
⊢ ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y ∈ I

tactic: refine' Ideal.sub_mem _ hxy (Ideal.sum_mem _ fun z H => _)
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
eq_add_sum :
  ↑(proj 𝒜 (max₁ + max₂)) (x * y) =
    ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y + ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y
⊢ ↑(proj 𝒜 (max₁ + max₂)) (x * y) - ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y ∈ I

tactic: rcases z with ⟨i, j⟩
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
eq_add_sum :
  ↑(proj 𝒜 (max₁ + max₂)) (x * y) =
    ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y + ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y
z : ι × ι
H : z ∈ erase antidiag (max₁, max₂)
⊢ ↑(proj 𝒜 z.fst) x * ↑(proj 𝒜 z.snd) y ∈ I

tactic: simp only [mem_erase, Prod.mk.inj_iff, Ne.def, mem_filter, mem_product] at H
state_before: case mk
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
eq_add_sum :
  ↑(proj 𝒜 (max₁ + max₂)) (x * y) =
    ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y + ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y
i j : ι
H : (i, j) ∈ erase antidiag (max₁, max₂)
⊢ ↑(proj 𝒜 (i, j).fst) x * ↑(proj 𝒜 (i, j).snd) y ∈ I

tactic: rcases H with ⟨H₁, ⟨H₂, H₃⟩, H₄⟩
state_before: case mk
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
eq_add_sum :
  ↑(proj 𝒜 (max₁ + max₂)) (x * y) =
    ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y + ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y
i j : ι
H :
  ¬(i =
          max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
            (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) ∧
        j =
          max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
            (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))) ∧
    (i ∈ Dfinsupp.support (↑(decompose 𝒜) x) ∧ j ∈ Dfinsupp.support (↑(decompose 𝒜) y)) ∧
      i + j =
        max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
            (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) +
          max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
            (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
⊢ ↑(proj 𝒜 (i, j).fst) x * ↑(proj 𝒜 (i, j).snd) y ∈ I

tactic: cases' max_lt with max_lt max_lt
state_before: case mk.intro.intro.intro
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
eq_add_sum :
  ↑(proj 𝒜 (max₁ + max₂)) (x * y) =
    ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y + ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y
i j : ι
H₁ :
  ¬(i =
        max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) ∧
      j =
        max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))))
H₄ :
  i + j =
    max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) +
      max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
H₂ : i ∈ Dfinsupp.support (↑(decompose 𝒜) x)
H₃ : j ∈ Dfinsupp.support (↑(decompose 𝒜) y)
max_lt : max₁ < i ∨ max₂ < j
⊢ ↑(proj 𝒜 (i, j).fst) x * ↑(proj 𝒜 (i, j).snd) y ∈ I

tactic: simp only [add_sum_erase, mem_filter, mem_product]
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
⊢ (max₁, max₂) ∈ antidiag

tactic: exact ⟨⟨mem_of_mem_filter _ mem_max₁, mem_of_mem_filter _ mem_max₂⟩, trivial⟩
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
⊢ (max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) ∈
        Dfinsupp.support (↑(decompose 𝒜) x) ∧
      max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))) ∈
        Dfinsupp.support (↑(decompose 𝒜) y)) ∧
    True

tactic: simp_rw [ha, proj_apply, DirectSum.decompose_mul, DirectSum.coe_mul_apply 𝒜]
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
⊢ ↑(proj 𝒜 (max₁ + max₂)) (x * y) = ∑ ij in antidiag, ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y

tactic: rcases lt_trichotomy max₁ i with (h | rfl | h)
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
eq_add_sum :
  ↑(proj 𝒜 (max₁ + max₂)) (x * y) =
    ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y + ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y
i j : ι
H₁ :
  ¬(i =
        max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) ∧
      j =
        max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))))
H₄ :
  i + j =
    max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) +
      max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
H₂ : i ∈ Dfinsupp.support (↑(decompose 𝒜) x)
H₃ : j ∈ Dfinsupp.support (↑(decompose 𝒜) y)
⊢ max₁ < i ∨ max₂ < j

tactic: exact Or.inl h
state_before: case inl
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
eq_add_sum :
  ↑(proj 𝒜 (max₁ + max₂)) (x * y) =
    ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y + ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y
i j : ι
H₁ :
  ¬(i =
        max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) ∧
      j =
        max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))))
H₄ :
  i + j =
    max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) +
      max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
H₂ : i ∈ Dfinsupp.support (↑(decompose 𝒜) x)
H₃ : j ∈ Dfinsupp.support (↑(decompose 𝒜) y)
h : max₁ < i
⊢ max₁ < i ∨ max₂ < j

tactic: refine' False.elim (H₁ ⟨rfl, add_left_cancel H₄⟩)
state_before: case inr.inl
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
eq_add_sum :
  ↑(proj 𝒜 (max₁ + max₂)) (x * y) =
    ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y + ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y
j : ι
H₃ : j ∈ Dfinsupp.support (↑(decompose 𝒜) y)
H₁ :
  ¬(max₁ =
        max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) ∧
      j =
        max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))))
H₄ :
  max₁ + j =
    max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) +
      max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
H₂ : max₁ ∈ Dfinsupp.support (↑(decompose 𝒜) x)
⊢ max₁ < max₁ ∨ max₂ < j

tactic: apply Or.inr
state_before: case inr.inr
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
eq_add_sum :
  ↑(proj 𝒜 (max₁ + max₂)) (x * y) =
    ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y + ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y
i j : ι
H₁ :
  ¬(i =
        max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) ∧
      j =
        max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))))
H₄ :
  i + j =
    max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) +
      max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
H₂ : i ∈ Dfinsupp.support (↑(decompose 𝒜) x)
H₃ : j ∈ Dfinsupp.support (↑(decompose 𝒜) y)
h : i < max₁
⊢ max₁ < i ∨ max₂ < j

tactic: have := add_lt_add_right h j
state_before: case inr.inr.h
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
eq_add_sum :
  ↑(proj 𝒜 (max₁ + max₂)) (x * y) =
    ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y + ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y
i j : ι
H₁ :
  ¬(i =
        max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) ∧
      j =
        max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))))
H₄ :
  i + j =
    max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) +
      max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
H₂ : i ∈ Dfinsupp.support (↑(decompose 𝒜) x)
H₃ : j ∈ Dfinsupp.support (↑(decompose 𝒜) y)
h : i < max₁
⊢ max₂ < j

tactic: rw [H₄] at this
state_before: case inr.inr.h
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
eq_add_sum :
  ↑(proj 𝒜 (max₁ + max₂)) (x * y) =
    ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y + ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y
i j : ι
H₁ :
  ¬(i =
        max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) ∧
      j =
        max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))))
H₄ :
  i + j =
    max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) +
      max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
H₂ : i ∈ Dfinsupp.support (↑(decompose 𝒜) x)
H₃ : j ∈ Dfinsupp.support (↑(decompose 𝒜) y)
h : i < max₁
this : i + j < max₁ + j
⊢ max₂ < j

tactic: exact lt_of_add_lt_add_left this
state_before: case inr.inr.h
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
eq_add_sum :
  ↑(proj 𝒜 (max₁ + max₂)) (x * y) =
    ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y + ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y
i j : ι
H₁ :
  ¬(i =
        max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) ∧
      j =
        max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))))
H₄ :
  i + j =
    max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) +
      max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
H₂ : i ∈ Dfinsupp.support (↑(decompose 𝒜) x)
H₃ : j ∈ Dfinsupp.support (↑(decompose 𝒜) y)
h : i < max₁
this :
  max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) +
      max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))) <
    max₁ + j
⊢ max₂ < j

tactic: have not_mem : i ∉ set₁ := fun h =>
  lt_irrefl _ ((max'_lt_iff set₁ (nonempty x rid₁)).mp max_lt i h)
state_before: case mk.intro.intro.intro.inl
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
eq_add_sum :
  ↑(proj 𝒜 (max₁ + max₂)) (x * y) =
    ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y + ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y
i j : ι
H₁ :
  ¬(i =
        max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) ∧
      j =
        max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))))
H₄ :
  i + j =
    max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) +
      max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
H₂ : i ∈ Dfinsupp.support (↑(decompose 𝒜) x)
H₃ : j ∈ Dfinsupp.support (↑(decompose 𝒜) y)
max_lt : max₁ < i
⊢ ↑(proj 𝒜 (i, j).fst) x * ↑(proj 𝒜 (i, j).snd) y ∈ I

tactic: rw [set₁_eq] at not_mem
state_before: case mk.intro.intro.intro.inl
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
eq_add_sum :
  ↑(proj 𝒜 (max₁ + max₂)) (x * y) =
    ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y + ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y
i j : ι
H₁ :
  ¬(i =
        max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) ∧
      j =
        max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))))
H₄ :
  i + j =
    max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) +
      max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
H₂ : i ∈ Dfinsupp.support (↑(decompose 𝒜) x)
H₃ : j ∈ Dfinsupp.support (↑(decompose 𝒜) y)
max_lt : max₁ < i
not_mem : ¬i ∈ set₁
⊢ ↑(proj 𝒜 (i, j).fst) x * ↑(proj 𝒜 (i, j).snd) y ∈ I

tactic: simp only [not_and, Classical.not_not, Ne.def, mem_filter] at not_mem
state_before: case mk.intro.intro.intro.inl
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
eq_add_sum :
  ↑(proj 𝒜 (max₁ + max₂)) (x * y) =
    ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y + ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y
i j : ι
H₁ :
  ¬(i =
        max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) ∧
      j =
        max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))))
H₄ :
  i + j =
    max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) +
      max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
H₂ : i ∈ Dfinsupp.support (↑(decompose 𝒜) x)
H₃ : j ∈ Dfinsupp.support (↑(decompose 𝒜) y)
max_lt : max₁ < i
not_mem : ¬i ∈ filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
⊢ ↑(proj 𝒜 (i, j).fst) x * ↑(proj 𝒜 (i, j).snd) y ∈ I

tactic: exact Ideal.mul_mem_right _ I (not_mem H₂)
state_before: case mk.intro.intro.intro.inl
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
eq_add_sum :
  ↑(proj 𝒜 (max₁ + max₂)) (x * y) =
    ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y + ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y
i j : ι
H₁ :
  ¬(i =
        max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) ∧
      j =
        max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))))
H₄ :
  i + j =
    max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) +
      max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
H₂ : i ∈ Dfinsupp.support (↑(decompose 𝒜) x)
H₃ : j ∈ Dfinsupp.support (↑(decompose 𝒜) y)
max_lt : max₁ < i
not_mem : i ∈ Dfinsupp.support (↑(decompose 𝒜) x) → ↑(proj 𝒜 i) x ∈ I
⊢ ↑(proj 𝒜 (i, j).fst) x * ↑(proj 𝒜 (i, j).snd) y ∈ I

tactic: have not_mem : j ∉ set₂ := fun h =>
  lt_irrefl _ ((max'_lt_iff set₂ (nonempty y rid₂)).mp max_lt j h)
state_before: case mk.intro.intro.intro.inr
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
eq_add_sum :
  ↑(proj 𝒜 (max₁ + max₂)) (x * y) =
    ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y + ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y
i j : ι
H₁ :
  ¬(i =
        max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) ∧
      j =
        max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))))
H₄ :
  i + j =
    max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) +
      max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
H₂ : i ∈ Dfinsupp.support (↑(decompose 𝒜) x)
H₃ : j ∈ Dfinsupp.support (↑(decompose 𝒜) y)
max_lt : max₂ < j
⊢ ↑(proj 𝒜 (i, j).fst) x * ↑(proj 𝒜 (i, j).snd) y ∈ I

tactic: rw [set₂_eq] at not_mem
state_before: case mk.intro.intro.intro.inr
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
eq_add_sum :
  ↑(proj 𝒜 (max₁ + max₂)) (x * y) =
    ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y + ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y
i j : ι
H₁ :
  ¬(i =
        max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) ∧
      j =
        max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))))
H₄ :
  i + j =
    max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) +
      max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
H₂ : i ∈ Dfinsupp.support (↑(decompose 𝒜) x)
H₃ : j ∈ Dfinsupp.support (↑(decompose 𝒜) y)
max_lt : max₂ < j
not_mem : ¬j ∈ set₂
⊢ ↑(proj 𝒜 (i, j).fst) x * ↑(proj 𝒜 (i, j).snd) y ∈ I

tactic: simp only [not_and, Classical.not_not, Ne.def, mem_filter] at not_mem
state_before: case mk.intro.intro.intro.inr
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
eq_add_sum :
  ↑(proj 𝒜 (max₁ + max₂)) (x * y) =
    ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y + ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y
i j : ι
H₁ :
  ¬(i =
        max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) ∧
      j =
        max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))))
H₄ :
  i + j =
    max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) +
      max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
H₂ : i ∈ Dfinsupp.support (↑(decompose 𝒜) x)
H₃ : j ∈ Dfinsupp.support (↑(decompose 𝒜) y)
max_lt : max₂ < j
not_mem : ¬j ∈ filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
⊢ ↑(proj 𝒜 (i, j).fst) x * ↑(proj 𝒜 (i, j).snd) y ∈ I

tactic: exact Ideal.mul_mem_left I _ (not_mem H₃)
state_before: case mk.intro.intro.intro.inr
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
antidiag : Finset (ι × ι) :=
  filter (fun z => z.fst + z.snd = max₁ + max₂)
    (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
ha :
  antidiag =
    filter (fun z => z.fst + z.snd = max₁ + max₂)
      (Dfinsupp.support (↑(decompose 𝒜) x) ×ˢ Dfinsupp.support (↑(decompose 𝒜) y))
mem_antidiag : (max₁, max₂) ∈ antidiag
eq_add_sum :
  ↑(proj 𝒜 (max₁ + max₂)) (x * y) =
    ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y + ∑ ij in erase antidiag (max₁, max₂), ↑(proj 𝒜 ij.fst) x * ↑(proj 𝒜 ij.snd) y
i j : ι
H₁ :
  ¬(i =
        max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) ∧
      j =
        max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
          (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))))
H₄ :
  i + j =
    max' (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))) +
      max' (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y)))
        (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
H₂ : i ∈ Dfinsupp.support (↑(decompose 𝒜) x)
H₃ : j ∈ Dfinsupp.support (↑(decompose 𝒜) y)
max_lt : max₂ < j
not_mem : j ∈ Dfinsupp.support (↑(decompose 𝒜) y) → ↑(proj 𝒜 j) y ∈ I
⊢ ↑(proj 𝒜 (i, j).fst) x * ↑(proj 𝒜 (i, j).snd) y ∈ I

tactic: have neither_mem : proj 𝒜 max₁ x ∉ I ∧ proj 𝒜 max₂ y ∉ I := by
  rw [mem_filter] at mem_max₁ mem_max₂
  exact ⟨mem_max₁.2, mem_max₂.2⟩
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
mem_I : ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y ∈ I
⊢ ¬↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y ∈ I

tactic: intro _rid
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
mem_I : ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y ∈ I
neither_mem : ¬↑(proj 𝒜 max₁) x ∈ I ∧ ¬↑(proj 𝒜 max₂) y ∈ I
⊢ ¬↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y ∈ I

tactic: cases' homogeneous_mem_or_mem ⟨max₁, SetLike.coe_mem _⟩ ⟨max₂, SetLike.coe_mem _⟩ mem_I
  with h h
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
mem_I : ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y ∈ I
neither_mem : ¬↑(proj 𝒜 max₁) x ∈ I ∧ ¬↑(proj 𝒜 max₂) y ∈ I
_rid : ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y ∈ I
⊢ False

tactic: rw [mem_filter] at mem_max₁ mem_max₂
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
mem_I : ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y ∈ I
⊢ ¬↑(proj 𝒜 max₁) x ∈ I ∧ ¬↑(proj 𝒜 max₂) y ∈ I

tactic: exact ⟨mem_max₁.2, mem_max₂.2⟩
state_before: ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ Dfinsupp.support (↑(decompose 𝒜) x) ∧ ¬↑(proj 𝒜 max₁) x ∈ I
mem_max₂ : max₂ ∈ Dfinsupp.support (↑(decompose 𝒜) y) ∧ ¬↑(proj 𝒜 max₂) y ∈ I
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
mem_I : ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y ∈ I
⊢ ¬↑(proj 𝒜 max₁) x ∈ I ∧ ¬↑(proj 𝒜 max₂) y ∈ I

tactic: apply neither_mem.1 h
state_before: case inl
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
mem_I : ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y ∈ I
neither_mem : ¬↑(proj 𝒜 max₁) x ∈ I ∧ ¬↑(proj 𝒜 max₂) y ∈ I
_rid : ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y ∈ I
h :
  ↑(↑(AddMonoidHom.comp (Dfinsupp.evalAddMonoidHom max₁)
            (RingHom.toAddMonoidHom (RingEquiv.toRingHom (decomposeRingEquiv 𝒜))))
        x) ∈
    I
⊢ False

tactic: apply neither_mem.2 h
state_before: case inr
ι : Type u_2
σ : Type u_3
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
hI : IsHomogeneous 𝒜 I
I_ne_top : I ≠ ⊤
homogeneous_mem_or_mem : ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I
x y : A
rid₁ : ¬x ∈ I
rid₂ : ¬y ∈ I
set₁ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₁_eq : set₁ = filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))
set₂ : Finset ι := filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
set₂_eq : set₂ = filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))
nonempty :
  ∀ (x : A), ¬x ∈ I → Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x)))
max₁ : ι := max' set₁ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) x ∈ I) (Dfinsupp.support (↑(decompose 𝒜) x))))
max₂ : ι := max' set₂ (_ : Finset.Nonempty (filter (fun i => ¬↑(proj 𝒜 i) y ∈ I) (Dfinsupp.support (↑(decompose 𝒜) y))))
mem_max₁ : max₁ ∈ set₁
mem_max₂ : max₂ ∈ set₂
hxy : ↑(proj 𝒜 (max₁ + max₂)) (x * y) ∈ I
mem_I : ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y ∈ I
neither_mem : ¬↑(proj 𝒜 max₁) x ∈ I ∧ ¬↑(proj 𝒜 max₂) y ∈ I
_rid : ↑(proj 𝒜 max₁) x * ↑(proj 𝒜 max₂) y ∈ I
h :
  ↑(↑(AddMonoidHom.comp (Dfinsupp.evalAddMonoidHom max₂)
            (RingHom.toAddMonoidHom (RingEquiv.toRingHom (decomposeRingEquiv 𝒜))))
        y) ∈
    I
⊢ False