l3lab/ntp-mathlib huggingface dataset:
/-- `x * y` and `y * x` have the same moves. -/
def mulCommRelabelling (x y : PGame.{u}) : x * y ≡r y * x :=
  match x, y with
  | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩ => by
    refine' ⟨Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _),
      (Equiv.sumComm _ _).trans (Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _)), _, _⟩
      <;>
    rintro (⟨i, j⟩ | ⟨i, j⟩) <;>
    { dsimp
      

Proof state:
case refine'_1.inl.mk
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
⊢ xL i * mk yl yr yL yR + mk xl xr xL xR * yL j - xL i * yL j ≡r
    moveLeft (mk yl yr yL yR * mk xl xr xL xR)
      ((Equiv.sumCongr (Equiv.prodComm xl yl) (Equiv.prodComm xr yr)) (Sum.inl (i, j)))

Next tactic:
exact ((addCommRelabelling _ _).trans <|
        (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
        (mulCommRelabelling _ _)
/-- `x * y` and `y * x` have the same moves. -/
def mulCommRelabelling (x y : PGame.{u}) : x * y ≡r y * x :=
  match x, y with
  | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩ => by
    refine' ⟨Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _),
      (Equiv.sumComm _ _).trans (Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _)), _, _⟩
      <;>
    rintro (⟨i, j⟩ | ⟨i, j⟩) <;>
    

Proof state:
case refine'_1.inr.mk
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
⊢ moveLeft (mk xl xr xL xR * mk yl yr yL yR) (Sum.inr (i, j)) ≡r
    moveLeft (mk yl yr yL yR * mk xl xr xL xR)
      ((Equiv.sumCongr (Equiv.prodComm xl yl) (Equiv.prodComm xr yr)) (Sum.inr (i, j)))

Next tactic:
{ dsimp
      exact ((addCommRelabelling _ _).trans <|
        (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
        (mulCommRelabelling _ _) }
/-- `x * y` and `y * x` have the same moves. -/
def mulCommRelabelling (x y : PGame.{u}) : x * y ≡r y * x :=
  match x, y with
  | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩ => by
    refine' ⟨Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _),
      (Equiv.sumComm _ _).trans (Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _)), _, _⟩
      <;>
    rintro (⟨i, j⟩ | ⟨i, j⟩) <;>
    { 

Proof state:
case refine'_1.inr.mk
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
⊢ moveLeft (mk xl xr xL xR * mk yl yr yL yR) (Sum.inr (i, j)) ≡r
    moveLeft (mk yl yr yL yR * mk xl xr xL xR)
      ((Equiv.sumCongr (Equiv.prodComm xl yl) (Equiv.prodComm xr yr)) (Sum.inr (i, j)))

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

Proof state:
case refine'_1.inr.mk
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
⊢ xR i * mk yl yr yL yR + mk xl xr xL xR * yR j - xR i * yR j ≡r
    moveLeft (mk yl yr yL yR * mk xl xr xL xR)
      ((Equiv.sumCongr (Equiv.prodComm xl yl) (Equiv.prodComm xr yr)) (Sum.inr (i, j)))

Next tactic:
exact ((addCommRelabelling _ _).trans <|
        (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
        (mulCommRelabelling _ _)
/-- `x * y` and `y * x` have the same moves. -/
def mulCommRelabelling (x y : PGame.{u}) : x * y ≡r y * x :=
  match x, y with
  | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩ => by
    refine' ⟨Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _),
      (Equiv.sumComm _ _).trans (Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _)), _, _⟩
      <;>
    rintro (⟨i, j⟩ | ⟨i, j⟩) <;>
    

Proof state:
case refine'_2.inl.mk
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 : yr
⊢ moveRight (mk xl xr xL xR * mk yl yr yL yR) (Sum.inl (i, j)) ≡r
    moveRight (mk yl yr yL yR * mk xl xr xL xR)
      (((Equiv.sumComm (xl × yr) (xr × yl)).trans (Equiv.sumCongr (Equiv.prodComm xr yl) (Equiv.prodComm xl yr)))
        (Sum.inl (i, j)))

Next tactic:
{ dsimp
      exact ((addCommRelabelling _ _).trans <|
        (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
        (mulCommRelabelling _ _) }
/-- `x * y` and `y * x` have the same moves. -/
def mulCommRelabelling (x y : PGame.{u}) : x * y ≡r y * x :=
  match x, y with
  | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩ => by
    refine' ⟨Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _),
      (Equiv.sumComm _ _).trans (Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _)), _, _⟩
      <;>
    rintro (⟨i, j⟩ | ⟨i, j⟩) <;>
    { 

Proof state:
case refine'_2.inl.mk
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 : yr
⊢ moveRight (mk xl xr xL xR * mk yl yr yL yR) (Sum.inl (i, j)) ≡r
    moveRight (mk yl yr yL yR * mk xl xr xL xR)
      (((Equiv.sumComm (xl × yr) (xr × yl)).trans (Equiv.sumCongr (Equiv.prodComm xr yl) (Equiv.prodComm xl yr)))
        (Sum.inl (i, j)))

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

Proof state:
case refine'_2.inl.mk
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 : yr
⊢ xL i * mk yl yr yL yR + mk xl xr xL xR * yR j - xL i * yR j ≡r
    moveRight (mk yl yr yL yR * mk xl xr xL xR)
      ((Equiv.sumCongr (Equiv.prodComm xr yl) (Equiv.prodComm xl yr))
        ((Equiv.sumComm (xl × yr) (xr × yl)) (Sum.inl (i, j))))

Next tactic:
exact ((addCommRelabelling _ _).trans <|
        (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
        (mulCommRelabelling _ _)
/-- `x * y` and `y * x` have the same moves. -/
def mulCommRelabelling (x y : PGame.{u}) : x * y ≡r y * x :=
  match x, y with
  | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩ => by
    refine' ⟨Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _),
      (Equiv.sumComm _ _).trans (Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _)), _, _⟩
      <;>
    rintro (⟨i, j⟩ | ⟨i, j⟩) <;>
    

Proof state:
case refine'_2.inr.mk
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
⊢ moveRight (mk xl xr xL xR * mk yl yr yL yR) (Sum.inr (i, j)) ≡r
    moveRight (mk yl yr yL yR * mk xl xr xL xR)
      (((Equiv.sumComm (xl × yr) (xr × yl)).trans (Equiv.sumCongr (Equiv.prodComm xr yl) (Equiv.prodComm xl yr)))
        (Sum.inr (i, j)))

Next tactic:
{ dsimp
      exact ((addCommRelabelling _ _).trans <|
        (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
        (mulCommRelabelling _ _) }
/-- `x * y` and `y * x` have the same moves. -/
def mulCommRelabelling (x y : PGame.{u}) : x * y ≡r y * x :=
  match x, y with
  | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩ => by
    refine' ⟨Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _),
      (Equiv.sumComm _ _).trans (Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _)), _, _⟩
      <;>
    rintro (⟨i, j⟩ | ⟨i, j⟩) <;>
    { 

Proof state:
case refine'_2.inr.mk
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
⊢ moveRight (mk xl xr xL xR * mk yl yr yL yR) (Sum.inr (i, j)) ≡r
    moveRight (mk yl yr yL yR * mk xl xr xL xR)
      (((Equiv.sumComm (xl × yr) (xr × yl)).trans (Equiv.sumCongr (Equiv.prodComm xr yl) (Equiv.prodComm xl yr)))
        (Sum.inr (i, j)))

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

Proof state:
case refine'_2.inr.mk
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
⊢ xR i * mk yl yr yL yR + mk xl xr xL xR * yL j - xR i * yL j ≡r
    moveRight (mk yl yr yL yR * mk xl xr xL xR)
      ((Equiv.sumCongr (Equiv.prodComm xr yl) (Equiv.prodComm xl yr))
        ((Equiv.sumComm (xl × yr) (xr × yl)) (Sum.inr (i, j))))

Next tactic:
exact ((addCommRelabelling _ _).trans <|
        (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
        (mulCommRelabelling _ _)
/-- `x * y` and `y * x` have the same moves. -/
def mulCommRelabelling (x y : PGame.{u}) : x * y ≡r y * x :=
  match x, y with
  | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩ => by
    refine' ⟨Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _),
      (Equiv.sumComm _ _).trans (Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _)), _, _⟩
      <;>
    rintro (⟨i, j⟩ | ⟨i, j⟩) <;>
    { dsimp
      exact ((addCommRelabelling _ _).trans <|
        (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
        (mulCommRelabelling _ _) }
  termination_by _ => (x, y)
  decreasing_by 

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => (x, snd)) Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := yL j } { fst := mk xl xr xL xR, snd := mk yl yr yL yR }

Next tactic:
pgame_wf_tac
/-- `x * y` and `y * x` have the same moves. -/
def mulCommRelabelling (x y : PGame.{u}) : x * y ≡r y * x :=
  match x, y with
  | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩ => by
    refine' ⟨Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _),
      (Equiv.sumComm _ _).trans (Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _)), _, _⟩
      <;>
    rintro (⟨i, j⟩ | ⟨i, j⟩) <;>
    { dsimp
      exact ((addCommRelabelling _ _).trans <|
        (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
        (mulCommRelabelling _ _) }
  termination_by _ => (x, y)
  decreasing_by 

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
i : xl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => (x, snd)) Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := mk yl yr yL yR } { fst := mk xl xr xL xR, snd := mk yl yr yL yR }

Next tactic:
pgame_wf_tac
/-- `x * y` and `y * x` have the same moves. -/
def mulCommRelabelling (x y : PGame.{u}) : x * y ≡r y * x :=
  match x, y with
  | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩ => by
    refine' ⟨Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _),
      (Equiv.sumComm _ _).trans (Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _)), _, _⟩
      <;>
    rintro (⟨i, j⟩ | ⟨i, j⟩) <;>
    { dsimp
      exact ((addCommRelabelling _ _).trans <|
        (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
        (mulCommRelabelling _ _) }
  termination_by _ => (x, y)
  decreasing_by 

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
i : xl
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => (x, snd)) Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := yL j } { fst := mk xl xr xL xR, snd := mk yl yr yL yR }

Next tactic:
pgame_wf_tac
/-- `x * y` and `y * x` have the same moves. -/
def mulCommRelabelling (x y : PGame.{u}) : x * y ≡r y * x :=
  match x, y with
  | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩ => by
    refine' ⟨Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _),
      (Equiv.sumComm _ _).trans (Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _)), _, _⟩
      <;>
    rintro (⟨i, j⟩ | ⟨i, j⟩) <;>
    { dsimp
      exact ((addCommRelabelling _ _).trans <|
        (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
        (mulCommRelabelling _ _) }
  termination_by _ => (x, y)
  decreasing_by 

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => (x, snd)) Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := yR j } { fst := mk xl xr xL xR, snd := mk yl yr yL yR }

Next tactic:
pgame_wf_tac
/-- `x * y` and `y * x` have the same moves. -/
def mulCommRelabelling (x y : PGame.{u}) : x * y ≡r y * x :=
  match x, y with
  | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩ => by
    refine' ⟨Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _),
      (Equiv.sumComm _ _).trans (Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _)), _, _⟩
      <;>
    rintro (⟨i, j⟩ | ⟨i, j⟩) <;>
    { dsimp
      exact ((addCommRelabelling _ _).trans <|
        (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
        (mulCommRelabelling _ _) }
  termination_by _ => (x, y)
  decreasing_by 

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
i : xr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => (x, snd)) Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := mk yl yr yL yR } { fst := mk xl xr xL xR, snd := mk yl yr yL yR }

Next tactic:
pgame_wf_tac
/-- `x * y` and `y * x` have the same moves. -/
def mulCommRelabelling (x y : PGame.{u}) : x * y ≡r y * x :=
  match x, y with
  | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩ => by
    refine' ⟨Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _),
      (Equiv.sumComm _ _).trans (Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _)), _, _⟩
      <;>
    rintro (⟨i, j⟩ | ⟨i, j⟩) <;>
    { dsimp
      exact ((addCommRelabelling _ _).trans <|
        (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
        (mulCommRelabelling _ _) }
  termination_by _ => (x, y)
  decreasing_by 

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
i : xr
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => (x, snd)) Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := yR j } { fst := mk xl xr xL xR, snd := mk yl yr yL yR }

Next tactic:
pgame_wf_tac
/-- `x * y` and `y * x` have the same moves. -/
def mulCommRelabelling (x y : PGame.{u}) : x * y ≡r y * x :=
  match x, y with
  | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩ => by
    refine' ⟨Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _),
      (Equiv.sumComm _ _).trans (Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _)), _, _⟩
      <;>
    rintro (⟨i, j⟩ | ⟨i, j⟩) <;>
    { dsimp
      exact ((addCommRelabelling _ _).trans <|
        (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
        (mulCommRelabelling _ _) }
  termination_by _ => (x, y)
  decreasing_by 

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
i : xl
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => (x, snd)) Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := yR j } { fst := mk xl xr xL xR, snd := mk yl yr yL yR }

Next tactic:
pgame_wf_tac
/-- `x * y` and `y * x` have the same moves. -/
def mulCommRelabelling (x y : PGame.{u}) : x * y ≡r y * x :=
  match x, y with
  | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩ => by
    refine' ⟨Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _),
      (Equiv.sumComm _ _).trans (Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _)), _, _⟩
      <;>
    rintro (⟨i, j⟩ | ⟨i, j⟩) <;>
    { dsimp
      exact ((addCommRelabelling _ _).trans <|
        (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
        (mulCommRelabelling _ _) }
  termination_by _ => (x, y)
  decreasing_by 

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
i : xr
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => (x, snd)) Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := yL j } { fst := mk xl xr xL xR, snd := mk yl yr yL yR }

Next tactic:
pgame_wf_tac
instance isEmpty_mul_zero_leftMoves (x : PGame.{u}) : IsEmpty (x * 0).LeftMoves := by
  

Proof state:
x : PGame
⊢ IsEmpty (LeftMoves (x * 0))

Next tactic:
cases x
instance isEmpty_mul_zero_leftMoves (x : PGame.{u}) : IsEmpty (x * 0).LeftMoves := by
  cases x
  

Proof state:
case mk
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ IsEmpty (LeftMoves (mk α✝ β✝ a✝¹ a✝ * 0))

Next tactic:
exact instIsEmptySum
instance isEmpty_mul_zero_rightMoves (x : PGame.{u}) : IsEmpty (x * 0).RightMoves := by
  

Proof state:
x : PGame
⊢ IsEmpty (RightMoves (x * 0))

Next tactic:
cases x
instance isEmpty_mul_zero_rightMoves (x : PGame.{u}) : IsEmpty (x * 0).RightMoves := by
  cases x
  

Proof state:
case mk
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ IsEmpty (RightMoves (mk α✝ β✝ a✝¹ a✝ * 0))

Next tactic:
apply instIsEmptySum
instance isEmpty_zero_mul_leftMoves (x : PGame.{u}) : IsEmpty (0 * x).LeftMoves := by
  

Proof state:
x : PGame
⊢ IsEmpty (LeftMoves (0 * x))

Next tactic:
cases x
instance isEmpty_zero_mul_leftMoves (x : PGame.{u}) : IsEmpty (0 * x).LeftMoves := by
  cases x
  

Proof state:
case mk
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ IsEmpty (LeftMoves (0 * mk α✝ β✝ a✝¹ a✝))

Next tactic:
apply instIsEmptySum
instance isEmpty_zero_mul_rightMoves (x : PGame.{u}) : IsEmpty (0 * x).RightMoves := by
  

Proof state:
x : PGame
⊢ IsEmpty (RightMoves (0 * x))

Next tactic:
cases x
instance isEmpty_zero_mul_rightMoves (x : PGame.{u}) : IsEmpty (0 * x).RightMoves := by
  cases x
  

Proof state:
case mk
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ IsEmpty (RightMoves (0 * mk α✝ β✝ a✝¹ a✝))

Next tactic:
apply instIsEmptySum
/-- `-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
      

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
⊢ -mk xl xr xL xR * mk yl yr yL yR ≡r -(mk xl xr xL xR * mk yl yr yL yR)

Next tactic:
refine' ⟨Equiv.sumComm _ _, Equiv.sumComm _ _, _, _⟩
/-- `-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 _ _, _, _⟩ <;>
      

Proof state:
case refine'_1
x y : PGame
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
⊢ (i : LeftMoves (-mk xl xr xL xR * mk yl yr yL yR)) →
    moveLeft (-mk xl xr xL xR * mk yl yr yL yR) i ≡r
      moveLeft (-(mk xl xr xL xR * mk yl yr yL yR)) ((Equiv.sumComm (xr × yl) (xl × yr)) i)

Next tactic:
rintro (⟨i, j⟩ | ⟨i, j⟩)
/-- `-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 _ _, _, _⟩ <;>
      

Proof state:
case refine'_2
x y : PGame
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
⊢ (j : RightMoves (-mk xl xr xL xR * mk yl yr yL yR)) →
    moveRight (-mk xl xr xL xR * mk yl yr yL yR) j ≡r
      moveRight (-(mk xl xr xL xR * mk yl yr yL yR)) ((Equiv.sumComm (xr × yr) (xl × yl)) j)

Next tactic:
rintro (⟨i, j⟩ | ⟨i, j⟩)
/-- `-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⟩) <;>
      · 

Proof state:
case refine'_1.inl.mk
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
⊢ moveLeft (-mk xl xr xL xR * mk yl yr yL yR) (Sum.inl (i, j)) ≡r
    moveLeft (-(mk xl xr xL xR * mk yl yr yL yR)) ((Equiv.sumComm (xr × yl) (xl × yr)) (Sum.inl (i, j)))

Next tactic:
dsimp
/-- `-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
        

Proof state:
case refine'_1.inl.mk
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
⊢ -xR i * mk yl yr yL yR + (mk xr xl (fun j => -xR j) fun i => -xL i) * yL j - -xR i * yL j ≡r
    moveLeft (-(mk xl xr xL xR * mk yl yr yL yR)) ((Equiv.sumComm (xr × yl) (xl × yr)) (Sum.inl (i, j)))

Next tactic:
apply ((negAddRelabelling _ _).trans _).symm
/-- `-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!?
        change -(mk xl xr xL xR * _) ≡r _
        

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

Next tactic:
exact (negMulRelabelling _ _).symm
/-- `-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⟩) <;>
      · 

Proof state:
case refine'_1.inr.mk
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 : yr
⊢ moveLeft (-mk xl xr xL xR * mk yl yr yL yR) (Sum.inr (i, j)) ≡r
    moveLeft (-(mk xl xr xL xR * mk yl yr yL yR)) ((Equiv.sumComm (xr × yl) (xl × yr)) (Sum.inr (i, j)))

Next tactic:
dsimp
/-- `-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
        

Proof state:
case refine'_1.inr.mk
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 : yr
⊢ -xL i * mk yl yr yL yR + (mk xr xl (fun j => -xR j) fun i => -xL i) * yR j - -xL i * yR j ≡r
    moveLeft (-(mk xl xr xL xR * mk yl yr yL yR)) ((Equiv.sumComm (xr × yl) (xl × yr)) (Sum.inr (i, j)))

Next tactic:
apply ((negAddRelabelling _ _).trans _).symm