[GOAL]
⊢ ∀ (a b c : Game), a + b + c = a + (b + c)
[PROOFSTEP]
rintro ⟨x⟩ ⟨y⟩ ⟨z⟩
[GOAL]
case mk.mk.mk
a✝ : Game
x : PGame
b✝ : Game
y : PGame
c✝ : Game
z : PGame
⊢ Quot.mk Setoid.r x + Quot.mk Setoid.r y + Quot.mk Setoid.r z =
    Quot.mk Setoid.r x + (Quot.mk Setoid.r y + Quot.mk Setoid.r z)
[PROOFSTEP]
exact Quot.sound add_assoc_equiv
[GOAL]
⊢ ∀ (a : Game), 0 + a = a
[PROOFSTEP]
rintro ⟨x⟩
[GOAL]
case mk
a✝ : Game
x : PGame
⊢ 0 + Quot.mk Setoid.r x = Quot.mk Setoid.r x
[PROOFSTEP]
exact Quot.sound (zero_add_equiv x)
[GOAL]
⊢ ∀ (a : Game), a + 0 = a
[PROOFSTEP]
rintro ⟨x⟩
[GOAL]
case mk
a✝ : Game
x : PGame
⊢ Quot.mk Setoid.r x + 0 = Quot.mk Setoid.r x
[PROOFSTEP]
exact Quot.sound (add_zero_equiv x)
[GOAL]
⊢ ∀ (a : Game), -a + a = 0
[PROOFSTEP]
rintro ⟨x⟩
[GOAL]
case mk
a✝ : Game
x : PGame
⊢ -Quot.mk Setoid.r x + Quot.mk Setoid.r x = 0
[PROOFSTEP]
exact Quot.sound (add_left_neg_equiv x)
[GOAL]
⊢ ∀ (a b : Game), a + b = b + a
[PROOFSTEP]
rintro ⟨x⟩ ⟨y⟩
[GOAL]
case mk.mk
a✝ : Game
x : PGame
b✝ : Game
y : PGame
⊢ Quot.mk Setoid.r x + Quot.mk Setoid.r y = Quot.mk Setoid.r y + Quot.mk Setoid.r x
[PROOFSTEP]
exact Quot.sound add_comm_equiv
[GOAL]
⊢ ∀ (a : Game), a ≤ a
[PROOFSTEP]
rintro ⟨x⟩
[GOAL]
case mk
a✝ : Game
x : PGame
⊢ Quot.mk Setoid.r x ≤ Quot.mk Setoid.r x
[PROOFSTEP]
exact le_refl x
[GOAL]
⊢ ∀ (a b c : Game), a ≤ b → b ≤ c → a ≤ c
[PROOFSTEP]
rintro ⟨x⟩ ⟨y⟩ ⟨z⟩
[GOAL]
case mk.mk.mk
a✝ : Game
x : PGame
b✝ : Game
y : PGame
c✝ : Game
z : PGame
⊢ Quot.mk Setoid.r x ≤ Quot.mk Setoid.r y →
    Quot.mk Setoid.r y ≤ Quot.mk Setoid.r z → Quot.mk Setoid.r x ≤ Quot.mk Setoid.r z
[PROOFSTEP]
exact @le_trans _ _ x y z
[GOAL]
⊢ ∀ (a b : Game), a < b ↔ a ≤ b ∧ ¬b ≤ a
[PROOFSTEP]
rintro ⟨x⟩ ⟨y⟩
[GOAL]
case mk.mk
a✝ : Game
x : PGame
b✝ : Game
y : PGame
⊢ Quot.mk Setoid.r x < Quot.mk Setoid.r y ↔
    Quot.mk Setoid.r x ≤ Quot.mk Setoid.r y ∧ ¬Quot.mk Setoid.r y ≤ Quot.mk Setoid.r x
[PROOFSTEP]
exact @lt_iff_le_not_le _ _ x y
[GOAL]
⊢ ∀ (a b : Game), a ≤ b → b ≤ a → a = b
[PROOFSTEP]
rintro ⟨x⟩ ⟨y⟩ h₁ h₂
[GOAL]
case mk.mk
a✝ : Game
x : PGame
b✝ : Game
y : PGame
h₁ : Quot.mk Setoid.r x ≤ Quot.mk Setoid.r y
h₂ : Quot.mk Setoid.r y ≤ Quot.mk Setoid.r x
⊢ Quot.mk Setoid.r x = Quot.mk Setoid.r y
[PROOFSTEP]
apply Quot.sound
[GOAL]
case mk.mk.a
a✝ : Game
x : PGame
b✝ : Game
y : PGame
h₁ : Quot.mk Setoid.r x ≤ Quot.mk Setoid.r y
h₂ : Quot.mk Setoid.r y ≤ Quot.mk Setoid.r x
⊢ Setoid.r x y
[PROOFSTEP]
exact ⟨h₁, h₂⟩
[GOAL]
⊢ ∀ {x y : Game}, ¬x ≤ y ↔ y ⧏ x
[PROOFSTEP]
rintro ⟨x⟩ ⟨y⟩
[GOAL]
case mk.mk
x✝ : Game
x : PGame
y✝ : Game
y : PGame
⊢ ¬Quot.mk Setoid.r x ≤ Quot.mk Setoid.r y ↔ Quot.mk Setoid.r y ⧏ Quot.mk Setoid.r x
[PROOFSTEP]
exact PGame.not_le
[GOAL]
⊢ ∀ {x y : Game}, ¬x ⧏ y ↔ y ≤ x
[PROOFSTEP]
rintro ⟨x⟩ ⟨y⟩
[GOAL]
case mk.mk
x✝ : Game
x : PGame
y✝ : Game
y : PGame
⊢ ¬Quot.mk Setoid.r x ⧏ Quot.mk Setoid.r y ↔ Quot.mk Setoid.r y ≤ Quot.mk Setoid.r x
[PROOFSTEP]
exact PGame.not_lf
[GOAL]
⊢ ∀ (a b : Game), a ⧏ b ∨ a = b ∨ b ⧏ a
[PROOFSTEP]
rintro ⟨x⟩ ⟨y⟩
[GOAL]
case mk.mk
a✝ : Game
x : PGame
b✝ : Game
y : PGame
⊢ Quot.mk Setoid.r x ⧏ Quot.mk Setoid.r y ∨
    Quot.mk Setoid.r x = Quot.mk Setoid.r y ∨ Quot.mk Setoid.r y ⧏ Quot.mk Setoid.r x
[PROOFSTEP]
change _ ∨ ⟦x⟧ = ⟦y⟧ ∨ _
[GOAL]
case mk.mk
a✝ : Game
x : PGame
b✝ : Game
y : PGame
⊢ Quot.mk Setoid.r x ⧏ Quot.mk Setoid.r y ∨
    Quotient.mk setoid x = Quotient.mk setoid y ∨ Quot.mk Setoid.r y ⧏ Quot.mk Setoid.r x
