/-- `-x * y` and `-(x * y)` have the same moves. -/
def negMulRelabelling (x y : PGame.{u}) : -x * y ≡r -(x * y) :=
  match x, y with
  | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩ => by
      refine' ⟨Equiv.sumComm _ _, Equiv.sumComm _ _, _, _⟩ <;>
      rintro (⟨i, j⟩ | ⟨i, j⟩) <;>
      · dsimp
        apply ((negAddRelabelling _ _).trans _).symm
        

Proof state:
x y : PGame
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
i : xr
j : yl
⊢ -((fun a =>
              rec (motive := fun x => PGame → PGame)
                (fun xl xr a a IHxl IHxr y =>
                  rec
                    (fun yl yr yL yR IHyl IHyr =>
                      let_fun y := mk yl yr yL yR;
                      mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl)
                        (fun a =>
                          Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j))
                            fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j))
                        fun a =>
                        Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j))
                          fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j))
                    y)
                (xR a))
            i (mk yl yr yL yR) +
          (fun a =>
              rec
                (fun yl yr yL yR IHyl IHyr =>
                  let_fun y := mk yl yr yL yR;
                  mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl)
                    (fun a =>
                      Sum.casesOn a
                        (fun val =>
                          Prod.casesOn val fun i j =>
                            (fun a =>
                                    rec (motive := fun x => PGame → PGame)
                                      (fun xl xr a a IHxl IHxr y =>
                                        rec
                                          (fun yl yr yL yR IHyl IHyr =>
                                            let_fun y := mk yl yr yL yR;
                                            mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl)
                                              (fun a =>
                                                Sum.casesOn a
                                                  (fun val =>
                                                    Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j))
                                                  fun val =>
                                                  Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j))
                                              fun a =>
                                              Sum.casesOn a
                                                (fun val =>
                                                  Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j))
                                                fun val =>
                                                Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j))
                                          y)
                                      (xL a))
                                  i y +
                                IHyl j -
                              (fun a =>
                                  rec (motive := fun x => PGame → PGame)
                                    (fun xl xr a a IHxl IHxr y =>
                                      rec
                                        (fun yl yr yL yR IHyl IHyr =>
                                          let_fun y := mk yl yr yL yR;
                                          mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl)
                                            (fun a =>
                                              Sum.casesOn a
                                                (fun val =>
                                                  Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j))
                                                fun val =>
                                                Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j))
                                            fun a =>
                                            Sum.casesOn a
                                              (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j))
                                              fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j))
                                        y)
                                    (xL a))
                                i (yL j))
                        fun val =>
                        Prod.casesOn val fun i j =>
                          (fun a =>
                                  rec (motive := fun x => PGame → PGame)
                                    (fun xl xr a a IHxl IHxr y =>
                                      rec
                                        (fun yl yr yL yR IHyl IHyr =>
                                          let_fun y := mk yl yr yL yR;
                                          mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl)
                                            (fun a =>
                                              Sum.casesOn a
                                                (fun val =>
                                                  Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j))
                                                fun val =>
                                                Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j))
                                            fun a =>
                                            Sum.casesOn a
                                              (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j))
                                              fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j))
                                        y)
                                    (xR a))
                                i y +
                              IHyr j -
                            (fun a =>
                                rec (motive := fun x => PGame → PGame)
                                  (fun xl xr a a IHxl IHxr y =>
                                    rec
                                      (fun yl yr yL yR IHyl IHyr =>
                                        let_fun y := mk yl yr yL yR;
                                        mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl)
                                          (fun a =>
                                            Sum.casesOn a
                                              (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j))
                                              fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j))
                                          fun a =>
                                          Sum.casesOn a
                                            (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j))
                                            fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j))
                                      y)
                                  (xR a))
                              i (yR j))
                    fun a =>
                    Sum.casesOn a
                      (fun val =>
                        Prod.casesOn val fun i j =>
                          (fun a =>
                                  rec (motive := fun x => PGame → PGame)
                                    (fun xl xr a a IHxl IHxr y =>
                                      rec
                                        (fun yl yr yL yR IHyl IHyr =>
                                          let_fun y := mk yl yr yL yR;
                                          mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl)
                                            (fun a =>
                                              Sum.casesOn a
                                                (fun val =>
                                                  Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j))
                                                fun val =>
                                                Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j))
                                            fun a =>
                                            Sum.casesOn a
                                              (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j))
                                              fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j))
                                        y)
                                    (xL a))
                                i y +
                              IHyr j -
                            (fun a =>
                                rec (motive := fun x => PGame → PGame)
                                  (fun xl xr a a IHxl IHxr y =>
                                    rec
                                      (fun yl yr yL yR IHyl IHyr =>
                                        let_fun y := mk yl yr yL yR;
                                        mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl)
                                          (fun a =>
                                            Sum.casesOn a
                                              (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j))
                                              fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j))
                                          fun a =>
                                          Sum.casesOn a
                                            (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j))
                                            fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j))
                                      y)
                                  (xL a))
                              i (yR j))
                      fun val =>
                      Prod.casesOn val fun i j =>
                        (fun a =>
                                rec (motive := fun x => PGame → PGame)
                                  (fun xl xr a a IHxl IHxr y =>
                                    rec
                                      (fun yl yr yL yR IHyl IHyr =>
                                        let_fun y := mk yl yr yL yR;
                                        mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl)
                                          (fun a =>
                                            Sum.casesOn a
                                              (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j))
                                              fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j))
                                          fun a =>
                                          Sum.casesOn a
                                            (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j))
                                            fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j))
                                      y)
                                  (xR a))
                              i y +
                            IHyl j -
                          (fun a =>
                              rec (motive := fun x => PGame → PGame)
                                (fun xl xr a a IHxl IHxr y =>
                                  rec
                                    (fun yl yr yL yR IHyl IHyr =>
                                      let_fun y := mk yl yr yL yR;
                                      mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl)
                                        (fun a =>
                                          Sum.casesOn a
                                            (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j))
                                            fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j))
                                        fun a =>
                                        Sum.casesOn a
                                          (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j))
                                          fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j))
                                    y)
                                (xR a))
                            i (yL j))
                (yL a))
            j) +
      - -(fun a =>
              rec (motive := fun x => PGame → PGame)
                (fun xl xr a a IHxl IHxr y =>
                  rec
                    (fun yl yr yL yR IHyl IHyr =>
                      let_fun y := mk yl yr yL yR;
                      mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl)
                        (fun a =>
                          Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j))
                            fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j))
                        fun a =>
                        Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j))
                          fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j))
                    y)
                (xR a))
            i (yL j) ≡r
    -xR i * mk yl yr yL yR + (mk xr xl (fun j => -xR j) fun i => -xL i) * yL j - -xR i * yL j

Next tactic:
apply ((negAddRelabelling _ _).trans (Relabelling.addCongr _ _)).subCongr