/-- `-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.
        exact (negMulRelabelling _ _).symm
        exact (negMulRelabelling _ _).symm
        -- Porting note: not sure what has gone wrong here.
        -- The goal is hideous here, and the `exact` doesn't work,
        -- but if we just `change` it to look like the mathlib3 goal then we're fine!?
        

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

Next tactic:
change -(mk xl xr xL xR * _) ≡r _