[PROOFSTEP]
rw [Quotient.eq]
[GOAL]
case mk.mk
a✝ : Game
x : PGame
b✝ : Game
y : PGame
⊢ Quot.mk Setoid.r x ⧏ Quot.mk Setoid.r y ∨ x ≈ y ∨ Quot.mk Setoid.r y ⧏ Quot.mk Setoid.r x
[PROOFSTEP]
apply lf_or_equiv_or_gf
[GOAL]
⊢ Covariant Game Game (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
[PROOFSTEP]
rintro ⟨a⟩ ⟨b⟩ ⟨c⟩ h
[GOAL]
case mk.mk.mk
m✝ : Game
a : PGame
n₁✝ : Game
b : PGame
n₂✝ : Game
c : PGame
h : Quot.mk Setoid.r b ≤ Quot.mk Setoid.r c
⊢ (fun x x_1 => x + x_1) (Quot.mk Setoid.r a) (Quot.mk Setoid.r b) ≤
    (fun x x_1 => x + x_1) (Quot.mk Setoid.r a) (Quot.mk Setoid.r c)
[PROOFSTEP]
exact @add_le_add_left _ _ _ _ b c h a
[GOAL]
⊢ Covariant Game Game (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
[PROOFSTEP]
rintro ⟨a⟩ ⟨b⟩ ⟨c⟩ h
[GOAL]
case mk.mk.mk
m✝ : Game
a : PGame
n₁✝ : Game
b : PGame
n₂✝ : Game
c : PGame
h : Quot.mk Setoid.r b ≤ Quot.mk Setoid.r c
⊢ swap (fun x x_1 => x + x_1) (Quot.mk Setoid.r a) (Quot.mk Setoid.r b) ≤
    swap (fun x x_1 => x + x_1) (Quot.mk Setoid.r a) (Quot.mk Setoid.r c)
[PROOFSTEP]
exact @add_le_add_right _ _ _ _ b c h a
[GOAL]
⊢ Covariant Game Game (fun x x_1 => x + x_1) fun x x_1 => x < x_1
[PROOFSTEP]
rintro ⟨a⟩ ⟨b⟩ ⟨c⟩ h
[GOAL]
case mk.mk.mk
m✝ : Game
a : PGame
n₁✝ : Game
b : PGame
n₂✝ : Game
c : PGame
h : Quot.mk Setoid.r b < Quot.mk Setoid.r c
⊢ (fun x x_1 => x + x_1) (Quot.mk Setoid.r a) (Quot.mk Setoid.r b) <
    (fun x x_1 => x + x_1) (Quot.mk Setoid.r a) (Quot.mk Setoid.r c)
[PROOFSTEP]
exact @add_lt_add_left _ _ _ _ b c h a
[GOAL]
⊢ Covariant Game Game (swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
[PROOFSTEP]
rintro ⟨a⟩ ⟨b⟩ ⟨c⟩ h
[GOAL]
case mk.mk.mk
m✝ : Game
a : PGame
n₁✝ : Game
b : PGame
n₂✝ : Game
c : PGame
h : Quot.mk Setoid.r b < Quot.mk Setoid.r c
⊢ swap (fun x x_1 => x + x_1) (Quot.mk Setoid.r a) (Quot.mk Setoid.r b) <
    swap (fun x x_1 => x + x_1) (Quot.mk Setoid.r a) (Quot.mk Setoid.r c)
[PROOFSTEP]
exact @add_lt_add_right _ _ _ _ b c h a
[GOAL]
⊢ ∀ {b c : Game}, b ⧏ c → ∀ (a : Game), b + a ⧏ c + a
[PROOFSTEP]
rintro ⟨b⟩ ⟨c⟩ h ⟨a⟩
[GOAL]
case mk.mk.mk
b✝ : Game
b : PGame
c✝ : Game
c : PGame
h : Quot.mk Setoid.r b ⧏ Quot.mk Setoid.r c
a✝ : Game
a : PGame
⊢ Quot.mk Setoid.r b + Quot.mk Setoid.r a ⧏ Quot.mk Setoid.r c + Quot.mk Setoid.r a
[PROOFSTEP]
apply PGame.add_lf_add_right h
[GOAL]
⊢ ∀ {b c : Game}, b ⧏ c → ∀ (a : Game), a + b ⧏ a + c
[PROOFSTEP]
rintro ⟨b⟩ ⟨c⟩ h ⟨a⟩
[GOAL]
case mk.mk.mk
b✝ : Game
b : PGame
c✝ : Game
c : PGame
h : Quot.mk Setoid.r b ⧏ Quot.mk Setoid.r c
a✝ : Game
a : PGame
⊢ Quot.mk Setoid.r a + Quot.mk Setoid.r b ⧏ Quot.mk Setoid.r a + Quot.mk Setoid.r c
[PROOFSTEP]
apply PGame.add_lf_add_left h
[GOAL]
x y : PGame
L : LeftMoves x ≃ LeftMoves y
R : RightMoves x ≃ RightMoves y
hl : ∀ (i : LeftMoves x), Quotient.mk setoid (moveLeft x i) = Quotient.mk setoid (moveLeft y (↑L i))
hr : ∀ (j : RightMoves x), Quotient.mk setoid (moveRight x j) = Quotient.mk setoid (moveRight y (↑R j))
⊢ Quotient.mk setoid x = Quotient.mk setoid y
[PROOFSTEP]
exact
  Quot.sound
    (equiv_of_mk_equiv L R (fun _ => Game.PGame.equiv_iff_game_eq.2 (hl _))
      (fun _ => Game.PGame.equiv_iff_game_eq.2 (hr _)))
[GOAL]
x y : PGame
⊢ PGame
[PROOFSTEP]
induction' x with xl xr _ _ IHxl IHxr generalizing y
[GOAL]
case mk
y✝ : PGame
xl xr : Type u
a✝¹ : xl → PGame
a✝ : xr → PGame
IHxl : xl → PGame → PGame
IHxr : xr → PGame → PGame
y : PGame
⊢ PGame
[PROOFSTEP]
induction' y with yl yr yL yR IHyl IHyr
[GOAL]
case mk.mk
y : PGame
xl xr : Type u
a✝¹ : xl → PGame
a✝ : xr → PGame
IHxl : xl → PGame → PGame
IHxr : xr → PGame → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
IHyl : yl → PGame
IHyr : yr → PGame
⊢ PGame
[PROOFSTEP]
have y := mk yl yr yL yR
[GOAL]
case mk.mk
y✝ : PGame
xl xr : Type u
a✝¹ : xl → PGame
a✝ : xr → PGame
IHxl : xl → PGame → PGame
IHxr : xr → PGame → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
IHyl : yl → PGame
IHyr : yr → PGame
y : PGame
⊢ PGame
[PROOFSTEP]
refine' ⟨Sum (xl × yl) (xr × yr), Sum (xl × yr) (xr × yl), _, _⟩
[GOAL]
case mk.mk.refine'_1
y✝ : PGame
xl xr : Type u
a✝¹ : xl → PGame
a✝ : xr → PGame
IHxl : xl → PGame → PGame
IHxr : xr → PGame → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
IHyl : yl → PGame
IHyr : yr → PGame
y : PGame
⊢ xl × yl ⊕ xr × yr → PGame
[PROOFSTEP]
rintro (⟨i, j⟩ | ⟨i, j⟩)
[GOAL]
case mk.mk.refine'_2
y✝ : PGame
xl xr : Type u
a✝¹ : xl → PGame
a✝ : xr → PGame
IHxl : xl → PGame → PGame
IHxr : xr → PGame → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
IHyl : yl → PGame
IHyr : yr → PGame
y : PGame
⊢ xl × yr ⊕ xr × yl → PGame
[PROOFSTEP]
rintro (⟨i, j⟩ | ⟨i, j⟩)
[GOAL]
case mk.mk.refine'_1.inl.mk
y✝ : PGame
xl xr : Type u
a✝¹ : xl → PGame
a✝ : xr → PGame
IHxl : xl → PGame → PGame
IHxr : xr → PGame → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
IHyl : yl → PGame
IHyr : yr → PGame
y : PGame
i : xl
j : yl
⊢ PGame
[PROOFSTEP]
exact IHxl i y + IHyl j - IHxl i (yL j)
[GOAL]
case mk.mk.refine'_1.inr.mk
y✝ : PGame
xl xr : Type u
a✝¹ : xl → PGame
a✝ : xr → PGame
IHxl : xl → PGame → PGame
IHxr : xr → PGame → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
IHyl : yl → PGame
IHyr : yr → PGame
y : PGame
i : xr
j : yr
⊢ PGame
[PROOFSTEP]
exact IHxr i y + IHyr j - IHxr i (yR j)
[GOAL]
case mk.mk.refine'_2.inl.mk
y✝ : PGame
xl xr : Type u
a✝¹ : xl → PGame
a✝ : xr → PGame
IHxl : xl → PGame → PGame
IHxr : xr → PGame → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
IHyl : yl → PGame
IHyr : yr → PGame
y : PGame
i : xl
j : yr
⊢ PGame
[PROOFSTEP]
exact IHxl i y + IHyr j - IHxl i (yR j)
[GOAL]
case mk.mk.refine'_2.inr.mk
y✝ : PGame
xl xr : Type u
a✝¹ : xl → PGame
a✝ : xr → PGame
IHxl : xl → PGame → PGame
IHxr : xr → PGame → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
IHyl : yl → PGame
IHyr : yr → PGame
y : PGame
i : xr
j : yl
⊢ PGame
[PROOFSTEP]
exact IHxr i y + IHyl j - IHxr i (yL j)
[GOAL]
x y : PGame
i : LeftMoves x
j : LeftMoves y
⊢ moveLeft (x * y) (↑toLeftMovesMul (Sum.inl (i, j))) =
    moveLeft x i * y + x * moveLeft y j - moveLeft x i * moveLeft y j
[PROOFSTEP]
cases x
[GOAL]
case mk
y : PGame
j : LeftMoves y
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : LeftMoves (mk α✝ β✝ a✝¹ a✝)
⊢ moveLeft (mk α✝ β✝ a✝¹ a✝ * y) (↑toLeftMovesMul (Sum.inl (i, j))) =
    moveLeft (mk α✝ β✝ a✝¹ a✝) i * y + mk α✝ β✝ a✝¹ a✝ * moveLeft y j - moveLeft (mk α✝ β✝ a✝¹ a✝) i * moveLeft y j
[PROOFSTEP]
cases y
[GOAL]
case mk.mk
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
i : LeftMoves (mk α✝¹ β✝¹ a✝³ a✝²)
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
j : LeftMoves (mk α✝ β✝ a✝¹ a✝)
⊢ moveLeft (mk α✝¹ β✝¹ a✝³ a✝² * mk α✝ β✝ a✝¹ a✝) (↑toLeftMovesMul (Sum.inl (i, j))) =
    moveLeft (mk α✝¹ β✝¹ a✝³ a✝²) i * mk α✝ β✝ a✝¹ a✝ + mk α✝¹ β✝¹ a✝³ a✝² * moveLeft (mk α✝ β✝ a✝¹ a✝) j -
      moveLeft (mk α✝¹ β✝¹ a✝³ a✝²) i * moveLeft (mk α✝ β✝ a✝¹ a✝) j
[PROOFSTEP]
rfl
[GOAL]
x y : PGame
i : RightMoves x
j : RightMoves y
⊢ moveLeft (x * y) (↑toLeftMovesMul (Sum.inr (i, j))) =
    moveRight x i * y + x * moveRight y j - moveRight x i * moveRight y j
[PROOFSTEP]
cases x
[GOAL]
case mk
y : PGame
j : RightMoves y
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : RightMoves (mk α✝ β✝ a✝¹ a✝)
⊢ moveLeft (mk α✝ β✝ a✝¹ a✝ * y) (↑toLeftMovesMul (Sum.inr (i, j))) =
    moveRight (mk α✝ β✝ a✝¹ a✝) i * y + mk α✝ β✝ a✝¹ a✝ * moveRight y j - moveRight (mk α✝ β✝ a✝¹ a✝) i * moveRight y j
[PROOFSTEP]
cases y
[GOAL]
case mk.mk
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
i : RightMoves (mk α✝¹ β✝¹ a✝³ a✝²)
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
j : RightMoves (mk α✝ β✝ a✝¹ a✝)
⊢ moveLeft (mk α✝¹ β✝¹ a✝³ a✝² * mk α✝ β✝ a✝¹ a✝) (↑toLeftMovesMul (Sum.inr (i, j))) =
    moveRight (mk α✝¹ β✝¹ a✝³ a✝²) i * mk α✝ β✝ a✝¹ a✝ + mk α✝¹ β✝¹ a✝³ a✝² * moveRight (mk α✝ β✝ a✝¹ a✝) j -
      moveRight (mk α✝¹ β✝¹ a✝³ a✝²) i * moveRight (mk α✝ β✝ a✝¹ a✝) j
[PROOFSTEP]
rfl
[GOAL]
x y : PGame
i : LeftMoves x
j : RightMoves y
⊢ moveRight (x * y) (↑toRightMovesMul (Sum.inl (i, j))) =
    moveLeft x i * y + x * moveRight y j - moveLeft x i * moveRight y j
[PROOFSTEP]
cases x
[GOAL]
case mk
y : PGame
j : RightMoves y
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : LeftMoves (mk α✝ β✝ a✝¹ a✝)
⊢ moveRight (mk α✝ β✝ a✝¹ a✝ * y) (↑toRightMovesMul (Sum.inl (i, j))) =
    moveLeft (mk α✝ β✝ a✝¹ a✝) i * y + mk α✝ β✝ a✝¹ a✝ * moveRight y j - moveLeft (mk α✝ β✝ a✝¹ a✝) i * moveRight y j
[PROOFSTEP]
cases y
[GOAL]
case mk.mk
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
i : LeftMoves (mk α✝¹ β✝¹ a✝³ a✝²)
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
j : RightMoves (mk α✝ β✝ a✝¹ a✝)
⊢ moveRight (mk α✝¹ β✝¹ a✝³ a✝² * mk α✝ β✝ a✝¹ a✝) (↑toRightMovesMul (Sum.inl (i, j))) =
    moveLeft (mk α✝¹ β✝¹ a✝³ a✝²) i * mk α✝ β✝ a✝¹ a✝ + mk α✝¹ β✝¹ a✝³ a✝² * moveRight (mk α✝ β✝ a✝¹ a✝) j -
      moveLeft (mk α✝¹ β✝¹ a✝³ a✝²) i * moveRight (mk α✝ β✝ a✝¹ a✝) j
[PROOFSTEP]
rfl
[GOAL]
x y : PGame
i : RightMoves x
j : LeftMoves y
⊢ moveRight (x * y) (↑toRightMovesMul (Sum.inr (i, j))) =
    moveRight x i * y + x * moveLeft y j - moveRight x i * moveLeft y j
[PROOFSTEP]
cases x
[GOAL]
case mk
y : PGame
j : LeftMoves y
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : RightMoves (mk α✝ β✝ a✝¹ a✝)
⊢ moveRight (mk α✝ β✝ a✝¹ a✝ * y) (↑toRightMovesMul (Sum.inr (i, j))) =
    moveRight (mk α✝ β✝ a✝¹ a✝) i * y + mk α✝ β✝ a✝¹ a✝ * moveLeft y j - moveRight (mk α✝ β✝ a✝¹ a✝) i * moveLeft y j
[PROOFSTEP]
cases y
[GOAL]
case mk.mk
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
i : RightMoves (mk α✝¹ β✝¹ a✝³ a✝²)
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
j : LeftMoves (mk α✝ β✝ a✝¹ a✝)
⊢ moveRight (mk α✝¹ β✝¹ a✝³ a✝² * mk α✝ β✝ a✝¹ a✝) (↑toRightMovesMul (Sum.inr (i, j))) =
    moveRight (mk α✝¹ β✝¹ a✝³ a✝²) i * mk α✝ β✝ a✝¹ a✝ + mk α✝¹ β✝¹ a✝³ a✝² * moveLeft (mk α✝ β✝ a✝¹ a✝) j -
      moveRight (mk α✝¹ β✝¹ a✝³ a✝²) i * moveLeft (mk α✝ β✝ a✝¹ a✝) j
[PROOFSTEP]
rfl
[GOAL]
x y : PGame
k : LeftMoves (x * y)
P : LeftMoves (x * y) → Prop
hl : ∀ (ix : LeftMoves x) (iy : LeftMoves y), P (↑toLeftMovesMul (Sum.inl (ix, iy)))
hr : ∀ (jx : RightMoves x) (jy : RightMoves y), P (↑toLeftMovesMul (Sum.inr (jx, jy)))
⊢ P k
[PROOFSTEP]
rw [← toLeftMovesMul.apply_symm_apply k]
[GOAL]
x y : PGame
k : LeftMoves (x * y)
P : LeftMoves (x * y) → Prop
hl : ∀ (ix : LeftMoves x) (iy : LeftMoves y), P (↑toLeftMovesMul (Sum.inl (ix, iy)))
hr : ∀ (jx : RightMoves x) (jy : RightMoves y), P (↑toLeftMovesMul (Sum.inr (jx, jy)))
⊢ P (↑toLeftMovesMul (↑toLeftMovesMul.symm k))
[PROOFSTEP]
rcases toLeftMovesMul.symm k with (⟨ix, iy⟩ | ⟨jx, jy⟩)
[GOAL]
case inl.mk
x y : PGame
k : LeftMoves (x * y)
P : LeftMoves (x * y) → Prop
hl : ∀ (ix : LeftMoves x) (iy : LeftMoves y), P (↑toLeftMovesMul (Sum.inl (ix, iy)))
hr : ∀ (jx : RightMoves x) (jy : RightMoves y), P (↑toLeftMovesMul (Sum.inr (jx, jy)))
ix : LeftMoves x
iy : LeftMoves y
⊢ P (↑toLeftMovesMul (Sum.inl (ix, iy)))
[PROOFSTEP]
apply hl
[GOAL]
case inr.mk
x y : PGame
k : LeftMoves (x * y)
P : LeftMoves (x * y) → Prop
hl : ∀ (ix : LeftMoves x) (iy : LeftMoves y), P (↑toLeftMovesMul (Sum.inl (ix, iy)))
hr : ∀ (jx : RightMoves x) (jy : RightMoves y), P (↑toLeftMovesMul (Sum.inr (jx, jy)))
jx : RightMoves x
jy : RightMoves y
⊢ P (↑toLeftMovesMul (Sum.inr (jx, jy)))
[PROOFSTEP]
apply hr
[GOAL]
x y : PGame
k : RightMoves (x * y)
P : RightMoves (x * y) → Prop
hl : ∀ (ix : LeftMoves x) (jy : RightMoves y), P (↑toRightMovesMul (Sum.inl (ix, jy)))
hr : ∀ (jx : RightMoves x) (iy : LeftMoves y), P (↑toRightMovesMul (Sum.inr (jx, iy)))
⊢ P k
[PROOFSTEP]
rw [← toRightMovesMul.apply_symm_apply k]
[GOAL]
x y : PGame
k : RightMoves (x * y)
P : RightMoves (x * y) → Prop
hl : ∀ (ix : LeftMoves x) (jy : RightMoves y), P (↑toRightMovesMul (Sum.inl (ix, jy)))
hr : ∀ (jx : RightMoves x) (iy : LeftMoves y), P (↑toRightMovesMul (Sum.inr (jx, iy)))
⊢ P (↑toRightMovesMul (↑toRightMovesMul.symm k))
[PROOFSTEP]
rcases toRightMovesMul.symm k with (⟨ix, iy⟩ | ⟨jx, jy⟩)
[GOAL]
case inl.mk
x y : PGame
k : RightMoves (x * y)
P : RightMoves (x * y) → Prop
hl : ∀ (ix : LeftMoves x) (jy : RightMoves y), P (↑toRightMovesMul (Sum.inl (ix, jy)))
hr : ∀ (jx : RightMoves x) (iy : LeftMoves y), P (↑toRightMovesMul (Sum.inr (jx, iy)))
ix : LeftMoves x
iy : RightMoves y
⊢ P (↑toRightMovesMul (Sum.inl (ix, iy)))
[PROOFSTEP]
apply hl
[GOAL]
case inr.mk
x y : PGame
k : RightMoves (x * y)
P : RightMoves (x * y) → Prop
hl : ∀ (ix : LeftMoves x) (jy : RightMoves y), P (↑toRightMovesMul (Sum.inl (ix, jy)))
hr : ∀ (jx : RightMoves x) (iy : LeftMoves y), P (↑toRightMovesMul (Sum.inr (jx, iy)))
jx : RightMoves x
jy : LeftMoves y
⊢ P (↑toRightMovesMul (Sum.inr (jx, jy)))
[PROOFSTEP]
apply hr
[GOAL]
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 yl yr yL yR * mk xl xr xL xR
[PROOFSTEP]
refine'
  ⟨Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _),
    (Equiv.sumComm _ _).trans (Equiv.sumCongr (Equiv.prodComm _ _) (Equiv.prodComm _ _)), _, _⟩
[GOAL]
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 yl yr yL yR * mk xl xr xL xR) (↑(Equiv.sumCongr (Equiv.prodComm xl yl) (Equiv.prodComm xr yr)) i)
[PROOFSTEP]
rintro (⟨i, j⟩ | ⟨i, j⟩)
[GOAL]
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 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))) j)
[PROOFSTEP]
rintro (⟨i, j⟩ | ⟨i, j⟩)
[GOAL]
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
⊢ moveLeft (mk xl xr xL xR * mk yl yr yL yR) (Sum.inl (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.inl (i, j)))
[PROOFSTEP]
{ dsimp
  exact
    ((addCommRelabelling _ _).trans <| (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
      (mulCommRelabelling _ _)
}
[GOAL]
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
⊢ moveLeft (mk xl xr xL xR * mk yl yr yL yR) (Sum.inl (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.inl (i, j)))
[PROOFSTEP]
dsimp
[GOAL]
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)))
[PROOFSTEP]
exact
  ((addCommRelabelling _ _).trans <| (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
    (mulCommRelabelling _ _)
[GOAL]
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)))
[PROOFSTEP]
{ dsimp
  exact
    ((addCommRelabelling _ _).trans <| (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
      (mulCommRelabelling _ _)
}
[GOAL]
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)))
[PROOFSTEP]
dsimp
[GOAL]
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)))
[PROOFSTEP]
exact
  ((addCommRelabelling _ _).trans <| (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
    (mulCommRelabelling _ _)
[GOAL]
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)))
[PROOFSTEP]
{ dsimp
  exact
    ((addCommRelabelling _ _).trans <| (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
      (mulCommRelabelling _ _)
}
[GOAL]
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)))
[PROOFSTEP]
dsimp
[GOAL]
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))))
[PROOFSTEP]
exact
  ((addCommRelabelling _ _).trans <| (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
    (mulCommRelabelling _ _)
[GOAL]
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)))
[PROOFSTEP]
{ dsimp
  exact
    ((addCommRelabelling _ _).trans <| (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
      (mulCommRelabelling _ _)
}
[GOAL]
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)))
[PROOFSTEP]
dsimp
[GOAL]
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))))
[PROOFSTEP]
exact
  ((addCommRelabelling _ _).trans <| (mulCommRelabelling _ _).addCongr (mulCommRelabelling _ _)).subCongr
    (mulCommRelabelling _ _)
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
x : PGame
⊢ IsEmpty (LeftMoves (x * 0))
[PROOFSTEP]
cases x
[GOAL]
case mk
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ IsEmpty (LeftMoves (mk α✝ β✝ a✝¹ a✝ * 0))
[PROOFSTEP]
exact instIsEmptySum
[GOAL]
x : PGame
⊢ IsEmpty (RightMoves (x * 0))
[PROOFSTEP]
cases x
[GOAL]
case mk
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ IsEmpty (RightMoves (mk α✝ β✝ a✝¹ a✝ * 0))
[PROOFSTEP]
apply instIsEmptySum
[GOAL]
x : PGame
⊢ IsEmpty (LeftMoves (0 * x))
[PROOFSTEP]
cases x
[GOAL]
case mk
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ IsEmpty (LeftMoves (0 * mk α✝ β✝ a✝¹ a✝))
[PROOFSTEP]
apply instIsEmptySum
[GOAL]
x : PGame
⊢ IsEmpty (RightMoves (0 * x))
[PROOFSTEP]
cases x
[GOAL]
case mk
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ IsEmpty (RightMoves (0 * mk α✝ β✝ a✝¹ a✝))
[PROOFSTEP]
apply instIsEmptySum
[GOAL]
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)
[PROOFSTEP]
refine' ⟨Equiv.sumComm _ _, Equiv.sumComm _ _, _, _⟩
[GOAL]
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)
[PROOFSTEP]
rintro (⟨i, j⟩ | ⟨i, j⟩)
[GOAL]
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)
[PROOFSTEP]
rintro (⟨i, j⟩ | ⟨i, j⟩)
[GOAL]
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)))
[PROOFSTEP]
dsimp
[GOAL]
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)))
[PROOFSTEP]
apply ((negAddRelabelling _ _).trans _).symm
[GOAL]
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
[PROOFSTEP]
apply ((negAddRelabelling _ _).trans (Relabelling.addCongr _ _)).subCongr
[GOAL]
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 (yL j) ≡r
    -xR i * yL 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 : 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) ≡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 : 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
[PROOFSTEP]
exact (negMulRelabelling _ _).symm
[GOAL]
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) ≡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 : 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
[PROOFSTEP]
exact (negMulRelabelling _ _).symm
[GOAL]
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
            (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
[PROOFSTEP]
change -(mk xl xr xL xR * _) ≡r _
[GOAL]
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
[PROOFSTEP]
exact (negMulRelabelling _ _).symm
[GOAL]
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)))
[PROOFSTEP]
dsimp
[GOAL]
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)))
[PROOFSTEP]
apply ((negAddRelabelling _ _).trans _).symm
[GOAL]
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
⊢ -((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 (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))
                (yR 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)
                (xL a))
            i (yR j) ≡r
    -xL i * mk yl yr yL yR + (mk xr xl (fun j => -xR j) fun i => -xL i) * yR j - -xL i * yR j
[PROOFSTEP]
apply ((negAddRelabelling _ _).trans (Relabelling.addCongr _ _)).subCongr
[GOAL]
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
⊢ -(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) ≡r
    -xL 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 : xl
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)
            (xL a))
        i (mk yl yr yL yR) ≡r
    -xL 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 : xl
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
[PROOFSTEP]
exact (negMulRelabelling _ _).symm
[GOAL]
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
⊢ -(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 (mk yl yr yL yR) ≡r
    -xL 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 : xl
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
[PROOFSTEP]
exact (negMulRelabelling _ _).symm
[GOAL]
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
⊢ -(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
[PROOFSTEP]
change -(mk xl xr xL xR * _) ≡r _
[GOAL]
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
⊢ -(mk xl xr xL xR * yR j) ≡r (mk xr xl (fun j => -xR j) fun i => -xL i) * yR j
[PROOFSTEP]
exact (negMulRelabelling _ _).symm
[GOAL]
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 : xr
j : yr
⊢ moveRight (-mk xl xr xL xR * mk yl yr yL yR) (Sum.inl (i, j)) ≡r
    moveRight (-(mk xl xr xL xR * mk yl yr yL yR)) (↑(Equiv.sumComm (xr × yr) (xl × yl)) (Sum.inl (i, j)))
[PROOFSTEP]
dsimp
[GOAL]
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 : xr
j : yr
⊢ -xR i * mk yl yr yL yR + (mk xr xl (fun j => -xR j) fun i => -xL i) * yR j - -xR i * yR j ≡r
    moveRight (-(mk xl xr xL xR * mk yl yr yL yR)) (↑(Equiv.sumComm (xr × yr) (xl × yl)) (Sum.inl (i, j)))
[PROOFSTEP]
apply ((negAddRelabelling _ _).trans _).symm
[GOAL]
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) +
          (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) +
      - -(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 * mk yl yr yL yR + (mk xr xl (fun j => -xR j) fun i => -xL i) * yR j - -xR i * yR j
[PROOFSTEP]
apply ((negAddRelabelling _ _).trans (Relabelling.addCongr _ _)).subCongr
[GOAL]
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
[PROOFSTEP]
exact (negMulRelabelling _ _).symm
[GOAL]
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
[PROOFSTEP]
exact (negMulRelabelling _ _).symm
[GOAL]
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
[PROOFSTEP]
change -(mk xl xr xL xR * _) ≡r _
[GOAL]
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
⊢ -(mk xl xr xL xR * yR j) ≡r (mk xr xl (fun j => -xR j) fun i => -xL i) * yR j
[PROOFSTEP]
exact (negMulRelabelling _ _).symm
[GOAL]
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 : xl
j : yl
⊢ moveRight (-mk xl xr xL xR * mk yl yr yL yR) (Sum.inr (i, j)) ≡r
    moveRight (-(mk xl xr xL xR * mk yl yr yL yR)) (↑(Equiv.sumComm (xr × yr) (xl × yl)) (Sum.inr (i, j)))
[PROOFSTEP]
dsimp
[GOAL]
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 : xl
j : yl
⊢ -xL i * mk yl yr yL yR + (mk xr xl (fun j => -xR j) fun i => -xL i) * yL j - -xL i * yL j ≡r
    moveRight (-(mk xl xr xL xR * mk yl yr yL yR)) (↑(Equiv.sumComm (xr × yr) (xl × yl)) (Sum.inr (i, j)))
[PROOFSTEP]
apply ((negAddRelabelling _ _).trans _).symm
[GOAL]
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 (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 (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)
                (xL a))
            i (yL j) ≡r
    -xL i * mk yl yr yL yR + (mk xr xl (fun j => -xR j) fun i => -xL i) * yL j - -xL i * yL j
[PROOFSTEP]
apply ((negAddRelabelling _ _).trans (Relabelling.addCongr _ _)).subCongr
[GOAL]
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 (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) ≡r
    -xL i * yL 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 : xl
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)
            (xL a))
        i (mk yl yr yL yR) ≡r
    -xL 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 : 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
[PROOFSTEP]
exact (negMulRelabelling _ _).symm
[GOAL]
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 (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 (mk yl yr yL yR) ≡r
    -xL 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 : 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
[PROOFSTEP]
exact (negMulRelabelling _ _).symm
[GOAL]
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
[PROOFSTEP]
change -(mk xl xr xL xR * _) ≡r _
[GOAL]
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
⊢ -(mk xl xr xL xR * yL j) ≡r (mk xr xl (fun j => -xR j) fun i => -xL i) * yL j
[PROOFSTEP]
exact (negMulRelabelling _ _).symm
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
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 }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
x y z : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
⊢ Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
let x := mk xl xr xL xR
[GOAL]
x✝ y z : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
⊢ Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
let y := mk yl yr yL yR
[GOAL]
x✝ y✝ z : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
⊢ Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
let z := mk zl zr zL zR
[GOAL]
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
refine' quot_eq_of_mk'_quot_eq _ _ _ _
[GOAL]
case refine'_1
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) ≃
    LeftMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
fconstructor
[GOAL]
case refine'_1.toFun
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) →
    LeftMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩)
[GOAL]
case refine'_1.toFun.inl.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xl
val✝ : yl
⊢ LeftMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_1.toFun.inl.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xl
val✝ : zl
⊢ LeftMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_1.toFun.inr.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xr
val✝ : yr
⊢ LeftMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_1.toFun.inr.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xr
val✝ : zr
⊢ LeftMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_1.invFun
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ LeftMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR) →
    LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))
