l3lab/ntp-mathlib huggingface dataset:
/-- `x + 0` has exactly the same moves as `x`. -/
def addZeroRelabelling : ∀ x : PGame.{u}, x + 0 ≡r x
  | ⟨xl, xr, xL, xR⟩ => by
    refine' ⟨Equiv.sumEmpty xl PEmpty, Equiv.sumEmpty xr PEmpty, _, _⟩ <;> rintro (⟨i⟩ | ⟨⟨⟩⟩) <;>
      

Proof state:
case refine'_1.inl
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
i : xl
⊢ moveLeft (mk xl xr xL xR + 0) (Sum.inl i) ≡r
    moveLeft (mk xl xr xL xR) ((Equiv.sumEmpty xl PEmpty.{u + 1}) (Sum.inl i))

Next tactic:
apply addZeroRelabelling
/-- `x + 0` has exactly the same moves as `x`. -/
def addZeroRelabelling : ∀ x : PGame.{u}, x + 0 ≡r x
  | ⟨xl, xr, xL, xR⟩ => by
    refine' ⟨Equiv.sumEmpty xl PEmpty, Equiv.sumEmpty xr PEmpty, _, _⟩ <;> rintro (⟨i⟩ | ⟨⟨⟩⟩) <;>
      

Proof state:
case refine'_2.inl
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
i : xr
⊢ moveRight (mk xl xr xL xR + 0) (Sum.inl i) ≡r
    moveRight (mk xl xr xL xR) ((Equiv.sumEmpty xr PEmpty.{u + 1}) (Sum.inl i))

Next tactic:
apply addZeroRelabelling
/-- `0 + x` has exactly the same moves as `x`. -/
def zeroAddRelabelling : ∀ x : PGame.{u}, 0 + x ≡r x
  | ⟨xl, xr, xL, xR⟩ => by
    

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
⊢ 0 + mk xl xr xL xR ≡r mk xl xr xL xR

Next tactic:
refine' ⟨Equiv.emptySum PEmpty xl, Equiv.emptySum PEmpty xr, _, _⟩
/-- `0 + x` has exactly the same moves as `x`. -/
def zeroAddRelabelling : ∀ x : PGame.{u}, 0 + x ≡r x
  | ⟨xl, xr, xL, xR⟩ => by
    refine' ⟨Equiv.emptySum PEmpty xl, Equiv.emptySum PEmpty xr, _, _⟩ <;> 

Proof state:
case refine'_1
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
⊢ (i : LeftMoves (0 + mk xl xr xL xR)) →
    moveLeft (0 + mk xl xr xL xR) i ≡r moveLeft (mk xl xr xL xR) ((Equiv.emptySum PEmpty.{u + 1} xl) i)

Next tactic:
rintro (⟨⟨⟩⟩ | ⟨i⟩)
/-- `0 + x` has exactly the same moves as `x`. -/
def zeroAddRelabelling : ∀ x : PGame.{u}, 0 + x ≡r x
  | ⟨xl, xr, xL, xR⟩ => by
    refine' ⟨Equiv.emptySum PEmpty xl, Equiv.emptySum PEmpty xr, _, _⟩ <;> 

Proof state:
case refine'_2
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
⊢ (j : RightMoves (0 + mk xl xr xL xR)) →
    moveRight (0 + mk xl xr xL xR) j ≡r moveRight (mk xl xr xL xR) ((Equiv.emptySum PEmpty.{u + 1} xr) j)

Next tactic:
rintro (⟨⟨⟩⟩ | ⟨i⟩)
/-- `0 + x` has exactly the same moves as `x`. -/
def zeroAddRelabelling : ∀ x : PGame.{u}, 0 + x ≡r x
  | ⟨xl, xr, xL, xR⟩ => by
    refine' ⟨Equiv.emptySum PEmpty xl, Equiv.emptySum PEmpty xr, _, _⟩ <;> rintro (⟨⟨⟩⟩ | ⟨i⟩) <;>
      

Proof state:
case refine'_1.inr
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
i : xl
⊢ moveLeft (0 + mk xl xr xL xR) (Sum.inr i) ≡r
    moveLeft (mk xl xr xL xR) ((Equiv.emptySum PEmpty.{u + 1} xl) (Sum.inr i))

Next tactic:
apply zeroAddRelabelling
/-- `0 + x` has exactly the same moves as `x`. -/
def zeroAddRelabelling : ∀ x : PGame.{u}, 0 + x ≡r x
  | ⟨xl, xr, xL, xR⟩ => by
    refine' ⟨Equiv.emptySum PEmpty xl, Equiv.emptySum PEmpty xr, _, _⟩ <;> rintro (⟨⟨⟩⟩ | ⟨i⟩) <;>
      

