Theorem: List.prod_erase_of_comm
File: Mathlib/Algebra/BigOperators/Group/List.lean

tactic: induction' l with b l ih
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
inst✝ : DecidableEq M
ha : a ∈ l
comm : ∀ x ∈ l, ∀ y ∈ l, x * y = y * x
⊢ a * (l.erase a).prod = l.prod
state_after: case nil
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
inst✝ : DecidableEq M
ha : a ∈ []
comm : ∀ x ∈ [], ∀ y ∈ [], x * y = y * x
⊢ a * ([].erase a).prod = [].prod

case cons
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l✝ l₁ l₂ : List M
a : M
inst✝ : DecidableEq M
b : M
l : List M
ih : a ∈ l → (∀ x ∈ l, ∀ y ∈ l, x * y = y * x) → a * (l.erase a).prod = l.prod
ha : a ∈ b :: l
comm : ∀ x ∈ b :: l, ∀ y ∈ b :: l, x * y = y * x
⊢ a * ((b :: l).erase a).prod = (b :: l).prod

tactic: obtain rfl | ⟨ne, h⟩ := List.eq_or_ne_mem_of_mem ha
state_before: case cons
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l✝ l₁ l₂ : List M
a : M
inst✝ : DecidableEq M
b : M
l : List M
ih : a ∈ l → (∀ x ∈ l, ∀ y ∈ l, x * y = y * x) → a * (l.erase a).prod = l.prod
ha : a ∈ b :: l
comm : ∀ x ∈ b :: l, ∀ y ∈ b :: l, x * y = y * x
⊢ a * ((b :: l).erase a).prod = (b :: l).prod
state_after: case cons.inl
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l✝ l₁ l₂ : List M
a : M
inst✝ : DecidableEq M
l : List M
ih : a ∈ l → (∀ x ∈ l, ∀ y ∈ l, x * y = y * x) → a * (l.erase a).prod = l.prod
ha : a ∈ a :: l
comm : ∀ x ∈ a :: l, ∀ y ∈ a :: l, x * y = y * x
⊢ a * ((a :: l).erase a).prod = (a :: l).prod

case cons.inr.intro
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l✝ l₁ l₂ : List M
a : M
inst✝ : DecidableEq M
b : M
l : List M
ih : a ∈ l → (∀ x ∈ l, ∀ y ∈ l, x * y = y * x) → a * (l.erase a).prod = l.prod
ha : a ∈ b :: l
comm : ∀ x ∈ b :: l, ∀ y ∈ b :: l, x * y = y * x
ne : a ≠ b
h : a ∈ l
⊢ a * ((b :: l).erase a).prod = (b :: l).prod

tactic: rw [List.erase, beq_false_of_ne ne.symm, List.prod_cons, List.prod_cons, ← mul_assoc,
  comm a ha b (l.mem_cons_self b), mul_assoc,
  ih h fun x hx y hy ↦ comm _ (List.mem_cons_of_mem b hx) _ (List.mem_cons_of_mem b hy)]
state_before: case cons.inr.intro
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l✝ l₁ l₂ : List M
a : M
inst✝ : DecidableEq M
b : M
l : List M
ih : a ∈ l → (∀ x ∈ l, ∀ y ∈ l, x * y = y * x) → a * (l.erase a).prod = l.prod
ha : a ∈ b :: l
comm : ∀ x ∈ b :: l, ∀ y ∈ b :: l, x * y = y * x
ne : a ≠ b
h : a ∈ l
⊢ a * ((b :: l).erase a).prod = (b :: l).prod
state_after: no goals

tactic: simp only [not_mem_nil] at ha
state_before: case nil
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
inst✝ : DecidableEq M
ha : a ∈ []
comm : ∀ x ∈ [], ∀ y ∈ [], x * y = y * x
⊢ a * ([].erase a).prod = [].prod
state_after: no goals

tactic: simp only [erase_cons_head, prod_cons]
state_before: case cons.inl
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l✝ l₁ l₂ : List M
a : M
inst✝ : DecidableEq M
l : List M
ih : a ∈ l → (∀ x ∈ l, ∀ y ∈ l, x * y = y * x) → a * (l.erase a).prod = l.prod
ha : a ∈ a :: l
comm : ∀ x ∈ a :: l, ∀ y ∈ a :: l, x * y = y * x
⊢ a * ((a :: l).erase a).prod = (a :: l).prod
state_after: no goals