[PROOFSTEP]
rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩)
[GOAL]
case refine'_1.invFun.inl.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xl
snd✝ : yl
⊢ LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_1.invFun.inl.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xr
snd✝ : yr
⊢ LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_1.invFun.inr.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xl
snd✝ : zl
⊢ LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_1.invFun.inr.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xr
snd✝ : zr
⊢ LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_1.left_inv
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ LeftInverse
    (fun a =>
      Sum.casesOn a
        (fun val =>
          Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
            Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
        fun val =>
        Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
          Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
    fun a =>
    Sum.casesOn a
      (fun val =>
        Prod.casesOn val fun fst snd =>
          Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
      fun val =>
      Prod.casesOn val fun fst snd =>
        Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))
[PROOFSTEP]
rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩)
[GOAL]
case refine'_1.left_inv.inl.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xl
val✝ : yl
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
              Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
          fun val =>
          Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
            Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)))
        (Sum.inl (fst✝, Sum.inl val✝))) =
    Sum.inl (fst✝, Sum.inl val✝)
[PROOFSTEP]
rfl
[GOAL]
case refine'_1.left_inv.inl.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xl
val✝ : zl
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
              Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
          fun val =>
          Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
            Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)))
        (Sum.inl (fst✝, Sum.inr val✝))) =
    Sum.inl (fst✝, Sum.inr val✝)
[PROOFSTEP]
rfl
[GOAL]
case refine'_1.left_inv.inr.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xr
val✝ : yr
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
              Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
          fun val =>
          Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
            Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)))
        (Sum.inr (fst✝, Sum.inl val✝))) =
    Sum.inr (fst✝, Sum.inl val✝)
[PROOFSTEP]
rfl
[GOAL]
case refine'_1.left_inv.inr.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xr
val✝ : zr
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
              Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
          fun val =>
          Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
            Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)))
        (Sum.inr (fst✝, Sum.inr val✝))) =
    Sum.inr (fst✝, Sum.inr val✝)
[PROOFSTEP]
rfl
[GOAL]
case refine'_1.right_inv
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ Function.RightInverse
    (fun a =>
      Sum.casesOn a
        (fun val =>
          Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
            Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
        fun val =>
        Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
          Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
    fun a =>
    Sum.casesOn a
      (fun val =>
        Prod.casesOn val fun fst snd =>
          Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
      fun val =>
      Prod.casesOn val fun fst snd =>
        Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))
[PROOFSTEP]
rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩)
[GOAL]
case refine'_1.right_inv.inl.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xl
snd✝ : yl
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
                Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
            fun val =>
            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
              Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
        (Sum.inl (Sum.inl (fst✝, snd✝)))) =
    Sum.inl (Sum.inl (fst✝, snd✝))
[PROOFSTEP]
rfl
[GOAL]
case refine'_1.right_inv.inl.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xr
snd✝ : yr
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
                Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
            fun val =>
            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
              Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
        (Sum.inl (Sum.inr (fst✝, snd✝)))) =
    Sum.inl (Sum.inr (fst✝, snd✝))
[PROOFSTEP]
rfl
[GOAL]
case refine'_1.right_inv.inr.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xl
snd✝ : zl
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
                Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
            fun val =>
            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
              Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
        (Sum.inr (Sum.inl (fst✝, snd✝)))) =
    Sum.inr (Sum.inl (fst✝, snd✝))
[PROOFSTEP]
rfl
[GOAL]
case refine'_1.right_inv.inr.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xr
snd✝ : zr
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
                Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
            fun val =>
            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
              Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
        (Sum.inr (Sum.inr (fst✝, snd✝)))) =
    Sum.inr (Sum.inr (fst✝, snd✝))
[PROOFSTEP]
rfl
[GOAL]
case refine'_2
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) ≃
    RightMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
fconstructor
[GOAL]
case refine'_2.toFun
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) →
    RightMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩)
[GOAL]
case refine'_2.toFun.inl.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xl
val✝ : yr
⊢ RightMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_2.toFun.inl.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xl
val✝ : zr
⊢ RightMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_2.toFun.inr.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xr
val✝ : yl
⊢ RightMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_2.toFun.inr.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xr
val✝ : zl
⊢ RightMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_2.invFun
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ RightMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR) →
    RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))
[PROOFSTEP]
rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩)
[GOAL]
case refine'_2.invFun.inl.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xl
snd✝ : yr
⊢ RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_2.invFun.inl.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xr
snd✝ : yl
⊢ RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_2.invFun.inr.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xl
snd✝ : zr
⊢ RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_2.invFun.inr.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xr
snd✝ : zl
⊢ RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_2.left_inv
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ LeftInverse
    (fun a =>
      Sum.casesOn a
        (fun val =>
          Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
            Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
        fun val =>
        Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
          Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
    fun a =>
    Sum.casesOn a
      (fun val =>
        Prod.casesOn val fun fst snd =>
          Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
      fun val =>
      Prod.casesOn val fun fst snd =>
        Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))
[PROOFSTEP]
rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩)
[GOAL]
case refine'_2.left_inv.inl.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xl
val✝ : yr
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
              Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
          fun val =>
          Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
            Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)))
        (Sum.inl (fst✝, Sum.inl val✝))) =
    Sum.inl (fst✝, Sum.inl val✝)
[PROOFSTEP]
rfl
[GOAL]
case refine'_2.left_inv.inl.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xl
val✝ : zr
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
              Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
          fun val =>
          Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
            Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)))
        (Sum.inl (fst✝, Sum.inr val✝))) =
    Sum.inl (fst✝, Sum.inr val✝)
[PROOFSTEP]
rfl
[GOAL]
case refine'_2.left_inv.inr.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xr
val✝ : yl
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
              Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
          fun val =>
          Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
            Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)))
        (Sum.inr (fst✝, Sum.inl val✝))) =
    Sum.inr (fst✝, Sum.inl val✝)
[PROOFSTEP]
rfl
[GOAL]
case refine'_2.left_inv.inr.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xr
val✝ : zl
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
              Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
          fun val =>
          Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
            Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)))
        (Sum.inr (fst✝, Sum.inr val✝))) =
    Sum.inr (fst✝, Sum.inr val✝)
[PROOFSTEP]
rfl
[GOAL]
case refine'_2.right_inv
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ Function.RightInverse
    (fun a =>
      Sum.casesOn a
        (fun val =>
          Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
            Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
        fun val =>
        Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
          Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
    fun a =>
    Sum.casesOn a
      (fun val =>
        Prod.casesOn val fun fst snd =>
          Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
      fun val =>
      Prod.casesOn val fun fst snd =>
        Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))
[PROOFSTEP]
rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩)
[GOAL]
case refine'_2.right_inv.inl.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xl
snd✝ : yr
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
                Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
            fun val =>
            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
              Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
        (Sum.inl (Sum.inl (fst✝, snd✝)))) =
    Sum.inl (Sum.inl (fst✝, snd✝))
[PROOFSTEP]
rfl
  -- Porting note: explicitly wrote out arguments to each recursive
      -- quot_left_distrib reference below, because otherwise the decreasing_by block
      -- failed. Previously, each branch ended with: `simp [quot_left_distrib]; abel`
      -- See https://github.com/leanprover/lean4/issues/2288
[GOAL]
case refine'_2.right_inv.inl.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xr
snd✝ : yl
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
                Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
            fun val =>
            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
              Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
        (Sum.inl (Sum.inr (fst✝, snd✝)))) =
    Sum.inl (Sum.inr (fst✝, snd✝))
[PROOFSTEP]
rfl
  -- Porting note: explicitly wrote out arguments to each recursive
      -- quot_left_distrib reference below, because otherwise the decreasing_by block
      -- failed. Previously, each branch ended with: `simp [quot_left_distrib]; abel`
      -- See https://github.com/leanprover/lean4/issues/2288
[GOAL]
case refine'_2.right_inv.inr.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xl
snd✝ : zr
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
                Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
            fun val =>
            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
              Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
        (Sum.inr (Sum.inl (fst✝, snd✝)))) =
    Sum.inr (Sum.inl (fst✝, snd✝))
[PROOFSTEP]
rfl
  -- Porting note: explicitly wrote out arguments to each recursive
      -- quot_left_distrib reference below, because otherwise the decreasing_by block
      -- failed. Previously, each branch ended with: `simp [quot_left_distrib]; abel`
      -- See https://github.com/leanprover/lean4/issues/2288
[GOAL]
case refine'_2.right_inv.inr.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝ : xr
snd✝ : zl
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
                Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
            fun val =>
            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
              Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
        (Sum.inr (Sum.inr (fst✝, snd✝)))) =
    Sum.inr (Sum.inr (fst✝, snd✝))
[PROOFSTEP]
rfl
  -- Porting note: explicitly wrote out arguments to each recursive
      -- quot_left_distrib reference below, because otherwise the decreasing_by block
      -- failed. Previously, each branch ended with: `simp [quot_left_distrib]; abel`
      -- See https://github.com/leanprover/lean4/issues/2288
[GOAL]
case refine'_3
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ ∀ (i : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))),
    Quotient.mk setoid (moveLeft (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) i) =
      Quotient.mk setoid
        (moveLeft (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
          (↑{
                toFun := fun a =>
                  Sum.casesOn a
                    (fun val =>
                      Prod.casesOn val fun fst snd =>
                        Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                          Sum.inr (Sum.inl (fst, val)))
                    fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)),
                invFun := fun a =>
                  Sum.casesOn a
                    (fun val =>
                      Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
                        Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                    fun val =>
                    Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
                      Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd),
                left_inv :=
                  (_ :
                    ∀ (x : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))),
                      (fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd))
                                  fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                              fun val =>
                              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd))
                                fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
                          ((fun a =>
                              Sum.casesOn a
                                (fun val =>
                                  Prod.casesOn val fun fst snd =>
                                    Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                                      Sum.inr (Sum.inl (fst, val)))
                                fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val =>
                                    Sum.inr (Sum.inr (fst, val)))
                            x) =
                        x),
                right_inv :=
                  (_ :
                    ∀ (x : LeftMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)),
                      (fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                                    Sum.inr (Sum.inl (fst, val)))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val =>
                                  Sum.inr (Sum.inr (fst, val)))
                          ((fun a =>
                              Sum.casesOn a
                                (fun val =>
                                  Sum.casesOn val
                                    (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
                                    Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                                fun val =>
                                Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd))
                                  fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
                            x) =
                        x) }
            i))
[PROOFSTEP]
rintro (⟨i, j | k⟩ | ⟨i, j | k⟩)
[GOAL]
case refine'_3.inl.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
j : yl
⊢ Quotient.mk setoid (moveLeft (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) (Sum.inl (i, Sum.inl j))) =
    Quotient.mk setoid
      (moveLeft (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
        (↑{
              toFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)),
              invFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
                      Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                  fun val =>
                  Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
                    Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd),
              left_inv :=
                (_ :
                  ∀ (x : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd))
                                fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                            fun val =>
                            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd))
                              fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                                    Sum.inr (Sum.inl (fst, val)))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val =>
                                  Sum.inr (Sum.inr (fst, val)))
                          x) =
                      x),
              right_inv :=
                (_ :
                  ∀ (x : LeftMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                                  Sum.inr (Sum.inl (fst, val)))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val =>
                                Sum.inr (Sum.inr (fst, val)))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd))
                                  fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                              fun val =>
                              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd))
                                fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
                          x) =
                      x) }
          (Sum.inl (i, Sum.inl j))))
[PROOFSTEP]
change ⟦xL i * (y + z) + x * (yL j + z) - xL i * (yL j + z)⟧ = ⟦xL i * y + x * yL j - xL i * yL j + x * z⟧
[GOAL]
case refine'_3.inl.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * (y + z) + x * (yL j + z) - xL i * (yL j + z)) =
    Quotient.mk setoid (xL i * y + x * yL j - xL i * yL j + x * z)
[PROOFSTEP]
simp only [quot_sub, quot_add]
[GOAL]
case refine'_3.inl.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR + mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (yL j + mk zl zr zL zR)) -
      Quotient.mk setoid (xL i * (yL j + mk zl zr zL zR)) =
    Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yL j) -
        Quotient.mk setoid (xL i * yL j) +
      Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
rw [quot_left_distrib (xL i) (mk yl yr yL yR) (mk zl zr zL zR)]
[GOAL]
case refine'_3.inl.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * (yL j + mk zl zr zL zR)) -
      Quotient.mk setoid (xL i * (yL j + mk zl zr zL zR)) =
    Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yL j) -
        Quotient.mk setoid (xL i * yL j) +
      Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
rw [quot_left_distrib (mk xl xr xL xR) (yL j) (mk zl zr zL zR)]
[GOAL]
case refine'_3.inl.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * yL j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)) -
      Quotient.mk setoid (xL i * (yL j + mk zl zr zL zR)) =
    Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yL j) -
        Quotient.mk setoid (xL i * yL j) +
      Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
rw [quot_left_distrib (xL i) (yL j) (mk zl zr zL zR)]
[GOAL]
case refine'_3.inl.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * yL j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)) -
      (Quotient.mk setoid (xL i * yL j) + Quotient.mk setoid (xL i * mk zl zr zL zR)) =
    Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yL j) -
        Quotient.mk setoid (xL i * yL j) +
      Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
abel
[GOAL]
case refine'_3.inl.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * yL j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)) -
      (Quotient.mk setoid (xL i * yL j) + Quotient.mk setoid (xL i * mk zl zr zL zR)) =
    Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yL j) -
        Quotient.mk setoid (xL i * yL j) +
      Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
abel
[GOAL]
case refine'_3.inl.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
k : zl
⊢ Quotient.mk setoid (moveLeft (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) (Sum.inl (i, Sum.inr k))) =
    Quotient.mk setoid
      (moveLeft (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
        (↑{
              toFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)),
              invFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
                      Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                  fun val =>
                  Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
                    Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd),
              left_inv :=
                (_ :
                  ∀ (x : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd))
                                fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                            fun val =>
                            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd))
                              fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                                    Sum.inr (Sum.inl (fst, val)))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val =>
                                  Sum.inr (Sum.inr (fst, val)))
                          x) =
                      x),
              right_inv :=
                (_ :
                  ∀ (x : LeftMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                                  Sum.inr (Sum.inl (fst, val)))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val =>
                                Sum.inr (Sum.inr (fst, val)))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd))
                                  fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                              fun val =>
                              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd))
                                fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
                          x) =
                      x) }
          (Sum.inl (i, Sum.inr k))))
[PROOFSTEP]
change ⟦xL i * (y + z) + x * (y + zL k) - xL i * (y + zL k)⟧ = ⟦x * y + (xL i * z + x * zL k - xL i * zL k)⟧
[GOAL]
case refine'_3.inl.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
k : zl
⊢ Quotient.mk setoid (xL i * (y + z) + x * (y + zL k) - xL i * (y + zL k)) =
    Quotient.mk setoid (x * y + (xL i * z + x * zL k - xL i * zL k))
[PROOFSTEP]
simp only [quot_sub, quot_add]
[GOAL]
case refine'_3.inl.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
k : zl
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR + mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + zL k)) -
      Quotient.mk setoid (xL i * (mk yl yr yL yR + zL k)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) +
      (Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zL k) -
        Quotient.mk setoid (xL i * zL k))
[PROOFSTEP]
rw [quot_left_distrib (xL i) (mk yl yr yL yR) (mk zl zr zL zR)]
[GOAL]
case refine'_3.inl.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
k : zl
⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + zL k)) -
      Quotient.mk setoid (xL i * (mk yl yr yL yR + zL k)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) +
      (Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zL k) -
        Quotient.mk setoid (xL i * zL k))
[PROOFSTEP]
rw [quot_left_distrib (mk xl xr xL xR) (mk yl yr yL yR) (zL k)]
[GOAL]
case refine'_3.inl.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
k : zl
⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * zL k)) -
      Quotient.mk setoid (xL i * (mk yl yr yL yR + zL k)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) +
      (Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zL k) -
        Quotient.mk setoid (xL i * zL k))
[PROOFSTEP]
rw [quot_left_distrib (xL i) (mk yl yr yL yR) (zL k)]
[GOAL]
case refine'_3.inl.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
k : zl
⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * zL k)) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * zL k)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) +
      (Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zL k) -
        Quotient.mk setoid (xL i * zL k))
[PROOFSTEP]
abel
[GOAL]
case refine'_3.inl.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
k : zl
⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * zL k)) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * zL k)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) +
      (Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zL k) -
        Quotient.mk setoid (xL i * zL k))
[PROOFSTEP]
abel
[GOAL]
case refine'_3.inr.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
j : yr
⊢ Quotient.mk setoid (moveLeft (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) (Sum.inr (i, Sum.inl j))) =
    Quotient.mk setoid
      (moveLeft (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
        (↑{
              toFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)),
              invFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
                      Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                  fun val =>
                  Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
                    Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd),
              left_inv :=
                (_ :
                  ∀ (x : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd))
                                fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                            fun val =>
                            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd))
                              fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                                    Sum.inr (Sum.inl (fst, val)))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val =>
                                  Sum.inr (Sum.inr (fst, val)))
                          x) =
                      x),
              right_inv :=
                (_ :
                  ∀ (x : LeftMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                                  Sum.inr (Sum.inl (fst, val)))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val =>
                                Sum.inr (Sum.inr (fst, val)))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd))
                                  fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                              fun val =>
                              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd))
                                fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
                          x) =
                      x) }
          (Sum.inr (i, Sum.inl j))))
[PROOFSTEP]
change ⟦xR i * (y + z) + x * (yR j + z) - xR i * (yR j + z)⟧ = ⟦xR i * y + x * yR j - xR i * yR j + x * z⟧
[GOAL]
case refine'_3.inr.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * (y + z) + x * (yR j + z) - xR i * (yR j + z)) =
    Quotient.mk setoid (xR i * y + x * yR j - xR i * yR j + x * z)
[PROOFSTEP]
simp only [quot_sub, quot_add]
[GOAL]
case refine'_3.inr.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR + mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (yR j + mk zl zr zL zR)) -
      Quotient.mk setoid (xR i * (yR j + mk zl zr zL zR)) =
    Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yR j) -
        Quotient.mk setoid (xR i * yR j) +
      Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
rw [quot_left_distrib (xR i) (mk yl yr yL yR) (mk zl zr zL zR)]
[GOAL]
case refine'_3.inr.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * (yR j + mk zl zr zL zR)) -
      Quotient.mk setoid (xR i * (yR j + mk zl zr zL zR)) =
    Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yR j) -
        Quotient.mk setoid (xR i * yR j) +
      Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
rw [quot_left_distrib (mk xl xr xL xR) (yR j) (mk zl zr zL zR)]
[GOAL]
case refine'_3.inr.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * yR j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)) -
      Quotient.mk setoid (xR i * (yR j + mk zl zr zL zR)) =
    Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yR j) -
        Quotient.mk setoid (xR i * yR j) +
      Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
rw [quot_left_distrib (xR i) (yR j) (mk zl zr zL zR)]
[GOAL]
case refine'_3.inr.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * yR j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)) -
      (Quotient.mk setoid (xR i * yR j) + Quotient.mk setoid (xR i * mk zl zr zL zR)) =
    Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yR j) -
        Quotient.mk setoid (xR i * yR j) +
      Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
abel
[GOAL]
case refine'_3.inr.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * yR j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)) -
      (Quotient.mk setoid (xR i * yR j) + Quotient.mk setoid (xR i * mk zl zr zL zR)) =
    Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yR j) -
        Quotient.mk setoid (xR i * yR j) +
      Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