Proof state:
case refine'_2.inr
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
i : xr
⊢ moveRight (0 + mk xl xr xL xR) (Sum.inr i) ≡r
    moveRight (mk xl xr xL xR) ((Equiv.emptySum PEmpty.{u + 1} xr) (Sum.inr i))

Next tactic:
apply zeroAddRelabelling
@[simp]
theorem add_moveLeft_inl {x : PGame} (y : PGame) (i) :
    (x + y).moveLeft (toLeftMovesAdd (Sum.inl i)) = x.moveLeft i + y := by
  

Proof state:
x y : PGame
i : LeftMoves x
⊢ moveLeft (x + y) (toLeftMovesAdd (Sum.inl i)) = moveLeft x i + y

Next tactic:
cases x
@[simp]
theorem add_moveLeft_inl {x : PGame} (y : PGame) (i) :
    (x + y).moveLeft (toLeftMovesAdd (Sum.inl i)) = x.moveLeft i + y := by
  cases x
  

Proof state:
case mk
y : PGame
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : LeftMoves (mk α✝ β✝ a✝¹ a✝)
⊢ moveLeft (mk α✝ β✝ a✝¹ a✝ + y) (toLeftMovesAdd (Sum.inl i)) = moveLeft (mk α✝ β✝ a✝¹ a✝) i + y

Next tactic:
cases y
@[simp]
theorem add_moveLeft_inl {x : PGame} (y : PGame) (i) :
    (x + y).moveLeft (toLeftMovesAdd (Sum.inl i)) = x.moveLeft i + y := by
  cases x
  cases y
  

Proof state:
case mk.mk
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
i : LeftMoves (mk α✝¹ β✝¹ a✝³ a✝²)
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ moveLeft (mk α✝¹ β✝¹ a✝³ a✝² + mk α✝ β✝ a✝¹ a✝) (toLeftMovesAdd (Sum.inl i)) =
    moveLeft (mk α✝¹ β✝¹ a✝³ a✝²) i + mk α✝ β✝ a✝¹ a✝

Next tactic:
rfl
@[simp]
theorem add_moveRight_inl {x : PGame} (y : PGame) (i) :
    (x + y).moveRight (toRightMovesAdd (Sum.inl i)) = x.moveRight i + y := by
  

Proof state:
x y : PGame
i : RightMoves x
⊢ moveRight (x + y) (toRightMovesAdd (Sum.inl i)) = moveRight x i + y

Next tactic:
cases x
@[simp]
theorem add_moveRight_inl {x : PGame} (y : PGame) (i) :
    (x + y).moveRight (toRightMovesAdd (Sum.inl i)) = x.moveRight i + y := by
  cases x
  

Proof state:
case mk
y : PGame
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : RightMoves (mk α✝ β✝ a✝¹ a✝)
⊢ moveRight (mk α✝ β✝ a✝¹ a✝ + y) (toRightMovesAdd (Sum.inl i)) = moveRight (mk α✝ β✝ a✝¹ a✝) i + y

Next tactic:
cases y
@[simp]
theorem add_moveRight_inl {x : PGame} (y : PGame) (i) :
    (x + y).moveRight (toRightMovesAdd (Sum.inl i)) = x.moveRight i + y := by
  cases x
  cases y
  

Proof state:
case mk.mk
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
i : RightMoves (mk α✝¹ β✝¹ a✝³ a✝²)
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ moveRight (mk α✝¹ β✝¹ a✝³ a✝² + mk α✝ β✝ a✝¹ a✝) (toRightMovesAdd (Sum.inl i)) =
    moveRight (mk α✝¹ β✝¹ a✝³ a✝²) i + mk α✝ β✝ a✝¹ a✝

Next tactic:
rfl
@[simp]
theorem add_moveLeft_inr (x : PGame) {y : PGame} (i) :
    (x + y).moveLeft (toLeftMovesAdd (Sum.inr i)) = x + y.moveLeft i := by
  

Proof state:
x y : PGame
i : LeftMoves y
⊢ moveLeft (x + y) (toLeftMovesAdd (Sum.inr i)) = x + moveLeft y i

Next tactic:
cases x
@[simp]
theorem add_moveLeft_inr (x : PGame) {y : PGame} (i) :
    (x + y).moveLeft (toLeftMovesAdd (Sum.inr i)) = x + y.moveLeft i := by
  cases x
  

Proof state:
case mk
y : PGame
i : LeftMoves y
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ moveLeft (mk α✝ β✝ a✝¹ a✝ + y) (toLeftMovesAdd (Sum.inr i)) = mk α✝ β✝ a✝¹ a✝ + moveLeft y i

Next tactic:
cases y
@[simp]
theorem add_moveLeft_inr (x : PGame) {y : PGame} (i) :
    (x + y).moveLeft (toLeftMovesAdd (Sum.inr i)) = x + y.moveLeft i := by
  cases x
  cases y
  

