l3lab/ntp-mathlib huggingface dataset:
theorem isOption_neg {x y : PGame} : IsOption x (-y) ↔ IsOption (-x) y := by
  rw [IsOption_iff, IsOption_iff, or_comm]
  cases y;
  apply or_congr <;>
    · apply exists_congr
      intro
      rw [neg_eq_iff_eq_neg]
      

Proof state:
case mk.h₁.h
x : PGame
α✝ β✝ : Type u_1
a✝² : α✝ → PGame
a✝¹ : β✝ → PGame
a✝ : RightMoves (-mk α✝ β✝ a✝² a✝¹)
⊢ x = moveRight (-mk α✝ β✝ a✝² a✝¹) a✝ ↔ x = -moveLeft (mk α✝ β✝ a✝² a✝¹) a✝

Next tactic:
rfl
theorem isOption_neg {x y : PGame} : IsOption x (-y) ↔ IsOption (-x) y := by
  rw [IsOption_iff, IsOption_iff, or_comm]
  cases y;
  apply or_congr <;>
    · 

Proof state:
case mk.h₂
x : PGame
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ (∃ i, x = moveLeft (-mk α✝ β✝ a✝¹ a✝) i) ↔ ∃ i, -x = moveRight (mk α✝ β✝ a✝¹ a✝) i

Next tactic:
apply exists_congr
theorem isOption_neg {x y : PGame} : IsOption x (-y) ↔ IsOption (-x) y := by
  rw [IsOption_iff, IsOption_iff, or_comm]
  cases y;
  apply or_congr <;>
    · apply exists_congr
      

Proof state:
case mk.h₂.h
x : PGame
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ ∀ (a : LeftMoves (-mk α✝ β✝ a✝¹ a✝)), x = moveLeft (-mk α✝ β✝ a✝¹ a✝) a ↔ -x = moveRight (mk α✝ β✝ a✝¹ a✝) a

Next tactic:
intro
theorem isOption_neg {x y : PGame} : IsOption x (-y) ↔ IsOption (-x) y := by
  rw [IsOption_iff, IsOption_iff, or_comm]
  cases y;
  apply or_congr <;>
    · apply exists_congr
      intro
      

Proof state:
case mk.h₂.h
x : PGame
α✝ β✝ : Type u_1
a✝² : α✝ → PGame
a✝¹ : β✝ → PGame
a✝ : LeftMoves (-mk α✝ β✝ a✝² a✝¹)
⊢ x = moveLeft (-mk α✝ β✝ a✝² a✝¹) a✝ ↔ -x = moveRight (mk α✝ β✝ a✝² a✝¹) a✝

Next tactic:
rw [neg_eq_iff_eq_neg]
theorem isOption_neg {x y : PGame} : IsOption x (-y) ↔ IsOption (-x) y := by
  rw [IsOption_iff, IsOption_iff, or_comm]
  cases y;
  apply or_congr <;>
    · apply exists_congr
      intro
      rw [neg_eq_iff_eq_neg]
      

Proof state:
case mk.h₂.h
x : PGame
α✝ β✝ : Type u_1
a✝² : α✝ → PGame
a✝¹ : β✝ → PGame
a✝ : LeftMoves (-mk α✝ β✝ a✝² a✝¹)
⊢ x = moveLeft (-mk α✝ β✝ a✝² a✝¹) a✝ ↔ x = -moveRight (mk α✝ β✝ a✝² a✝¹) a✝

Next tactic:
rfl
@[simp]
theorem isOption_neg_neg {x y : PGame} : IsOption (-x) (-y) ↔ IsOption x y := by
  

Proof state:
x y : PGame
⊢ IsOption (-x) (-y) ↔ IsOption x y

Next tactic:
rw [isOption_neg, neg_neg]
theorem moveLeft_neg {x : PGame} (i) : (-x).moveLeft (toLeftMovesNeg i) = -x.moveRight i := by
  

Proof state:
x : PGame
i : RightMoves x
⊢ moveLeft (-x) (toLeftMovesNeg i) = -moveRight x i

Next tactic:
cases x
theorem moveLeft_neg {x : PGame} (i) : (-x).moveLeft (toLeftMovesNeg i) = -x.moveRight i := by
  cases x
  