abel
[GOAL]
case refine'_3.inr.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
k : zr
⊢ Quotient.mk setoid (moveLeft (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) (Sum.inr (i, Sum.inr k))) =
    Quotient.mk setoid
      (moveLeft (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
        (↑{
              toFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)),
              invFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
                      Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                  fun val =>
                  Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
                    Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd),
              left_inv :=
                (_ :
                  ∀ (x : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd))
                                fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                            fun val =>
                            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd))
                              fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                                    Sum.inr (Sum.inl (fst, val)))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val =>
                                  Sum.inr (Sum.inr (fst, val)))
                          x) =
                      x),
              right_inv :=
                (_ :
                  ∀ (x : LeftMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                                  Sum.inr (Sum.inl (fst, val)))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val =>
                                Sum.inr (Sum.inr (fst, val)))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd))
                                  fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                              fun val =>
                              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd))
                                fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
                          x) =
                      x) }
          (Sum.inr (i, Sum.inr k))))
[PROOFSTEP]
change ⟦xR i * (y + z) + x * (y + zR k) - xR i * (y + zR k)⟧ = ⟦x * y + (xR i * z + x * zR k - xR i * zR k)⟧
[GOAL]
case refine'_3.inr.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
k : zr
⊢ Quotient.mk setoid (xR i * (y + z) + x * (y + zR k) - xR i * (y + zR k)) =
    Quotient.mk setoid (x * y + (xR i * z + x * zR k - xR i * zR k))
[PROOFSTEP]
simp only [quot_sub, quot_add]
[GOAL]
case refine'_3.inr.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
k : zr
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR + mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + zR k)) -
      Quotient.mk setoid (xR i * (mk yl yr yL yR + zR k)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) +
      (Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zR k) -
        Quotient.mk setoid (xR i * zR k))
[PROOFSTEP]
rw [quot_left_distrib (xR i) (mk yl yr yL yR) (mk zl zr zL zR)]
[GOAL]
case refine'_3.inr.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
k : zr
⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + zR k)) -
      Quotient.mk setoid (xR i * (mk yl yr yL yR + zR k)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) +
      (Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zR k) -
        Quotient.mk setoid (xR i * zR k))
[PROOFSTEP]
rw [quot_left_distrib (mk xl xr xL xR) (mk yl yr yL yR) (zR k)]
[GOAL]
case refine'_3.inr.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
k : zr
⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * zR k)) -
      Quotient.mk setoid (xR i * (mk yl yr yL yR + zR k)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) +
      (Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zR k) -
        Quotient.mk setoid (xR i * zR k))
[PROOFSTEP]
rw [quot_left_distrib (xR i) (mk yl yr yL yR) (zR k)]
[GOAL]
case refine'_3.inr.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
k : zr
⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * zR k)) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * zR k)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) +
      (Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zR k) -
        Quotient.mk setoid (xR i * zR k))
[PROOFSTEP]
abel
[GOAL]
case refine'_3.inr.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
k : zr
⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * zR k)) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * zR k)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) +
      (Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zR k) -
        Quotient.mk setoid (xR i * zR k))
[PROOFSTEP]
abel
[GOAL]
case refine'_4
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ ∀ (j : RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))),
    Quotient.mk setoid (moveRight (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) j) =
      Quotient.mk setoid
        (moveRight (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
          (↑{
                toFun := fun a =>
                  Sum.casesOn a
                    (fun val =>
                      Prod.casesOn val fun fst snd =>
                        Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                          Sum.inr (Sum.inl (fst, val)))
                    fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)),
                invFun := fun a =>
                  Sum.casesOn a
                    (fun val =>
                      Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
                        Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                    fun val =>
                    Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
                      Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd),
                left_inv :=
                  (_ :
                    ∀ (x : RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))),
                      (fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd))
                                  fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                              fun val =>
                              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd))
                                fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
                          ((fun a =>
                              Sum.casesOn a
                                (fun val =>
                                  Prod.casesOn val fun fst snd =>
                                    Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                                      Sum.inr (Sum.inl (fst, val)))
                                fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val =>
                                    Sum.inr (Sum.inr (fst, val)))
                            x) =
                        x),
                right_inv :=
                  (_ :
                    ∀ (x : RightMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)),
                      (fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                                    Sum.inr (Sum.inl (fst, val)))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val =>
                                  Sum.inr (Sum.inr (fst, val)))
                          ((fun a =>
                              Sum.casesOn a
                                (fun val =>
                                  Sum.casesOn val
                                    (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
                                    Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                                fun val =>
                                Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd))
                                  fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
                            x) =
                        x) }
            j))
[PROOFSTEP]
rintro (⟨i, j | k⟩ | ⟨i, j | k⟩)
[GOAL]
case refine'_4.inl.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
j : yr
⊢ Quotient.mk setoid (moveRight (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) (Sum.inl (i, Sum.inl j))) =
    Quotient.mk setoid
      (moveRight (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
        (↑{
              toFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)),
              invFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
                      Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                  fun val =>
                  Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
                    Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd),
              left_inv :=
                (_ :
                  ∀ (x : RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd))
                                fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                            fun val =>
                            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd))
                              fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                                    Sum.inr (Sum.inl (fst, val)))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val =>
                                  Sum.inr (Sum.inr (fst, val)))
                          x) =
                      x),
              right_inv :=
                (_ :
                  ∀ (x : RightMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                                  Sum.inr (Sum.inl (fst, val)))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val =>
                                Sum.inr (Sum.inr (fst, val)))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd))
                                  fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                              fun val =>
                              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd))
                                fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
                          x) =
                      x) }
          (Sum.inl (i, Sum.inl j))))
[PROOFSTEP]
change ⟦xL i * (y + z) + x * (yR j + z) - xL i * (yR j + z)⟧ = ⟦xL i * y + x * yR j - xL i * yR j + x * z⟧
[GOAL]
case refine'_4.inl.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * (y + z) + x * (yR j + z) - xL i * (yR j + z)) =
    Quotient.mk setoid (xL i * y + x * yR j - xL i * yR j + x * z)
[PROOFSTEP]
simp only [quot_sub, quot_add]
[GOAL]
case refine'_4.inl.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR + mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (yR j + mk zl zr zL zR)) -
      Quotient.mk setoid (xL i * (yR j + mk zl zr zL zR)) =
    Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yR j) -
        Quotient.mk setoid (xL i * yR j) +
      Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
rw [quot_left_distrib (xL i) (mk yl yr yL yR) (mk zl zr zL zR)]
[GOAL]
case refine'_4.inl.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * (yR j + mk zl zr zL zR)) -
      Quotient.mk setoid (xL i * (yR j + mk zl zr zL zR)) =
    Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yR j) -
        Quotient.mk setoid (xL i * yR j) +
      Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
rw [quot_left_distrib (mk xl xr xL xR) (yR j) (mk zl zr zL zR)]
[GOAL]
case refine'_4.inl.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * yR j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)) -
      Quotient.mk setoid (xL i * (yR j + mk zl zr zL zR)) =
    Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yR j) -
        Quotient.mk setoid (xL i * yR j) +
      Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
rw [quot_left_distrib (xL i) (yR j) (mk zl zr zL zR)]
[GOAL]
case refine'_4.inl.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * yR j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)) -
      (Quotient.mk setoid (xL i * yR j) + Quotient.mk setoid (xL i * mk zl zr zL zR)) =
    Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yR j) -
        Quotient.mk setoid (xL i * yR j) +
      Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
abel
[GOAL]
case refine'_4.inl.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * yR j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)) -
      (Quotient.mk setoid (xL i * yR j) + Quotient.mk setoid (xL i * mk zl zr zL zR)) =
    Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yR j) -
        Quotient.mk setoid (xL i * yR j) +
      Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
abel
[GOAL]
case refine'_4.inl.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
k : zr
⊢ Quotient.mk setoid (moveRight (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) (Sum.inl (i, Sum.inr k))) =
    Quotient.mk setoid
      (moveRight (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
        (↑{
              toFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)),
              invFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
                      Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                  fun val =>
                  Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
                    Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd),
              left_inv :=
                (_ :
                  ∀ (x : RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd))
                                fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                            fun val =>
                            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd))
                              fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                                    Sum.inr (Sum.inl (fst, val)))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val =>
                                  Sum.inr (Sum.inr (fst, val)))
                          x) =
                      x),
              right_inv :=
                (_ :
                  ∀ (x : RightMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                                  Sum.inr (Sum.inl (fst, val)))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val =>
                                Sum.inr (Sum.inr (fst, val)))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd))
                                  fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                              fun val =>
                              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd))
                                fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
                          x) =
                      x) }
          (Sum.inl (i, Sum.inr k))))
[PROOFSTEP]
change ⟦xL i * (y + z) + x * (y + zR k) - xL i * (y + zR k)⟧ = ⟦x * y + (xL i * z + x * zR k - xL i * zR k)⟧
[GOAL]
case refine'_4.inl.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
k : zr
⊢ Quotient.mk setoid (xL i * (y + z) + x * (y + zR k) - xL i * (y + zR k)) =
    Quotient.mk setoid (x * y + (xL i * z + x * zR k - xL i * zR k))
[PROOFSTEP]
simp only [quot_sub, quot_add]
[GOAL]
case refine'_4.inl.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
k : zr
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR + mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + zR k)) -
      Quotient.mk setoid (xL i * (mk yl yr yL yR + zR k)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) +
      (Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zR k) -
        Quotient.mk setoid (xL i * zR k))
[PROOFSTEP]
rw [quot_left_distrib (xL i) (mk yl yr yL yR) (mk zl zr zL zR)]
[GOAL]
case refine'_4.inl.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
k : zr
⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + zR k)) -
      Quotient.mk setoid (xL i * (mk yl yr yL yR + zR k)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) +
      (Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zR k) -
        Quotient.mk setoid (xL i * zR k))
[PROOFSTEP]
rw [quot_left_distrib (mk xl xr xL xR) (mk yl yr yL yR) (zR k)]
[GOAL]
case refine'_4.inl.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
k : zr
⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * zR k)) -
      Quotient.mk setoid (xL i * (mk yl yr yL yR + zR k)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) +
      (Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zR k) -
        Quotient.mk setoid (xL i * zR k))
[PROOFSTEP]
rw [quot_left_distrib (xL i) (mk yl yr yL yR) (zR k)]
[GOAL]
case refine'_4.inl.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
k : zr
⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * zR k)) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * zR k)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) +
      (Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zR k) -
        Quotient.mk setoid (xL i * zR k))
[PROOFSTEP]
abel
[GOAL]
case refine'_4.inl.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xl
k : zr
⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * zR k)) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * zR k)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) +
      (Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zR k) -
        Quotient.mk setoid (xL i * zR k))
[PROOFSTEP]
abel
[GOAL]
case refine'_4.inr.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
j : yl
⊢ Quotient.mk setoid (moveRight (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) (Sum.inr (i, Sum.inl j))) =
    Quotient.mk setoid
      (moveRight (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
        (↑{
              toFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)),
              invFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
                      Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                  fun val =>
                  Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
                    Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd),
              left_inv :=
                (_ :
                  ∀ (x : RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd))
                                fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                            fun val =>
                            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd))
                              fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                                    Sum.inr (Sum.inl (fst, val)))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val =>
                                  Sum.inr (Sum.inr (fst, val)))
                          x) =
                      x),
              right_inv :=
                (_ :
                  ∀ (x : RightMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                                  Sum.inr (Sum.inl (fst, val)))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val =>
                                Sum.inr (Sum.inr (fst, val)))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd))
                                  fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                              fun val =>
                              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd))
                                fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
                          x) =
                      x) }
          (Sum.inr (i, Sum.inl j))))
[PROOFSTEP]
change ⟦xR i * (y + z) + x * (yL j + z) - xR i * (yL j + z)⟧ = ⟦xR i * y + x * yL j - xR i * yL j + x * z⟧
[GOAL]
case refine'_4.inr.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * (y + z) + x * (yL j + z) - xR i * (yL j + z)) =
    Quotient.mk setoid (xR i * y + x * yL j - xR i * yL j + x * z)
[PROOFSTEP]
simp only [quot_sub, quot_add]
[GOAL]
case refine'_4.inr.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR + mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (yL j + mk zl zr zL zR)) -
      Quotient.mk setoid (xR i * (yL j + mk zl zr zL zR)) =
    Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yL j) -
        Quotient.mk setoid (xR i * yL j) +
      Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
rw [quot_left_distrib (xR i) (mk yl yr yL yR) (mk zl zr zL zR)]
[GOAL]
case refine'_4.inr.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * (yL j + mk zl zr zL zR)) -
      Quotient.mk setoid (xR i * (yL j + mk zl zr zL zR)) =
    Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yL j) -
        Quotient.mk setoid (xR i * yL j) +
      Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
rw [quot_left_distrib (mk xl xr xL xR) (yL j) (mk zl zr zL zR)]
[GOAL]
case refine'_4.inr.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * yL j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)) -
      Quotient.mk setoid (xR i * (yL j + mk zl zr zL zR)) =
    Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yL j) -
        Quotient.mk setoid (xR i * yL j) +
      Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
rw [quot_left_distrib (xR i) (yL j) (mk zl zr zL zR)]
[GOAL]
case refine'_4.inr.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * yL j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)) -
      (Quotient.mk setoid (xR i * yL j) + Quotient.mk setoid (xR i * mk zl zr zL zR)) =
    Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yL j) -
        Quotient.mk setoid (xR i * yL j) +
      Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
abel
[GOAL]
case refine'_4.inr.mk.inl
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * yL j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)) -
      (Quotient.mk setoid (xR i * yL j) + Quotient.mk setoid (xR i * mk zl zr zL zR)) =
    Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yL j) -
        Quotient.mk setoid (xR i * yL j) +
      Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)
[PROOFSTEP]
abel
[GOAL]
case refine'_4.inr.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
k : zl
⊢ Quotient.mk setoid (moveRight (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) (Sum.inr (i, Sum.inr k))) =
    Quotient.mk setoid
      (moveRight (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)
        (↑{
              toFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val)))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)),
              invFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val =>
                      Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                  fun val =>
                  Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val =>
                    Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd),
              left_inv :=
                (_ :
                  ∀ (x : RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd))
                                fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                            fun val =>
                            Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd))
                              fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                                    Sum.inr (Sum.inl (fst, val)))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val =>
                                  Sum.inr (Sum.inr (fst, val)))
                          x) =
                      x),
              right_inv :=
                (_ :
                  ∀ (x : RightMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val =>
                                  Sum.inr (Sum.inl (fst, val)))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val =>
                                Sum.inr (Sum.inr (fst, val)))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd))
                                  fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd))
                              fun val =>
                              Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd))
                                fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd))
                          x) =
                      x) }
          (Sum.inr (i, Sum.inr k))))
[PROOFSTEP]
change ⟦xR i * (y + z) + x * (y + zL k) - xR i * (y + zL k)⟧ = ⟦x * y + (xR i * z + x * zL k - xR i * zL k)⟧
[GOAL]
case refine'_4.inr.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
k : zl
⊢ Quotient.mk setoid (xR i * (y + z) + x * (y + zL k) - xR i * (y + zL k)) =
    Quotient.mk setoid (x * y + (xR i * z + x * zL k - xR i * zL k))
[PROOFSTEP]
simp only [quot_sub, quot_add]
[GOAL]
case refine'_4.inr.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
k : zl
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR + mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + zL k)) -
      Quotient.mk setoid (xR i * (mk yl yr yL yR + zL k)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) +
      (Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zL k) -
        Quotient.mk setoid (xR i * zL k))
[PROOFSTEP]
rw [quot_left_distrib (xR i) (mk yl yr yL yR) (mk zl zr zL zR)]
[GOAL]
case refine'_4.inr.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
k : zl
⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + zL k)) -
      Quotient.mk setoid (xR i * (mk yl yr yL yR + zL k)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) +
      (Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zL k) -
        Quotient.mk setoid (xR i * zL k))
[PROOFSTEP]
rw [quot_left_distrib (mk xl xr xL xR) (mk yl yr yL yR) (zL k)]
[GOAL]
case refine'_4.inr.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
k : zl
⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * zL k)) -
      Quotient.mk setoid (xR i * (mk yl yr yL yR + zL k)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) +
      (Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zL k) -
        Quotient.mk setoid (xR i * zL k))
[PROOFSTEP]
rw [quot_left_distrib (xR i) (mk yl yr yL yR) (zL k)]
[GOAL]
case refine'_4.inr.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
k : zl
⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * zL k)) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * zL k)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) +
      (Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zL k) -
        Quotient.mk setoid (xR i * zL k))
[PROOFSTEP]
abel
[GOAL]
case refine'_4.inr.mk.inr
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
i : xr
k : zl
⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) +
        (Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * zL k)) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * zL k)) =
    Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) +
      (Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zL k) -
        Quotient.mk setoid (xR i * zL k))
[PROOFSTEP]
abel
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
i : xl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := yL j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
i : xl
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := yL j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
i : xl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
k : zl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := zL k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
i : xl
k : zl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := mk yl yr yL yR, snd := zL k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
i : xr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := yR j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
i : xr
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := yR j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
i : xr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
k : zr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := zR k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
i : xr
k : zr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := mk yl yr yL yR, snd := zR k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
i : xl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := yR j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
i : xl
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := yR j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
i : xl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
k : zr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := zR k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
i : xl
k : zr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := mk yl yr yL yR, snd := zR k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
i : xr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := yL j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
i : xr
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := yL j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
i : xr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
k : zl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := zL k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2)
i : xr
k : zl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := mk yl yr yL yR, snd := zL k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
x y z : PGame
⊢ Quotient.mk setoid (x * (y - z)) = Quotient.mk setoid (x * y) - Quotient.mk setoid (x * z)
[PROOFSTEP]
change (⟦x * (y + -z)⟧ : Game) = ⟦x * y⟧ + -⟦x * z⟧
[GOAL]
x y z : PGame
⊢ Quotient.mk setoid (x * (y + -z)) = Quotient.mk setoid (x * y) + -Quotient.mk setoid (x * z)
[PROOFSTEP]
rw [quot_left_distrib, quot_mul_neg]
[GOAL]
x y z : PGame
⊢ Quotient.mk setoid ((x + y) * z) = Quotient.mk setoid (x * z) + Quotient.mk setoid (y * z)
[PROOFSTEP]
simp only [quot_mul_comm, quot_left_distrib]
[GOAL]
x y z : PGame
⊢ Quotient.mk setoid ((y - z) * x) = Quotient.mk setoid (y * x) - Quotient.mk setoid (z * x)
[PROOFSTEP]
change (⟦(y + -z) * x⟧ : Game) = ⟦y * x⟧ + -⟦z * x⟧
[GOAL]
x y z : PGame
⊢ Quotient.mk setoid ((y + -z) * x) = Quotient.mk setoid (y * x) + -Quotient.mk setoid (z * x)
[PROOFSTEP]
rw [quot_right_distrib, quot_neg_mul]
[GOAL]
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
⊢ mk xl xr xL xR * 1 ≡r mk xl xr xL xR
[PROOFSTEP]
show _ * One.one ≡r _
[GOAL]
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
⊢ mk xl xr xL xR * One.one ≡r mk xl xr xL xR
[PROOFSTEP]
unfold One.one
[GOAL]
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
⊢ mk xl xr xL xR * instOnePGame.1 ≡r mk xl xr xL xR
[PROOFSTEP]
unfold instOnePGame
[GOAL]
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
⊢ mk xl xr xL xR * { one := mk PUnit PEmpty (fun x => 0) PEmpty.elim }.1 ≡r mk xl xr xL xR
[PROOFSTEP]
change
  mk _ _ _ _ * mk _ _ _ _ ≡r
    _
      -- Porting note: changed `refine'` to `refine`,
          -- otherwise there are typeclass inference failures.