Proof state:
case mk.mk
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : LeftMoves (mk α✝ β✝ a✝¹ a✝)
⊢ moveLeft (mk α✝¹ β✝¹ a✝³ a✝² + mk α✝ β✝ a✝¹ a✝) (toLeftMovesAdd (Sum.inr i)) =
    mk α✝¹ β✝¹ a✝³ a✝² + moveLeft (mk α✝ β✝ a✝¹ a✝) i

Next tactic:
rfl
@[simp]
theorem add_moveRight_inr (x : PGame) {y : PGame} (i) :
    (x + y).moveRight (toRightMovesAdd (Sum.inr i)) = x + y.moveRight i := by
  

Proof state:
x y : PGame
i : RightMoves y
⊢ moveRight (x + y) (toRightMovesAdd (Sum.inr i)) = x + moveRight y i

Next tactic:
cases x
@[simp]
theorem add_moveRight_inr (x : PGame) {y : PGame} (i) :
    (x + y).moveRight (toRightMovesAdd (Sum.inr i)) = x + y.moveRight i := by
  cases x
  

Proof state:
case mk
y : PGame
i : RightMoves y
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ moveRight (mk α✝ β✝ a✝¹ a✝ + y) (toRightMovesAdd (Sum.inr i)) = mk α✝ β✝ a✝¹ a✝ + moveRight y i

Next tactic:
cases y
@[simp]
theorem add_moveRight_inr (x : PGame) {y : PGame} (i) :
    (x + y).moveRight (toRightMovesAdd (Sum.inr i)) = x + y.moveRight i := by
  cases x
  cases y
  

Proof state:
case mk.mk
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : RightMoves (mk α✝ β✝ a✝¹ a✝)
⊢ moveRight (mk α✝¹ β✝¹ a✝³ a✝² + mk α✝ β✝ a✝¹ a✝) (toRightMovesAdd (Sum.inr i)) =
    mk α✝¹ β✝¹ a✝³ a✝² + moveRight (mk α✝ β✝ a✝¹ a✝) i

Next tactic:
rfl
theorem leftMoves_add_cases {x y : PGame} (k) {P : (x + y).LeftMoves → Prop}
    (hl : ∀ i, P <| toLeftMovesAdd (Sum.inl i)) (hr : ∀ i, P <| toLeftMovesAdd (Sum.inr i)) :
    P k := by
  

Proof state:
x y : PGame
k : LeftMoves (x + y)
P : LeftMoves (x + y) → Prop
hl : ∀ (i : LeftMoves x), P (toLeftMovesAdd (Sum.inl i))
hr : ∀ (i : LeftMoves y), P (toLeftMovesAdd (Sum.inr i))
⊢ P k

Next tactic:
rw [← toLeftMovesAdd.apply_symm_apply k]
theorem leftMoves_add_cases {x y : PGame} (k) {P : (x + y).LeftMoves → Prop}
    (hl : ∀ i, P <| toLeftMovesAdd (Sum.inl i)) (hr : ∀ i, P <| toLeftMovesAdd (Sum.inr i)) :
    P k := by
  rw [← toLeftMovesAdd.apply_symm_apply k]
  

Proof state:
x y : PGame
k : LeftMoves (x + y)
P : LeftMoves (x + y) → Prop
hl : ∀ (i : LeftMoves x), P (toLeftMovesAdd (Sum.inl i))
hr : ∀ (i : LeftMoves y), P (toLeftMovesAdd (Sum.inr i))
⊢ P (toLeftMovesAdd (toLeftMovesAdd.symm k))

Next tactic:
cases' toLeftMovesAdd.symm k with i i
theorem leftMoves_add_cases {x y : PGame} (k) {P : (x + y).LeftMoves → Prop}
    (hl : ∀ i, P <| toLeftMovesAdd (Sum.inl i)) (hr : ∀ i, P <| toLeftMovesAdd (Sum.inr i)) :
    P k := by
  rw [← toLeftMovesAdd.apply_symm_apply k]
  cases' toLeftMovesAdd.symm k with i i
  · 

Proof state:
case inl
x y : PGame
k : LeftMoves (x + y)
P : LeftMoves (x + y) → Prop
hl : ∀ (i : LeftMoves x), P (toLeftMovesAdd (Sum.inl i))
hr : ∀ (i : LeftMoves y), P (toLeftMovesAdd (Sum.inr i))
i : LeftMoves x
⊢ P (toLeftMovesAdd (Sum.inl i))

Next tactic:
exact hl i
theorem leftMoves_add_cases {x y : PGame} (k) {P : (x + y).LeftMoves → Prop}
    (hl : ∀ i, P <| toLeftMovesAdd (Sum.inl i)) (hr : ∀ i, P <| toLeftMovesAdd (Sum.inr i)) :
    P k := by
  rw [← toLeftMovesAdd.apply_symm_apply k]
  cases' toLeftMovesAdd.symm k with i i
  · exact hl i
  · 

