Theorem: Finset.sum_pow_of_commute
File: Mathlib/Data/Nat/Choose/Multinomial.lean

tactic: induction' s using Finset.induction with a s ha ih
state_before: α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑s).Pairwise fun i j => Commute (x i) (x j)
⊢ ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
state_after: case empty
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
⊢ ∀ (n : ℕ), ∅.sum x ^ n = ∑ k : { x // x ∈ ∅.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯

case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
ih :
  ∀ (hc : (↑s).Pairwise fun i j => Commute (x i) (x j)) (n : ℕ),
    s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
⊢ ∀ (n : ℕ),
    (insert a s).sum x ^ n =
      ∑ k : { x // x ∈ (insert a s).sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯

tactic: intro n
state_before: case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
ih :
  ∀ (hc : (↑s).Pairwise fun i j => Commute (x i) (x j)) (n : ℕ),
    s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
⊢ ∀ (n : ℕ),
    (insert a s).sum x ^ n =
      ∑ k : { x // x ∈ (insert a s).sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
state_after: case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
ih :
  ∀ (hc : (↑s).Pairwise fun i j => Commute (x i) (x j)) (n : ℕ),
    s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
⊢ (insert a s).sum x ^ n =
    ∑ k : { x // x ∈ (insert a s).sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯

tactic: specialize ih (hc.mono <| s.subset_insert a)
state_before: case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
ih :
  ∀ (hc : (↑s).Pairwise fun i j => Commute (x i) (x j)) (n : ℕ),
    s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
⊢ (insert a s).sum x ^ n =
    ∑ k : { x // x ∈ (insert a s).sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
state_after: case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
⊢ (insert a s).sum x ^ n =
    ∑ k : { x // x ∈ (insert a s).sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯

tactic: rw [sum_insert ha, (Commute.sum_right s _ _ _).add_pow, sum_range]
state_before: case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
⊢ (insert a s).sum x ^ n =
    ∑ k : { x // x ∈ (insert a s).sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
state_after: case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
⊢ ∑ i : Fin (n + 1), x a ^ ↑i * (∑ i ∈ s, x i) ^ (n - ↑i) * ↑(n.choose ↑i) =
    ∑ k : { x // x ∈ (insert a s).sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯

α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
⊢ ∀ i ∈ s, Commute (x a) (x i)

tactic: swap
state_before: case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
⊢ ∑ i : Fin (n + 1), x a ^ ↑i * (∑ i ∈ s, x i) ^ (n - ↑i) * ↑(n.choose ↑i) =
    ∑ k : { x // x ∈ (insert a s).sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯

α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
⊢ ∀ i ∈ s, Commute (x a) (x i)
state_after: α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
⊢ ∀ i ∈ s, Commute (x a) (x i)

case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
⊢ ∑ i : Fin (n + 1), x a ^ ↑i * (∑ i ∈ s, x i) ^ (n - ↑i) * ↑(n.choose ↑i) =
    ∑ k : { x // x ∈ (insert a s).sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯

tactic: rw [sum_empty]
state_before: case empty
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
⊢ ∀ (n : ℕ), ∅.sum x ^ n = ∑ k : { x // x ∈ ∅.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
state_after: case empty
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
⊢ ∀ (n : ℕ), 0 ^ n = ∑ k : { x // x ∈ ∅.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯

tactic: rintro (_ | n)
state_before: case empty
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
⊢ ∀ (n : ℕ), 0 ^ n = ∑ k : { x // x ∈ ∅.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
state_after: case empty.zero
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
⊢ 0 ^ 0 = ∑ k : { x // x ∈ ∅.sym 0 }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯

case empty.succ
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
⊢ 0 ^ (n + 1) = ∑ k : { x // x ∈ ∅.sym (n + 1) }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯

tactic: haveI : Subsingleton (Sym α 0) := Unique.instSubsingleton
state_before: case empty.zero
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
⊢ 0 ^ 0 = ∑ k : { x // x ∈ ∅.sym 0 }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
state_after: case empty.zero
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
this : Subsingleton (Sym α 0)
⊢ 0 ^ 0 = ∑ k : { x // x ∈ ∅.sym 0 }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯

tactic: rw [_root_.pow_zero, Fintype.sum_subsingleton]
state_before: case empty.zero
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
this : Subsingleton (Sym α 0)
⊢ 0 ^ 0 = ∑ k : { x // x ∈ ∅.sym 0 }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
state_after: case empty.zero
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
this : Subsingleton (Sym α 0)
⊢ 1 = ↑(↑↑?empty.zero.a).multinomial * (Multiset.map x ↑↑?empty.zero.a).noncommProd ⋯

case empty.zero.a
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
this : Subsingleton (Sym α 0)
⊢ { x // x ∈ ∅.sym 0 }

tactic: swap
state_before: case empty.zero
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
this : Subsingleton (Sym α 0)
⊢ 1 = ↑(↑↑?empty.zero.a).multinomial * (Multiset.map x ↑↑?empty.zero.a).noncommProd ⋯

case empty.zero.a
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
this : Subsingleton (Sym α 0)
⊢ { x // x ∈ ∅.sym 0 }
state_after: case empty.zero.a
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
this : Subsingleton (Sym α 0)
⊢ { x // x ∈ ∅.sym 0 }

case empty.zero
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
this : Subsingleton (Sym α 0)
⊢ 1 = ↑(↑↑?empty.zero.a).multinomial * (Multiset.map x ↑↑?empty.zero.a).noncommProd ⋯

tactic: convert (@one_mul R _ _).symm
state_before: case empty.zero
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
this : Subsingleton (Sym α 0)
⊢ 1 =
    ↑(↑↑(let_fun this_1 := Sym.instZeroSym;
              ⟨0, ⋯⟩)).multinomial *
      (Multiset.map x
            ↑↑(let_fun this_1 := Sym.instZeroSym;
                ⟨0, ⋯⟩)).noncommProd
        ⋯
state_after: case h.e'_3.h.e'_5
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
this : Subsingleton (Sym α 0)
⊢ ↑(↑↑(let_fun this_1 := Sym.instZeroSym;
            ⟨0, ⋯⟩)).multinomial =
    1

tactic: convert @Nat.cast_one R _
state_before: case h.e'_3.h.e'_5
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
this : Subsingleton (Sym α 0)
⊢ ↑(↑↑(let_fun this_1 := Sym.instZeroSym;
            ⟨0, ⋯⟩)).multinomial =
    1
state_after: case h.e'_2.h.e'_3
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
this : Subsingleton (Sym α 0)
⊢ (↑↑(let_fun this_1 := Sym.instZeroSym;
          ⟨0, ⋯⟩)).multinomial =
    1

tactic: simp
state_before: case h.e'_2.h.e'_3
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
this : Subsingleton (Sym α 0)
⊢ (↑↑(let_fun this_1 := Sym.instZeroSym;
          ⟨0, ⋯⟩)).multinomial =
    1
state_after: no goals

tactic: have : Zero (Sym α 0) := Sym.instZeroSym
state_before: case empty.zero.a
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
this : Subsingleton (Sym α 0)
⊢ { x // x ∈ ∅.sym 0 }
state_after: case empty.zero.a
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
this✝ : Subsingleton (Sym α 0)
this : Zero (Sym α 0)
⊢ { x // x ∈ ∅.sym 0 }

tactic: exact ⟨0, by simp [eq_iff_true_of_subsingleton]⟩
state_before: case empty.zero.a
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
this✝ : Subsingleton (Sym α 0)
this : Zero (Sym α 0)
⊢ { x // x ∈ ∅.sym 0 }
state_after: no goals

tactic: simp [eq_iff_true_of_subsingleton]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
this✝ : Subsingleton (Sym α 0)
this : Zero (Sym α 0)
⊢ 0 ∈ ∅.sym 0
state_after: no goals

tactic: rw [_root_.pow_succ, mul_zero]
state_before: case empty.succ
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
⊢ 0 ^ (n + 1) = ∑ k : { x // x ∈ ∅.sym (n + 1) }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
state_after: case empty.succ
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
⊢ 0 = ∑ k : { x // x ∈ ∅.sym (n + 1) }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯

tactic: haveI : IsEmpty (Finset.sym (∅ : Finset α) n.succ) := Finset.instIsEmpty
state_before: case empty.succ
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
⊢ 0 = ∑ k : { x // x ∈ ∅.sym (n + 1) }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
state_after: case empty.succ
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
this : IsEmpty { x // x ∈ ∅.sym n.succ }
⊢ 0 = ∑ k : { x // x ∈ ∅.sym (n + 1) }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯

tactic: apply (Fintype.sum_empty _).symm
state_before: case empty.succ
α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
hc : (↑∅).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
this : IsEmpty { x // x ∈ ∅.sym n.succ }
⊢ 0 = ∑ k : { x // x ∈ ∅.sym (n + 1) }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
state_after: no goals

tactic: exact fun _ hb => hc (mem_insert_self a s) (mem_insert_of_mem hb)
  (ne_of_mem_of_not_mem hb ha).symm
state_before: α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
⊢ ∀ i ∈ s, Commute (x a) (x i)
state_after: no goals

tactic: simp_rw [ih, mul_sum, sum_mul, sum_sigma', univ_sigma_univ]
state_before: case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
⊢ ∑ i : Fin (n + 1), x a ^ ↑i * (∑ i ∈ s, x i) ^ (n - ↑i) * ↑(n.choose ↑i) =
    ∑ k : { x // x ∈ (insert a s).sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
state_after: case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
⊢ ∑ x_1 : (i : Fin (n + 1)) × { x // x ∈ s.sym (n - ↑i) },
      x a ^ ↑x_1.fst * (↑(↑↑x_1.snd).multinomial * (Multiset.map x ↑↑x_1.snd).noncommProd ⋯) * ↑(n.choose ↑x_1.fst) =
    ∑ k : { x // x ∈ (insert a s).sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯

tactic: refine (Fintype.sum_equiv (symInsertEquiv ha) _ _ fun m => ?_).symm
state_before: case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
⊢ ∑ x_1 : (i : Fin (n + 1)) × { x // x ∈ s.sym (n - ↑i) },
      x a ^ ↑x_1.fst * (↑(↑↑x_1.snd).multinomial * (Multiset.map x ↑↑x_1.snd).noncommProd ⋯) * ↑(n.choose ↑x_1.fst) =
    ∑ k : { x // x ∈ (insert a s).sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
state_after: case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
m : { x // x ∈ (insert a s).sym n }
⊢ ↑(↑↑m).multinomial * (Multiset.map x ↑↑m).noncommProd ⋯ =
    x a ^ ↑((symInsertEquiv ha) m).fst *
        (↑(↑↑((symInsertEquiv ha) m).snd).multinomial * (Multiset.map x ↑↑((symInsertEquiv ha) m).snd).noncommProd ⋯) *
      ↑(n.choose ↑((symInsertEquiv ha) m).fst)

tactic: rw [m.1.1.multinomial_filter_ne a]
state_before: case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
m : { x // x ∈ (insert a s).sym n }
⊢ ↑(↑↑m).multinomial * (Multiset.map x ↑↑m).noncommProd ⋯ =
    x a ^ ↑((symInsertEquiv ha) m).fst *
        (↑(↑↑((symInsertEquiv ha) m).snd).multinomial * (Multiset.map x ↑↑((symInsertEquiv ha) m).snd).noncommProd ⋯) *
      ↑(n.choose ↑((symInsertEquiv ha) m).fst)
state_after: case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
m : { x // x ∈ (insert a s).sym n }
⊢ ↑((Multiset.card ↑↑m).choose (Multiset.count a ↑↑m) * (Multiset.filter (fun x => a ≠ x) ↑↑m).multinomial) *
      (Multiset.map x ↑↑m).noncommProd ⋯ =
    x a ^ ↑((symInsertEquiv ha) m).fst *
        (↑(↑↑((symInsertEquiv ha) m).snd).multinomial * (Multiset.map x ↑↑((symInsertEquiv ha) m).snd).noncommProd ⋯) *
      ↑(n.choose ↑((symInsertEquiv ha) m).fst)

tactic: simp_rw [Multiset.noncommProd_add, m.1.1.filter_eq, Multiset.map_replicate, m.1.2]
state_before: case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
m : { x // x ∈ (insert a s).sym n }
⊢ ↑((Multiset.card ↑↑m).choose (Multiset.count a ↑↑m) * (Multiset.filter (fun x => a ≠ x) ↑↑m).multinomial) *
      (Multiset.map x (Multiset.filter (fun x => a = x) ↑↑m) +
            Multiset.map x (Multiset.filter (fun a_1 => ¬a = a_1) ↑↑m)).noncommProd
        ⋯ =
    x a ^ ↑((symInsertEquiv ha) m).fst *
        (↑(↑↑((symInsertEquiv ha) m).snd).multinomial * (Multiset.map x ↑↑((symInsertEquiv ha) m).snd).noncommProd ⋯) *
      ↑(n.choose ↑((symInsertEquiv ha) m).fst)
state_after: case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
m : { x // x ∈ (insert a s).sym n }
⊢ ↑(n.choose (Multiset.count a ↑↑m) * (Multiset.filter (fun x => a ≠ x) ↑↑m).multinomial) *
      ((Multiset.replicate (Multiset.count a ↑↑m) (x a)).noncommProd ⋯ *
        (Multiset.map x (Multiset.filter (fun a_1 => ¬a = a_1) ↑↑m)).noncommProd ⋯) =
    x a ^ ↑((symInsertEquiv ha) m).fst *
        (↑(↑↑((symInsertEquiv ha) m).snd).multinomial * (Multiset.map x ↑↑((symInsertEquiv ha) m).snd).noncommProd ⋯) *
      ↑(n.choose ↑((symInsertEquiv ha) m).fst)

tactic: rw [Multiset.noncommProd_eq_pow_card _ _ _ fun _ => Multiset.eq_of_mem_replicate]
state_before: case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
m : { x // x ∈ (insert a s).sym n }
⊢ ↑(n.choose (Multiset.count a ↑↑m) * (Multiset.filter (fun x => a ≠ x) ↑↑m).multinomial) *
      ((Multiset.replicate (Multiset.count a ↑↑m) (x a)).noncommProd ⋯ *
        (Multiset.map x (Multiset.filter (fun a_1 => ¬a = a_1) ↑↑m)).noncommProd ⋯) =
    x a ^ ↑((symInsertEquiv ha) m).fst *
        (↑(↑↑((symInsertEquiv ha) m).snd).multinomial * (Multiset.map x ↑↑((symInsertEquiv ha) m).snd).noncommProd ⋯) *
      ↑(n.choose ↑((symInsertEquiv ha) m).fst)
state_after: case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
m : { x // x ∈ (insert a s).sym n }
⊢ ↑(n.choose (Multiset.count a ↑↑m) * (Multiset.filter (fun x => a ≠ x) ↑↑m).multinomial) *
      (x a ^ Multiset.card (Multiset.replicate (Multiset.count a ↑↑m) (x a)) *
        (Multiset.map x (Multiset.filter (fun a_1 => ¬a = a_1) ↑↑m)).noncommProd ⋯) =
    x a ^ ↑((symInsertEquiv ha) m).fst *
        (↑(↑↑((symInsertEquiv ha) m).snd).multinomial * (Multiset.map x ↑↑((symInsertEquiv ha) m).snd).noncommProd ⋯) *
      ↑(n.choose ↑((symInsertEquiv ha) m).fst)

tactic: rw [Multiset.card_replicate, Nat.cast_mul, mul_assoc, Nat.cast_comm]
state_before: case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
m : { x // x ∈ (insert a s).sym n }
⊢ ↑(n.choose (Multiset.count a ↑↑m) * (Multiset.filter (fun x => a ≠ x) ↑↑m).multinomial) *
      (x a ^ Multiset.card (Multiset.replicate (Multiset.count a ↑↑m) (x a)) *
        (Multiset.map x (Multiset.filter (fun a_1 => ¬a = a_1) ↑↑m)).noncommProd ⋯) =
    x a ^ ↑((symInsertEquiv ha) m).fst *
        (↑(↑↑((symInsertEquiv ha) m).snd).multinomial * (Multiset.map x ↑↑((symInsertEquiv ha) m).snd).noncommProd ⋯) *
      ↑(n.choose ↑((symInsertEquiv ha) m).fst)
state_after: case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
m : { x // x ∈ (insert a s).sym n }
⊢ ↑(Multiset.filter (fun x => a ≠ x) ↑↑m).multinomial *
        (x a ^ Multiset.count a ↑↑m * (Multiset.map x (Multiset.filter (fun a_1 => ¬a = a_1) ↑↑m)).noncommProd ⋯) *
      ↑(n.choose (Multiset.count a ↑↑m)) =
    x a ^ ↑((symInsertEquiv ha) m).fst *
        (↑(↑↑((symInsertEquiv ha) m).snd).multinomial * (Multiset.map x ↑↑((symInsertEquiv ha) m).snd).noncommProd ⋯) *
      ↑(n.choose ↑((symInsertEquiv ha) m).fst)

tactic: congr 1
state_before: case insert
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
m : { x // x ∈ (insert a s).sym n }
⊢ ↑(Multiset.filter (fun x => a ≠ x) ↑↑m).multinomial *
        (x a ^ Multiset.count a ↑↑m * (Multiset.map x (Multiset.filter (fun a_1 => ¬a = a_1) ↑↑m)).noncommProd ⋯) *
      ↑(n.choose (Multiset.count a ↑↑m)) =
    x a ^ ↑((symInsertEquiv ha) m).fst *
        (↑(↑↑((symInsertEquiv ha) m).snd).multinomial * (Multiset.map x ↑↑((symInsertEquiv ha) m).snd).noncommProd ⋯) *
      ↑(n.choose ↑((symInsertEquiv ha) m).fst)
state_after: case insert.e_a
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
m : { x // x ∈ (insert a s).sym n }
⊢ ↑(Multiset.filter (fun x => a ≠ x) ↑↑m).multinomial *
      (x a ^ Multiset.count a ↑↑m * (Multiset.map x (Multiset.filter (fun a_1 => ¬a = a_1) ↑↑m)).noncommProd ⋯) =
    x a ^ ↑((symInsertEquiv ha) m).fst *
      (↑(↑↑((symInsertEquiv ha) m).snd).multinomial * (Multiset.map x ↑↑((symInsertEquiv ha) m).snd).noncommProd ⋯)

tactic: simp_rw [← mul_assoc, Nat.cast_comm]
state_before: case insert.e_a
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
m : { x // x ∈ (insert a s).sym n }
⊢ ↑(Multiset.filter (fun x => a ≠ x) ↑↑m).multinomial *
      (x a ^ Multiset.count a ↑↑m * (Multiset.map x (Multiset.filter (fun a_1 => ¬a = a_1) ↑↑m)).noncommProd ⋯) =
    x a ^ ↑((symInsertEquiv ha) m).fst *
      (↑(↑↑((symInsertEquiv ha) m).snd).multinomial * (Multiset.map x ↑↑((symInsertEquiv ha) m).snd).noncommProd ⋯)
state_after: case insert.e_a
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
m : { x // x ∈ (insert a s).sym n }
⊢ x a ^ Multiset.count a ↑↑m * ↑(Multiset.filter (fun x => a ≠ x) ↑↑m).multinomial *
      (Multiset.map x (Multiset.filter (fun a_1 => ¬a = a_1) ↑↑m)).noncommProd ⋯ =
    x a ^ ↑((symInsertEquiv ha) m).fst * ↑(↑↑((symInsertEquiv ha) m).snd).multinomial *
      (Multiset.map x ↑↑((symInsertEquiv ha) m).snd).noncommProd ⋯

tactic: rfl
state_before: case insert.e_a
α : Type u_1
inst✝¹ : DecidableEq α
s✝ : Finset α
R : Type u_2
inst✝ : Semiring R
x : α → R
a : α
s : Finset α
ha : a ∉ s
hc : (↑(insert a s)).Pairwise fun i j => Commute (x i) (x j)
n : ℕ
ih : ∀ (n : ℕ), s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
m : { x // x ∈ (insert a s).sym n }
⊢ x a ^ Multiset.count a ↑↑m * ↑(Multiset.filter (fun x => a ≠ x) ↑↑m).multinomial *
      (Multiset.map x (Multiset.filter (fun a_1 => ¬a = a_1) ↑↑m)).noncommProd ⋯ =
    x a ^ ↑((symInsertEquiv ha) m).fst * ↑(↑↑((symInsertEquiv ha) m).snd).multinomial *
      (Multiset.map x ↑↑((symInsertEquiv ha) m).snd).noncommProd ⋯
state_after: no goals