[GOAL]
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
⊢ mk xl xr xL xR * mk PUnit PEmpty (fun x => 0) PEmpty.elim ≡r mk xl xr xL xR
[PROOFSTEP]
refine ⟨(Equiv.sumEmpty _ _).trans (Equiv.prodPUnit _), (Equiv.emptySum _ _).trans (Equiv.prodPUnit _), ?_, ?_⟩
[GOAL]
case refine_1
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
⊢ (i : LeftMoves (mk xl xr xL xR * mk PUnit PEmpty (fun x => 0) PEmpty.elim)) →
    moveLeft (mk xl xr xL xR * mk PUnit PEmpty (fun x => 0) PEmpty.elim) i ≡r
      moveLeft (mk xl xr xL xR) (↑((Equiv.sumEmpty (xl × PUnit) (xr × PEmpty)).trans (Equiv.prodPUnit xl)) i)
[PROOFSTEP]
try rintro (⟨i, ⟨⟩⟩ | ⟨i, ⟨⟩⟩)
[GOAL]
case refine_1
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
⊢ (i : LeftMoves (mk xl xr xL xR * mk PUnit PEmpty (fun x => 0) PEmpty.elim)) →
    moveLeft (mk xl xr xL xR * mk PUnit PEmpty (fun x => 0) PEmpty.elim) i ≡r
      moveLeft (mk xl xr xL xR) (↑((Equiv.sumEmpty (xl × PUnit) (xr × PEmpty)).trans (Equiv.prodPUnit xl)) i)
[PROOFSTEP]
rintro (⟨i, ⟨⟩⟩ | ⟨i, ⟨⟩⟩)
[GOAL]
case refine_2
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
⊢ (j : RightMoves (mk xl xr xL xR * mk PUnit PEmpty (fun x => 0) PEmpty.elim)) →
    moveRight (mk xl xr xL xR * mk PUnit PEmpty (fun x => 0) PEmpty.elim) j ≡r
      moveRight (mk xl xr xL xR) (↑((Equiv.emptySum (xl × PEmpty) (xr × PUnit)).trans (Equiv.prodPUnit xr)) j)
[PROOFSTEP]
try rintro (⟨i, ⟨⟩⟩ | ⟨i, ⟨⟩⟩)
[GOAL]
case refine_2
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
⊢ (j : RightMoves (mk xl xr xL xR * mk PUnit PEmpty (fun x => 0) PEmpty.elim)) →
    moveRight (mk xl xr xL xR * mk PUnit PEmpty (fun x => 0) PEmpty.elim) j ≡r
      moveRight (mk xl xr xL xR) (↑((Equiv.emptySum (xl × PEmpty) (xr × PUnit)).trans (Equiv.prodPUnit xr)) j)
[PROOFSTEP]
rintro (⟨i, ⟨⟩⟩ | ⟨i, ⟨⟩⟩)
[GOAL]
case refine_1.inl.mk.unit
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
i : xl
⊢ moveLeft (mk xl xr xL xR * mk PUnit PEmpty (fun x => 0) PEmpty.elim) (Sum.inl (i, PUnit.unit)) ≡r
    moveLeft (mk xl xr xL xR)
      (↑((Equiv.sumEmpty (xl × PUnit) (xr × PEmpty)).trans (Equiv.prodPUnit xl)) (Sum.inl (i, PUnit.unit)))
[PROOFSTEP]
{ (try intro i)
  dsimp
  apply (Relabelling.subCongr (Relabelling.refl _) (mulZeroRelabelling _)).trans
  rw [sub_zero]
  exact
    (addZeroRelabelling _).trans <|
      (((mulOneRelabelling _).addCongr (mulZeroRelabelling _)).trans <| addZeroRelabelling _)
}
[GOAL]
case refine_1.inl.mk.unit
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
i : xl
⊢ moveLeft (mk xl xr xL xR * mk PUnit PEmpty (fun x => 0) PEmpty.elim) (Sum.inl (i, PUnit.unit)) ≡r
    moveLeft (mk xl xr xL xR)
      (↑((Equiv.sumEmpty (xl × PUnit) (xr × PEmpty)).trans (Equiv.prodPUnit xl)) (Sum.inl (i, PUnit.unit)))
[PROOFSTEP]
try intro i
[GOAL]
case refine_1.inl.mk.unit
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
i : xl
⊢ moveLeft (mk xl xr xL xR * mk PUnit PEmpty (fun x => 0) PEmpty.elim) (Sum.inl (i, PUnit.unit)) ≡r
    moveLeft (mk xl xr xL xR)
      (↑((Equiv.sumEmpty (xl × PUnit) (xr × PEmpty)).trans (Equiv.prodPUnit xl)) (Sum.inl (i, PUnit.unit)))
[PROOFSTEP]
intro i
[GOAL]
case refine_1.inl.mk.unit
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
i : xl
⊢ moveLeft (mk xl xr xL xR * mk PUnit PEmpty (fun x => 0) PEmpty.elim) (Sum.inl (i, PUnit.unit)) ≡r
    moveLeft (mk xl xr xL xR)
      (↑((Equiv.sumEmpty (xl × PUnit) (xr × PEmpty)).trans (Equiv.prodPUnit xl)) (Sum.inl (i, PUnit.unit)))
[PROOFSTEP]
dsimp
[GOAL]
case refine_1.inl.mk.unit
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
i : xl
⊢ xL i * mk PUnit PEmpty (fun x => 0) PEmpty.elim + mk xl xr xL xR * 0 - xL i * 0 ≡r
    xL (↑(Equiv.sumEmpty (xl × PUnit) (xr × PEmpty)) (Sum.inl (i, PUnit.unit))).fst
[PROOFSTEP]
apply (Relabelling.subCongr (Relabelling.refl _) (mulZeroRelabelling _)).trans
[GOAL]
case refine_1.inl.mk.unit
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
i : xl
⊢ xL i * mk PUnit PEmpty (fun x => 0) PEmpty.elim + mk xl xr xL xR * 0 - 0 ≡r
    xL (↑(Equiv.sumEmpty (xl × PUnit) (xr × PEmpty)) (Sum.inl (i, PUnit.unit))).fst
[PROOFSTEP]
rw [sub_zero]
[GOAL]
case refine_1.inl.mk.unit
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
i : xl
⊢ xL i * mk PUnit PEmpty (fun x => 0) PEmpty.elim + mk xl xr xL xR * 0 + 0 ≡r
    xL (↑(Equiv.sumEmpty (xl × PUnit) (xr × PEmpty)) (Sum.inl (i, PUnit.unit))).fst
[PROOFSTEP]
exact
  (addZeroRelabelling _).trans <|
    (((mulOneRelabelling _).addCongr (mulZeroRelabelling _)).trans <| addZeroRelabelling _)
[GOAL]
case refine_2.inr.mk.unit
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
i : xr
⊢ moveRight (mk xl xr xL xR * mk PUnit PEmpty (fun x => 0) PEmpty.elim) (Sum.inr (i, PUnit.unit)) ≡r
    moveRight (mk xl xr xL xR)
      (↑((Equiv.emptySum (xl × PEmpty) (xr × PUnit)).trans (Equiv.prodPUnit xr)) (Sum.inr (i, PUnit.unit)))
[PROOFSTEP]
{ (try intro i)
  dsimp
  apply (Relabelling.subCongr (Relabelling.refl _) (mulZeroRelabelling _)).trans
  rw [sub_zero]
  exact
    (addZeroRelabelling _).trans <|
      (((mulOneRelabelling _).addCongr (mulZeroRelabelling _)).trans <| addZeroRelabelling _)
}
[GOAL]
case refine_2.inr.mk.unit
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
i : xr
⊢ moveRight (mk xl xr xL xR * mk PUnit PEmpty (fun x => 0) PEmpty.elim) (Sum.inr (i, PUnit.unit)) ≡r
    moveRight (mk xl xr xL xR)
      (↑((Equiv.emptySum (xl × PEmpty) (xr × PUnit)).trans (Equiv.prodPUnit xr)) (Sum.inr (i, PUnit.unit)))
[PROOFSTEP]
try intro i
[GOAL]
case refine_2.inr.mk.unit
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
i : xr
⊢ moveRight (mk xl xr xL xR * mk PUnit PEmpty (fun x => 0) PEmpty.elim) (Sum.inr (i, PUnit.unit)) ≡r
    moveRight (mk xl xr xL xR)
      (↑((Equiv.emptySum (xl × PEmpty) (xr × PUnit)).trans (Equiv.prodPUnit xr)) (Sum.inr (i, PUnit.unit)))
[PROOFSTEP]
intro i
[GOAL]
case refine_2.inr.mk.unit
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
i : xr
⊢ moveRight (mk xl xr xL xR * mk PUnit PEmpty (fun x => 0) PEmpty.elim) (Sum.inr (i, PUnit.unit)) ≡r
    moveRight (mk xl xr xL xR)
      (↑((Equiv.emptySum (xl × PEmpty) (xr × PUnit)).trans (Equiv.prodPUnit xr)) (Sum.inr (i, PUnit.unit)))
[PROOFSTEP]
dsimp
[GOAL]
case refine_2.inr.mk.unit
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
i : xr
⊢ xR i * mk PUnit PEmpty (fun x => 0) PEmpty.elim + mk xl xr xL xR * 0 - xR i * 0 ≡r
    xR (↑(Equiv.emptySum (xl × PEmpty) (xr × PUnit)) (Sum.inr (i, PUnit.unit))).fst
[PROOFSTEP]
apply (Relabelling.subCongr (Relabelling.refl _) (mulZeroRelabelling _)).trans
[GOAL]
case refine_2.inr.mk.unit
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
i : xr
⊢ xR i * mk PUnit PEmpty (fun x => 0) PEmpty.elim + mk xl xr xL xR * 0 - 0 ≡r
    xR (↑(Equiv.emptySum (xl × PEmpty) (xr × PUnit)) (Sum.inr (i, PUnit.unit))).fst
[PROOFSTEP]
rw [sub_zero]
[GOAL]
case refine_2.inr.mk.unit
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
i : xr
⊢ xR i * mk PUnit PEmpty (fun x => 0) PEmpty.elim + mk xl xr xL xR * 0 + 0 ≡r
    xR (↑(Equiv.emptySum (xl × PEmpty) (xr × PUnit)) (Sum.inr (i, PUnit.unit))).fst
[PROOFSTEP]
exact
  (addZeroRelabelling _).trans <|
    (((mulOneRelabelling _).addCongr (mulZeroRelabelling _)).trans <| addZeroRelabelling _)
[GOAL]
x y z : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
⊢ Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) =
    Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
[PROOFSTEP]
let x := mk xl xr xL xR
[GOAL]
x✝ y z : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
⊢ Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) =
    Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
[PROOFSTEP]
let y := mk yl yr yL yR
[GOAL]
x✝ y✝ z : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
⊢ Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) =
    Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
[PROOFSTEP]
let z := mk zl zr zL zR
[GOAL]
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) =
    Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
[PROOFSTEP]
refine' quot_eq_of_mk'_quot_eq _ _ _ _
[GOAL]
case refine'_1
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) ≃
    LeftMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
[PROOFSTEP]
fconstructor
[GOAL]
case refine'_1.toFun
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) →
    LeftMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
[PROOFSTEP]
rintro (⟨⟨_, _⟩ | ⟨_, _⟩, _⟩ | ⟨⟨_, _⟩ | ⟨_, _⟩, _⟩)
[GOAL]
case refine'_1.toFun.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
snd✝¹ : zl
fst✝ : xl
snd✝ : yl
⊢ LeftMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_1.toFun.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
snd✝¹ : zl
fst✝ : xr
snd✝ : yr
⊢ LeftMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_1.toFun.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
snd✝¹ : zr
fst✝ : xl
snd✝ : yr
⊢ LeftMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_1.toFun.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
snd✝¹ : zr
fst✝ : xr
snd✝ : yl
⊢ LeftMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_1.invFun
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ LeftMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) →
    LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)
[PROOFSTEP]
rintro (⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩)
[GOAL]
case refine'_1.invFun.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝¹ : xl
fst✝ : yl
snd✝ : zl
⊢ LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_1.invFun.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝¹ : xl
fst✝ : yr
snd✝ : zr
⊢ LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_1.invFun.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝¹ : xr
fst✝ : yl
snd✝ : zr
⊢ LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_1.invFun.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝¹ : xr
fst✝ : yr
snd✝ : zl
⊢ LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_1.left_inv
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ LeftInverse
    (fun a =>
      Sum.casesOn a
        (fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
              fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
        fun val =>
        Prod.casesOn val fun fst snd =>
          Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val =>
            Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
    fun a =>
    Sum.casesOn a
      (fun val =>
        Prod.casesOn val fun fst snd =>
          Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val =>
            Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
      fun val =>
      Prod.casesOn val fun fst snd =>
        Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val =>
          Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))
[PROOFSTEP]
rintro (⟨⟨_, _⟩ | ⟨_, _⟩, _⟩ | ⟨⟨_, _⟩ | ⟨_, _⟩, _⟩)
[GOAL]
case refine'_1.left_inv.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
snd✝¹ : zl
fst✝ : xl
snd✝ : yl
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
              fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
        (Sum.inl (Sum.inl (fst✝, snd✝), snd✝¹))) =
    Sum.inl (Sum.inl (fst✝, snd✝), snd✝¹)
[PROOFSTEP]
rfl
[GOAL]
case refine'_1.left_inv.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
snd✝¹ : zl
fst✝ : xr
snd✝ : yr
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
              fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
        (Sum.inl (Sum.inr (fst✝, snd✝), snd✝¹))) =
    Sum.inl (Sum.inr (fst✝, snd✝), snd✝¹)
[PROOFSTEP]
rfl
[GOAL]
case refine'_1.left_inv.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
snd✝¹ : zr
fst✝ : xl
snd✝ : yr
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
              fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
        (Sum.inr (Sum.inl (fst✝, snd✝), snd✝¹))) =
    Sum.inr (Sum.inl (fst✝, snd✝), snd✝¹)
[PROOFSTEP]
rfl
[GOAL]
case refine'_1.left_inv.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
snd✝¹ : zr
fst✝ : xr
snd✝ : yl
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
              fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
        (Sum.inr (Sum.inr (fst✝, snd✝), snd✝¹))) =
    Sum.inr (Sum.inr (fst✝, snd✝), snd✝¹)
[PROOFSTEP]
rfl
[GOAL]
case refine'_1.right_inv
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ Function.RightInverse
    (fun a =>
      Sum.casesOn a
        (fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
              fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
        fun val =>
        Prod.casesOn val fun fst snd =>
          Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val =>
            Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
    fun a =>
    Sum.casesOn a
      (fun val =>
        Prod.casesOn val fun fst snd =>
          Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val =>
            Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
      fun val =>
      Prod.casesOn val fun fst snd =>
        Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val =>
          Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))
[PROOFSTEP]
rintro (⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩)
[GOAL]
case refine'_1.right_inv.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝¹ : xl
fst✝ : yl
snd✝ : zl
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
              fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
        (Sum.inl (fst✝¹, Sum.inl (fst✝, snd✝)))) =
    Sum.inl (fst✝¹, Sum.inl (fst✝, snd✝))
[PROOFSTEP]
rfl
[GOAL]
case refine'_1.right_inv.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝¹ : xl
fst✝ : yr
snd✝ : zr
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
              fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
        (Sum.inl (fst✝¹, Sum.inr (fst✝, snd✝)))) =
    Sum.inl (fst✝¹, Sum.inr (fst✝, snd✝))
[PROOFSTEP]
rfl
[GOAL]
case refine'_1.right_inv.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝¹ : xr
fst✝ : yl
snd✝ : zr
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
              fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
        (Sum.inr (fst✝¹, Sum.inl (fst✝, snd✝)))) =
    Sum.inr (fst✝¹, Sum.inl (fst✝, snd✝))
[PROOFSTEP]
rfl
[GOAL]
case refine'_1.right_inv.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝¹ : xr
fst✝ : yr
snd✝ : zl
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
              fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
        (Sum.inr (fst✝¹, Sum.inr (fst✝, snd✝)))) =
    Sum.inr (fst✝¹, Sum.inr (fst✝, snd✝))
[PROOFSTEP]
rfl
[GOAL]
case refine'_2
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) ≃
    RightMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
[PROOFSTEP]
fconstructor
[GOAL]
case refine'_2.toFun
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) →
    RightMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
[PROOFSTEP]
rintro (⟨⟨_, _⟩ | ⟨_, _⟩, _⟩ | ⟨⟨_, _⟩ | ⟨_, _⟩, _⟩)
[GOAL]
case refine'_2.toFun.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
snd✝¹ : zr
fst✝ : xl
snd✝ : yl
⊢ RightMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_2.toFun.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
snd✝¹ : zr
fst✝ : xr
snd✝ : yr
⊢ RightMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_2.toFun.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
snd✝¹ : zl
fst✝ : xl
snd✝ : yr
⊢ RightMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_2.toFun.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
snd✝¹ : zl
fst✝ : xr
snd✝ : yl
⊢ RightMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_2.invFun
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ RightMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) →
    RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)
[PROOFSTEP]
rintro (⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩)
[GOAL]
case refine'_2.invFun.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝¹ : xl
fst✝ : yl
snd✝ : zr
⊢ RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_2.invFun.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝¹ : xl
fst✝ : yr
snd✝ : zl
⊢ RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_2.invFun.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝¹ : xr
fst✝ : yl
snd✝ : zl
⊢ RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_2.invFun.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝¹ : xr
fst✝ : yr
snd✝ : zr
⊢ RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)
[PROOFSTEP]
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk]
[GOAL]
case refine'_2.left_inv
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ LeftInverse
    (fun a =>
      Sum.casesOn a
        (fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
              fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
        fun val =>
        Prod.casesOn val fun fst snd =>
          Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val =>
            Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
    fun a =>
    Sum.casesOn a
      (fun val =>
        Prod.casesOn val fun fst snd =>
          Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val =>
            Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
      fun val =>
      Prod.casesOn val fun fst snd =>
        Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val =>
          Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))
[PROOFSTEP]
rintro (⟨⟨_, _⟩ | ⟨_, _⟩, _⟩ | ⟨⟨_, _⟩ | ⟨_, _⟩, _⟩)
[GOAL]
case refine'_2.left_inv.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
snd✝¹ : zr
fst✝ : xl
snd✝ : yl
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
              fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
        (Sum.inl (Sum.inl (fst✝, snd✝), snd✝¹))) =
    Sum.inl (Sum.inl (fst✝, snd✝), snd✝¹)
[PROOFSTEP]
rfl
[GOAL]
case refine'_2.left_inv.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
snd✝¹ : zr
fst✝ : xr
snd✝ : yr
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
              fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
        (Sum.inl (Sum.inr (fst✝, snd✝), snd✝¹))) =
    Sum.inl (Sum.inr (fst✝, snd✝), snd✝¹)
[PROOFSTEP]
rfl
[GOAL]
case refine'_2.left_inv.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
snd✝¹ : zl
fst✝ : xl
snd✝ : yr
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
              fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
        (Sum.inr (Sum.inl (fst✝, snd✝), snd✝¹))) =
    Sum.inr (Sum.inl (fst✝, snd✝), snd✝¹)
[PROOFSTEP]
rfl
[GOAL]
case refine'_2.left_inv.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
snd✝¹ : zl
fst✝ : xr
snd✝ : yl
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
              fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
        (Sum.inr (Sum.inr (fst✝, snd✝), snd✝¹))) =
    Sum.inr (Sum.inr (fst✝, snd✝), snd✝¹)