Proof state:
case inr
x y : PGame
k : LeftMoves (x + y)
P : LeftMoves (x + y) → Prop
hl : ∀ (i : LeftMoves x), P (toLeftMovesAdd (Sum.inl i))
hr : ∀ (i : LeftMoves y), P (toLeftMovesAdd (Sum.inr i))
i : LeftMoves y
⊢ P (toLeftMovesAdd (Sum.inr i))

Next tactic:
exact hr i
theorem rightMoves_add_cases {x y : PGame} (k) {P : (x + y).RightMoves → Prop}
    (hl : ∀ j, P <| toRightMovesAdd (Sum.inl j)) (hr : ∀ j, P <| toRightMovesAdd (Sum.inr j)) :
    P k := by
  

Proof state:
x y : PGame
k : RightMoves (x + y)
P : RightMoves (x + y) → Prop
hl : ∀ (j : RightMoves x), P (toRightMovesAdd (Sum.inl j))
hr : ∀ (j : RightMoves y), P (toRightMovesAdd (Sum.inr j))
⊢ P k

Next tactic:
rw [← toRightMovesAdd.apply_symm_apply k]
theorem rightMoves_add_cases {x y : PGame} (k) {P : (x + y).RightMoves → Prop}
    (hl : ∀ j, P <| toRightMovesAdd (Sum.inl j)) (hr : ∀ j, P <| toRightMovesAdd (Sum.inr j)) :
    P k := by
  rw [← toRightMovesAdd.apply_symm_apply k]
  

Proof state:
x y : PGame
k : RightMoves (x + y)
P : RightMoves (x + y) → Prop
hl : ∀ (j : RightMoves x), P (toRightMovesAdd (Sum.inl j))
hr : ∀ (j : RightMoves y), P (toRightMovesAdd (Sum.inr j))
⊢ P (toRightMovesAdd (toRightMovesAdd.symm k))

Next tactic:
cases' toRightMovesAdd.symm k with i i
theorem rightMoves_add_cases {x y : PGame} (k) {P : (x + y).RightMoves → Prop}
    (hl : ∀ j, P <| toRightMovesAdd (Sum.inl j)) (hr : ∀ j, P <| toRightMovesAdd (Sum.inr j)) :
    P k := by
  rw [← toRightMovesAdd.apply_symm_apply k]
  cases' toRightMovesAdd.symm k with i i
  · 

Proof state:
case inl
x y : PGame
k : RightMoves (x + y)
P : RightMoves (x + y) → Prop
hl : ∀ (j : RightMoves x), P (toRightMovesAdd (Sum.inl j))
hr : ∀ (j : RightMoves y), P (toRightMovesAdd (Sum.inr j))
i : RightMoves x
⊢ P (toRightMovesAdd (Sum.inl i))

Next tactic:
exact hl i
theorem rightMoves_add_cases {x y : PGame} (k) {P : (x + y).RightMoves → Prop}
    (hl : ∀ j, P <| toRightMovesAdd (Sum.inl j)) (hr : ∀ j, P <| toRightMovesAdd (Sum.inr j)) :
    P k := by
  rw [← toRightMovesAdd.apply_symm_apply k]
  cases' toRightMovesAdd.symm k with i i
  · exact hl i
  · 

Proof state:
case inr
x y : PGame
k : RightMoves (x + y)
P : RightMoves (x + y) → Prop
hl : ∀ (j : RightMoves x), P (toRightMovesAdd (Sum.inl j))
hr : ∀ (j : RightMoves y), P (toRightMovesAdd (Sum.inr j))
i : RightMoves y
⊢ P (toRightMovesAdd (Sum.inr i))

Next tactic:
exact hr i
instance isEmpty_nat_rightMoves : ∀ n : ℕ, IsEmpty (RightMoves n)
  | 0 => inferInstanceAs (IsEmpty PEmpty)
  | n + 1 => by
    

Proof state:
n : ℕ
⊢ IsEmpty (RightMoves ↑(n + 1))

Next tactic:
haveI := isEmpty_nat_rightMoves n
instance isEmpty_nat_rightMoves : ∀ n : ℕ, IsEmpty (RightMoves n)
  | 0 => inferInstanceAs (IsEmpty PEmpty)
  | n + 1 => by
    haveI := isEmpty_nat_rightMoves n
    

Proof state:
n : ℕ
this : IsEmpty (RightMoves ↑n)
⊢ IsEmpty (RightMoves ↑(n + 1))

Next tactic:
rw [PGame.nat_succ, rightMoves_add]
instance isEmpty_nat_rightMoves : ∀ n : ℕ, IsEmpty (RightMoves n)
  | 0 => inferInstanceAs (IsEmpty PEmpty)
  | n + 1 => by
    haveI := isEmpty_nat_rightMoves n
    rw [PGame.nat_succ, rightMoves_add]
    

