theorem mul_smul' (f g : ArithmeticFunction R) (h : ArithmeticFunction M) :
    (f * g) • h = f • g • h := by
  ext n
  simp only [mul_apply, smul_apply, sum_smul, mul_smul, smul_sum, Finset.sum_sigma']
  apply Finset.sum_bij
  pick_goal 5
  · rintro ⟨⟨i, j⟩, ⟨k, l⟩⟩ _H
    exact ⟨(k, l * j), (l, j)⟩
  · rintro ⟨⟨i, j⟩, ⟨k, l⟩⟩ H
    simp only [Finset.mem_sigma, mem_divisorsAntidiagonal] at H ⊢
    rcases H with ⟨⟨rfl, n0⟩, rfl, i0⟩
    refine' ⟨⟨(mul_assoc _ _ _).symm, n0⟩, trivial, _⟩
    rw [mul_ne_zero_iff] at *
    exact ⟨i0.2, n0.2⟩
  · 

Proof state:
case h.h
R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f g : ArithmeticFunction R
h : ArithmeticFunction M
n : ℕ
⊢ ∀ (a : (_ : ℕ × ℕ) × ℕ × ℕ) (ha : a ∈ Finset.sigma (divisorsAntidiagonal n) fun a => divisorsAntidiagonal a.1),
    f a.snd.1 • g a.snd.2 • h a.fst.2 =
      f
          (Sigma.casesOn (motive := fun x =>
                (x ∈ Finset.sigma (divisorsAntidiagonal n) fun a => divisorsAntidiagonal a.1) → (_ : ℕ × ℕ) × ℕ × ℕ) a
                (fun fst snd =>
                  Prod.casesOn (motive := fun x =>
                    ({ fst := x, snd := snd } ∈
                        Finset.sigma (divisorsAntidiagonal n) fun a => divisorsAntidiagonal a.1) →
                      (_ : ℕ × ℕ) × ℕ × ℕ)
                    fst fun i j =>
                    Prod.casesOn (motive := fun x =>
                      ({ fst := (i, j), snd := x } ∈
                          Finset.sigma (divisorsAntidiagonal n) fun a => divisorsAntidiagonal a.1) →
                        (_ : ℕ × ℕ) × ℕ × ℕ)
                      snd fun k l _H => { fst := (k, l * j), snd := (l, j) })
                ha).fst.1 •
        g
            (Sigma.casesOn (motive := fun x =>
                  (x ∈ Finset.sigma (divisorsAntidiagonal n) fun a => divisorsAntidiagonal a.1) → (_ : ℕ × ℕ) × ℕ × ℕ) a
                  (fun fst snd =>
                    Prod.casesOn (motive := fun x =>
                      ({ fst := x, snd := snd } ∈
                          Finset.sigma (divisorsAntidiagonal n) fun a => divisorsAntidiagonal a.1) →
                        (_ : ℕ × ℕ) × ℕ × ℕ)
                      fst fun i j =>
                      Prod.casesOn (motive := fun x =>
                        ({ fst := (i, j), snd := x } ∈
                            Finset.sigma (divisorsAntidiagonal n) fun a => divisorsAntidiagonal a.1) →
                          (_ : ℕ × ℕ) × ℕ × ℕ)
                        snd fun k l _H => { fst := (k, l * j), snd := (l, j) })
                  ha).snd.1 •
          h
            (Sigma.casesOn (motive := fun x =>
                  (x ∈ Finset.sigma (divisorsAntidiagonal n) fun a => divisorsAntidiagonal a.1) → (_ : ℕ × ℕ) × ℕ × ℕ) a
                  (fun fst snd =>
                    Prod.casesOn (motive := fun x =>
                      ({ fst := x, snd := snd } ∈
                          Finset.sigma (divisorsAntidiagonal n) fun a => divisorsAntidiagonal a.1) →
                        (_ : ℕ × ℕ) × ℕ × ℕ)
                      fst fun i j =>
                      Prod.casesOn (motive := fun x =>
                        ({ fst := (i, j), snd := x } ∈
                            Finset.sigma (divisorsAntidiagonal n) fun a => divisorsAntidiagonal a.1) →
                          (_ : ℕ × ℕ) × ℕ × ℕ)
                        snd fun k l _H => { fst := (k, l * j), snd := (l, j) })
                  ha).snd.2

Next tactic:
rintro ⟨⟨i, j⟩, ⟨k, l⟩⟩ _H