/-- `-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
        apply ((negAddRelabelling _ _).trans (Relabelling.addCongr _ _)).subCongr
        -- Porting note: we used to just do `<;> exact (negMulRelabelling _ _).symm` from here.
        

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 : yr
⊢ -(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) ≡r
    -xR i * yR j
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 : yr
⊢ -(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) ≡r
    -xR i * mk yl yr yL yR
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 : 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))
            (yR a))
        j ≡r
    (mk xr xl (fun j => -xR j) fun i => -xL i) * yR j

Next tactic:
exact (negMulRelabelling _ _).symm