Proof state:
n : ℕ
this : IsEmpty (RightMoves ↑n)
⊢ IsEmpty (RightMoves ↑n ⊕ RightMoves 1)

Next tactic:
infer_instance
/-- If `w` has the same moves as `x` and `y` has the same moves as `z`,
then `w + y` has the same moves as `x + z`. -/
def Relabelling.addCongr : ∀ {w x y z : PGame.{u}}, w ≡r x → y ≡r z → w + y ≡r x + z
  | ⟨wl, wr, wL, wR⟩, ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩, ⟨zl, zr, zL, zR⟩, ⟨L₁, R₁, hL₁, hR₁⟩,
    ⟨L₂, R₂, hL₂, hR₂⟩ => by
    

Proof state:
wl wr : Type u
wL : wl → PGame
wR : wr → PGame
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
zl zr : Type u
zL : zl → PGame
zR : zr → PGame
L₁ : LeftMoves (PGame.mk wl wr wL wR) ≃ LeftMoves (PGame.mk xl xr xL xR)
R₁ : RightMoves (PGame.mk wl wr wL wR) ≃ RightMoves (PGame.mk xl xr xL xR)
hL₁ :
  (i : LeftMoves (PGame.mk wl wr wL wR)) →
    PGame.moveLeft (PGame.mk wl wr wL wR) i ≡r PGame.moveLeft (PGame.mk xl xr xL xR) (L₁ i)
hR₁ :
  (j : RightMoves (PGame.mk wl wr wL wR)) →
    PGame.moveRight (PGame.mk wl wr wL wR) j ≡r PGame.moveRight (PGame.mk xl xr xL xR) (R₁ j)
L₂ : LeftMoves (PGame.mk yl yr yL yR) ≃ LeftMoves (PGame.mk zl zr zL zR)
R₂ : RightMoves (PGame.mk yl yr yL yR) ≃ RightMoves (PGame.mk zl zr zL zR)
hL₂ :
  (i : LeftMoves (PGame.mk yl yr yL yR)) →
    PGame.moveLeft (PGame.mk yl yr yL yR) i ≡r PGame.moveLeft (PGame.mk zl zr zL zR) (L₂ i)
hR₂ :
  (j : RightMoves (PGame.mk yl yr yL yR)) →
    PGame.moveRight (PGame.mk yl yr yL yR) j ≡r PGame.moveRight (PGame.mk zl zr zL zR) (R₂ j)
⊢ PGame.mk wl wr wL wR + PGame.mk yl yr yL yR ≡r PGame.mk xl xr xL xR + PGame.mk zl zr zL zR

Next tactic:
let Hwx : ⟨wl, wr, wL, wR⟩ ≡r ⟨xl, xr, xL, xR⟩ := ⟨L₁, R₁, hL₁, hR₁⟩
/-- If `w` has the same moves as `x` and `y` has the same moves as `z`,
then `w + y` has the same moves as `x + z`. -/
def Relabelling.addCongr : ∀ {w x y z : PGame.{u}}, w ≡r x → y ≡r z → w + y ≡r x + z
  | ⟨wl, wr, wL, wR⟩, ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩, ⟨zl, zr, zL, zR⟩, ⟨L₁, R₁, hL₁, hR₁⟩,
    ⟨L₂, R₂, hL₂, hR₂⟩ => by
    let Hwx : ⟨wl, wr, wL, wR⟩ ≡r ⟨xl, xr, xL, xR⟩ := ⟨L₁, R₁, hL₁, hR₁⟩
    

Proof state:
wl wr : Type u
wL : wl → PGame
wR : wr → PGame
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
zl zr : Type u
zL : zl → PGame
zR : zr → PGame
L₁ : LeftMoves (PGame.mk wl wr wL wR) ≃ LeftMoves (PGame.mk xl xr xL xR)
R₁ : RightMoves (PGame.mk wl wr wL wR) ≃ RightMoves (PGame.mk xl xr xL xR)
hL₁ :
  (i : LeftMoves (PGame.mk wl wr wL wR)) →
    PGame.moveLeft (PGame.mk wl wr wL wR) i ≡r PGame.moveLeft (PGame.mk xl xr xL xR) (L₁ i)
hR₁ :
  (j : RightMoves (PGame.mk wl wr wL wR)) →
    PGame.moveRight (PGame.mk wl wr wL wR) j ≡r PGame.moveRight (PGame.mk xl xr xL xR) (R₁ j)
L₂ : LeftMoves (PGame.mk yl yr yL yR) ≃ LeftMoves (PGame.mk zl zr zL zR)
R₂ : RightMoves (PGame.mk yl yr yL yR) ≃ RightMoves (PGame.mk zl zr zL zR)
hL₂ :
  (i : LeftMoves (PGame.mk yl yr yL yR)) →
    PGame.moveLeft (PGame.mk yl yr yL yR) i ≡r PGame.moveLeft (PGame.mk zl zr zL zR) (L₂ i)
