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⟩
  · rintro ⟨⟨i, j⟩, ⟨k, l⟩⟩ _H
    

Proof state:
case h.h.mk.mk.mk
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 i j k l : ℕ
_H : { fst := (i, j), snd := (k, l) } ∈ Finset.sigma (divisorsAntidiagonal n) fun a => divisorsAntidiagonal a.1
⊢ f { fst := (i, j), snd := (k, l) }.snd.1 •
      g { fst := (i, j), snd := (k, l) }.snd.2 • h { fst := (i, j), snd := (k, l) }.fst.2 =
    f
        (Sigma.casesOn (motive := fun x =>
              (x ∈ Finset.sigma (divisorsAntidiagonal n) fun a => divisorsAntidiagonal a.1) → (_ : ℕ × ℕ) × ℕ × ℕ)
              { fst := (i, j), snd := (k, l) }
              (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) })
              _H).fst.1 •
      g
          (Sigma.casesOn (motive := fun x =>
                (x ∈ Finset.sigma (divisorsAntidiagonal n) fun a => divisorsAntidiagonal a.1) → (_ : ℕ × ℕ) × ℕ × ℕ)
                { fst := (i, j), snd := (k, l) }
                (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) })
                _H).snd.1 •
        h
          (Sigma.casesOn (motive := fun x =>
                (x ∈ Finset.sigma (divisorsAntidiagonal n) fun a => divisorsAntidiagonal a.1) → (_ : ℕ × ℕ) × ℕ × ℕ)
                { fst := (i, j), snd := (k, l) }
                (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) })
                _H).snd.2

Next tactic:
simp only [mul_assoc]