[PROOFSTEP]
rfl
[GOAL]
case refine'_2.right_inv
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ Function.RightInverse
    (fun a =>
      Sum.casesOn a
        (fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
              fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
        fun val =>
        Prod.casesOn val fun fst snd =>
          Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val =>
            Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
    fun a =>
    Sum.casesOn a
      (fun val =>
        Prod.casesOn val fun fst snd =>
          Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val =>
            Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
      fun val =>
      Prod.casesOn val fun fst snd =>
        Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val =>
          Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))
[PROOFSTEP]
rintro (⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩)
[GOAL]
case refine'_2.right_inv.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝¹ : xl
fst✝ : yl
snd✝ : zr
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
              fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
        (Sum.inl (fst✝¹, Sum.inl (fst✝, snd✝)))) =
    Sum.inl (fst✝¹, Sum.inl (fst✝, snd✝))
[PROOFSTEP]
rfl
  -- Porting note: explicitly wrote out arguments to each recursive
      -- quot_mul_assoc reference below, because otherwise the decreasing_by block
      -- failed. Each branch previously ended with: `simp [quot_mul_assoc]; abel`
      -- See https://github.com/leanprover/lean4/issues/2288
[GOAL]
case refine'_2.right_inv.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝¹ : xl
fst✝ : yr
snd✝ : zl
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
              fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
        (Sum.inl (fst✝¹, Sum.inr (fst✝, snd✝)))) =
    Sum.inl (fst✝¹, Sum.inr (fst✝, snd✝))
[PROOFSTEP]
rfl
  -- Porting note: explicitly wrote out arguments to each recursive
      -- quot_mul_assoc reference below, because otherwise the decreasing_by block
      -- failed. Each branch previously ended with: `simp [quot_mul_assoc]; abel`
      -- See https://github.com/leanprover/lean4/issues/2288
[GOAL]
case refine'_2.right_inv.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝¹ : xr
fst✝ : yl
snd✝ : zl
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
              fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
        (Sum.inr (fst✝¹, Sum.inl (fst✝, snd✝)))) =
    Sum.inr (fst✝¹, Sum.inl (fst✝, snd✝))
[PROOFSTEP]
rfl
  -- Porting note: explicitly wrote out arguments to each recursive
      -- quot_mul_assoc reference below, because otherwise the decreasing_by block
      -- failed. Each branch previously ended with: `simp [quot_mul_assoc]; abel`
      -- See https://github.com/leanprover/lean4/issues/2288