hR₂ :
  (j : RightMoves (PGame.mk yl yr yL yR)) →
    PGame.moveRight (PGame.mk yl yr yL yR) j ≡r PGame.moveRight (PGame.mk zl zr zL zR) (R₂ j)
Hwx : PGame.mk wl wr wL wR ≡r PGame.mk xl xr xL xR := mk L₁ R₁ hL₁ hR₁
⊢ PGame.mk wl wr wL wR + PGame.mk yl yr yL yR ≡r PGame.mk xl xr xL xR + PGame.mk zl zr zL zR

Next tactic:
let Hyz : ⟨yl, yr, yL, yR⟩ ≡r ⟨zl, zr, zL, zR⟩ := ⟨L₂, R₂, hL₂, hR₂⟩
/-- If `w` has the same moves as `x` and `y` has the same moves as `z`,
then `w + y` has the same moves as `x + z`. -/
def Relabelling.addCongr : ∀ {w x y z : PGame.{u}}, w ≡r x → y ≡r z → w + y ≡r x + z
  | ⟨wl, wr, wL, wR⟩, ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩, ⟨zl, zr, zL, zR⟩, ⟨L₁, R₁, hL₁, hR₁⟩,
    ⟨L₂, R₂, hL₂, hR₂⟩ => by
    let Hwx : ⟨wl, wr, wL, wR⟩ ≡r ⟨xl, xr, xL, xR⟩ := ⟨L₁, R₁, hL₁, hR₁⟩
    let Hyz : ⟨yl, yr, yL, yR⟩ ≡r ⟨zl, zr, zL, zR⟩ := ⟨L₂, R₂, hL₂, hR₂⟩
    

Proof state:
wl wr : Type u
wL : wl → PGame
wR : wr → PGame
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
zl zr : Type u
zL : zl → PGame
zR : zr → PGame
L₁ : LeftMoves (PGame.mk wl wr wL wR) ≃ LeftMoves (PGame.mk xl xr xL xR)
R₁ : RightMoves (PGame.mk wl wr wL wR) ≃ RightMoves (PGame.mk xl xr xL xR)
hL₁ :
  (i : LeftMoves (PGame.mk wl wr wL wR)) →
    PGame.moveLeft (PGame.mk wl wr wL wR) i ≡r PGame.moveLeft (PGame.mk xl xr xL xR) (L₁ i)
hR₁ :
  (j : RightMoves (PGame.mk wl wr wL wR)) →
    PGame.moveRight (PGame.mk wl wr wL wR) j ≡r PGame.moveRight (PGame.mk xl xr xL xR) (R₁ j)
L₂ : LeftMoves (PGame.mk yl yr yL yR) ≃ LeftMoves (PGame.mk zl zr zL zR)
R₂ : RightMoves (PGame.mk yl yr yL yR) ≃ RightMoves (PGame.mk zl zr zL zR)
hL₂ :
  (i : LeftMoves (PGame.mk yl yr yL yR)) →
    PGame.moveLeft (PGame.mk yl yr yL yR) i ≡r PGame.moveLeft (PGame.mk zl zr zL zR) (L₂ i)
hR₂ :
  (j : RightMoves (PGame.mk yl yr yL yR)) →
    PGame.moveRight (PGame.mk yl yr yL yR) j ≡r PGame.moveRight (PGame.mk zl zr zL zR) (R₂ j)
Hwx : PGame.mk wl wr wL wR ≡r PGame.mk xl xr xL xR := mk L₁ R₁ hL₁ hR₁
Hyz : PGame.mk yl yr yL yR ≡r PGame.mk zl zr zL zR := mk L₂ R₂ hL₂ hR₂
⊢ PGame.mk wl wr wL wR + PGame.mk yl yr yL yR ≡r PGame.mk xl xr xL xR + PGame.mk zl zr zL zR

Next tactic:
refine' ⟨Equiv.sumCongr L₁ L₂, Equiv.sumCongr R₁ R₂, _, _⟩
/-- If `w` has the same moves as `x` and `y` has the same moves as `z`,
then `w + y` has the same moves as `x + z`. -/
def Relabelling.addCongr : ∀ {w x y z : PGame.{u}}, w ≡r x → y ≡r z → w + y ≡r x + z
  | ⟨wl, wr, wL, wR⟩, ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩, ⟨zl, zr, zL, zR⟩, ⟨L₁, R₁, hL₁, hR₁⟩,
    ⟨L₂, R₂, hL₂, hR₂⟩ => by
    let Hwx : ⟨wl, wr, wL, wR⟩ ≡r ⟨xl, xr, xL, xR⟩ := ⟨L₁, R₁, hL₁, hR₁⟩
    let Hyz : ⟨yl, yr, yL, yR⟩ ≡r ⟨zl, zr, zL, zR⟩ := ⟨L₂, R₂, hL₂, hR₂⟩
    refine' ⟨Equiv.sumCongr L₁ L₂, Equiv.sumCongr R₁ R₂, _, _⟩ <;> 

