l3lab/ntp-mathlib huggingface dataset:
/-- The definition of `x ⧏ y` on pre-games, in terms of `⧏` two moves later. -/
theorem lf_def {x y : PGame} :
    x ⧏ y ↔
      (∃ i, (∀ i', x.moveLeft i' ⧏ y.moveLeft i) ∧ ∀ j, x ⧏ (y.moveLeft i).moveRight j) ∨
        ∃ j, (∀ i, (x.moveRight j).moveLeft i ⧏ y) ∧ ∀ j', x.moveRight j ⧏ y.moveRight j' := by
  rw [lf_iff_exists_le]
  

Proof state:
x y : PGame
⊢ ((∃ i, x ≤ moveLeft y i) ∨ ∃ j, moveRight x j ≤ y) ↔
    (∃ i,
        (∀ (i' : LeftMoves x), moveLeft x i' ⧏ moveLeft y i) ∧
          ∀ (j : RightMoves (moveLeft y i)), x ⧏ moveRight (moveLeft y i) j) ∨
      ∃ j,
        (∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i ⧏ y) ∧
          ∀ (j' : RightMoves y), moveRight x j ⧏ moveRight y j'

Next tactic:
conv =>
    lhs
    simp only [le_iff_forall_lf]
/-- The definition of `x ⧏ y` on pre-games, in terms of `⧏` two moves later. -/
theorem lf_def {x y : PGame} :
    x ⧏ y ↔
      (∃ i, (∀ i', x.moveLeft i' ⧏ y.moveLeft i) ∧ ∀ j, x ⧏ (y.moveLeft i).moveRight j) ∨
        ∃ j, (∀ i, (x.moveRight j).moveLeft i ⧏ y) ∧ ∀ j', x.moveRight j ⧏ y.moveRight j' := by
  rw [lf_iff_exists_le]
  conv =>
    

Proof state:
x y : PGame
| ((∃ i, x ≤ moveLeft y i) ∨ ∃ j, moveRight x j ≤ y) ↔
    (∃ i,
        (∀ (i' : LeftMoves x), moveLeft x i' ⧏ moveLeft y i) ∧
          ∀ (j : RightMoves (moveLeft y i)), x ⧏ moveRight (moveLeft y i) j) ∨
      ∃ j,
        (∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i ⧏ y) ∧
          ∀ (j' : RightMoves y), moveRight x j ⧏ moveRight y j'

Next tactic:
lhs
    simp only [le_iff_forall_lf]
/-- The definition of `x ⧏ y` on pre-games, in terms of `⧏` two moves later. -/
theorem lf_def {x y : PGame} :
    x ⧏ y ↔
      (∃ i, (∀ i', x.moveLeft i' ⧏ y.moveLeft i) ∧ ∀ j, x ⧏ (y.moveLeft i).moveRight j) ∨
        ∃ j, (∀ i, (x.moveRight j).moveLeft i ⧏ y) ∧ ∀ j', x.moveRight j ⧏ y.moveRight j' := by
  rw [lf_iff_exists_le]
  conv =>
    

Proof state:
x y : PGame
| ((∃ i, x ≤ moveLeft y i) ∨ ∃ j, moveRight x j ≤ y) ↔
    (∃ i,
        (∀ (i' : LeftMoves x), moveLeft x i' ⧏ moveLeft y i) ∧
          ∀ (j : RightMoves (moveLeft y i)), x ⧏ moveRight (moveLeft y i) j) ∨
      ∃ j,
        (∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i ⧏ y) ∧
          ∀ (j' : RightMoves y), moveRight x j ⧏ moveRight y j'

Next tactic:
lhs
/-- The definition of `x ⧏ y` on pre-games, in terms of `⧏` two moves later. -/
theorem lf_def {x y : PGame} :
    x ⧏ y ↔
      (∃ i, (∀ i', x.moveLeft i' ⧏ y.moveLeft i) ∧ ∀ j, x ⧏ (y.moveLeft i).moveRight j) ∨
        ∃ j, (∀ i, (x.moveRight j).moveLeft i ⧏ y) ∧ ∀ j', x.moveRight j ⧏ y.moveRight j' := by
  rw [lf_iff_exists_le]
  conv =>
    lhs
    

Proof state:
x y : PGame
| (∃ i, x ≤ moveLeft y i) ∨ ∃ j, moveRight x j ≤ y

Next tactic:
simp only [le_iff_forall_lf]
/-- The definition of `0 ≤ x` on pre-games, in terms of `0 ⧏`. -/
theorem zero_le_lf {x : PGame} : 0 ≤ x ↔ ∀ j, 0 ⧏ x.moveRight j := by
  

Proof state:
x : PGame
⊢ 0 ≤ x ↔ ∀ (j : RightMoves x), 0 ⧏ moveRight x j

Next tactic:
rw [le_iff_forall_lf]
/-- The definition of `0 ≤ x` on pre-games, in terms of `0 ⧏`. -/
theorem zero_le_lf {x : PGame} : 0 ≤ x ↔ ∀ j, 0 ⧏ x.moveRight j := by
  rw [le_iff_forall_lf]
  

Proof state:
x : PGame
⊢ ((∀ (i : LeftMoves 0), moveLeft 0 i ⧏ x) ∧ ∀ (j : RightMoves x), 0 ⧏ moveRight x j) ↔
    ∀ (j : RightMoves x), 0 ⧏ moveRight x j

Next tactic:
simp
/-- The definition of `x ≤ 0` on pre-games, in terms of `⧏ 0`. -/
theorem le_zero_lf {x : PGame} : x ≤ 0 ↔ ∀ i, x.moveLeft i ⧏ 0 := by
  

Proof state:
x : PGame
⊢ x ≤ 0 ↔ ∀ (i : LeftMoves x), moveLeft x i ⧏ 0

Next tactic:
rw [le_iff_forall_lf]
/-- The definition of `x ≤ 0` on pre-games, in terms of `⧏ 0`. -/
theorem le_zero_lf {x : PGame} : x ≤ 0 ↔ ∀ i, x.moveLeft i ⧏ 0 := by
  rw [le_iff_forall_lf]
  

Proof state:
x : PGame
⊢ ((∀ (i : LeftMoves x), moveLeft x i ⧏ 0) ∧ ∀ (j : RightMoves 0), x ⧏ moveRight 0 j) ↔
    ∀ (i : LeftMoves x), moveLeft x i ⧏ 0

Next tactic:
simp
/-- The definition of `0 ⧏ x` on pre-games, in terms of `0 ≤`. -/
theorem zero_lf_le {x : PGame} : 0 ⧏ x ↔ ∃ i, 0 ≤ x.moveLeft i := by
  

Proof state:
x : PGame
⊢ 0 ⧏ x ↔ ∃ i, 0 ≤ moveLeft x i

Next tactic:
rw [lf_iff_exists_le]
/-- The definition of `0 ⧏ x` on pre-games, in terms of `0 ≤`. -/
theorem zero_lf_le {x : PGame} : 0 ⧏ x ↔ ∃ i, 0 ≤ x.moveLeft i := by
  rw [lf_iff_exists_le]
  

Proof state:
x : PGame
⊢ ((∃ i, 0 ≤ moveLeft x i) ∨ ∃ j, moveRight 0 j ≤ x) ↔ ∃ i, 0 ≤ moveLeft x i

Next tactic:
simp
/-- The definition of `x ⧏ 0` on pre-games, in terms of `≤ 0`. -/
theorem lf_zero_le {x : PGame} : x ⧏ 0 ↔ ∃ j, x.moveRight j ≤ 0 := by
  

Proof state:
x : PGame
⊢ x ⧏ 0 ↔ ∃ j, moveRight x j ≤ 0

Next tactic:
rw [lf_iff_exists_le]
/-- The definition of `x ⧏ 0` on pre-games, in terms of `≤ 0`. -/
theorem lf_zero_le {x : PGame} : x ⧏ 0 ↔ ∃ j, x.moveRight j ≤ 0 := by
  rw [lf_iff_exists_le]
  

Proof state:
x : PGame
⊢ ((∃ i, x ≤ moveLeft 0 i) ∨ ∃ j, moveRight x j ≤ 0) ↔ ∃ j, moveRight x j ≤ 0

Next tactic:
simp
/-- The definition of `0 ≤ x` on pre-games, in terms of `0 ≤` two moves later. -/
theorem zero_le {x : PGame} : 0 ≤ x ↔ ∀ j, ∃ i, 0 ≤ (x.moveRight j).moveLeft i := by
  

Proof state:
x : PGame
⊢ 0 ≤ x ↔ ∀ (j : RightMoves x), ∃ i, 0 ≤ moveLeft (moveRight x j) i

Next tactic:
rw [le_def]
/-- The definition of `0 ≤ x` on pre-games, in terms of `0 ≤` two moves later. -/
theorem zero_le {x : PGame} : 0 ≤ x ↔ ∀ j, ∃ i, 0 ≤ (x.moveRight j).moveLeft i := by
  rw [le_def]
  

Proof state:
x : PGame
⊢ ((∀ (i : LeftMoves 0), (∃ i', moveLeft 0 i ≤ moveLeft x i') ∨ ∃ j, moveRight (moveLeft 0 i) j ≤ x) ∧
      ∀ (j : RightMoves x), (∃ i, 0 ≤ moveLeft (moveRight x j) i) ∨ ∃ j', moveRight 0 j' ≤ moveRight x j) ↔
    ∀ (j : RightMoves x), ∃ i, 0 ≤ moveLeft (moveRight x j) i

Next tactic:
simp
/-- The definition of `x ≤ 0` on pre-games, in terms of `≤ 0` two moves later. -/
theorem le_zero {x : PGame} : x ≤ 0 ↔ ∀ i, ∃ j, (x.moveLeft i).moveRight j ≤ 0 := by
  

Proof state:
x : PGame
⊢ x ≤ 0 ↔ ∀ (i : LeftMoves x), ∃ j, moveRight (moveLeft x i) j ≤ 0

Next tactic:
rw [le_def]
/-- The definition of `x ≤ 0` on pre-games, in terms of `≤ 0` two moves later. -/
theorem le_zero {x : PGame} : x ≤ 0 ↔ ∀ i, ∃ j, (x.moveLeft i).moveRight j ≤ 0 := by
  rw [le_def]
  

Proof state:
x : PGame
⊢ ((∀ (i : LeftMoves x), (∃ i', moveLeft x i ≤ moveLeft 0 i') ∨ ∃ j, moveRight (moveLeft x i) j ≤ 0) ∧
      ∀ (j : RightMoves 0), (∃ i, x ≤ moveLeft (moveRight 0 j) i) ∨ ∃ j', moveRight x j' ≤ moveRight 0 j) ↔
    ∀ (i : LeftMoves x), ∃ j, moveRight (moveLeft x i) j ≤ 0

Next tactic:
simp
/-- The definition of `0 ⧏ x` on pre-games, in terms of `0 ⧏` two moves later. -/
theorem zero_lf {x : PGame} : 0 ⧏ x ↔ ∃ i, ∀ j, 0 ⧏ (x.moveLeft i).moveRight j := by
  

Proof state:
x : PGame
⊢ 0 ⧏ x ↔ ∃ i, ∀ (j : RightMoves (moveLeft x i)), 0 ⧏ moveRight (moveLeft x i) j

Next tactic:
rw [lf_def]
/-- The definition of `0 ⧏ x` on pre-games, in terms of `0 ⧏` two moves later. -/
theorem zero_lf {x : PGame} : 0 ⧏ x ↔ ∃ i, ∀ j, 0 ⧏ (x.moveLeft i).moveRight j := by
  rw [lf_def]
  

Proof state:
x : PGame
⊢ ((∃ i,
        (∀ (i' : LeftMoves 0), moveLeft 0 i' ⧏ moveLeft x i) ∧
          ∀ (j : RightMoves (moveLeft x i)), 0 ⧏ moveRight (moveLeft x i) j) ∨
      ∃ j,
        (∀ (i : LeftMoves (moveRight 0 j)), moveLeft (moveRight 0 j) i ⧏ x) ∧
          ∀ (j' : RightMoves x), moveRight 0 j ⧏ moveRight x j') ↔
    ∃ i, ∀ (j : RightMoves (moveLeft x i)), 0 ⧏ moveRight (moveLeft x i) j

Next tactic:
simp
/-- The definition of `x ⧏ 0` on pre-games, in terms of `⧏ 0` two moves later. -/
theorem lf_zero {x : PGame} : x ⧏ 0 ↔ ∃ j, ∀ i, (x.moveRight j).moveLeft i ⧏ 0 := by
  

Proof state:
x : PGame
⊢ x ⧏ 0 ↔ ∃ j, ∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i ⧏ 0

Next tactic:
rw [lf_def]
/-- The definition of `x ⧏ 0` on pre-games, in terms of `⧏ 0` two moves later. -/
theorem lf_zero {x : PGame} : x ⧏ 0 ↔ ∃ j, ∀ i, (x.moveRight j).moveLeft i ⧏ 0 := by
  rw [lf_def]
  

Proof state:
x : PGame
⊢ ((∃ i,
        (∀ (i' : LeftMoves x), moveLeft x i' ⧏ moveLeft 0 i) ∧
          ∀ (j : RightMoves (moveLeft 0 i)), x ⧏ moveRight (moveLeft 0 i) j) ∨
      ∃ j,
        (∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i ⧏ 0) ∧
          ∀ (j' : RightMoves 0), moveRight x j ⧏ moveRight 0 j') ↔
    ∃ j, ∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i ⧏ 0

Next tactic:
simp
theorem equiv_of_eq {x y : PGame} (h : x = y) : x ≈ y := by 

Proof state:
x y : PGame
h : x = y
⊢ x ≈ y

Next tactic:
subst h
theorem equiv_of_eq {x y : PGame} (h : x = y) : x ≈ y := by subst h; 

Proof state:
x : PGame
⊢ x ≈ x

Next tactic:
rfl
theorem lf_or_equiv_or_gf (x y : PGame) : x ⧏ y ∨ (x ≈ y) ∨ y ⧏ x := by
  

Proof state:
x y : PGame
⊢ x ⧏ y ∨ x ≈ y ∨ y ⧏ x

Next tactic:
by_cases h : x ⧏ y
theorem lf_or_equiv_or_gf (x y : PGame) : x ⧏ y ∨ (x ≈ y) ∨ y ⧏ x := by
  by_cases h : x ⧏ y
  · 

Proof state:
case pos
x y : PGame
h : x ⧏ y
⊢ x ⧏ y ∨ x ≈ y ∨ y ⧏ x

Next tactic:
exact Or.inl h
theorem lf_or_equiv_or_gf (x y : PGame) : x ⧏ y ∨ (x ≈ y) ∨ y ⧏ x := by
  by_cases h : x ⧏ y
  · exact Or.inl h
  · 

Proof state:
case neg
x y : PGame
h : ¬x ⧏ y
⊢ x ⧏ y ∨ x ≈ y ∨ y ⧏ x

Next tactic:
right
theorem lf_or_equiv_or_gf (x y : PGame) : x ⧏ y ∨ (x ≈ y) ∨ y ⧏ x := by
  by_cases h : x ⧏ y
  · exact Or.inl h
  · right
    

Proof state:
case neg.h
x y : PGame
h : ¬x ⧏ y
⊢ x ≈ y ∨ y ⧏ x

Next tactic:
cases' lt_or_equiv_of_le (PGame.not_lf.1 h) with h' h'
theorem lf_or_equiv_or_gf (x y : PGame) : x ⧏ y ∨ (x ≈ y) ∨ y ⧏ x := by
  by_cases h : x ⧏ y
  · exact Or.inl h
  · right
    cases' lt_or_equiv_of_le (PGame.not_lf.1 h) with h' h'
    · 

Proof state:
case neg.h.inl
x y : PGame
h : ¬x ⧏ y
h' : y < x
⊢ x ≈ y ∨ y ⧏ x

Next tactic:
exact Or.inr h'.lf
theorem lf_or_equiv_or_gf (x y : PGame) : x ⧏ y ∨ (x ≈ y) ∨ y ⧏ x := by
  by_cases h : x ⧏ y
  · exact Or.inl h
  · right
    cases' lt_or_equiv_of_le (PGame.not_lf.1 h) with h' h'
    · exact Or.inr h'.lf
    · 

Proof state:
case neg.h.inr
x y : PGame
h : ¬x ⧏ y
h' : y ≈ x
⊢ x ≈ y ∨ y ⧏ x

Next tactic:
exact Or.inl (Equiv.symm h')
theorem equiv_of_mk_equiv {x y : PGame} (L : x.LeftMoves ≃ y.LeftMoves)
    (R : x.RightMoves ≃ y.RightMoves) (hl : ∀ i, x.moveLeft i ≈ y.moveLeft (L i))
    (hr : ∀ j, x.moveRight j ≈ y.moveRight (R j)) : x ≈ y := by
  

Proof state:
x y : PGame
L : LeftMoves x ≃ LeftMoves y
R : RightMoves x ≃ RightMoves y
hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (L i)
hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (R j)
⊢ x ≈ y

Next tactic:
constructor
theorem equiv_of_mk_equiv {x y : PGame} (L : x.LeftMoves ≃ y.LeftMoves)
    (R : x.RightMoves ≃ y.RightMoves) (hl : ∀ i, x.moveLeft i ≈ y.moveLeft (L i))
    (hr : ∀ j, x.moveRight j ≈ y.moveRight (R j)) : x ≈ y := by
  constructor <;> 

Proof state:
case left
x y : PGame
L : LeftMoves x ≃ LeftMoves y
R : RightMoves x ≃ RightMoves y
hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (L i)
hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (R j)
⊢ x ≤ y

Next tactic:
rw [le_def]
theorem equiv_of_mk_equiv {x y : PGame} (L : x.LeftMoves ≃ y.LeftMoves)
    (R : x.RightMoves ≃ y.RightMoves) (hl : ∀ i, x.moveLeft i ≈ y.moveLeft (L i))
    (hr : ∀ j, x.moveRight j ≈ y.moveRight (R j)) : x ≈ y := by
  constructor <;> 

Proof state:
case right
x y : PGame
L : LeftMoves x ≃ LeftMoves y
R : RightMoves x ≃ RightMoves y
hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (L i)
hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (R j)
⊢ y ≤ x

Next tactic:
rw [le_def]
theorem equiv_of_mk_equiv {x y : PGame} (L : x.LeftMoves ≃ y.LeftMoves)
    (R : x.RightMoves ≃ y.RightMoves) (hl : ∀ i, x.moveLeft i ≈ y.moveLeft (L i))
    (hr : ∀ j, x.moveRight j ≈ y.moveRight (R j)) : x ≈ y := by
  constructor <;> rw [le_def]
  · 

Proof state:
case left
x y : PGame
L : LeftMoves x ≃ LeftMoves y
R : RightMoves x ≃ RightMoves y
hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (L i)
hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (R j)
⊢ (∀ (i : LeftMoves x), (∃ i', moveLeft x i ≤ moveLeft y i') ∨ ∃ j, moveRight (moveLeft x i) j ≤ y) ∧
    ∀ (j : RightMoves y), (∃ i, x ≤ moveLeft (moveRight y j) i) ∨ ∃ j', moveRight x j' ≤ moveRight y j

Next tactic:
exact ⟨fun i => Or.inl ⟨_, (hl i).1⟩, fun j => Or.inr ⟨_, by simpa using (hr (R.symm j)).1⟩⟩
theorem equiv_of_mk_equiv {x y : PGame} (L : x.LeftMoves ≃ y.LeftMoves)
    (R : x.RightMoves ≃ y.RightMoves) (hl : ∀ i, x.moveLeft i ≈ y.moveLeft (L i))
    (hr : ∀ j, x.moveRight j ≈ y.moveRight (R j)) : x ≈ y := by
  constructor <;> rw [le_def]
  · exact ⟨fun i => Or.inl ⟨_, (hl i).1⟩, fun j => Or.inr ⟨_, by 

Proof state:
x y : PGame
L : LeftMoves x ≃ LeftMoves y
R : RightMoves x ≃ RightMoves y
hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (L i)
hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (R j)
j : RightMoves y
⊢ moveRight x (?m.66974 j) ≤ moveRight y j

Next tactic:
simpa using (hr (R.symm j)).1
theorem equiv_of_mk_equiv {x y : PGame} (L : x.LeftMoves ≃ y.LeftMoves)
    (R : x.RightMoves ≃ y.RightMoves) (hl : ∀ i, x.moveLeft i ≈ y.moveLeft (L i))
    (hr : ∀ j, x.moveRight j ≈ y.moveRight (R j)) : x ≈ y := by
  constructor <;> rw [le_def]
  · exact ⟨fun i => Or.inl ⟨_, (hl i).1⟩, fun j => Or.inr ⟨_, by simpa using (hr (R.symm j)).1⟩⟩
  · 

Proof state:
case right
x y : PGame
L : LeftMoves x ≃ LeftMoves y
R : RightMoves x ≃ RightMoves y
hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (L i)
hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (R j)
⊢ (∀ (i : LeftMoves y), (∃ i', moveLeft y i ≤ moveLeft x i') ∨ ∃ j, moveRight (moveLeft y i) j ≤ x) ∧
    ∀ (j : RightMoves x), (∃ i, y ≤ moveLeft (moveRight x j) i) ∨ ∃ j', moveRight y j' ≤ moveRight x j

Next tactic:
exact ⟨fun i => Or.inl ⟨_, by simpa using (hl (L.symm i)).2⟩, fun j => Or.inr ⟨_, (hr j).2⟩⟩
theorem equiv_of_mk_equiv {x y : PGame} (L : x.LeftMoves ≃ y.LeftMoves)
    (R : x.RightMoves ≃ y.RightMoves) (hl : ∀ i, x.moveLeft i ≈ y.moveLeft (L i))
    (hr : ∀ j, x.moveRight j ≈ y.moveRight (R j)) : x ≈ y := by
  constructor <;> rw [le_def]
  · exact ⟨fun i => Or.inl ⟨_, (hl i).1⟩, fun j => Or.inr ⟨_, by simpa using (hr (R.symm j)).1⟩⟩
  · exact ⟨fun i => Or.inl ⟨_, by 

Proof state:
x y : PGame
L : LeftMoves x ≃ LeftMoves y
R : RightMoves x ≃ RightMoves y
hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (L i)
hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (R j)
i : LeftMoves y
⊢ moveLeft y i ≤ moveLeft x (?m.67650 i)

Next tactic:
simpa using (hl (L.symm i)).2
theorem lf_iff_lt_or_fuzzy {x y : PGame} : x ⧏ y ↔ x < y ∨ x ‖ y := by
  

Proof state:
x y : PGame
⊢ x ⧏ y ↔ x < y ∨ x ‖ y

Next tactic:
simp only [lt_iff_le_and_lf, Fuzzy, ← PGame.not_le]
theorem lf_iff_lt_or_fuzzy {x y : PGame} : x ⧏ y ↔ x < y ∨ x ‖ y := by
  simp only [lt_iff_le_and_lf, Fuzzy, ← PGame.not_le]
  

Proof state:
x y : PGame
⊢ ¬y ≤ x ↔ x ≤ y ∧ ¬y ≤ x ∨ ¬y ≤ x ∧ ¬x ≤ y

Next tactic:
tauto
theorem fuzzy_congr {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ‖ y₁ ↔ x₂ ‖ y₂ :=
  show _ ∧ _ ↔ _ ∧ _ by 

Proof state:
x₁ y₁ x₂ y₂ : PGame
hx : x₁ ≈ x₂
hy : y₁ ≈ y₂
⊢ x₁ ⧏ y₁ ∧ y₁ ⧏ x₁ ↔ x₂ ⧏ y₂ ∧ y₂ ⧏ x₂

Next tactic:
rw [lf_congr hx hy, lf_congr hy hx]
/-- Exactly one of the following is true (although we don't prove this here). -/
theorem lt_or_equiv_or_gt_or_fuzzy (x y : PGame) : x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y := by
  

Proof state:
x y : PGame
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y

Next tactic:
cases' le_or_gf x y with h₁ h₁
/-- Exactly one of the following is true (although we don't prove this here). -/
theorem lt_or_equiv_or_gt_or_fuzzy (x y : PGame) : x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y := by
  cases' le_or_gf x y with h₁ h₁ <;> 

Proof state:
case inl
x y : PGame
h₁ : x ≤ y
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y

Next tactic:
cases' le_or_gf y x with h₂ h₂
/-- Exactly one of the following is true (although we don't prove this here). -/
theorem lt_or_equiv_or_gt_or_fuzzy (x y : PGame) : x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y := by
  cases' le_or_gf x y with h₁ h₁ <;> 

Proof state:
case inr
x y : PGame
h₁ : y ⧏ x
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y

Next tactic:
cases' le_or_gf y x with h₂ h₂
/-- Exactly one of the following is true (although we don't prove this here). -/
theorem lt_or_equiv_or_gt_or_fuzzy (x y : PGame) : x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y := by
  cases' le_or_gf x y with h₁ h₁ <;> cases' le_or_gf y x with h₂ h₂
  · 

Proof state:
case inl.inl
x y : PGame
h₁ : x ≤ y
h₂ : y ≤ x
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y

Next tactic:
right
/-- Exactly one of the following is true (although we don't prove this here). -/
theorem lt_or_equiv_or_gt_or_fuzzy (x y : PGame) : x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y := by
  cases' le_or_gf x y with h₁ h₁ <;> cases' le_or_gf y x with h₂ h₂
  · right
    

Proof state:
case inl.inl.h
x y : PGame
h₁ : x ≤ y
h₂ : y ≤ x
⊢ x ≈ y ∨ y < x ∨ x ‖ y

Next tactic:
left
/-- Exactly one of the following is true (although we don't prove this here). -/
theorem lt_or_equiv_or_gt_or_fuzzy (x y : PGame) : x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y := by
  cases' le_or_gf x y with h₁ h₁ <;> cases' le_or_gf y x with h₂ h₂
  · right
    left
    

Proof state:
case inl.inl.h.h
x y : PGame
h₁ : x ≤ y
h₂ : y ≤ x
⊢ x ≈ y

Next tactic:
exact ⟨h₁, h₂⟩
/-- Exactly one of the following is true (although we don't prove this here). -/
theorem lt_or_equiv_or_gt_or_fuzzy (x y : PGame) : x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y := by
  cases' le_or_gf x y with h₁ h₁ <;> cases' le_or_gf y x with h₂ h₂
  · right
    left
    exact ⟨h₁, h₂⟩
  · 

Proof state:
case inl.inr
x y : PGame
h₁ : x ≤ y
h₂ : x ⧏ y
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y

Next tactic:
left
/-- Exactly one of the following is true (although we don't prove this here). -/
theorem lt_or_equiv_or_gt_or_fuzzy (x y : PGame) : x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y := by
  cases' le_or_gf x y with h₁ h₁ <;> cases' le_or_gf y x with h₂ h₂
  · right
    left
    exact ⟨h₁, h₂⟩
  · left
    

Proof state:
case inl.inr.h
x y : PGame
h₁ : x ≤ y
h₂ : x ⧏ y
⊢ x < y

Next tactic:
exact ⟨h₁, h₂⟩
/-- Exactly one of the following is true (although we don't prove this here). -/
theorem lt_or_equiv_or_gt_or_fuzzy (x y : PGame) : x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y := by
  cases' le_or_gf x y with h₁ h₁ <;> cases' le_or_gf y x with h₂ h₂
  · right
    left
    exact ⟨h₁, h₂⟩
  · left
    exact ⟨h₁, h₂⟩
  · 

Proof state:
case inr.inl
x y : PGame
h₁ : y ⧏ x
h₂ : y ≤ x
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y

Next tactic:
right
/-- Exactly one of the following is true (although we don't prove this here). -/
theorem lt_or_equiv_or_gt_or_fuzzy (x y : PGame) : x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y := by
  cases' le_or_gf x y with h₁ h₁ <;> cases' le_or_gf y x with h₂ h₂
  · right
    left
    exact ⟨h₁, h₂⟩
  · left
    exact ⟨h₁, h₂⟩
  · right
    

Proof state:
case inr.inl.h
x y : PGame
h₁ : y ⧏ x
h₂ : y ≤ x
⊢ x ≈ y ∨ y < x ∨ x ‖ y

Next tactic:
right
/-- Exactly one of the following is true (although we don't prove this here). -/
theorem lt_or_equiv_or_gt_or_fuzzy (x y : PGame) : x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y := by
  cases' le_or_gf x y with h₁ h₁ <;> cases' le_or_gf y x with h₂ h₂
  · right
    left
    exact ⟨h₁, h₂⟩
  · left
    exact ⟨h₁, h₂⟩
  · right
    right
    

Proof state:
case inr.inl.h.h
x y : PGame
h₁ : y ⧏ x
h₂ : y ≤ x
⊢ y < x ∨ x ‖ y

Next tactic:
left
/-- Exactly one of the following is true (although we don't prove this here). -/
theorem lt_or_equiv_or_gt_or_fuzzy (x y : PGame) : x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y := by
  cases' le_or_gf x y with h₁ h₁ <;> cases' le_or_gf y x with h₂ h₂
  · right
    left
    exact ⟨h₁, h₂⟩
  · left
    exact ⟨h₁, h₂⟩
  · right
    right
    left
    

Proof state:
case inr.inl.h.h.h
x y : PGame
h₁ : y ⧏ x
h₂ : y ≤ x
⊢ y < x

Next tactic:
exact ⟨h₂, h₁⟩
/-- Exactly one of the following is true (although we don't prove this here). -/
theorem lt_or_equiv_or_gt_or_fuzzy (x y : PGame) : x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y := by
  cases' le_or_gf x y with h₁ h₁ <;> cases' le_or_gf y x with h₂ h₂
  · right
    left
    exact ⟨h₁, h₂⟩
  · left
    exact ⟨h₁, h₂⟩
  · right
    right
    left
    exact ⟨h₂, h₁⟩
  · 

Proof state:
case inr.inr
x y : PGame
h₁ : y ⧏ x
h₂ : x ⧏ y
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y

Next tactic:
right
/-- Exactly one of the following is true (although we don't prove this here). -/
theorem lt_or_equiv_or_gt_or_fuzzy (x y : PGame) : x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y := by
  cases' le_or_gf x y with h₁ h₁ <;> cases' le_or_gf y x with h₂ h₂
  · right
    left
    exact ⟨h₁, h₂⟩
  · left
    exact ⟨h₁, h₂⟩
  · right
    right
    left
    exact ⟨h₂, h₁⟩
  · right
    

Proof state:
case inr.inr.h
x y : PGame
h₁ : y ⧏ x
h₂ : x ⧏ y
⊢ x ≈ y ∨ y < x ∨ x ‖ y

Next tactic:
right
/-- Exactly one of the following is true (although we don't prove this here). -/
theorem lt_or_equiv_or_gt_or_fuzzy (x y : PGame) : x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y := by
  cases' le_or_gf x y with h₁ h₁ <;> cases' le_or_gf y x with h₂ h₂
  · right
    left
    exact ⟨h₁, h₂⟩
  · left
    exact ⟨h₁, h₂⟩
  · right
    right
    left
    exact ⟨h₂, h₁⟩
  · right
    right
    

Proof state:
case inr.inr.h.h
x y : PGame
h₁ : y ⧏ x
h₂ : x ⧏ y
⊢ y < x ∨ x ‖ y

Next tactic:
right
/-- Exactly one of the following is true (although we don't prove this here). -/
theorem lt_or_equiv_or_gt_or_fuzzy (x y : PGame) : x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y := by
  cases' le_or_gf x y with h₁ h₁ <;> cases' le_or_gf y x with h₂ h₂
  · right
    left
    exact ⟨h₁, h₂⟩
  · left
    exact ⟨h₁, h₂⟩
  · right
    right
    left
    exact ⟨h₂, h₁⟩
  · right
    right
    right
    

Proof state:
case inr.inr.h.h.h
x y : PGame
h₁ : y ⧏ x
h₂ : x ⧏ y
⊢ x ‖ y

Next tactic:
exact ⟨h₂, h₁⟩
theorem lt_or_equiv_or_gf (x y : PGame) : x < y ∨ (x ≈ y) ∨ y ⧏ x := by
  

Proof state:
x y : PGame
⊢ x < y ∨ x ≈ y ∨ y ⧏ x

Next tactic:
rw [lf_iff_lt_or_fuzzy, Fuzzy.swap_iff]
theorem lt_or_equiv_or_gf (x y : PGame) : x < y ∨ (x ≈ y) ∨ y ⧏ x := by
  rw [lf_iff_lt_or_fuzzy, Fuzzy.swap_iff]
  

Proof state:
x y : PGame
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y

Next tactic:
exact lt_or_equiv_or_gt_or_fuzzy x y
/-- A constructor for relabellings swapping the equivalences. -/
def mk' (L : y.LeftMoves ≃ x.LeftMoves) (R : y.RightMoves ≃ x.RightMoves)
    (hL : ∀ i, x.moveLeft (L i) ≡r y.moveLeft i) (hR : ∀ j, x.moveRight (R j) ≡r y.moveRight j) :
    x ≡r y :=
  ⟨L.symm, R.symm, fun i => by 

Proof state:
x y : PGame
L : LeftMoves y ≃ LeftMoves x
R : RightMoves y ≃ RightMoves x
hL : (i : LeftMoves y) → moveLeft x (L i) ≡r moveLeft y i
hR : (j : RightMoves y) → moveRight x (R j) ≡r moveRight y j
i : LeftMoves x
⊢ moveLeft x i ≡r moveLeft y (L.symm i)

Next tactic:
simpa using hL (L.symm i)
/-- A constructor for relabellings swapping the equivalences. -/
def mk' (L : y.LeftMoves ≃ x.LeftMoves) (R : y.RightMoves ≃ x.RightMoves)
    (hL : ∀ i, x.moveLeft (L i) ≡r y.moveLeft i) (hR : ∀ j, x.moveRight (R j) ≡r y.moveRight j) :
    x ≡r y :=
  ⟨L.symm, R.symm, fun i => by simpa using hL (L.symm i), fun j => by 

Proof state:
x y : PGame
L : LeftMoves y ≃ LeftMoves x
R : RightMoves y ≃ RightMoves x
hL : (i : LeftMoves y) → moveLeft x (L i) ≡r moveLeft y i
hR : (j : RightMoves y) → moveRight x (R j) ≡r moveRight y j
j : RightMoves x
⊢ moveRight x j ≡r moveRight y (R.symm j)

Next tactic:
simpa using hR (R.symm j)
/-- A left move of `y` is a relabelling of a left move of `x`. -/
def moveLeftSymm :
    ∀ (r : x ≡r y) (i : y.LeftMoves), x.moveLeft (r.leftMovesEquiv.symm i) ≡r y.moveLeft i
  | ⟨L, R, hL, hR⟩, i => by 

Proof state:
x y : PGame
L : LeftMoves x ≃ LeftMoves y
R : RightMoves x ≃ RightMoves y
hL : (i : LeftMoves x) → PGame.moveLeft x i ≡r PGame.moveLeft y (L i)
hR : (j : RightMoves x) → moveRight x j ≡r moveRight y (R j)
i : LeftMoves y
⊢ PGame.moveLeft x ((leftMovesEquiv (mk L R hL hR)).symm i) ≡r PGame.moveLeft y i

Next tactic:
simpa using hL (L.symm i)
/-- A right move of `y` is a relabelling of a right move of `x`. -/
def moveRightSymm :
    ∀ (r : x ≡r y) (i : y.RightMoves), x.moveRight (r.rightMovesEquiv.symm i) ≡r y.moveRight i
  | ⟨L, R, hL, hR⟩, i => by 

Proof state:
x y : PGame
L : LeftMoves x ≃ LeftMoves y
R : RightMoves x ≃ RightMoves y
hL : (i : LeftMoves x) → PGame.moveLeft x i ≡r PGame.moveLeft y (L i)
hR : (j : RightMoves x) → PGame.moveRight x j ≡r PGame.moveRight y (R j)
i : RightMoves y
⊢ PGame.moveRight x ((rightMovesEquiv (mk L R hL hR)).symm i) ≡r PGame.moveRight y i

Next tactic:
simpa using hR (R.symm i)