Proof state:
case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : RightMoves (mk α✝ β✝ a✝¹ a✝)
⊢ moveLeft (-mk α✝ β✝ a✝¹ a✝) (toLeftMovesNeg i) = -moveRight (mk α✝ β✝ a✝¹ a✝) i

Next tactic:
rfl
@[simp]
theorem moveLeft_neg' {x : PGame} (i) : (-x).moveLeft i = -x.moveRight (toLeftMovesNeg.symm i) := by
  

Proof state:
x : PGame
i : LeftMoves (-x)
⊢ moveLeft (-x) i = -moveRight x (toLeftMovesNeg.symm i)

Next tactic:
cases x
@[simp]
theorem moveLeft_neg' {x : PGame} (i) : (-x).moveLeft i = -x.moveRight (toLeftMovesNeg.symm i) := by
  cases x
  

Proof state:
case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : LeftMoves (-mk α✝ β✝ a✝¹ a✝)
⊢ moveLeft (-mk α✝ β✝ a✝¹ a✝) i = -moveRight (mk α✝ β✝ a✝¹ a✝) (toLeftMovesNeg.symm i)

Next tactic:
rfl
theorem moveRight_neg {x : PGame} (i) : (-x).moveRight (toRightMovesNeg i) = -x.moveLeft i := by
  

Proof state:
x : PGame
i : LeftMoves x
⊢ moveRight (-x) (toRightMovesNeg i) = -moveLeft x i

Next tactic:
cases x
theorem moveRight_neg {x : PGame} (i) : (-x).moveRight (toRightMovesNeg i) = -x.moveLeft i := by
  cases x
  

Proof state:
case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : LeftMoves (mk α✝ β✝ a✝¹ a✝)
⊢ moveRight (-mk α✝ β✝ a✝¹ a✝) (toRightMovesNeg i) = -moveLeft (mk α✝ β✝ a✝¹ a✝) i

Next tactic:
rfl
@[simp]
theorem moveRight_neg' {x : PGame} (i) :
    (-x).moveRight i = -x.moveLeft (toRightMovesNeg.symm i) := by
  

Proof state:
x : PGame
i : RightMoves (-x)
⊢ moveRight (-x) i = -moveLeft x (toRightMovesNeg.symm i)

Next tactic:
cases x
@[simp]
theorem moveRight_neg' {x : PGame} (i) :
    (-x).moveRight i = -x.moveLeft (toRightMovesNeg.symm i) := by
  cases x
  

Proof state:
case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : RightMoves (-mk α✝ β✝ a✝¹ a✝)
⊢ moveRight (-mk α✝ β✝ a✝¹ a✝) i = -moveLeft (mk α✝ β✝ a✝¹ a✝) (toRightMovesNeg.symm i)

Next tactic:
rfl
theorem moveLeft_neg_symm {x : PGame} (i) :
    x.moveLeft (toRightMovesNeg.symm i) = -(-x).moveRight i := by 

Proof state:
x : PGame
i : RightMoves (-x)
⊢ moveLeft x (toRightMovesNeg.symm i) = -moveRight (-x) i

Next tactic:
simp
theorem moveLeft_neg_symm' {x : PGame} (i) : x.moveLeft i = -(-x).moveRight (toRightMovesNeg i) :=
  by 

Proof state:
x : PGame
i : LeftMoves x
⊢ moveLeft x i = -moveRight (-x) (toRightMovesNeg i)

Next tactic:
simp
theorem moveRight_neg_symm {x : PGame} (i) :
    x.moveRight (toLeftMovesNeg.symm i) = -(-x).moveLeft i := by 

Proof state:
x : PGame
i : LeftMoves (-x)
⊢ moveRight x (toLeftMovesNeg.symm i) = -moveLeft (-x) i

Next tactic:
simp
theorem moveRight_neg_symm' {x : PGame} (i) : x.moveRight i = -(-x).moveLeft (toLeftMovesNeg i) :=
  by 

Proof state:
x : PGame
i : RightMoves x
⊢ moveRight x i = -moveLeft (-x) (toLeftMovesNeg i)