Proof state:
case refine'_1
wl wr : Type u
wL : wl → PGame
wR : wr → PGame
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
zl zr : Type u
zL : zl → PGame
zR : zr → PGame
L₁ : LeftMoves (PGame.mk wl wr wL wR) ≃ LeftMoves (PGame.mk xl xr xL xR)
R₁ : RightMoves (PGame.mk wl wr wL wR) ≃ RightMoves (PGame.mk xl xr xL xR)
hL₁ :
  (i : LeftMoves (PGame.mk wl wr wL wR)) →
    PGame.moveLeft (PGame.mk wl wr wL wR) i ≡r PGame.moveLeft (PGame.mk xl xr xL xR) (L₁ i)
hR₁ :
  (j : RightMoves (PGame.mk wl wr wL wR)) →
    PGame.moveRight (PGame.mk wl wr wL wR) j ≡r PGame.moveRight (PGame.mk xl xr xL xR) (R₁ j)
L₂ : LeftMoves (PGame.mk yl yr yL yR) ≃ LeftMoves (PGame.mk zl zr zL zR)
R₂ : RightMoves (PGame.mk yl yr yL yR) ≃ RightMoves (PGame.mk zl zr zL zR)
hL₂ :
  (i : LeftMoves (PGame.mk yl yr yL yR)) →
    PGame.moveLeft (PGame.mk yl yr yL yR) i ≡r PGame.moveLeft (PGame.mk zl zr zL zR) (L₂ i)
hR₂ :
  (j : RightMoves (PGame.mk yl yr yL yR)) →
    PGame.moveRight (PGame.mk yl yr yL yR) j ≡r PGame.moveRight (PGame.mk zl zr zL zR) (R₂ j)
Hwx : PGame.mk wl wr wL wR ≡r PGame.mk xl xr xL xR := mk L₁ R₁ hL₁ hR₁
Hyz : PGame.mk yl yr yL yR ≡r PGame.mk zl zr zL zR := mk L₂ R₂ hL₂ hR₂
⊢ (i : LeftMoves (PGame.mk wl wr wL wR + PGame.mk yl yr yL yR)) →
    PGame.moveLeft (PGame.mk wl wr wL wR + PGame.mk yl yr yL yR) i ≡r
      PGame.moveLeft (PGame.mk xl xr xL xR + PGame.mk zl zr zL zR) ((Equiv.sumCongr L₁ L₂) i)

Next tactic:
rintro (i | j)
/-- If `w` has the same moves as `x` and `y` has the same moves as `z`,
then `w + y` has the same moves as `x + z`. -/
def Relabelling.addCongr : ∀ {w x y z : PGame.{u}}, w ≡r x → y ≡r z → w + y ≡r x + z
  | ⟨wl, wr, wL, wR⟩, ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩, ⟨zl, zr, zL, zR⟩, ⟨L₁, R₁, hL₁, hR₁⟩,
    ⟨L₂, R₂, hL₂, hR₂⟩ => by
    let Hwx : ⟨wl, wr, wL, wR⟩ ≡r ⟨xl, xr, xL, xR⟩ := ⟨L₁, R₁, hL₁, hR₁⟩
    let Hyz : ⟨yl, yr, yL, yR⟩ ≡r ⟨zl, zr, zL, zR⟩ := ⟨L₂, R₂, hL₂, hR₂⟩
    refine' ⟨Equiv.sumCongr L₁ L₂, Equiv.sumCongr R₁ R₂, _, _⟩ <;> 

Proof state:
case refine'_2
wl wr : Type u
wL : wl → PGame
wR : wr → PGame
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
zl zr : Type u
zL : zl → PGame
zR : zr → PGame
L₁ : LeftMoves (PGame.mk wl wr wL wR) ≃ LeftMoves (PGame.mk xl xr xL xR)
R₁ : RightMoves (PGame.mk wl wr wL wR) ≃ RightMoves (PGame.mk xl xr xL xR)
hL₁ :
  (i : LeftMoves (PGame.mk wl wr wL wR)) →
    PGame.moveLeft (PGame.mk wl wr wL wR) i ≡r PGame.moveLeft (PGame.mk xl xr xL xR) (L₁ i)
hR₁ :
  (j : RightMoves (PGame.mk wl wr wL wR)) →
    PGame.moveRight (PGame.mk wl wr wL wR) j ≡r PGame.moveRight (PGame.mk xl xr xL xR) (R₁ j)