[GOAL]
case refine'_2.right_inv.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
fst✝¹ : xr
fst✝ : yr
snd✝ : zr
⊢ (fun a =>
        Sum.casesOn a
          (fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
          fun val =>
          Prod.casesOn val fun fst snd =>
            Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
              fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
      ((fun a =>
          Sum.casesOn a
            (fun val =>
              Prod.casesOn val fun fst snd =>
                Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
            fun val =>
            Prod.casesOn val fun fst snd =>
              Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
        (Sum.inr (fst✝¹, Sum.inr (fst✝, snd✝)))) =
    Sum.inr (fst✝¹, Sum.inr (fst✝, snd✝))
[PROOFSTEP]
rfl
  -- Porting note: explicitly wrote out arguments to each recursive
      -- quot_mul_assoc reference below, because otherwise the decreasing_by block
      -- failed. Each branch previously ended with: `simp [quot_mul_assoc]; abel`
      -- See https://github.com/leanprover/lean4/issues/2288
[GOAL]
case refine'_3
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ ∀ (i : LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)),
    Quotient.mk setoid (moveLeft (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) i) =
      Quotient.mk setoid
        (moveLeft (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
          (↑{
                toFun := fun a =>
                  Sum.casesOn a
                    (fun val =>
                      Prod.casesOn val fun fst snd =>
                        Sum.casesOn fst
                          (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val =>
                          Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                    fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                        fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)),
                invFun := fun a =>
                  Sum.casesOn a
                    (fun val =>
                      Prod.casesOn val fun fst snd =>
                        Sum.casesOn snd
                          (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val =>
                          Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                    fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                        fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd),
                left_inv :=
                  (_ :
                    ∀ (x : LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)),
                      (fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd
                                    (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                                    fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd
                                  (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
                          ((fun a =>
                              Sum.casesOn a
                                (fun val =>
                                  Prod.casesOn val fun fst snd =>
                                    Sum.casesOn fst
                                      (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                                      fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                                fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn fst
                                    (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                                    fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
                            x) =
                        x),
                right_inv :=
                  (_ :
                    ∀ (x : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))),
                      (fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn fst
                                    (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                                    fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn fst
                                  (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
                          ((fun a =>
                              Sum.casesOn a
                                (fun val =>
                                  Prod.casesOn val fun fst snd =>
                                    Sum.casesOn snd
                                      (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                                      fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                                fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd
                                    (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                                    fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
                            x) =
                        x) }
            i))
[PROOFSTEP]
rintro (⟨⟨i, j⟩ | ⟨i, j⟩, k⟩ | ⟨⟨i, j⟩ | ⟨i, j⟩, k⟩)
[GOAL]
case refine'_3.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yl
⊢ Quotient.mk setoid (moveLeft (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) (Sum.inl (Sum.inl (i, j), k))) =
    Quotient.mk setoid
      (moveLeft (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
        (↑{
              toFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                        fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                      fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)),
              invFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                        fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                      fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd),
              left_inv :=
                (_ :
                  ∀ (x : LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd
                                  (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn snd
                                (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                                fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn fst
                                    (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                                    fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn fst
                                  (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
                          x) =
                      x),
              right_inv :=
                (_ :
                  ∀ (x : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn fst
                                  (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn fst
                                (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd
                                    (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                                    fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd
                                  (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
                          x) =
                      x) }
          (Sum.inl (Sum.inl (i, j), k))))
[PROOFSTEP]
change
  ⟦(xL i * y + x * yL j - xL i * yL j) * z + x * y * zL k - (xL i * y + x * yL j - xL i * yL j) * zL k⟧ =
    ⟦xL i * (y * z) + x * (yL j * z + y * zL k - yL j * zL k) - xL i * (yL j * z + y * zL k - yL j * zL k)⟧
[GOAL]
case refine'_3.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yl
⊢ Quotient.mk setoid
      ((xL i * y + x * yL j - xL i * yL j) * z + x * y * zL k - (xL i * y + x * yL j - xL i * yL j) * zL k) =
    Quotient.mk setoid
      (xL i * (y * z) + x * (yL j * z + y * zL k - yL j * zL k) - xL i * (yL j * z + y * zL k - yL j * zL k))
[PROOFSTEP]
simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib, quot_left_distrib_sub, quot_left_distrib]
[GOAL]
case refine'_3.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * mk yl yr yL yR * mk zl zr zL zR) +
            Quotient.mk setoid (mk xl xr xL xR * yL j * mk zl zr zL zR) -
          Quotient.mk setoid (xL i * yL j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) -
        Quotient.mk setoid (xL i * yL j * zL k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) -
      (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xL i * (yL j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (mk zl zr zL zR)]
[GOAL]
case refine'_3.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * yL j * mk zl zr zL zR) -
          Quotient.mk setoid (xL i * yL j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) -
        Quotient.mk setoid (xL i * yL j * zL k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) -
      (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xL i * (yL j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (mk zl zr zL zR)]
[GOAL]
case refine'_3.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * yL j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) -
        Quotient.mk setoid (xL i * yL j * zL k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) -
      (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xL i * (yL j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (xL i) (yL j) (mk zl zr zL zR)]
[GOAL]
case refine'_3.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) -
        Quotient.mk setoid (xL i * yL j * zL k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) -
      (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xL i * (yL j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zL k)]
[GOAL]
case refine'_3.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) -
        Quotient.mk setoid (xL i * yL j * zL k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) -
      (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xL i * (yL j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (zL k)]
[GOAL]
case refine'_3.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
      (Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) -
        Quotient.mk setoid (xL i * yL j * zL k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) -
      (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xL i * (yL j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (zL k)]
[GOAL]
case refine'_3.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
      (Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k)) -
        Quotient.mk setoid (xL i * yL j * zL k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) -
      (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xL i * (yL j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (xL i) (yL j) (zL k)]
[GOAL]
case refine'_3.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
      (Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k)) -
        Quotient.mk setoid (xL i * (yL j * zL k))) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) -
      (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xL i * (yL j * zL k)))
[PROOFSTEP]
abel
[GOAL]
case refine'_3.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
      (Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k)) -
        Quotient.mk setoid (xL i * (yL j * zL k))) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) -
      (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xL i * (yL j * zL k)))
[PROOFSTEP]
abel
[GOAL]
case refine'_3.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yr
⊢ Quotient.mk setoid (moveLeft (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) (Sum.inl (Sum.inr (i, j), k))) =
    Quotient.mk setoid
      (moveLeft (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
        (↑{
              toFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                        fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                      fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)),
              invFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                        fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                      fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd),
              left_inv :=
                (_ :
                  ∀ (x : LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd
                                  (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn snd
                                (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                                fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn fst
                                    (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                                    fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn fst
                                  (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
                          x) =
                      x),
              right_inv :=
                (_ :
                  ∀ (x : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn fst
                                  (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn fst
                                (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd
                                    (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                                    fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd
                                  (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
                          x) =
                      x) }
          (Sum.inl (Sum.inr (i, j), k))))
[PROOFSTEP]
change
  ⟦(xR i * y + x * yR j - xR i * yR j) * z + x * y * zL k - (xR i * y + x * yR j - xR i * yR j) * zL k⟧ =
    ⟦xR i * (y * z) + x * (yR j * z + y * zL k - yR j * zL k) - xR i * (yR j * z + y * zL k - yR j * zL k)⟧
[GOAL]
case refine'_3.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yr
⊢ Quotient.mk setoid
      ((xR i * y + x * yR j - xR i * yR j) * z + x * y * zL k - (xR i * y + x * yR j - xR i * yR j) * zL k) =
    Quotient.mk setoid
      (xR i * (y * z) + x * (yR j * z + y * zL k - yR j * zL k) - xR i * (yR j * z + y * zL k - yR j * zL k))
[PROOFSTEP]
simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib, quot_left_distrib_sub, quot_left_distrib]
[GOAL]
case refine'_3.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * mk yl yr yL yR * mk zl zr zL zR) +
            Quotient.mk setoid (mk xl xr xL xR * yR j * mk zl zr zL zR) -
          Quotient.mk setoid (xR i * yR j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) -
        Quotient.mk setoid (xR i * yR j * zL k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) -
      (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xR i * (yR j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (mk zl zr zL zR)]
[GOAL]
case refine'_3.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * yR j * mk zl zr zL zR) -
          Quotient.mk setoid (xR i * yR j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) -
        Quotient.mk setoid (xR i * yR j * zL k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) -
      (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xR i * (yR j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (mk zl zr zL zR)]
[GOAL]
case refine'_3.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * yR j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) -
        Quotient.mk setoid (xR i * yR j * zL k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) -
      (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xR i * (yR j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (xR i) (yR j) (mk zl zr zL zR)]
[GOAL]
case refine'_3.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) -
        Quotient.mk setoid (xR i * yR j * zL k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) -
      (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xR i * (yR j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zL k)]
[GOAL]
case refine'_3.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) -
        Quotient.mk setoid (xR i * yR j * zL k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) -
      (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xR i * (yR j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (zL k)]
[GOAL]
case refine'_3.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
      (Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) -
        Quotient.mk setoid (xR i * yR j * zL k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) -
      (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xR i * (yR j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (zL k)]
[GOAL]
case refine'_3.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
      (Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k)) -
        Quotient.mk setoid (xR i * yR j * zL k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) -
      (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xR i * (yR j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (xR i) (yR j) (zL k)]
[GOAL]
case refine'_3.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
      (Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k)) -
        Quotient.mk setoid (xR i * (yR j * zL k))) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) -
      (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xR i * (yR j * zL k)))
[PROOFSTEP]
abel
[GOAL]
case refine'_3.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
      (Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k)) -
        Quotient.mk setoid (xR i * (yR j * zL k))) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) -
      (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xR i * (yR j * zL k)))
[PROOFSTEP]
abel
[GOAL]
case refine'_3.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yr
⊢ Quotient.mk setoid (moveLeft (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) (Sum.inr (Sum.inl (i, j), k))) =
    Quotient.mk setoid
      (moveLeft (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
        (↑{
              toFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                        fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                      fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)),
              invFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                        fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                      fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd),
              left_inv :=
                (_ :
                  ∀ (x : LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd
                                  (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn snd
                                (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                                fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn fst
                                    (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                                    fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn fst
                                  (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
                          x) =
                      x),
              right_inv :=
                (_ :
                  ∀ (x : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn fst
                                  (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn fst
                                (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd
                                    (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                                    fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd
                                  (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
                          x) =
                      x) }
          (Sum.inr (Sum.inl (i, j), k))))
[PROOFSTEP]
change
  ⟦(xL i * y + x * yR j - xL i * yR j) * z + x * y * zR k - (xL i * y + x * yR j - xL i * yR j) * zR k⟧ =
    ⟦xL i * (y * z) + x * (yR j * z + y * zR k - yR j * zR k) - xL i * (yR j * z + y * zR k - yR j * zR k)⟧
[GOAL]
case refine'_3.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yr
⊢ Quotient.mk setoid
      ((xL i * y + x * yR j - xL i * yR j) * z + x * y * zR k - (xL i * y + x * yR j - xL i * yR j) * zR k) =
    Quotient.mk setoid
      (xL i * (y * z) + x * (yR j * z + y * zR k - yR j * zR k) - xL i * (yR j * z + y * zR k - yR j * zR k))
[PROOFSTEP]
simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib, quot_left_distrib_sub, quot_left_distrib]
[GOAL]
case refine'_3.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * mk yl yr yL yR * mk zl zr zL zR) +
            Quotient.mk setoid (mk xl xr xL xR * yR j * mk zl zr zL zR) -
          Quotient.mk setoid (xL i * yR j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) -
        Quotient.mk setoid (xL i * yR j * zR k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) -
      (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xL i * (yR j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (mk zl zr zL zR)]
[GOAL]
case refine'_3.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * yR j * mk zl zr zL zR) -
          Quotient.mk setoid (xL i * yR j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) -
        Quotient.mk setoid (xL i * yR j * zR k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) -
      (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xL i * (yR j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (mk zl zr zL zR)]
[GOAL]
case refine'_3.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * yR j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) -
        Quotient.mk setoid (xL i * yR j * zR k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) -
      (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xL i * (yR j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (xL i) (yR j) (mk zl zr zL zR)]
[GOAL]
case refine'_3.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) -
        Quotient.mk setoid (xL i * yR j * zR k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) -
      (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xL i * (yR j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zR k)]
[GOAL]
case refine'_3.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) -
        Quotient.mk setoid (xL i * yR j * zR k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) -
      (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xL i * (yR j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (zR k)]
[GOAL]
case refine'_3.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
      (Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) -
        Quotient.mk setoid (xL i * yR j * zR k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) -
      (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xL i * (yR j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (zR k)]
[GOAL]
case refine'_3.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
      (Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k)) -
        Quotient.mk setoid (xL i * yR j * zR k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) -
      (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xL i * (yR j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (xL i) (yR j) (zR k)]
[GOAL]
case refine'_3.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
      (Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k)) -
        Quotient.mk setoid (xL i * (yR j * zR k))) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) -
      (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xL i * (yR j * zR k)))
[PROOFSTEP]
abel
[GOAL]
case refine'_3.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
      (Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k)) -
        Quotient.mk setoid (xL i * (yR j * zR k))) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) -
      (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xL i * (yR j * zR k)))
[PROOFSTEP]
abel
[GOAL]
case refine'_3.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yl
⊢ Quotient.mk setoid (moveLeft (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) (Sum.inr (Sum.inr (i, j), k))) =
    Quotient.mk setoid
      (moveLeft (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
        (↑{
              toFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                        fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                      fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)),
              invFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                        fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                      fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd),
              left_inv :=
                (_ :
                  ∀ (x : LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd
                                  (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn snd
                                (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                                fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn fst
                                    (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                                    fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn fst
                                  (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
                          x) =
                      x),
              right_inv :=
                (_ :
                  ∀ (x : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn fst
                                  (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn fst
                                (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd
                                    (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                                    fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd
                                  (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
                          x) =
                      x) }
          (Sum.inr (Sum.inr (i, j), k))))
[PROOFSTEP]
change
  ⟦(xR i * y + x * yL j - xR i * yL j) * z + x * y * zR k - (xR i * y + x * yL j - xR i * yL j) * zR k⟧ =
    ⟦xR i * (y * z) + x * (yL j * z + y * zR k - yL j * zR k) - xR i * (yL j * z + y * zR k - yL j * zR k)⟧
[GOAL]
case refine'_3.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yl
⊢ Quotient.mk setoid
      ((xR i * y + x * yL j - xR i * yL j) * z + x * y * zR k - (xR i * y + x * yL j - xR i * yL j) * zR k) =
    Quotient.mk setoid
      (xR i * (y * z) + x * (yL j * z + y * zR k - yL j * zR k) - xR i * (yL j * z + y * zR k - yL j * zR k))
[PROOFSTEP]
simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib, quot_left_distrib_sub, quot_left_distrib]
[GOAL]
case refine'_3.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * mk yl yr yL yR * mk zl zr zL zR) +
            Quotient.mk setoid (mk xl xr xL xR * yL j * mk zl zr zL zR) -
          Quotient.mk setoid (xR i * yL j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) -
        Quotient.mk setoid (xR i * yL j * zR k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) -
      (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xR i * (yL j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (mk zl zr zL zR)]
[GOAL]
case refine'_3.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * yL j * mk zl zr zL zR) -
          Quotient.mk setoid (xR i * yL j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) -
        Quotient.mk setoid (xR i * yL j * zR k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) -
      (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xR i * (yL j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (mk zl zr zL zR)]
[GOAL]
case refine'_3.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * yL j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) -
        Quotient.mk setoid (xR i * yL j * zR k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) -
      (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xR i * (yL j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (xR i) (yL j) (mk zl zr zL zR)]
[GOAL]
case refine'_3.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) -
        Quotient.mk setoid (xR i * yL j * zR k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) -
      (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xR i * (yL j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zR k)]
[GOAL]
case refine'_3.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) -
        Quotient.mk setoid (xR i * yL j * zR k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) -
      (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xR i * (yL j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (zR k)]
[GOAL]
case refine'_3.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
      (Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) -
        Quotient.mk setoid (xR i * yL j * zR k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) -
      (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xR i * (yL j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (zR k)]
[GOAL]
case refine'_3.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
      (Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k)) -
        Quotient.mk setoid (xR i * yL j * zR k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) -
      (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xR i * (yL j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (xR i) (yL j) (zR k)]
[GOAL]
case refine'_3.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
      (Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k)) -
        Quotient.mk setoid (xR i * (yL j * zR k))) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) -
      (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xR i * (yL j * zR k)))
[PROOFSTEP]
abel
[GOAL]
case refine'_3.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
      (Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k)) -
        Quotient.mk setoid (xR i * (yL j * zR k))) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) -
      (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xR i * (yL j * zR k)))
[PROOFSTEP]
abel
[GOAL]
case refine'_4
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
⊢ ∀ (j : RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)),
    Quotient.mk setoid (moveRight (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) j) =
      Quotient.mk setoid
        (moveRight (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
          (↑{
                toFun := fun a =>
                  Sum.casesOn a
                    (fun val =>
                      Prod.casesOn val fun fst snd =>
                        Sum.casesOn fst
                          (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val =>
                          Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                    fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                        fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)),
                invFun := fun a =>
                  Sum.casesOn a
                    (fun val =>
                      Prod.casesOn val fun fst snd =>
                        Sum.casesOn snd
                          (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val =>
                          Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                    fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                        fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd),
                left_inv :=
                  (_ :
                    ∀ (x : RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)),
                      (fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd
                                    (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                                    fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd
                                  (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
                          ((fun a =>
                              Sum.casesOn a
                                (fun val =>
                                  Prod.casesOn val fun fst snd =>
                                    Sum.casesOn fst
                                      (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                                      fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                                fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn fst
                                    (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                                    fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
                            x) =
                        x),
                right_inv :=
                  (_ :
                    ∀ (x : RightMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))),
                      (fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn fst
                                    (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                                    fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn fst
                                  (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
                          ((fun a =>
                              Sum.casesOn a
                                (fun val =>
                                  Prod.casesOn val fun fst snd =>
                                    Sum.casesOn snd
                                      (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                                      fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                                fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd
                                    (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                                    fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
                            x) =
                        x) }
            j))
[PROOFSTEP]
rintro (⟨⟨i, j⟩ | ⟨i, j⟩, k⟩ | ⟨⟨i, j⟩ | ⟨i, j⟩, k⟩)
[GOAL]
case refine'_4.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yl
⊢ Quotient.mk setoid (moveRight (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) (Sum.inl (Sum.inl (i, j), k))) =
    Quotient.mk setoid
      (moveRight (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
        (↑{
              toFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                        fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                      fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)),
              invFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                        fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                      fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd),
              left_inv :=
                (_ :
                  ∀ (x : RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd
                                  (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn snd
                                (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                                fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn fst
                                    (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                                    fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn fst
                                  (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
                          x) =
                      x),
              right_inv :=
                (_ :
                  ∀ (x : RightMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn fst
                                  (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn fst
                                (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd
                                    (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                                    fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd
                                  (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
                          x) =
                      x) }
          (Sum.inl (Sum.inl (i, j), k))))
[PROOFSTEP]
change
  ⟦(xL i * y + x * yL j - xL i * yL j) * z + x * y * zR k - (xL i * y + x * yL j - xL i * yL j) * zR k⟧ =
    ⟦xL i * (y * z) + x * (yL j * z + y * zR k - yL j * zR k) - xL i * (yL j * z + y * zR k - yL j * zR k)⟧
[GOAL]
case refine'_4.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yl
⊢ Quotient.mk setoid
      ((xL i * y + x * yL j - xL i * yL j) * z + x * y * zR k - (xL i * y + x * yL j - xL i * yL j) * zR k) =
    Quotient.mk setoid
      (xL i * (y * z) + x * (yL j * z + y * zR k - yL j * zR k) - xL i * (yL j * z + y * zR k - yL j * zR k))
[PROOFSTEP]
simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib, quot_left_distrib_sub, quot_left_distrib]
[GOAL]
case refine'_4.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * mk yl yr yL yR * mk zl zr zL zR) +
            Quotient.mk setoid (mk xl xr xL xR * yL j * mk zl zr zL zR) -
          Quotient.mk setoid (xL i * yL j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) -
        Quotient.mk setoid (xL i * yL j * zR k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) -
      (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xL i * (yL j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (mk zl zr zL zR)]
[GOAL]
case refine'_4.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * yL j * mk zl zr zL zR) -
          Quotient.mk setoid (xL i * yL j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) -
        Quotient.mk setoid (xL i * yL j * zR k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) -
      (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xL i * (yL j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (mk zl zr zL zR)]
[GOAL]
case refine'_4.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * yL j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) -
        Quotient.mk setoid (xL i * yL j * zR k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) -
      (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xL i * (yL j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (xL i) (yL j) (mk zl zr zL zR)]
[GOAL]
case refine'_4.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) -
        Quotient.mk setoid (xL i * yL j * zR k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) -
      (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xL i * (yL j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zR k)]
[GOAL]
case refine'_4.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) -
        Quotient.mk setoid (xL i * yL j * zR k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) -
      (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xL i * (yL j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (zR k)]
[GOAL]
case refine'_4.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
      (Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) -
        Quotient.mk setoid (xL i * yL j * zR k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) -
      (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xL i * (yL j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (zR k)]
[GOAL]
case refine'_4.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
      (Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k)) -
        Quotient.mk setoid (xL i * yL j * zR k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) -
      (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xL i * (yL j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (xL i) (yL j) (zR k)]
[GOAL]
case refine'_4.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
      (Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k)) -
        Quotient.mk setoid (xL i * (yL j * zR k))) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) -
      (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xL i * (yL j * zR k)))
[PROOFSTEP]
abel
[GOAL]
case refine'_4.inl.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xl
j : yl
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
      (Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k)) -
        Quotient.mk setoid (xL i * (yL j * zR k))) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) -
      (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xL i * (yL j * zR k)))
[PROOFSTEP]
abel
[GOAL]
case refine'_4.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yr
⊢ Quotient.mk setoid (moveRight (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) (Sum.inl (Sum.inr (i, j), k))) =
    Quotient.mk setoid
      (moveRight (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
        (↑{
              toFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                        fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                      fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)),
              invFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                        fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                      fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd),
              left_inv :=
                (_ :
                  ∀ (x : RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd
                                  (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn snd
                                (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                                fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn fst
                                    (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                                    fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn fst
                                  (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
                          x) =
                      x),
              right_inv :=
                (_ :
                  ∀ (x : RightMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn fst
                                  (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn fst
                                (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd
                                    (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                                    fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd
                                  (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
                          x) =
                      x) }
          (Sum.inl (Sum.inr (i, j), k))))
[PROOFSTEP]
change
  ⟦(xR i * y + x * yR j - xR i * yR j) * z + x * y * zR k - (xR i * y + x * yR j - xR i * yR j) * zR k⟧ =
    ⟦xR i * (y * z) + x * (yR j * z + y * zR k - yR j * zR k) - xR i * (yR j * z + y * zR k - yR j * zR k)⟧
[GOAL]
case refine'_4.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yr
⊢ Quotient.mk setoid
      ((xR i * y + x * yR j - xR i * yR j) * z + x * y * zR k - (xR i * y + x * yR j - xR i * yR j) * zR k) =
    Quotient.mk setoid
      (xR i * (y * z) + x * (yR j * z + y * zR k - yR j * zR k) - xR i * (yR j * z + y * zR k - yR j * zR k))
[PROOFSTEP]
simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib, quot_left_distrib_sub, quot_left_distrib]
[GOAL]
case refine'_4.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * mk yl yr yL yR * mk zl zr zL zR) +
            Quotient.mk setoid (mk xl xr xL xR * yR j * mk zl zr zL zR) -
          Quotient.mk setoid (xR i * yR j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) -
        Quotient.mk setoid (xR i * yR j * zR k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) -
      (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xR i * (yR j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (mk zl zr zL zR)]
[GOAL]
case refine'_4.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * yR j * mk zl zr zL zR) -
          Quotient.mk setoid (xR i * yR j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) -
        Quotient.mk setoid (xR i * yR j * zR k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) -
      (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xR i * (yR j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (mk zl zr zL zR)]
[GOAL]
case refine'_4.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * yR j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) -
        Quotient.mk setoid (xR i * yR j * zR k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) -
      (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xR i * (yR j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (xR i) (yR j) (mk zl zr zL zR)]
[GOAL]
case refine'_4.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) -
        Quotient.mk setoid (xR i * yR j * zR k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) -
      (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xR i * (yR j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zR k)]
[GOAL]
case refine'_4.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) -
        Quotient.mk setoid (xR i * yR j * zR k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) -
      (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xR i * (yR j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (zR k)]
[GOAL]
case refine'_4.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
      (Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) -
        Quotient.mk setoid (xR i * yR j * zR k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) -
      (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xR i * (yR j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (zR k)]
[GOAL]
case refine'_4.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
      (Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k)) -
        Quotient.mk setoid (xR i * yR j * zR k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) -
      (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xR i * (yR j * zR k)))
[PROOFSTEP]
rw [quot_mul_assoc (xR i) (yR j) (zR k)]
[GOAL]
case refine'_4.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
      (Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k)) -
        Quotient.mk setoid (xR i * (yR j * zR k))) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) -
      (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xR i * (yR j * zR k)))
[PROOFSTEP]
abel
[GOAL]
case refine'_4.inl.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zr
i : xr
j : yr
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
      (Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k)) -
        Quotient.mk setoid (xR i * (yR j * zR k))) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) -
      (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) -
        Quotient.mk setoid (xR i * (yR j * zR k)))
[PROOFSTEP]
abel
[GOAL]
case refine'_4.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yr
⊢ Quotient.mk setoid (moveRight (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) (Sum.inr (Sum.inl (i, j), k))) =
    Quotient.mk setoid
      (moveRight (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
        (↑{
              toFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                        fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                      fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)),
              invFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                        fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                      fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd),
              left_inv :=
                (_ :
                  ∀ (x : RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd
                                  (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn snd
                                (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                                fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn fst
                                    (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                                    fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn fst
                                  (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
                          x) =
                      x),
              right_inv :=
                (_ :
                  ∀ (x : RightMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn fst
                                  (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn fst
                                (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd
                                    (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                                    fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd
                                  (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
                          x) =
                      x) }
          (Sum.inr (Sum.inl (i, j), k))))
[PROOFSTEP]
change
  ⟦(xL i * y + x * yR j - xL i * yR j) * z + x * y * zL k - (xL i * y + x * yR j - xL i * yR j) * zL k⟧ =
    ⟦xL i * (y * z) + x * (yR j * z + y * zL k - yR j * zL k) - xL i * (yR j * z + y * zL k - yR j * zL k)⟧
[GOAL]
case refine'_4.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yr
⊢ Quotient.mk setoid
      ((xL i * y + x * yR j - xL i * yR j) * z + x * y * zL k - (xL i * y + x * yR j - xL i * yR j) * zL k) =
    Quotient.mk setoid
      (xL i * (y * z) + x * (yR j * z + y * zL k - yR j * zL k) - xL i * (yR j * z + y * zL k - yR j * zL k))
[PROOFSTEP]
simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib, quot_left_distrib_sub, quot_left_distrib]
[GOAL]
case refine'_4.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * mk yl yr yL yR * mk zl zr zL zR) +
            Quotient.mk setoid (mk xl xr xL xR * yR j * mk zl zr zL zR) -
          Quotient.mk setoid (xL i * yR j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) -
        Quotient.mk setoid (xL i * yR j * zL k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) -
      (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xL i * (yR j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (mk zl zr zL zR)]
[GOAL]
case refine'_4.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * yR j * mk zl zr zL zR) -
          Quotient.mk setoid (xL i * yR j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) -
        Quotient.mk setoid (xL i * yR j * zL k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) -
      (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xL i * (yR j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (mk zl zr zL zR)]
[GOAL]
case refine'_4.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * yR j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) -
        Quotient.mk setoid (xL i * yR j * zL k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) -
      (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xL i * (yR j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (xL i) (yR j) (mk zl zr zL zR)]
[GOAL]
case refine'_4.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) -
        Quotient.mk setoid (xL i * yR j * zL k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) -
      (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xL i * (yR j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zL k)]
[GOAL]
case refine'_4.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
      (Quotient.mk setoid (xL i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) -
        Quotient.mk setoid (xL i * yR j * zL k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) -
      (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xL i * (yR j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (zL k)]
[GOAL]
case refine'_4.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
      (Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) -
        Quotient.mk setoid (xL i * yR j * zL k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) -
      (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xL i * (yR j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (zL k)]
[GOAL]
case refine'_4.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
      (Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k)) -
        Quotient.mk setoid (xL i * yR j * zL k)) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) -
      (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xL i * (yR j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (xL i) (yR j) (zL k)]
[GOAL]
case refine'_4.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
      (Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k)) -
        Quotient.mk setoid (xL i * (yR j * zL k))) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) -
      (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xL i * (yR j * zL k)))
[PROOFSTEP]
abel
[GOAL]
case refine'_4.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yr
⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) -
          Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
      (Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k)) -
        Quotient.mk setoid (xL i * (yR j * zL k))) =
    Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) -
      (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xL i * (yR j * zL k)))
[PROOFSTEP]
abel
[GOAL]
case refine'_4.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yl
⊢ Quotient.mk setoid (moveRight (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) (Sum.inr (Sum.inr (i, j), k))) =
    Quotient.mk setoid
      (moveRight (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))
        (↑{
              toFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                        fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                      fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)),
              invFun := fun a =>
                Sum.casesOn a
                  (fun val =>
                    Prod.casesOn val fun fst snd =>
                      Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                        fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                  fun val =>
                  Prod.casesOn val fun fst snd =>
                    Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                      fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd),
              left_inv :=
                (_ :
                  ∀ (x : RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd
                                  (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn snd
                                (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                                fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn fst
                                    (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                                    fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn fst
                                  (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
                          x) =
                      x),
              right_inv :=
                (_ :
                  ∀ (x : RightMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))),
                    (fun a =>
                          Sum.casesOn a
                            (fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn fst
                                  (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd)))
                                  fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd)))
                            fun val =>
                            Prod.casesOn val fun fst snd =>
                              Sum.casesOn fst
                                (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd)))
                                fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)))
                        ((fun a =>
                            Sum.casesOn a
                              (fun val =>
                                Prod.casesOn val fun fst snd =>
                                  Sum.casesOn snd
                                    (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd))
                                    fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd))
                              fun val =>
                              Prod.casesOn val fun fst snd =>
                                Sum.casesOn snd
                                  (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd))
                                  fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd))
                          x) =
                      x) }
          (Sum.inr (Sum.inr (i, j), k))))
[PROOFSTEP]
change
  ⟦(xR i * y + x * yL j - xR i * yL j) * z + x * y * zL k - (xR i * y + x * yL j - xR i * yL j) * zL k⟧ =
    ⟦xR i * (y * z) + x * (yL j * z + y * zL k - yL j * zL k) - xR i * (yL j * z + y * zL k - yL j * zL k)⟧
[GOAL]
case refine'_4.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yl
⊢ Quotient.mk setoid
      ((xR i * y + x * yL j - xR i * yL j) * z + x * y * zL k - (xR i * y + x * yL j - xR i * yL j) * zL k) =
    Quotient.mk setoid
      (xR i * (y * z) + x * (yL j * z + y * zL k - yL j * zL k) - xR i * (yL j * z + y * zL k - yL j * zL k))
[PROOFSTEP]
simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib, quot_left_distrib_sub, quot_left_distrib]
[GOAL]
case refine'_4.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * mk yl yr yL yR * mk zl zr zL zR) +
            Quotient.mk setoid (mk xl xr xL xR * yL j * mk zl zr zL zR) -
          Quotient.mk setoid (xR i * yL j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) -
        Quotient.mk setoid (xR i * yL j * zL k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) -
      (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xR i * (yL j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (mk zl zr zL zR)]
[GOAL]
case refine'_4.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * yL j * mk zl zr zL zR) -
          Quotient.mk setoid (xR i * yL j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) -
        Quotient.mk setoid (xR i * yL j * zL k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) -
      (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xR i * (yL j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (mk zl zr zL zR)]
[GOAL]
case refine'_4.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * yL j * mk zl zr zL zR) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) -
        Quotient.mk setoid (xR i * yL j * zL k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) -
      (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xR i * (yL j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (xR i) (yL j) (mk zl zr zL zR)]
[GOAL]
case refine'_4.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) -
        Quotient.mk setoid (xR i * yL j * zL k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) -
      (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xR i * (yL j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zL k)]
[GOAL]
case refine'_4.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
      (Quotient.mk setoid (xR i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) -
        Quotient.mk setoid (xR i * yL j * zL k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) -
      (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xR i * (yL j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (zL k)]
[GOAL]
case refine'_4.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
      (Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) -
        Quotient.mk setoid (xR i * yL j * zL k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) -
      (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xR i * (yL j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (zL k)]
[GOAL]
case refine'_4.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
      (Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k)) -
        Quotient.mk setoid (xR i * yL j * zL k)) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) -
      (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xR i * (yL j * zL k)))
[PROOFSTEP]
rw [quot_mul_assoc (xR i) (yL j) (zL k)]
[GOAL]
case refine'_4.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
      (Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k)) -
        Quotient.mk setoid (xR i * (yL j * zL k))) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) -
      (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xR i * (yL j * zL k)))
[PROOFSTEP]
abel
[GOAL]
case refine'_4.inr.mk.inr.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xr
j : yl
⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) -
          Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) +
        Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
      (Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k)) -
        Quotient.mk setoid (xR i * (yL j * zL k))) =
    Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) +
        (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) +
            Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) -
          Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) -
      (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) -
        Quotient.mk setoid (xR i * (yL j * zL k)))
[PROOFSTEP]
abel
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
i : xl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := yL j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
i : xl
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := yL j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := zL k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zl
i : xl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := mk yl yr yL yR, snd := zL k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zl
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := yL j, snd := zL k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zl
i : xl
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := yL j, snd := zL k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
i : xr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := yR j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
i : xr
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := yR j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := zL k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zl
i : xr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := mk yl yr yL yR, snd := zL k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zl
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := yR j, snd := zL k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zl
i : xr
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := yR j, snd := zL k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
i : xl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := yR j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
i : xl
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := yR j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := zR k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zr
i : xl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := mk yl yr yL yR, snd := zR k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zr
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := yR j, snd := zR k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zr
i : xl
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := yR j, snd := zR k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
i : xr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := yL j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
i : xr
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := yL j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := zR k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zr
i : xr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := mk yl yr yL yR, snd := zR k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zr
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := yL j, snd := zR k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zr
i : xr
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := yL j, snd := zR k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
i : xl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := yL j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
i : xl
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := yL j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := zR k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zr
i : xl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := mk yl yr yL yR, snd := zR k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zr
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := yL j, snd := zR k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zr
i : xl
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := yL j, snd := zR k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
i : xr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := yR j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
i : xr
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := yR j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := zR k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zr
i : xr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := mk yl yr yL yR, snd := zR k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zr
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := yR j, snd := zR k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zr
i : xr
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := yR j, snd := zR k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
i : xl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := yR j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
i : xl
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := yR j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := zL k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zl
i : xl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := mk yl yr yL yR, snd := zL k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zl
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := yR j, snd := zL k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zl
i : xl
j : yr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xL i, snd := { fst := yR j, snd := zL k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
i : xr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := yL j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
i : xr
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := yL j, snd := mk zl zr zL zR } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := zL k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zl
i : xr
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := mk yl yr yL yR, snd := zL k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zl
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := mk xl xr xL xR, snd := { fst := yL j, snd := zL k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x✝ :
  ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame),
    (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
            Prod.instWellFoundedRelationProd).1
        y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } →
      Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2))
k : zl
i : xr
j : yl
⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd))
        Prod.instWellFoundedRelationProd).1
    { fst := xR i, snd := { fst := yL j, snd := zL k } }
    { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } }
[PROOFSTEP]
pgame_wf_tac
[GOAL]
l r : Type u
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
⊢ InvTy l r true → False
[PROOFSTEP]
rintro (_ | _ | _ | a | a)
[GOAL]
case right₁
l r : Type u
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
a : l
a✝ : InvTy l r false
⊢ False
[PROOFSTEP]
exact isEmptyElim a
[GOAL]
case right₂
l r : Type u
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
a : r
a✝ : InvTy l r true
⊢ False
[PROOFSTEP]
exact isEmptyElim a
[GOAL]
l r : Type u
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
src✝ : Inhabited (InvTy l r false) := InvTy.instInhabited l r
⊢ ∀ (a : InvTy l r false), a = default
[PROOFSTEP]
rintro (a | a | a)
[GOAL]
case zero
l r : Type u
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
src✝ : Inhabited (InvTy l r false) := InvTy.instInhabited l r
⊢ InvTy.zero = default
case left₁
l r : Type u
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
src✝ : Inhabited (InvTy l r false) := InvTy.instInhabited l r
a : r
a✝ : InvTy l r false
⊢ InvTy.left₁ a a✝ = default
case left₂
l r : Type u
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
src✝ : Inhabited (InvTy l r false) := InvTy.instInhabited l r
a : l
a✝ : InvTy l r true
⊢ InvTy.left₂ a a✝ = default
[PROOFSTEP]
rfl
[GOAL]
case left₁
l r : Type u
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
src✝ : Inhabited (InvTy l r false) := InvTy.instInhabited l r
a : r
a✝ : InvTy l r false
⊢ InvTy.left₁ a a✝ = default
case left₂
l r : Type u
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
src✝ : Inhabited (InvTy l r false) := InvTy.instInhabited l r
a : l
a✝ : InvTy l r true
⊢ InvTy.left₂ a a✝ = default
[PROOFSTEP]
all_goals exact isEmptyElim a
[GOAL]
case left₁
l r : Type u
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
src✝ : Inhabited (InvTy l r false) := InvTy.instInhabited l r
a : r
a✝ : InvTy l r false
⊢ InvTy.left₁ a a✝ = default
[PROOFSTEP]
exact isEmptyElim a
[GOAL]
case left₂
l r : Type u
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
src✝ : Inhabited (InvTy l r false) := InvTy.instInhabited l r
a : l
a✝ : InvTy l r true
⊢ InvTy.left₂ a a✝ = default
[PROOFSTEP]
exact isEmptyElim a
[GOAL]
l r : Type u
b : Bool
L : l → PGame
R : r → PGame
IHl : l → PGame
IHr : r → PGame
i : InvTy l r b
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
⊢ invVal L R IHl IHr i = 0
[PROOFSTEP]
cases' i with a _ a _ a _ a
[GOAL]
case zero
l r : Type u
L : l → PGame
R : r → PGame
IHl : l → PGame
IHr : r → PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
⊢ invVal L R IHl IHr InvTy.zero = 0
[PROOFSTEP]
rfl
[GOAL]
case left₁
l r : Type u
L : l → PGame
R : r → PGame
IHl : l → PGame
IHr : r → PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
a : r
a✝ : InvTy l r false
⊢ invVal L R IHl IHr (InvTy.left₁ a a✝) = 0
case left₂
l r : Type u
L : l → PGame
R : r → PGame
IHl : l → PGame
IHr : r → PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
a : l
a✝ : InvTy l r true
⊢ invVal L R IHl IHr (InvTy.left₂ a a✝) = 0
case right₁
l r : Type u
L : l → PGame
R : r → PGame
IHl : l → PGame
IHr : r → PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
a : l
a✝ : InvTy l r false
⊢ invVal L R IHl IHr (InvTy.right₁ a a✝) = 0
case right₂
l r : Type u
L : l → PGame
R : r → PGame
IHl : l → PGame
IHr : r → PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
a : r
a✝ : InvTy l r true
⊢ invVal L R IHl IHr (InvTy.right₂ a a✝) = 0
[PROOFSTEP]
all_goals exact isEmptyElim a
[GOAL]
case left₁
l r : Type u
L : l → PGame
R : r → PGame
IHl : l → PGame
IHr : r → PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
a : r
a✝ : InvTy l r false
⊢ invVal L R IHl IHr (InvTy.left₁ a a✝) = 0
[PROOFSTEP]
exact isEmptyElim a
[GOAL]
case left₂
l r : Type u
L : l → PGame
R : r → PGame
IHl : l → PGame
IHr : r → PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
a : l
a✝ : InvTy l r true
⊢ invVal L R IHl IHr (InvTy.left₂ a a✝) = 0
[PROOFSTEP]
exact isEmptyElim a
[GOAL]
case right₁
l r : Type u
L : l → PGame
R : r → PGame
IHl : l → PGame
IHr : r → PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
a : l
a✝ : InvTy l r false
⊢ invVal L R IHl IHr (InvTy.right₁ a a✝) = 0
[PROOFSTEP]
exact isEmptyElim a
[GOAL]
case right₂
l r : Type u
L : l → PGame
R : r → PGame
IHl : l → PGame
IHr : r → PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
a : r
a✝ : InvTy l r true
⊢ invVal L R IHl IHr (InvTy.right₂ a a✝) = 0
[PROOFSTEP]
exact isEmptyElim a
[GOAL]
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
⊢ 0 ⧏ inv' (mk xl xr xL xR)
[PROOFSTEP]
convert lf_mk _ _ InvTy.zero
[GOAL]
case h.e'_1
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
⊢ 0 = invVal (fun i => xL ↑i) xR (fun i => inv' (xL ↑i)) (fun i => inv' (xR i)) InvTy.zero
[PROOFSTEP]
rfl
[GOAL]
⊢ inv' 0 ≡r 1
[PROOFSTEP]
change mk _ _ _ _ ≡r 1
[GOAL]
⊢ mk (InvTy { i // 0 < PEmpty.elim i } PEmpty false) (InvTy { i // 0 < PEmpty.elim i } PEmpty true)
      (invVal (fun i => PEmpty.elim ↑i) PEmpty.elim (fun i => inv' (PEmpty.elim ↑i)) fun i => inv' (PEmpty.elim i))
      (invVal (fun i => PEmpty.elim ↑i) PEmpty.elim (fun i => inv' (PEmpty.elim ↑i)) fun i => inv' (PEmpty.elim i)) ≡r
    1
[PROOFSTEP]
refine' ⟨_, _, fun i => _, IsEmpty.elim _⟩
[GOAL]
case refine'_1
⊢ LeftMoves
      (mk (InvTy { i // 0 < PEmpty.elim i } PEmpty false) (InvTy { i // 0 < PEmpty.elim i } PEmpty true)
        (invVal (fun i => PEmpty.elim ↑i) PEmpty.elim (fun i => inv' (PEmpty.elim ↑i)) fun i => inv' (PEmpty.elim i))
        (invVal (fun i => PEmpty.elim ↑i) PEmpty.elim (fun i => inv' (PEmpty.elim ↑i)) fun i => inv' (PEmpty.elim i))) ≃
    LeftMoves 1
[PROOFSTEP]
apply Equiv.equivPUnit (InvTy _ _ _)
[GOAL]
case refine'_2
⊢ RightMoves
      (mk (InvTy { i // 0 < PEmpty.elim i } PEmpty false) (InvTy { i // 0 < PEmpty.elim i } PEmpty true)
        (invVal (fun i => PEmpty.elim ↑i) PEmpty.elim (fun i => inv' (PEmpty.elim ↑i)) fun i => inv' (PEmpty.elim i))
        (invVal (fun i => PEmpty.elim ↑i) PEmpty.elim (fun i => inv' (PEmpty.elim ↑i)) fun i => inv' (PEmpty.elim i))) ≃
    RightMoves 1
[PROOFSTEP]
apply Equiv.equivPEmpty (InvTy _ _ _)
[GOAL]
case refine'_3
i :
  LeftMoves
    (mk (InvTy { i // 0 < PEmpty.elim i } PEmpty false) (InvTy { i // 0 < PEmpty.elim i } PEmpty true)
      (invVal (fun i => PEmpty.elim ↑i) PEmpty.elim (fun i => inv' (PEmpty.elim ↑i)) fun i => inv' (PEmpty.elim i))
      (invVal (fun i => PEmpty.elim ↑i) PEmpty.elim (fun i => inv' (PEmpty.elim ↑i)) fun i => inv' (PEmpty.elim i)))
⊢ moveLeft
      (mk (InvTy { i // 0 < PEmpty.elim i } PEmpty false) (InvTy { i // 0 < PEmpty.elim i } PEmpty true)
        (invVal (fun i => PEmpty.elim ↑i) PEmpty.elim (fun i => inv' (PEmpty.elim ↑i)) fun i => inv' (PEmpty.elim i))
        (invVal (fun i => PEmpty.elim ↑i) PEmpty.elim (fun i => inv' (PEmpty.elim ↑i)) fun i => inv' (PEmpty.elim i)))
      i ≡r
    moveLeft 1 (↑(Equiv.equivPUnit (InvTy { i // 0 < PEmpty.elim i } PEmpty false)) i)
[PROOFSTEP]
simp
[GOAL]
case refine'_3
i :
  LeftMoves
    (mk (InvTy { i // 0 < PEmpty.elim i } PEmpty false) (InvTy { i // 0 < PEmpty.elim i } PEmpty true)
      (invVal (fun i => PEmpty.elim ↑i) PEmpty.elim (fun i => inv' (PEmpty.elim ↑i)) fun i => inv' (PEmpty.elim i))
      (invVal (fun i => PEmpty.elim ↑i) PEmpty.elim (fun i => inv' (PEmpty.elim ↑i)) fun i => inv' (PEmpty.elim i)))
⊢ 0 ≡r 0
[PROOFSTEP]
rfl
[GOAL]
case refine'_4
⊢ IsEmpty
    (RightMoves
      (mk (InvTy { i // 0 < PEmpty.elim i } PEmpty false) (InvTy { i // 0 < PEmpty.elim i } PEmpty true)
        (invVal (fun i => PEmpty.elim ↑i) PEmpty.elim (fun i => inv' (PEmpty.elim ↑i)) fun i => inv' (PEmpty.elim i))
        (invVal (fun i => PEmpty.elim ↑i) PEmpty.elim (fun i => inv' (PEmpty.elim ↑i)) fun i => inv' (PEmpty.elim i))))
[PROOFSTEP]
dsimp
[GOAL]
case refine'_4
⊢ IsEmpty (InvTy { i // 0 < PEmpty.elim i } PEmpty true)
[PROOFSTEP]
infer_instance
[GOAL]
⊢ inv' 1 ≡r 1
[PROOFSTEP]
change Relabelling (mk _ _ _ _) 1
[GOAL]
⊢ mk (InvTy { i // 0 < (fun x => 0) i } PEmpty false) (InvTy { i // 0 < (fun x => 0) i } PEmpty true)
      (invVal (fun i => (fun x => 0) ↑i) PEmpty.elim (fun i => inv' ((fun x => 0) ↑i)) fun i => inv' (PEmpty.elim i))
      (invVal (fun i => (fun x => 0) ↑i) PEmpty.elim (fun i => inv' ((fun x => 0) ↑i)) fun i => inv' (PEmpty.elim i)) ≡r
    1
[PROOFSTEP]
have : IsEmpty { _i : PUnit.{u + 1} // (0 : PGame.{u}) < 0 } :=
  by
  rw [lt_self_iff_false]
  infer_instance
[GOAL]
⊢ IsEmpty { _i // 0 < 0 }
[PROOFSTEP]
rw [lt_self_iff_false]
[GOAL]
⊢ IsEmpty { _i // False }
[PROOFSTEP]
infer_instance
[GOAL]
this : IsEmpty { _i // 0 < 0 }
⊢ mk (InvTy { i // 0 < (fun x => 0) i } PEmpty false) (InvTy { i // 0 < (fun x => 0) i } PEmpty true)
      (invVal (fun i => (fun x => 0) ↑i) PEmpty.elim (fun i => inv' ((fun x => 0) ↑i)) fun i => inv' (PEmpty.elim i))
      (invVal (fun i => (fun x => 0) ↑i) PEmpty.elim (fun i => inv' ((fun x => 0) ↑i)) fun i => inv' (PEmpty.elim i)) ≡r
    1
[PROOFSTEP]
refine' ⟨_, _, fun i => _, IsEmpty.elim _⟩
[GOAL]
case refine'_1
this : IsEmpty { _i // 0 < 0 }
⊢ LeftMoves
      (mk (InvTy { i // 0 < (fun x => 0) i } PEmpty false) (InvTy { i // 0 < (fun x => 0) i } PEmpty true)
        (invVal (fun i => (fun x => 0) ↑i) PEmpty.elim (fun i => inv' ((fun x => 0) ↑i)) fun i => inv' (PEmpty.elim i))
        (invVal (fun i => (fun x => 0) ↑i) PEmpty.elim (fun i => inv' ((fun x => 0) ↑i)) fun i =>
          inv' (PEmpty.elim i))) ≃
    LeftMoves 1
[PROOFSTEP]
dsimp
[GOAL]
case refine'_2
this : IsEmpty { _i // 0 < 0 }
⊢ RightMoves
      (mk (InvTy { i // 0 < (fun x => 0) i } PEmpty false) (InvTy { i // 0 < (fun x => 0) i } PEmpty true)
        (invVal (fun i => (fun x => 0) ↑i) PEmpty.elim (fun i => inv' ((fun x => 0) ↑i)) fun i => inv' (PEmpty.elim i))
        (invVal (fun i => (fun x => 0) ↑i) PEmpty.elim (fun i => inv' ((fun x => 0) ↑i)) fun i =>
          inv' (PEmpty.elim i))) ≃
    RightMoves 1
[PROOFSTEP]
dsimp
[GOAL]
case refine'_3
this : IsEmpty { _i // 0 < 0 }
i :
  LeftMoves
    (mk (InvTy { i // 0 < (fun x => 0) i } PEmpty false) (InvTy { i // 0 < (fun x => 0) i } PEmpty true)
      (invVal (fun i => (fun x => 0) ↑i) PEmpty.elim (fun i => inv' ((fun x => 0) ↑i)) fun i => inv' (PEmpty.elim i))
      (invVal (fun i => (fun x => 0) ↑i) PEmpty.elim (fun i => inv' ((fun x => 0) ↑i)) fun i => inv' (PEmpty.elim i)))
⊢ moveLeft
      (mk (InvTy { i // 0 < (fun x => 0) i } PEmpty false) (InvTy { i // 0 < (fun x => 0) i } PEmpty true)
        (invVal (fun i => (fun x => 0) ↑i) PEmpty.elim (fun i => inv' ((fun x => 0) ↑i)) fun i => inv' (PEmpty.elim i))
        (invVal (fun i => (fun x => 0) ↑i) PEmpty.elim (fun i => inv' ((fun x => 0) ↑i)) fun i => inv' (PEmpty.elim i)))
      i ≡r
    moveLeft 1 (↑(id ?refine'_1) i)
[PROOFSTEP]
dsimp
[GOAL]
case refine'_4
this : IsEmpty { _i // 0 < 0 }
⊢ IsEmpty
    (RightMoves
      (mk (InvTy { i // 0 < (fun x => 0) i } PEmpty false) (InvTy { i // 0 < (fun x => 0) i } PEmpty true)
        (invVal (fun i => (fun x => 0) ↑i) PEmpty.elim (fun i => inv' ((fun x => 0) ↑i)) fun i => inv' (PEmpty.elim i))
        (invVal (fun i => (fun x => 0) ↑i) PEmpty.elim (fun i => inv' ((fun x => 0) ↑i)) fun i =>
          inv' (PEmpty.elim i))))
[PROOFSTEP]
dsimp
[GOAL]
case refine'_1
this : IsEmpty { _i // 0 < 0 }
⊢ InvTy { i // 0 < 0 } PEmpty false ≃ PUnit
[PROOFSTEP]
apply Equiv.equivPUnit
[GOAL]
case refine'_2
this : IsEmpty { _i // 0 < 0 }
⊢ InvTy { i // 0 < 0 } PEmpty true ≃ PEmpty
[PROOFSTEP]
apply Equiv.equivOfIsEmpty
[GOAL]
case refine'_3
this : IsEmpty { _i // 0 < 0 }
i :
  LeftMoves
    (mk (InvTy { i // 0 < (fun x => 0) i } PEmpty false) (InvTy { i // 0 < (fun x => 0) i } PEmpty true)
      (invVal (fun i => (fun x => 0) ↑i) PEmpty.elim (fun i => inv' ((fun x => 0) ↑i)) fun i => inv' (PEmpty.elim i))
      (invVal (fun i => (fun x => 0) ↑i) PEmpty.elim (fun i => inv' ((fun x => 0) ↑i)) fun i => inv' (PEmpty.elim i)))
⊢ invVal (fun i => 0) PEmpty.elim (fun i => inv' 0) (fun i => inv' (PEmpty.elim i)) i ≡r 0
[PROOFSTEP]
simp
[GOAL]
case refine'_3
this : IsEmpty { _i // 0 < 0 }
i :
  LeftMoves
    (mk (InvTy { i // 0 < (fun x => 0) i } PEmpty false) (InvTy { i // 0 < (fun x => 0) i } PEmpty true)
      (invVal (fun i => (fun x => 0) ↑i) PEmpty.elim (fun i => inv' ((fun x => 0) ↑i)) fun i => inv' (PEmpty.elim i))
      (invVal (fun i => (fun x => 0) ↑i) PEmpty.elim (fun i => inv' ((fun x => 0) ↑i)) fun i => inv' (PEmpty.elim i)))
⊢ 0 ≡r 0
[PROOFSTEP]
rfl
[GOAL]
case refine'_4
this : IsEmpty { _i // 0 < 0 }
⊢ IsEmpty (InvTy { i // 0 < 0 } PEmpty true)
[PROOFSTEP]
infer_instance
[GOAL]
⊢ PGame → PGame
[PROOFSTEP]
classical exact fun x => if x ≈ 0 then 0 else if 0 < x then inv' x else -inv' (-x)
[GOAL]
⊢ PGame → PGame
[PROOFSTEP]
exact fun x => if x ≈ 0 then 0 else if 0 < x then inv' x else -inv' (-x)
[GOAL]
x : PGame
h : x ≈ 0
⊢ x⁻¹ = 0
[PROOFSTEP]
classical exact if_pos h
[GOAL]
x : PGame
h : x ≈ 0
⊢ x⁻¹ = 0
[PROOFSTEP]
exact if_pos h
[GOAL]
x : PGame
h : 0 < x
⊢ x⁻¹ = inv' x
[PROOFSTEP]
classical exact (if_neg h.lf.not_equiv').trans (if_pos h)
[GOAL]
x : PGame
h : 0 < x
⊢ x⁻¹ = inv' x
[PROOFSTEP]
exact (if_neg h.lf.not_equiv').trans (if_pos h)
[GOAL]
x : PGame
h : x ⧏ 0
⊢ x⁻¹ = -inv' (-x)
[PROOFSTEP]
classical exact (if_neg h.not_equiv).trans (if_neg h.not_gt)
[GOAL]
x : PGame
h : x ⧏ 0
⊢ x⁻¹ = -inv' (-x)
[PROOFSTEP]
exact (if_neg h.not_equiv).trans (if_neg h.not_gt)
[GOAL]
⊢ 1⁻¹ ≡r 1
[PROOFSTEP]
rw [inv_eq_of_pos PGame.zero_lt_one]
[GOAL]
⊢ inv' 1 ≡r 1
[PROOFSTEP]
exact inv'One