Next tactic:
simp
private theorem neg_le_lf_neg_iff : ∀ {x y : PGame.{u}}, (-y ≤ -x ↔ x ≤ y) ∧ (-y ⧏ -x ↔ x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR => by
    

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
⊢ (-mk yl yr yL yR ≤ -mk xl xr xL xR ↔ mk xl xr xL xR ≤ mk yl yr yL yR) ∧
    (-mk yl yr yL yR ⧏ -mk xl xr xL xR ↔ mk xl xr xL xR ⧏ mk yl yr yL yR)

Next tactic:
simp_rw [neg_def, mk_le_mk, mk_lf_mk, ← neg_def]
private theorem neg_le_lf_neg_iff : ∀ {x y : PGame.{u}}, (-y ≤ -x ↔ x ≤ y) ∧ (-y ⧏ -x ↔ x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR => by
    simp_rw [neg_def, mk_le_mk, mk_lf_mk, ← neg_def]
    

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
⊢ (((∀ (i : yr), -yR i ⧏ -mk xl xr (fun i => xL i) fun j => xR j) ∧
        ∀ (j : xl), (-mk yl yr (fun i => yL i) fun j => yR j) ⧏ -xL j) ↔
      (∀ (i : xl), xL i ⧏ mk yl yr yL yR) ∧ ∀ (j : yr), mk xl xr xL xR ⧏ yR j) ∧
    (((∃ i, (-mk yl yr (fun i => yL i) fun j => yR j) ≤ -xR i) ∨ ∃ j, -yL j ≤ -mk xl xr (fun i => xL i) fun j => xR j) ↔
      (∃ i, mk xl xr xL xR ≤ yL i) ∨ ∃ j, xR j ≤ mk yl yr yL yR)

Next tactic:
constructor
private theorem neg_le_lf_neg_iff : ∀ {x y : PGame.{u}}, (-y ≤ -x ↔ x ≤ y) ∧ (-y ⧏ -x ↔ x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR => by
    simp_rw [neg_def, mk_le_mk, mk_lf_mk, ← neg_def]
    constructor
    · 

Proof state:
case left
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
⊢ ((∀ (i : yr), -yR i ⧏ -mk xl xr (fun i => xL i) fun j => xR j) ∧
      ∀ (j : xl), (-mk yl yr (fun i => yL i) fun j => yR j) ⧏ -xL j) ↔
    (∀ (i : xl), xL i ⧏ mk yl yr yL yR) ∧ ∀ (j : yr), mk xl xr xL xR ⧏ yR j

Next tactic:
rw [and_comm]
private theorem neg_le_lf_neg_iff : ∀ {x y : PGame.{u}}, (-y ≤ -x ↔ x ≤ y) ∧ (-y ⧏ -x ↔ x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR => by
    simp_rw [neg_def, mk_le_mk, mk_lf_mk, ← neg_def]
    constructor
    · rw [and_comm]
      

Proof state:
case left
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
⊢ ((∀ (j : xl), (-mk yl yr (fun i => yL i) fun j => yR j) ⧏ -xL j) ∧
      ∀ (i : yr), -yR i ⧏ -mk xl xr (fun i => xL i) fun j => xR j) ↔
    (∀ (i : xl), xL i ⧏ mk yl yr yL yR) ∧ ∀ (j : yr), mk xl xr xL xR ⧏ yR j

Next tactic:
apply and_congr
private theorem neg_le_lf_neg_iff : ∀ {x y : PGame.{u}}, (-y ≤ -x ↔ x ≤ y) ∧ (-y ⧏ -x ↔ x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR => by
    simp_rw [neg_def, mk_le_mk, mk_lf_mk, ← neg_def]
    constructor
    · rw [and_comm]
      apply and_congr <;> 

Proof state:
case left.h₁
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
⊢ (∀ (j : xl), (-mk yl yr (fun i => yL i) fun j => yR j) ⧏ -xL j) ↔ ∀ (i : xl), xL i ⧏ mk yl yr yL yR

Next tactic:
exact forall_congr' fun _ => neg_le_lf_neg_iff.2
private theorem neg_le_lf_neg_iff : ∀ {x y : PGame.{u}}, (-y ≤ -x ↔ x ≤ y) ∧ (-y ⧏ -x ↔ x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR => by
    simp_rw [neg_def, mk_le_mk, mk_lf_mk, ← neg_def]
    constructor
    · rw [and_comm]
      apply and_congr <;> 

Proof state:
case left.h₂
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
⊢ (∀ (i : yr), -yR i ⧏ -mk xl xr (fun i => xL i) fun j => xR j) ↔ ∀ (j : yr), mk xl xr xL xR ⧏ yR j

Next tactic:
exact forall_congr' fun _ => neg_le_lf_neg_iff.2
private theorem neg_le_lf_neg_iff : ∀ {x y : PGame.{u}}, (-y ≤ -x ↔ x ≤ y) ∧ (-y ⧏ -x ↔ x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR => by
    simp_rw [neg_def, mk_le_mk, mk_lf_mk, ← neg_def]
    constructor
    · rw [and_comm]
      apply and_congr <;> exact forall_congr' fun _ => neg_le_lf_neg_iff.2
    · 

Proof state:
case right
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
⊢ ((∃ i, (-mk yl yr (fun i => yL i) fun j => yR j) ≤ -xR i) ∨ ∃ j, -yL j ≤ -mk xl xr (fun i => xL i) fun j => xR j) ↔
    (∃ i, mk xl xr xL xR ≤ yL i) ∨ ∃ j, xR j ≤ mk yl yr yL yR

Next tactic:
rw [or_comm]
private theorem neg_le_lf_neg_iff : ∀ {x y : PGame.{u}}, (-y ≤ -x ↔ x ≤ y) ∧ (-y ⧏ -x ↔ x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR => by
    simp_rw [neg_def, mk_le_mk, mk_lf_mk, ← neg_def]
    constructor
    · rw [and_comm]
      apply and_congr <;> exact forall_congr' fun _ => neg_le_lf_neg_iff.2
    · rw [or_comm]
      

Proof state:
case right
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
⊢ ((∃ j, -yL j ≤ -mk xl xr (fun i => xL i) fun j => xR j) ∨ ∃ i, (-mk yl yr (fun i => yL i) fun j => yR j) ≤ -xR i) ↔
    (∃ i, mk xl xr xL xR ≤ yL i) ∨ ∃ j, xR j ≤ mk yl yr yL yR

Next tactic:
apply or_congr
private theorem neg_le_lf_neg_iff : ∀ {x y : PGame.{u}}, (-y ≤ -x ↔ x ≤ y) ∧ (-y ⧏ -x ↔ x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR => by
    simp_rw [neg_def, mk_le_mk, mk_lf_mk, ← neg_def]
    constructor
    · rw [and_comm]
      apply and_congr <;> exact forall_congr' fun _ => neg_le_lf_neg_iff.2
    · rw [or_comm]
      apply or_congr <;> 

Proof state:
case right.h₁
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
⊢ (∃ j, -yL j ≤ -mk xl xr (fun i => xL i) fun j => xR j) ↔ ∃ i, mk xl xr xL xR ≤ yL i

Next tactic:
exact exists_congr fun _ => neg_le_lf_neg_iff.1
private theorem neg_le_lf_neg_iff : ∀ {x y : PGame.{u}}, (-y ≤ -x ↔ x ≤ y) ∧ (-y ⧏ -x ↔ x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR => by
    simp_rw [neg_def, mk_le_mk, mk_lf_mk, ← neg_def]
    constructor
    · rw [and_comm]
      apply and_congr <;> exact forall_congr' fun _ => neg_le_lf_neg_iff.2
    · rw [or_comm]
      apply or_congr <;> 

Proof state:
case right.h₂
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
⊢ (∃ i, (-mk yl yr (fun i => yL i) fun j => yR j) ≤ -xR i) ↔ ∃ j, xR j ≤ mk yl yr yL yR

Next tactic:
exact exists_congr fun _ => neg_le_lf_neg_iff.1
@[simp]
theorem neg_lt_neg_iff {x y : PGame} : -y < -x ↔ x < y := by
  

Proof state:
x y : PGame
⊢ -y < -x ↔ x < y

Next tactic:
rw [lt_iff_le_and_lf, lt_iff_le_and_lf, neg_le_neg_iff, neg_lf_neg_iff]
@[simp]
theorem neg_equiv_neg_iff {x y : PGame} : (-x ≈ -y) ↔ (x ≈ y) := by
  

Proof state:
x y : PGame
⊢ -x ≈ -y ↔ x ≈ y

Next tactic:
show Equiv (-x) (-y) ↔ Equiv x y
@[simp]
theorem neg_equiv_neg_iff {x y : PGame} : (-x ≈ -y) ↔ (x ≈ y) := by
  show Equiv (-x) (-y) ↔ Equiv x y
  

Proof state:
x y : PGame
⊢ Equiv (-x) (-y) ↔ Equiv x y

Next tactic:
rw [Equiv, Equiv, neg_le_neg_iff, neg_le_neg_iff, and_comm]
@[simp]
theorem neg_fuzzy_neg_iff {x y : PGame} : -x ‖ -y ↔ x ‖ y := by
  

Proof state:
x y : PGame
⊢ -x ‖ -y ↔ x ‖ y

Next tactic:
rw [Fuzzy, Fuzzy, neg_lf_neg_iff, neg_lf_neg_iff, and_comm]
theorem neg_le_iff {x y : PGame} : -y ≤ x ↔ -x ≤ y := by 

Proof state:
x y : PGame
⊢ -y ≤ x ↔ -x ≤ y

Next tactic:
rw [← neg_neg x, neg_le_neg_iff, neg_neg]
theorem neg_lf_iff {x y : PGame} : -y ⧏ x ↔ -x ⧏ y := by 

Proof state:
x y : PGame
⊢ -y ⧏ x ↔ -x ⧏ y

Next tactic:
rw [← neg_neg x, neg_lf_neg_iff, neg_neg]
theorem neg_lt_iff {x y : PGame} : -y < x ↔ -x < y := by 

Proof state:
x y : PGame
⊢ -y < x ↔ -x < y

Next tactic:
rw [← neg_neg x, neg_lt_neg_iff, neg_neg]
theorem neg_equiv_iff {x y : PGame} : (-x ≈ y) ↔ (x ≈ -y) := by
  

Proof state:
x y : PGame
⊢ -x ≈ y ↔ x ≈ -y

Next tactic:
rw [← neg_neg y, neg_equiv_neg_iff, neg_neg]
theorem neg_fuzzy_iff {x y : PGame} : -x ‖ y ↔ x ‖ -y := by
  

Proof state:
x y : PGame
⊢ -x ‖ y ↔ x ‖ -y

Next tactic:
rw [← neg_neg y, neg_fuzzy_neg_iff, neg_neg]
theorem le_neg_iff {x y : PGame} : y ≤ -x ↔ x ≤ -y := by 

Proof state:
x y : PGame
⊢ y ≤ -x ↔ x ≤ -y

Next tactic:
rw [← neg_neg x, neg_le_neg_iff, neg_neg]
theorem lf_neg_iff {x y : PGame} : y ⧏ -x ↔ x ⧏ -y := by 

Proof state:
x y : PGame
⊢ y ⧏ -x ↔ x ⧏ -y

Next tactic:
rw [← neg_neg x, neg_lf_neg_iff, neg_neg]
theorem lt_neg_iff {x y : PGame} : y < -x ↔ x < -y := by 

Proof state:
x y : PGame
⊢ y < -x ↔ x < -y

Next tactic:
rw [← neg_neg x, neg_lt_neg_iff, neg_neg]
@[simp]
theorem neg_le_zero_iff {x : PGame} : -x ≤ 0 ↔ 0 ≤ x := by 

Proof state:
x : PGame
⊢ -x ≤ 0 ↔ 0 ≤ x

Next tactic:
rw [neg_le_iff, neg_zero]
@[simp]
theorem zero_le_neg_iff {x : PGame} : 0 ≤ -x ↔ x ≤ 0 := by 

Proof state:
x : PGame
⊢ 0 ≤ -x ↔ x ≤ 0

Next tactic:
rw [le_neg_iff, neg_zero]
@[simp]
theorem neg_lf_zero_iff {x : PGame} : -x ⧏ 0 ↔ 0 ⧏ x := by 

Proof state:
x : PGame
⊢ -x ⧏ 0 ↔ 0 ⧏ x

Next tactic:
rw [neg_lf_iff, neg_zero]
@[simp]
theorem zero_lf_neg_iff {x : PGame} : 0 ⧏ -x ↔ x ⧏ 0 := by 

Proof state:
x : PGame
⊢ 0 ⧏ -x ↔ x ⧏ 0

Next tactic:
rw [lf_neg_iff, neg_zero]
@[simp]
theorem neg_lt_zero_iff {x : PGame} : -x < 0 ↔ 0 < x := by 

Proof state:
x : PGame
⊢ -x < 0 ↔ 0 < x

Next tactic:
rw [neg_lt_iff, neg_zero]
@[simp]
theorem zero_lt_neg_iff {x : PGame} : 0 < -x ↔ x < 0 := by 

Proof state:
x : PGame
⊢ 0 < -x ↔ x < 0

Next tactic:
rw [lt_neg_iff, neg_zero]
@[simp]
theorem neg_equiv_zero_iff {x : PGame} : (-x ≈ 0) ↔ (x ≈ 0) := by 

Proof state:
x : PGame
⊢ -x ≈ 0 ↔ x ≈ 0

Next tactic:
rw [neg_equiv_iff, neg_zero]
@[simp]
theorem neg_fuzzy_zero_iff {x : PGame} : -x ‖ 0 ↔ x ‖ 0 := by 

Proof state:
x : PGame
⊢ -x ‖ 0 ↔ x ‖ 0

Next tactic:
rw [neg_fuzzy_iff, neg_zero]
@[simp]
theorem zero_equiv_neg_iff {x : PGame} : (0 ≈ -x) ↔ (0 ≈ x) := by 

Proof state:
x : PGame
⊢ 0 ≈ -x ↔ 0 ≈ x

Next tactic:
rw [← neg_equiv_iff, neg_zero]
@[simp]
theorem zero_fuzzy_neg_iff {x : PGame} : 0 ‖ -x ↔ 0 ‖ x := by 

Proof state:
x : PGame
⊢ 0 ‖ -x ↔ 0 ‖ x

Next tactic:
rw [← neg_fuzzy_iff, neg_zero]
/-- The sum of `x = {xL | xR}` and `y = {yL | yR}` is `{xL + y, x + yL | xR + y, x + yR}`. -/
instance : Add PGame.{u} :=
  ⟨fun x y => by
    

Proof state:
x y : PGame
⊢ PGame

Next tactic:
induction' x with xl xr _ _ IHxl IHxr generalizing y
/-- The sum of `x = {xL | xR}` and `y = {yL | yR}` is `{xL + y, x + yL | xR + y, x + yR}`. -/
instance : Add PGame.{u} :=
  ⟨fun x y => by
    induction' x with xl xr _ _ IHxl IHxr generalizing y
    

Proof state:
case mk
xl xr : Type u
a✝¹ : xl → PGame
a✝ : xr → PGame
IHxl : xl → PGame → PGame
IHxr : xr → PGame → PGame
y : PGame
⊢ PGame

Next tactic:
induction' y with yl yr yL yR IHyl IHyr
/-- The sum of `x = {xL | xR}` and `y = {yL | yR}` is `{xL + y, x + yL | xR + y, x + yR}`. -/
instance : Add PGame.{u} :=
  ⟨fun x y => by
    induction' x with xl xr _ _ IHxl IHxr generalizing y
    induction' y with yl yr yL yR IHyl IHyr
    

Proof state:
case mk.mk
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

Next tactic:
have y := mk yl yr yL yR
/-- The sum of `x = {xL | xR}` and `y = {yL | yR}` is `{xL + y, x + yL | xR + y, x + yR}`. -/
instance : Add PGame.{u} :=
  ⟨fun x y => by
    induction' x with xl xr _ _ IHxl IHxr generalizing y
    induction' y with yl yr yL yR IHyl IHyr
    have y := mk yl yr yL yR
    

Proof state:
case mk.mk
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

Next tactic:
refine' ⟨Sum xl yl, Sum xr yr, Sum.rec _ _, Sum.rec _ _⟩
/-- The sum of `x = {xL | xR}` and `y = {yL | yR}` is `{xL + y, x + yL | xR + y, x + yR}`. -/
instance : Add PGame.{u} :=
  ⟨fun x y => by
    induction' x with xl xr _ _ IHxl IHxr generalizing y
    induction' y with yl yr yL yR IHyl IHyr
    have y := mk yl yr yL yR
    refine' ⟨Sum xl yl, Sum xr yr, Sum.rec _ _, Sum.rec _ _⟩
    · 

Proof state:
case mk.mk.refine'_1
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 → PGame

Next tactic:
exact fun i => IHxl i y
/-- The sum of `x = {xL | xR}` and `y = {yL | yR}` is `{xL + y, x + yL | xR + y, x + yR}`. -/
instance : Add PGame.{u} :=
  ⟨fun x y => by
    induction' x with xl xr _ _ IHxl IHxr generalizing y
    induction' y with yl yr yL yR IHyl IHyr
    have y := mk yl yr yL yR
    refine' ⟨Sum xl yl, Sum xr yr, Sum.rec _ _, Sum.rec _ _⟩
    · exact fun i => IHxl i y
    · 

Proof state:
case mk.mk.refine'_2
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
⊢ yl → PGame

Next tactic:
exact IHyl
/-- The sum of `x = {xL | xR}` and `y = {yL | yR}` is `{xL + y, x + yL | xR + y, x + yR}`. -/
instance : Add PGame.{u} :=
  ⟨fun x y => by
    induction' x with xl xr _ _ IHxl IHxr generalizing y
    induction' y with yl yr yL yR IHyl IHyr
    have y := mk yl yr yL yR
    refine' ⟨Sum xl yl, Sum xr yr, Sum.rec _ _, Sum.rec _ _⟩
    · exact fun i => IHxl i y
    · exact IHyl
    · 

Proof state:
case mk.mk.refine'_3
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
⊢ xr → PGame

Next tactic:
exact fun i => IHxr i y
/-- The sum of `x = {xL | xR}` and `y = {yL | yR}` is `{xL + y, x + yL | xR + y, x + yR}`. -/
instance : Add PGame.{u} :=
  ⟨fun x y => by
    induction' x with xl xr _ _ IHxl IHxr generalizing y
    induction' y with yl yr yL yR IHyl IHyr
    have y := mk yl yr yL yR
    refine' ⟨Sum xl yl, Sum xr yr, Sum.rec _ _, Sum.rec _ _⟩
    · exact fun i => IHxl i y
    · exact IHyl
    · exact fun i => IHxr i y
    · 

Proof state:
case mk.mk.refine'_4
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
⊢ yr → PGame

Next tactic:
exact IHyr
instance isEmpty_leftMoves_add (x y : PGame.{u}) [IsEmpty x.LeftMoves] [IsEmpty y.LeftMoves] :
    IsEmpty (x + y).LeftMoves := by
  

Proof state:
x y : PGame
inst✝¹ : IsEmpty (LeftMoves x)
inst✝ : IsEmpty (LeftMoves y)
⊢ IsEmpty (LeftMoves (x + y))

Next tactic:
cases x
instance isEmpty_leftMoves_add (x y : PGame.{u}) [IsEmpty x.LeftMoves] [IsEmpty y.LeftMoves] :
    IsEmpty (x + y).LeftMoves := by
  cases x
  

Proof state:
case mk
y : PGame
inst✝¹ : IsEmpty (LeftMoves y)
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
inst✝ : IsEmpty (LeftMoves (mk α✝ β✝ a✝¹ a✝))
⊢ IsEmpty (LeftMoves (mk α✝ β✝ a✝¹ a✝ + y))

Next tactic:
cases y
instance isEmpty_leftMoves_add (x y : PGame.{u}) [IsEmpty x.LeftMoves] [IsEmpty y.LeftMoves] :
    IsEmpty (x + y).LeftMoves := by
  cases x
  cases y
  

Proof state:
case mk.mk
α✝¹ β✝¹ : Type u
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
inst✝¹ : IsEmpty (LeftMoves (mk α✝¹ β✝¹ a✝³ a✝²))
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
inst✝ : IsEmpty (LeftMoves (mk α✝ β✝ a✝¹ a✝))
⊢ IsEmpty (LeftMoves (mk α✝¹ β✝¹ a✝³ a✝² + mk α✝ β✝ a✝¹ a✝))

Next tactic:
apply isEmpty_sum.2 ⟨_, _⟩
instance isEmpty_leftMoves_add (x y : PGame.{u}) [IsEmpty x.LeftMoves] [IsEmpty y.LeftMoves] :
    IsEmpty (x + y).LeftMoves := by
  cases x
  cases y
  apply isEmpty_sum.2 ⟨_, _⟩
  

Proof state:
α✝¹ β✝¹ : Type u
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
inst✝¹ : IsEmpty (LeftMoves (mk α✝¹ β✝¹ a✝³ a✝²))
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
inst✝ : IsEmpty (LeftMoves (mk α✝ β✝ a✝¹ a✝))
⊢ IsEmpty α✝¹
α✝¹ β✝¹ : Type u
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
inst✝¹ : IsEmpty (LeftMoves (mk α✝¹ β✝¹ a✝³ a✝²))
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
inst✝ : IsEmpty (LeftMoves (mk α✝ β✝ a✝¹ a✝))
⊢ IsEmpty α✝

Next tactic:
assumption'
instance isEmpty_rightMoves_add (x y : PGame.{u}) [IsEmpty x.RightMoves] [IsEmpty y.RightMoves] :
    IsEmpty (x + y).RightMoves := by
  

Proof state:
x y : PGame
inst✝¹ : IsEmpty (RightMoves x)
inst✝ : IsEmpty (RightMoves y)
⊢ IsEmpty (RightMoves (x + y))

Next tactic:
cases x
instance isEmpty_rightMoves_add (x y : PGame.{u}) [IsEmpty x.RightMoves] [IsEmpty y.RightMoves] :
    IsEmpty (x + y).RightMoves := by
  cases x
  

Proof state:
case mk
y : PGame
inst✝¹ : IsEmpty (RightMoves y)
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
inst✝ : IsEmpty (RightMoves (mk α✝ β✝ a✝¹ a✝))
⊢ IsEmpty (RightMoves (mk α✝ β✝ a✝¹ a✝ + y))

Next tactic:
cases y
instance isEmpty_rightMoves_add (x y : PGame.{u}) [IsEmpty x.RightMoves] [IsEmpty y.RightMoves] :
    IsEmpty (x + y).RightMoves := by
  cases x
  cases y
  

Proof state:
case mk.mk
α✝¹ β✝¹ : Type u
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
inst✝¹ : IsEmpty (RightMoves (mk α✝¹ β✝¹ a✝³ a✝²))
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
inst✝ : IsEmpty (RightMoves (mk α✝ β✝ a✝¹ a✝))
⊢ IsEmpty (RightMoves (mk α✝¹ β✝¹ a✝³ a✝² + mk α✝ β✝ a✝¹ a✝))

Next tactic:
apply isEmpty_sum.2 ⟨_, _⟩
instance isEmpty_rightMoves_add (x y : PGame.{u}) [IsEmpty x.RightMoves] [IsEmpty y.RightMoves] :
    IsEmpty (x + y).RightMoves := by
  cases x
  cases y
  apply isEmpty_sum.2 ⟨_, _⟩
  

Proof state:
α✝¹ β✝¹ : Type u
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
inst✝¹ : IsEmpty (RightMoves (mk α✝¹ β✝¹ a✝³ a✝²))
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
inst✝ : IsEmpty (RightMoves (mk α✝ β✝ a✝¹ a✝))
⊢ IsEmpty β✝¹
α✝¹ β✝¹ : Type u
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
inst✝¹ : IsEmpty (RightMoves (mk α✝¹ β✝¹ a✝³ a✝²))
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
inst✝ : IsEmpty (RightMoves (mk α✝ β✝ a✝¹ a✝))
⊢ IsEmpty β✝

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

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

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

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

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

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

Next tactic:
rintro (⟨i⟩ | ⟨⟨⟩⟩)