L₂ : LeftMoves (PGame.mk yl yr yL yR) ≃ LeftMoves (PGame.mk zl zr zL zR)
R₂ : RightMoves (PGame.mk yl yr yL yR) ≃ RightMoves (PGame.mk zl zr zL zR)
hL₂ :
  (i : LeftMoves (PGame.mk yl yr yL yR)) →
    PGame.moveLeft (PGame.mk yl yr yL yR) i ≡r PGame.moveLeft (PGame.mk zl zr zL zR) (L₂ i)
hR₂ :
  (j : RightMoves (PGame.mk yl yr yL yR)) →
    PGame.moveRight (PGame.mk yl yr yL yR) j ≡r PGame.moveRight (PGame.mk zl zr zL zR) (R₂ j)
Hwx : PGame.mk wl wr wL wR ≡r PGame.mk xl xr xL xR := mk L₁ R₁ hL₁ hR₁
Hyz : PGame.mk yl yr yL yR ≡r PGame.mk zl zr zL zR := mk L₂ R₂ hL₂ hR₂
⊢ (j : RightMoves (PGame.mk wl wr wL wR + PGame.mk yl yr yL yR)) →
    PGame.moveRight (PGame.mk wl wr wL wR + PGame.mk yl yr yL yR) j ≡r
      PGame.moveRight (PGame.mk xl xr xL xR + PGame.mk zl zr zL zR) ((Equiv.sumCongr R₁ R₂) j)

Next tactic:
rintro (i | j)
/-- If `w` has the same moves as `x` and `y` has the same moves as `z`,
then `w + y` has the same moves as `x + z`. -/
def Relabelling.addCongr : ∀ {w x y z : PGame.{u}}, w ≡r x → y ≡r z → w + y ≡r x + z
  | ⟨wl, wr, wL, wR⟩, ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩, ⟨zl, zr, zL, zR⟩, ⟨L₁, R₁, hL₁, hR₁⟩,
    ⟨L₂, R₂, hL₂, hR₂⟩ => by
    let Hwx : ⟨wl, wr, wL, wR⟩ ≡r ⟨xl, xr, xL, xR⟩ := ⟨L₁, R₁, hL₁, hR₁⟩
    let Hyz : ⟨yl, yr, yL, yR⟩ ≡r ⟨zl, zr, zL, zR⟩ := ⟨L₂, R₂, hL₂, hR₂⟩
    refine' ⟨Equiv.sumCongr L₁ L₂, Equiv.sumCongr R₁ R₂, _, _⟩ <;> rintro (i | j)
    · 

Proof state:
case refine'_1.inl
wl wr : Type u
wL : wl → PGame
wR : wr → PGame
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
zl zr : Type u
zL : zl → PGame
zR : zr → PGame
L₁ : LeftMoves (PGame.mk wl wr wL wR) ≃ LeftMoves (PGame.mk xl xr xL xR)
R₁ : RightMoves (PGame.mk wl wr wL wR) ≃ RightMoves (PGame.mk xl xr xL xR)
hL₁ :
  (i : LeftMoves (PGame.mk wl wr wL wR)) →
    PGame.moveLeft (PGame.mk wl wr wL wR) i ≡r PGame.moveLeft (PGame.mk xl xr xL xR) (L₁ i)
hR₁ :
  (j : RightMoves (PGame.mk wl wr wL wR)) →
    PGame.moveRight (PGame.mk wl wr wL wR) j ≡r PGame.moveRight (PGame.mk xl xr xL xR) (R₁ j)
L₂ : LeftMoves (PGame.mk yl yr yL yR) ≃ LeftMoves (PGame.mk zl zr zL zR)
R₂ : RightMoves (PGame.mk yl yr yL yR) ≃ RightMoves (PGame.mk zl zr zL zR)
hL₂ :
  (i : LeftMoves (PGame.mk yl yr yL yR)) →
    PGame.moveLeft (PGame.mk yl yr yL yR) i ≡r PGame.moveLeft (PGame.mk zl zr zL zR) (L₂ i)
hR₂ :
  (j : RightMoves (PGame.mk yl yr yL yR)) →
    PGame.moveRight (PGame.mk yl yr yL yR) j ≡r PGame.moveRight (PGame.mk zl zr zL zR) (R₂ j)
Hwx : PGame.mk wl wr wL wR ≡r PGame.mk xl xr xL xR := mk L₁ R₁ hL₁ hR₁
Hyz : PGame.mk yl yr yL yR ≡r PGame.mk zl zr zL zR := mk L₂ R₂ hL₂ hR₂
i : wl
⊢ PGame.moveLeft (PGame.mk wl wr wL wR + PGame.mk yl yr yL yR) (Sum.inl i) ≡r
    PGame.moveLeft (PGame.mk xl xr xL xR + PGame.mk zl zr zL zR) ((Equiv.sumCongr L₁ L₂) (Sum.inl i))

Next tactic:
exact (hL₁ i).addCongr Hyz