set_theory.game.pgame ⟷ Mathlib.SetTheory.Game.PGame

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -1637,7 +1637,7 @@ theorem SetTheory.PGame.neg_ofLists (L R : List SetTheory.PGame) :
 theorem SetTheory.PGame.isOption_neg {x y : SetTheory.PGame} :
     SetTheory.PGame.IsOption x (-y) ↔ SetTheory.PGame.IsOption (-x) y :=
   by
-  rw [is_option_iff, is_option_iff, or_comm']
+  rw [is_option_iff, is_option_iff, or_comm]
   cases y; apply or_congr <;> · apply exists_congr; intro; rw [neg_eq_iff_eq_neg]; rfl
 #align pgame.is_option_neg SetTheory.PGame.isOption_neg
 -/
@@ -1746,8 +1746,8 @@ private theorem neg_le_lf_neg_iff :
     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 <;> exact exists_congr fun _ => neg_le_lf_neg_iff.1
+    · rw [and_comm]; apply and_congr <;> exact forall_congr' fun _ => neg_le_lf_neg_iff.2
+    · rw [or_comm]; apply or_congr <;> exact exists_congr fun _ => neg_le_lf_neg_iff.1
 decreasing_by pgame_wf_tac
 
 #print SetTheory.PGame.neg_le_neg_iff /-

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -6,7 +6,7 @@ Authors: Reid Barton, Mario Carneiro, Isabel Longbottom, Scott Morrison
 import Data.Fin.Basic
 import Data.List.Basic
 import Logic.Relation
-import Logic.Small.Basic
+import Logic.Small.Defs
 import Order.GameAdd
 
 #align_import set_theory.game.pgame from "leanprover-community/mathlib"@"8900d545017cd21961daa2a1734bb658ef52c618"

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -2281,7 +2281,7 @@ private theorem add_le_add_right' : ∀ {x y z : SetTheory.PGame} (h : x ≤ y),
   | mk xl xr xL xR, mk yl yr yL yR, mk zl zr zL zR => fun h =>
     by
     refine' le_def.2 ⟨fun i => _, fun i => _⟩ <;> cases i
-    · rw [le_def] at h 
+    · rw [le_def] at h
       cases h
       rcases h_left i with (⟨i', ih⟩ | ⟨j, jh⟩)
       · exact Or.inl ⟨to_left_moves_add (Sum.inl i'), add_le_add_right' ih⟩
@@ -2289,7 +2289,7 @@ private theorem add_le_add_right' : ∀ {x y z : SetTheory.PGame} (h : x ≤ y),
         convert add_le_add_right' jh
         apply add_move_right_inl
     · exact Or.inl ⟨@to_left_moves_add _ ⟨_, _, _, _⟩ (Sum.inr i), add_le_add_right' h⟩
-    · rw [le_def] at h 
+    · rw [le_def] at h
       cases h
       rcases h_right i with (⟨i, ih⟩ | ⟨j', jh⟩)
       · refine' Or.inl ⟨to_left_moves_add (Sum.inl i), _⟩

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -908,11 +908,13 @@ theorem SetTheory.PGame.upperBound_mem_upperBounds (s : Set SetTheory.PGame.{u})
   by simpa using le_upper_bound (Subtype.val ∘ (equivShrink s).symm) (equivShrink s ⟨i, hi⟩)
 #align pgame.upper_bound_mem_upper_bounds SetTheory.PGame.upperBound_mem_upperBounds
 
+#print SetTheory.PGame.bddAbove_of_small /-
 /-- A small set `s` of pre-games is bounded above. -/
 theorem SetTheory.PGame.bddAbove_of_small (s : Set SetTheory.PGame.{u}) [Small.{u} s] :
     BddAbove s :=
   ⟨_, SetTheory.PGame.upperBound_mem_upperBounds s⟩
 #align pgame.bdd_above_of_small SetTheory.PGame.bddAbove_of_small
+-/
 
 /-- An explicit lower bound for a family of pre-games, whose right moves are the union of the right
 moves of all the pre-games in the family. -/
@@ -939,11 +941,13 @@ theorem SetTheory.PGame.lowerBound_mem_lowerBounds (s : Set SetTheory.PGame.{u})
   by simpa using lower_bound_le (Subtype.val ∘ (equivShrink s).symm) (equivShrink s ⟨i, hi⟩)
 #align pgame.lower_bound_mem_lower_bounds SetTheory.PGame.lowerBound_mem_lowerBounds
 
+#print SetTheory.PGame.bddBelow_of_small /-
 /-- A small set `s` of pre-games is bounded below. -/
 theorem SetTheory.PGame.bddBelow_of_small (s : Set SetTheory.PGame.{u}) [Small.{u} s] :
     BddBelow s :=
   ⟨_, SetTheory.PGame.lowerBound_mem_lowerBounds s⟩
 #align pgame.bdd_below_of_small SetTheory.PGame.bddBelow_of_small
+-/
 
 #print SetTheory.PGame.Equiv /-
 /-- The equivalence relation on pre-games. Two pre-games `x`, `y` are equivalent if `x ≤ y` and

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

@@ -3,11 +3,11 @@ Copyright (c) 2019 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Reid Barton, Mario Carneiro, Isabel Longbottom, Scott Morrison
 -/
-import Mathbin.Data.Fin.Basic
-import Mathbin.Data.List.Basic
-import Mathbin.Logic.Relation
-import Mathbin.Logic.Small.Basic
-import Mathbin.Order.GameAdd
+import Data.Fin.Basic
+import Data.List.Basic
+import Logic.Relation
+import Logic.Small.Basic
+import Order.GameAdd
 
 #align_import set_theory.game.pgame from "leanprover-community/mathlib"@"8900d545017cd21961daa2a1734bb658ef52c618"
 
@@ -365,7 +365,7 @@ theorem SetTheory.PGame.Subsequent.mk_right {xl xr} (xL : xl → SetTheory.PGame
 #align pgame.subsequent.mk_right SetTheory.PGame.Subsequent.mk_right
 -/
 
-/- ./././Mathport/Syntax/Translate/Expr.lean:336:4: warning: unsupported (TODO): `[tacs] -/
+/- ./././Mathport/Syntax/Translate/Expr.lean:337:4: warning: unsupported (TODO): `[tacs] -/
 /-- A local tactic for proving well-foundedness of recursive definitions involving pregames. -/
 unsafe def pgame_wf_tac :=
   sorry

mathlib commit https://github.com/leanprover-community/mathlib/commit/001ffdc42920050657fd45bd2b8bfbec8eaaeb29

@@ -455,16 +455,16 @@ instance : LE SetTheory.PGame :=
       (∀ i, ¬le y (x.moveLeft i) (Sym2.GameAdd.snd_fst <| SetTheory.PGame.IsOption.moveLeft i)) ∧
         ∀ j, ¬le (y.moveRight j) x (Sym2.GameAdd.fst_snd <| SetTheory.PGame.IsOption.moveRight j)⟩
 
-#print SetTheory.PGame.Lf /-
+#print SetTheory.PGame.LF /-
 /-- The less or fuzzy relation on pre-games.
 
 If `0 ⧏ x`, then Left can win `x` as the first player. -/
-def SetTheory.PGame.Lf (x y : SetTheory.PGame) : Prop :=
+def SetTheory.PGame.LF (x y : SetTheory.PGame) : Prop :=
   ¬y ≤ x
-#align pgame.lf SetTheory.PGame.Lf
+#align pgame.lf SetTheory.PGame.LF
 -/
 
-scoped infixl:50 " ⧏ " => SetTheory.PGame.Lf
+scoped infixl:50 " ⧏ " => SetTheory.PGame.LF
 
 #print SetTheory.PGame.not_le /-
 @[simp]
@@ -486,10 +486,10 @@ theorem LE.le.not_gf {x y : SetTheory.PGame} : x ≤ y → ¬y ⧏ x :=
 #align has_le.le.not_gf LE.le.not_gf
 -/
 
-#print SetTheory.PGame.Lf.not_ge /-
-theorem SetTheory.PGame.Lf.not_ge {x y : SetTheory.PGame} : x ⧏ y → ¬y ≤ x :=
+#print SetTheory.PGame.LF.not_ge /-
+theorem SetTheory.PGame.LF.not_ge {x y : SetTheory.PGame} : x ⧏ y → ¬y ≤ x :=
   id
-#align pgame.lf.not_ge SetTheory.PGame.Lf.not_ge
+#align pgame.lf.not_ge SetTheory.PGame.LF.not_ge
 -/
 
 #print SetTheory.PGame.le_iff_forall_lf /-
@@ -690,7 +690,7 @@ alias _root_.has_le.le.trans_lf := lf_of_le_of_lf
 #align has_le.le.trans_lf LE.le.trans_lf
 
 alias lf.trans_le := lf_of_lf_of_le
-#align pgame.lf.trans_le SetTheory.PGame.Lf.trans_le
+#align pgame.lf.trans_le SetTheory.PGame.LF.trans_le
 
 #print SetTheory.PGame.lf_of_lt_of_lf /-
 @[trans]
@@ -712,7 +712,7 @@ alias _root_.has_lt.lt.trans_lf := lf_of_lt_of_lf
 #align has_lt.lt.trans_lf LT.lt.trans_lf
 
 alias lf.trans_lt := lf_of_lf_of_lt
-#align pgame.lf.trans_lt SetTheory.PGame.Lf.trans_lt
+#align pgame.lf.trans_lt SetTheory.PGame.LF.trans_lt
 
 #print SetTheory.PGame.moveLeft_lf /-
 theorem SetTheory.PGame.moveLeft_lf {x : SetTheory.PGame} : ∀ i, x.moveLeft i ⧏ x :=
@@ -745,7 +745,7 @@ theorem SetTheory.PGame.mk_lf {xl xr} (xL : xl → SetTheory.PGame) (xR : xr →
 preferred over `⧏`. -/
 theorem SetTheory.PGame.le_of_forall_lt {x y : SetTheory.PGame} (h₁ : ∀ i, x.moveLeft i < y)
     (h₂ : ∀ j, x < y.moveRight j) : x ≤ y :=
-  SetTheory.PGame.le_of_forall_lf (fun i => (h₁ i).Lf) fun i => (h₂ i).Lf
+  SetTheory.PGame.le_of_forall_lf (fun i => (h₁ i).LF) fun i => (h₂ i).LF
 #align pgame.le_of_forall_lt SetTheory.PGame.le_of_forall_lt
 -/
 
@@ -1026,19 +1026,19 @@ theorem SetTheory.PGame.le_of_equiv_of_le {x y z} (h₁ : x ≈ y) : y ≤ z →
 #align pgame.le_of_equiv_of_le SetTheory.PGame.le_of_equiv_of_le
 -/
 
-#print SetTheory.PGame.Lf.not_equiv /-
-theorem SetTheory.PGame.Lf.not_equiv {x y} (h : x ⧏ y) : ¬(x ≈ y) := fun h' => h.not_ge h'.2
-#align pgame.lf.not_equiv SetTheory.PGame.Lf.not_equiv
+#print SetTheory.PGame.LF.not_equiv /-
+theorem SetTheory.PGame.LF.not_equiv {x y} (h : x ⧏ y) : ¬(x ≈ y) := fun h' => h.not_ge h'.2
+#align pgame.lf.not_equiv SetTheory.PGame.LF.not_equiv
 -/
 
-#print SetTheory.PGame.Lf.not_equiv' /-
-theorem SetTheory.PGame.Lf.not_equiv' {x y} (h : x ⧏ y) : ¬(y ≈ x) := fun h' => h.not_ge h'.1
-#align pgame.lf.not_equiv' SetTheory.PGame.Lf.not_equiv'
+#print SetTheory.PGame.LF.not_equiv' /-
+theorem SetTheory.PGame.LF.not_equiv' {x y} (h : x ⧏ y) : ¬(y ≈ x) := fun h' => h.not_ge h'.1
+#align pgame.lf.not_equiv' SetTheory.PGame.LF.not_equiv'
 -/
 
-#print SetTheory.PGame.Lf.not_gt /-
-theorem SetTheory.PGame.Lf.not_gt {x y} (h : x ⧏ y) : ¬y < x := fun h' => h.not_ge h'.le
-#align pgame.lf.not_gt SetTheory.PGame.Lf.not_gt
+#print SetTheory.PGame.LF.not_gt /-
+theorem SetTheory.PGame.LF.not_gt {x y} (h : x ⧏ y) : ¬y < x := fun h' => h.not_ge h'.le
+#align pgame.lf.not_gt SetTheory.PGame.LF.not_gt
 -/
 
 #print SetTheory.PGame.le_congr_imp /-
@@ -1749,14 +1749,14 @@ decreasing_by pgame_wf_tac
 #print SetTheory.PGame.neg_le_neg_iff /-
 @[simp]
 theorem SetTheory.PGame.neg_le_neg_iff {x y : SetTheory.PGame} : -y ≤ -x ↔ x ≤ y :=
-  neg_le_lf_neg_iff.1
+  neg_le_lF_neg_iff.1
 #align pgame.neg_le_neg_iff SetTheory.PGame.neg_le_neg_iff
 -/
 
 #print SetTheory.PGame.neg_lf_neg_iff /-
 @[simp]
 theorem SetTheory.PGame.neg_lf_neg_iff {x y : SetTheory.PGame} : -y ⧏ -x ↔ x ⧏ y :=
-  neg_le_lf_neg_iff.2
+  neg_le_lF_neg_iff.2
 #align pgame.neg_lf_neg_iff SetTheory.PGame.neg_lf_neg_iff
 -/
 
@@ -2513,7 +2513,7 @@ instance : ZeroLEOneClass SetTheory.PGame :=
 #print SetTheory.PGame.zero_lf_one /-
 @[simp]
 theorem SetTheory.PGame.zero_lf_one : (0 : SetTheory.PGame) ⧏ 1 :=
-  SetTheory.PGame.zero_lt_one.Lf
+  SetTheory.PGame.zero_lt_one.LF
 #align pgame.zero_lf_one SetTheory.PGame.zero_lf_one
 -/
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/442a83d738cb208d3600056c489be16900ba701d

@@ -107,7 +107,7 @@ universe u
 /-! ### Pre-game moves -/
 
 
-#print PGame /-
+#print SetTheory.PGame /-
 /-- The type of pre-games, before we have quotiented
   by equivalence (`pgame.setoid`). In ZFC, a combinatorial game is constructed from
   two sets of combinatorial games that have been constructed at an earlier
@@ -115,233 +115,254 @@ universe u
   inductively from two families of pre-games indexed over any type
   in Type u. The resulting type `pgame.{u}` lives in `Type (u+1)`,
   reflecting that it is a proper class in ZFC. -/
-inductive PGame : Type (u + 1)
-  | mk : ∀ α β : Type u, (α → PGame) → (β → PGame) → PGame
-#align pgame PGame
+inductive SetTheory.PGame : Type (u + 1)
+  | mk : ∀ α β : Type u, (α → SetTheory.PGame) → (β → SetTheory.PGame) → SetTheory.PGame
+#align pgame SetTheory.PGame
 -/
 
-namespace PGame
+namespace SetTheory.PGame
 
-#print PGame.LeftMoves /-
+#print SetTheory.PGame.LeftMoves /-
 /-- The indexing type for allowable moves by Left. -/
-def LeftMoves : PGame → Type u
+def SetTheory.PGame.LeftMoves : SetTheory.PGame → Type u
   | mk l _ _ _ => l
-#align pgame.left_moves PGame.LeftMoves
+#align pgame.left_moves SetTheory.PGame.LeftMoves
 -/
 
-#print PGame.RightMoves /-
+#print SetTheory.PGame.RightMoves /-
 /-- The indexing type for allowable moves by Right. -/
-def RightMoves : PGame → Type u
+def SetTheory.PGame.RightMoves : SetTheory.PGame → Type u
   | mk _ r _ _ => r
-#align pgame.right_moves PGame.RightMoves
+#align pgame.right_moves SetTheory.PGame.RightMoves
 -/
 
-#print PGame.moveLeft /-
+#print SetTheory.PGame.moveLeft /-
 /-- The new game after Left makes an allowed move. -/
-def moveLeft : ∀ g : PGame, LeftMoves g → PGame
+def SetTheory.PGame.moveLeft : ∀ g : SetTheory.PGame, SetTheory.PGame.LeftMoves g → SetTheory.PGame
   | mk l _ L _ => L
-#align pgame.move_left PGame.moveLeft
+#align pgame.move_left SetTheory.PGame.moveLeft
 -/
 
-#print PGame.moveRight /-
+#print SetTheory.PGame.moveRight /-
 /-- The new game after Right makes an allowed move. -/
-def moveRight : ∀ g : PGame, RightMoves g → PGame
+def SetTheory.PGame.moveRight :
+    ∀ g : SetTheory.PGame, SetTheory.PGame.RightMoves g → SetTheory.PGame
   | mk _ r _ R => R
-#align pgame.move_right PGame.moveRight
+#align pgame.move_right SetTheory.PGame.moveRight
 -/
 
-#print PGame.leftMoves_mk /-
+#print SetTheory.PGame.leftMoves_mk /-
 @[simp]
-theorem leftMoves_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).LeftMoves = xl :=
+theorem SetTheory.PGame.leftMoves_mk {xl xr xL xR} :
+    (⟨xl, xr, xL, xR⟩ : SetTheory.PGame).LeftMoves = xl :=
   rfl
-#align pgame.left_moves_mk PGame.leftMoves_mk
+#align pgame.left_moves_mk SetTheory.PGame.leftMoves_mk
 -/
 
-#print PGame.moveLeft_mk /-
+#print SetTheory.PGame.moveLeft_mk /-
 @[simp]
-theorem moveLeft_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).moveLeft = xL :=
+theorem SetTheory.PGame.moveLeft_mk {xl xr xL xR} :
+    (⟨xl, xr, xL, xR⟩ : SetTheory.PGame).moveLeft = xL :=
   rfl
-#align pgame.move_left_mk PGame.moveLeft_mk
+#align pgame.move_left_mk SetTheory.PGame.moveLeft_mk
 -/
 
-#print PGame.rightMoves_mk /-
+#print SetTheory.PGame.rightMoves_mk /-
 @[simp]
-theorem rightMoves_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).RightMoves = xr :=
+theorem SetTheory.PGame.rightMoves_mk {xl xr xL xR} :
+    (⟨xl, xr, xL, xR⟩ : SetTheory.PGame).RightMoves = xr :=
   rfl
-#align pgame.right_moves_mk PGame.rightMoves_mk
+#align pgame.right_moves_mk SetTheory.PGame.rightMoves_mk
 -/
 
-#print PGame.moveRight_mk /-
+#print SetTheory.PGame.moveRight_mk /-
 @[simp]
-theorem moveRight_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).moveRight = xR :=
+theorem SetTheory.PGame.moveRight_mk {xl xr xL xR} :
+    (⟨xl, xr, xL, xR⟩ : SetTheory.PGame).moveRight = xR :=
   rfl
-#align pgame.move_right_mk PGame.moveRight_mk
+#align pgame.move_right_mk SetTheory.PGame.moveRight_mk
 -/
 
-#print PGame.ofLists /-
+#print SetTheory.PGame.ofLists /-
 -- TODO define this at the level of games, as well, and perhaps also for finsets of games.
 /-- Construct a pre-game from list of pre-games describing the available moves for Left and Right.
 -/
-def ofLists (L R : List PGame.{u}) : PGame.{u} :=
-  mk (ULift (Fin L.length)) (ULift (Fin R.length)) (fun i => L.nthLe i.down i.down.is_lt) fun j =>
-    R.nthLe j.down j.down.Prop
-#align pgame.of_lists PGame.ofLists
+def SetTheory.PGame.ofLists (L R : List SetTheory.PGame.{u}) : SetTheory.PGame.{u} :=
+  SetTheory.PGame.mk (ULift (Fin L.length)) (ULift (Fin R.length))
+    (fun i => L.nthLe i.down i.down.is_lt) fun j => R.nthLe j.down j.down.Prop
+#align pgame.of_lists SetTheory.PGame.ofLists
 -/
 
-#print PGame.leftMoves_ofLists /-
-theorem leftMoves_ofLists (L R : List PGame) : (ofLists L R).LeftMoves = ULift (Fin L.length) :=
+#print SetTheory.PGame.leftMoves_ofLists /-
+theorem SetTheory.PGame.leftMoves_ofLists (L R : List SetTheory.PGame) :
+    (SetTheory.PGame.ofLists L R).LeftMoves = ULift (Fin L.length) :=
   rfl
-#align pgame.left_moves_of_lists PGame.leftMoves_ofLists
+#align pgame.left_moves_of_lists SetTheory.PGame.leftMoves_ofLists
 -/
 
-#print PGame.rightMoves_ofLists /-
-theorem rightMoves_ofLists (L R : List PGame) : (ofLists L R).RightMoves = ULift (Fin R.length) :=
+#print SetTheory.PGame.rightMoves_ofLists /-
+theorem SetTheory.PGame.rightMoves_ofLists (L R : List SetTheory.PGame) :
+    (SetTheory.PGame.ofLists L R).RightMoves = ULift (Fin R.length) :=
   rfl
-#align pgame.right_moves_of_lists PGame.rightMoves_ofLists
+#align pgame.right_moves_of_lists SetTheory.PGame.rightMoves_ofLists
 -/
 
-#print PGame.toOfListsLeftMoves /-
+#print SetTheory.PGame.toOfListsLeftMoves /-
 /-- Converts a number into a left move for `of_lists`. -/
-def toOfListsLeftMoves {L R : List PGame} : Fin L.length ≃ (ofLists L R).LeftMoves :=
-  ((Equiv.cast (leftMoves_ofLists L R).symm).trans Equiv.ulift).symm
-#align pgame.to_of_lists_left_moves PGame.toOfListsLeftMoves
+def SetTheory.PGame.toOfListsLeftMoves {L R : List SetTheory.PGame} :
+    Fin L.length ≃ (SetTheory.PGame.ofLists L R).LeftMoves :=
+  ((Equiv.cast (SetTheory.PGame.leftMoves_ofLists L R).symm).trans Equiv.ulift).symm
+#align pgame.to_of_lists_left_moves SetTheory.PGame.toOfListsLeftMoves
 -/
 
-#print PGame.toOfListsRightMoves /-
+#print SetTheory.PGame.toOfListsRightMoves /-
 /-- Converts a number into a right move for `of_lists`. -/
-def toOfListsRightMoves {L R : List PGame} : Fin R.length ≃ (ofLists L R).RightMoves :=
-  ((Equiv.cast (rightMoves_ofLists L R).symm).trans Equiv.ulift).symm
-#align pgame.to_of_lists_right_moves PGame.toOfListsRightMoves
+def SetTheory.PGame.toOfListsRightMoves {L R : List SetTheory.PGame} :
+    Fin R.length ≃ (SetTheory.PGame.ofLists L R).RightMoves :=
+  ((Equiv.cast (SetTheory.PGame.rightMoves_ofLists L R).symm).trans Equiv.ulift).symm
+#align pgame.to_of_lists_right_moves SetTheory.PGame.toOfListsRightMoves
 -/
 
-#print PGame.ofLists_moveLeft /-
-theorem ofLists_moveLeft {L R : List PGame} (i : Fin L.length) :
-    (ofLists L R).moveLeft (toOfListsLeftMoves i) = L.nthLe i i.is_lt :=
+#print SetTheory.PGame.ofLists_moveLeft /-
+theorem SetTheory.PGame.ofLists_moveLeft {L R : List SetTheory.PGame} (i : Fin L.length) :
+    (SetTheory.PGame.ofLists L R).moveLeft (SetTheory.PGame.toOfListsLeftMoves i) =
+      L.nthLe i i.is_lt :=
   rfl
-#align pgame.of_lists_move_left PGame.ofLists_moveLeft
+#align pgame.of_lists_move_left SetTheory.PGame.ofLists_moveLeft
 -/
 
-#print PGame.ofLists_moveLeft' /-
+#print SetTheory.PGame.ofLists_moveLeft' /-
 @[simp]
-theorem ofLists_moveLeft' {L R : List PGame} (i : (ofLists L R).LeftMoves) :
-    (ofLists L R).moveLeft i =
-      L.nthLe (toOfListsLeftMoves.symm i) (toOfListsLeftMoves.symm i).is_lt :=
+theorem SetTheory.PGame.ofLists_moveLeft' {L R : List SetTheory.PGame}
+    (i : (SetTheory.PGame.ofLists L R).LeftMoves) :
+    (SetTheory.PGame.ofLists L R).moveLeft i =
+      L.nthLe (SetTheory.PGame.toOfListsLeftMoves.symm i)
+        (SetTheory.PGame.toOfListsLeftMoves.symm i).is_lt :=
   rfl
-#align pgame.of_lists_move_left' PGame.ofLists_moveLeft'
+#align pgame.of_lists_move_left' SetTheory.PGame.ofLists_moveLeft'
 -/
 
-#print PGame.ofLists_moveRight /-
-theorem ofLists_moveRight {L R : List PGame} (i : Fin R.length) :
-    (ofLists L R).moveRight (toOfListsRightMoves i) = R.nthLe i i.is_lt :=
+#print SetTheory.PGame.ofLists_moveRight /-
+theorem SetTheory.PGame.ofLists_moveRight {L R : List SetTheory.PGame} (i : Fin R.length) :
+    (SetTheory.PGame.ofLists L R).moveRight (SetTheory.PGame.toOfListsRightMoves i) =
+      R.nthLe i i.is_lt :=
   rfl
-#align pgame.of_lists_move_right PGame.ofLists_moveRight
+#align pgame.of_lists_move_right SetTheory.PGame.ofLists_moveRight
 -/
 
-#print PGame.ofLists_moveRight' /-
+#print SetTheory.PGame.ofLists_moveRight' /-
 @[simp]
-theorem ofLists_moveRight' {L R : List PGame} (i : (ofLists L R).RightMoves) :
-    (ofLists L R).moveRight i =
-      R.nthLe (toOfListsRightMoves.symm i) (toOfListsRightMoves.symm i).is_lt :=
+theorem SetTheory.PGame.ofLists_moveRight' {L R : List SetTheory.PGame}
+    (i : (SetTheory.PGame.ofLists L R).RightMoves) :
+    (SetTheory.PGame.ofLists L R).moveRight i =
+      R.nthLe (SetTheory.PGame.toOfListsRightMoves.symm i)
+        (SetTheory.PGame.toOfListsRightMoves.symm i).is_lt :=
   rfl
-#align pgame.of_lists_move_right' PGame.ofLists_moveRight'
+#align pgame.of_lists_move_right' SetTheory.PGame.ofLists_moveRight'
 -/
 
-#print PGame.moveRecOn /-
+#print SetTheory.PGame.moveRecOn /-
 /-- A variant of `pgame.rec_on` expressed in terms of `pgame.move_left` and `pgame.move_right`.
 
 Both this and `pgame.rec_on` describe Conway induction on games. -/
 @[elab_as_elim]
-def moveRecOn {C : PGame → Sort _} (x : PGame)
-    (IH : ∀ y : PGame, (∀ i, C (y.moveLeft i)) → (∀ j, C (y.moveRight j)) → C y) : C x :=
-  x.recOn fun yl yr yL yR => IH (mk yl yr yL yR)
-#align pgame.move_rec_on PGame.moveRecOn
+def SetTheory.PGame.moveRecOn {C : SetTheory.PGame → Sort _} (x : SetTheory.PGame)
+    (IH : ∀ y : SetTheory.PGame, (∀ i, C (y.moveLeft i)) → (∀ j, C (y.moveRight j)) → C y) : C x :=
+  x.recOn fun yl yr yL yR => IH (SetTheory.PGame.mk yl yr yL yR)
+#align pgame.move_rec_on SetTheory.PGame.moveRecOn
 -/
 
-#print PGame.IsOption /-
+#print SetTheory.PGame.IsOption /-
 /-- `is_option x y` means that `x` is either a left or right option for `y`. -/
 @[mk_iff]
-inductive IsOption : PGame → PGame → Prop
-  | move_left {x : PGame} (i : x.LeftMoves) : is_option (x.moveLeft i) x
-  | move_right {x : PGame} (i : x.RightMoves) : is_option (x.moveRight i) x
-#align pgame.is_option PGame.IsOption
+inductive SetTheory.PGame.IsOption : SetTheory.PGame → SetTheory.PGame → Prop
+  | move_left {x : SetTheory.PGame} (i : x.LeftMoves) : is_option (x.moveLeft i) x
+  | move_right {x : SetTheory.PGame} (i : x.RightMoves) : is_option (x.moveRight i) x
+#align pgame.is_option SetTheory.PGame.IsOption
 -/
 
-#print PGame.IsOption.mk_left /-
-theorem IsOption.mk_left {xl xr : Type u} (xL : xl → PGame) (xR : xr → PGame) (i : xl) :
-    (xL i).IsOption (mk xl xr xL xR) :=
-  @IsOption.moveLeft (mk _ _ _ _) i
-#align pgame.is_option.mk_left PGame.IsOption.mk_left
+#print SetTheory.PGame.IsOption.mk_left /-
+theorem SetTheory.PGame.IsOption.mk_left {xl xr : Type u} (xL : xl → SetTheory.PGame)
+    (xR : xr → SetTheory.PGame) (i : xl) : (xL i).IsOption (SetTheory.PGame.mk xl xr xL xR) :=
+  @SetTheory.PGame.IsOption.moveLeft (SetTheory.PGame.mk _ _ _ _) i
+#align pgame.is_option.mk_left SetTheory.PGame.IsOption.mk_left
 -/
 
-#print PGame.IsOption.mk_right /-
-theorem IsOption.mk_right {xl xr : Type u} (xL : xl → PGame) (xR : xr → PGame) (i : xr) :
-    (xR i).IsOption (mk xl xr xL xR) :=
-  @IsOption.moveRight (mk _ _ _ _) i
-#align pgame.is_option.mk_right PGame.IsOption.mk_right
+#print SetTheory.PGame.IsOption.mk_right /-
+theorem SetTheory.PGame.IsOption.mk_right {xl xr : Type u} (xL : xl → SetTheory.PGame)
+    (xR : xr → SetTheory.PGame) (i : xr) : (xR i).IsOption (SetTheory.PGame.mk xl xr xL xR) :=
+  @SetTheory.PGame.IsOption.moveRight (SetTheory.PGame.mk _ _ _ _) i
+#align pgame.is_option.mk_right SetTheory.PGame.IsOption.mk_right
 -/
 
-#print PGame.wf_isOption /-
-theorem wf_isOption : WellFounded IsOption :=
+#print SetTheory.PGame.wf_isOption /-
+theorem SetTheory.PGame.wf_isOption : WellFounded SetTheory.PGame.IsOption :=
   ⟨fun x =>
-    moveRecOn x fun x IHl IHr =>
+    SetTheory.PGame.moveRecOn x fun x IHl IHr =>
       Acc.intro x fun y h => by
         induction' h with _ i _ j
         · exact IHl i
         · exact IHr j⟩
-#align pgame.wf_is_option PGame.wf_isOption
+#align pgame.wf_is_option SetTheory.PGame.wf_isOption
 -/
 
-#print PGame.Subsequent /-
+#print SetTheory.PGame.Subsequent /-
 /-- `subsequent x y` says that `x` can be obtained by playing some nonempty sequence of moves from
 `y`. It is the transitive closure of `is_option`. -/
-def Subsequent : PGame → PGame → Prop :=
-  TransGen IsOption
-#align pgame.subsequent PGame.Subsequent
+def SetTheory.PGame.Subsequent : SetTheory.PGame → SetTheory.PGame → Prop :=
+  TransGen SetTheory.PGame.IsOption
+#align pgame.subsequent SetTheory.PGame.Subsequent
 -/
 
-instance : IsTrans _ Subsequent :=
+instance : IsTrans _ SetTheory.PGame.Subsequent :=
   TransGen.isTrans
 
-#print PGame.Subsequent.trans /-
+#print SetTheory.PGame.Subsequent.trans /-
 @[trans]
-theorem Subsequent.trans {x y z} : Subsequent x y → Subsequent y z → Subsequent x z :=
+theorem SetTheory.PGame.Subsequent.trans {x y z} :
+    SetTheory.PGame.Subsequent x y →
+      SetTheory.PGame.Subsequent y z → SetTheory.PGame.Subsequent x z :=
   TransGen.trans
-#align pgame.subsequent.trans PGame.Subsequent.trans
+#align pgame.subsequent.trans SetTheory.PGame.Subsequent.trans
 -/
 
-#print PGame.wf_subsequent /-
-theorem wf_subsequent : WellFounded Subsequent :=
-  wf_isOption.TransGen
-#align pgame.wf_subsequent PGame.wf_subsequent
+#print SetTheory.PGame.wf_subsequent /-
+theorem SetTheory.PGame.wf_subsequent : WellFounded SetTheory.PGame.Subsequent :=
+  SetTheory.PGame.wf_isOption.TransGen
+#align pgame.wf_subsequent SetTheory.PGame.wf_subsequent
 -/
 
-instance : WellFoundedRelation PGame :=
-  ⟨_, wf_subsequent⟩
+instance : WellFoundedRelation SetTheory.PGame :=
+  ⟨_, SetTheory.PGame.wf_subsequent⟩
 
-#print PGame.Subsequent.moveLeft /-
-theorem Subsequent.moveLeft {x : PGame} (i : x.LeftMoves) : Subsequent (x.moveLeft i) x :=
-  TransGen.single (IsOption.moveLeft i)
-#align pgame.subsequent.move_left PGame.Subsequent.moveLeft
+#print SetTheory.PGame.Subsequent.moveLeft /-
+theorem SetTheory.PGame.Subsequent.moveLeft {x : SetTheory.PGame} (i : x.LeftMoves) :
+    SetTheory.PGame.Subsequent (x.moveLeft i) x :=
+  TransGen.single (SetTheory.PGame.IsOption.moveLeft i)
+#align pgame.subsequent.move_left SetTheory.PGame.Subsequent.moveLeft
 -/
 
-#print PGame.Subsequent.moveRight /-
-theorem Subsequent.moveRight {x : PGame} (j : x.RightMoves) : Subsequent (x.moveRight j) x :=
-  TransGen.single (IsOption.moveRight j)
-#align pgame.subsequent.move_right PGame.Subsequent.moveRight
+#print SetTheory.PGame.Subsequent.moveRight /-
+theorem SetTheory.PGame.Subsequent.moveRight {x : SetTheory.PGame} (j : x.RightMoves) :
+    SetTheory.PGame.Subsequent (x.moveRight j) x :=
+  TransGen.single (SetTheory.PGame.IsOption.moveRight j)
+#align pgame.subsequent.move_right SetTheory.PGame.Subsequent.moveRight
 -/
 
-#print PGame.Subsequent.mk_left /-
-theorem Subsequent.mk_left {xl xr} (xL : xl → PGame) (xR : xr → PGame) (i : xl) :
-    Subsequent (xL i) (mk xl xr xL xR) :=
-  @Subsequent.moveLeft (mk _ _ _ _) i
-#align pgame.subsequent.mk_left PGame.Subsequent.mk_left
+#print SetTheory.PGame.Subsequent.mk_left /-
+theorem SetTheory.PGame.Subsequent.mk_left {xl xr} (xL : xl → SetTheory.PGame)
+    (xR : xr → SetTheory.PGame) (i : xl) :
+    SetTheory.PGame.Subsequent (xL i) (SetTheory.PGame.mk xl xr xL xR) :=
+  @SetTheory.PGame.Subsequent.moveLeft (SetTheory.PGame.mk _ _ _ _) i
+#align pgame.subsequent.mk_left SetTheory.PGame.Subsequent.mk_left
 -/
 
-#print PGame.Subsequent.mk_right /-
-theorem Subsequent.mk_right {xl xr} (xL : xl → PGame) (xR : xr → PGame) (j : xr) :
-    Subsequent (xR j) (mk xl xr xL xR) :=
-  @Subsequent.moveRight (mk _ _ _ _) j
-#align pgame.subsequent.mk_right PGame.Subsequent.mk_right
+#print SetTheory.PGame.Subsequent.mk_right /-
+theorem SetTheory.PGame.Subsequent.mk_right {xl xr} (xL : xl → SetTheory.PGame)
+    (xR : xr → SetTheory.PGame) (j : xr) :
+    SetTheory.PGame.Subsequent (xR j) (SetTheory.PGame.mk xl xr xL xR) :=
+  @SetTheory.PGame.Subsequent.moveRight (SetTheory.PGame.mk _ _ _ _) j
+#align pgame.subsequent.mk_right SetTheory.PGame.Subsequent.mk_right
 -/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:336:4: warning: unsupported (TODO): `[tacs] -/
@@ -354,73 +375,73 @@ unsafe def pgame_wf_tac :=
 
 
 /-- The pre-game `zero` is defined by `0 = { | }`. -/
-instance : Zero PGame :=
+instance : Zero SetTheory.PGame :=
   ⟨⟨PEmpty, PEmpty, PEmpty.elim, PEmpty.elim⟩⟩
 
-#print PGame.zero_leftMoves /-
+#print SetTheory.PGame.zero_leftMoves /-
 @[simp]
-theorem zero_leftMoves : LeftMoves 0 = PEmpty :=
+theorem SetTheory.PGame.zero_leftMoves : SetTheory.PGame.LeftMoves 0 = PEmpty :=
   rfl
-#align pgame.zero_left_moves PGame.zero_leftMoves
+#align pgame.zero_left_moves SetTheory.PGame.zero_leftMoves
 -/
 
-#print PGame.zero_rightMoves /-
+#print SetTheory.PGame.zero_rightMoves /-
 @[simp]
-theorem zero_rightMoves : RightMoves 0 = PEmpty :=
+theorem SetTheory.PGame.zero_rightMoves : SetTheory.PGame.RightMoves 0 = PEmpty :=
   rfl
-#align pgame.zero_right_moves PGame.zero_rightMoves
+#align pgame.zero_right_moves SetTheory.PGame.zero_rightMoves
 -/
 
-#print PGame.isEmpty_zero_leftMoves /-
-instance isEmpty_zero_leftMoves : IsEmpty (LeftMoves 0) :=
+#print SetTheory.PGame.isEmpty_zero_leftMoves /-
+instance SetTheory.PGame.isEmpty_zero_leftMoves : IsEmpty (SetTheory.PGame.LeftMoves 0) :=
   PEmpty.isEmpty
-#align pgame.is_empty_zero_left_moves PGame.isEmpty_zero_leftMoves
+#align pgame.is_empty_zero_left_moves SetTheory.PGame.isEmpty_zero_leftMoves
 -/
 
-#print PGame.isEmpty_zero_rightMoves /-
-instance isEmpty_zero_rightMoves : IsEmpty (RightMoves 0) :=
+#print SetTheory.PGame.isEmpty_zero_rightMoves /-
+instance SetTheory.PGame.isEmpty_zero_rightMoves : IsEmpty (SetTheory.PGame.RightMoves 0) :=
   PEmpty.isEmpty
-#align pgame.is_empty_zero_right_moves PGame.isEmpty_zero_rightMoves
+#align pgame.is_empty_zero_right_moves SetTheory.PGame.isEmpty_zero_rightMoves
 -/
 
-instance : Inhabited PGame :=
+instance : Inhabited SetTheory.PGame :=
   ⟨0⟩
 
 /-- The pre-game `one` is defined by `1 = { 0 | }`. -/
-instance : One PGame :=
+instance : One SetTheory.PGame :=
   ⟨⟨PUnit, PEmpty, fun _ => 0, PEmpty.elim⟩⟩
 
-#print PGame.one_leftMoves /-
+#print SetTheory.PGame.one_leftMoves /-
 @[simp]
-theorem one_leftMoves : LeftMoves 1 = PUnit :=
+theorem SetTheory.PGame.one_leftMoves : SetTheory.PGame.LeftMoves 1 = PUnit :=
   rfl
-#align pgame.one_left_moves PGame.one_leftMoves
+#align pgame.one_left_moves SetTheory.PGame.one_leftMoves
 -/
 
-#print PGame.one_moveLeft /-
+#print SetTheory.PGame.one_moveLeft /-
 @[simp]
-theorem one_moveLeft (x) : moveLeft 1 x = 0 :=
+theorem SetTheory.PGame.one_moveLeft (x) : SetTheory.PGame.moveLeft 1 x = 0 :=
   rfl
-#align pgame.one_move_left PGame.one_moveLeft
+#align pgame.one_move_left SetTheory.PGame.one_moveLeft
 -/
 
-#print PGame.one_rightMoves /-
+#print SetTheory.PGame.one_rightMoves /-
 @[simp]
-theorem one_rightMoves : RightMoves 1 = PEmpty :=
+theorem SetTheory.PGame.one_rightMoves : SetTheory.PGame.RightMoves 1 = PEmpty :=
   rfl
-#align pgame.one_right_moves PGame.one_rightMoves
+#align pgame.one_right_moves SetTheory.PGame.one_rightMoves
 -/
 
-#print PGame.uniqueOneLeftMoves /-
-instance uniqueOneLeftMoves : Unique (LeftMoves 1) :=
+#print SetTheory.PGame.uniqueOneLeftMoves /-
+instance SetTheory.PGame.uniqueOneLeftMoves : Unique (SetTheory.PGame.LeftMoves 1) :=
   PUnit.unique
-#align pgame.unique_one_left_moves PGame.uniqueOneLeftMoves
+#align pgame.unique_one_left_moves SetTheory.PGame.uniqueOneLeftMoves
 -/
 
-#print PGame.isEmpty_one_rightMoves /-
-instance isEmpty_one_rightMoves : IsEmpty (RightMoves 1) :=
+#print SetTheory.PGame.isEmpty_one_rightMoves /-
+instance SetTheory.PGame.isEmpty_one_rightMoves : IsEmpty (SetTheory.PGame.RightMoves 1) :=
   PEmpty.isEmpty
-#align pgame.is_empty_one_right_moves PGame.isEmpty_one_rightMoves
+#align pgame.is_empty_one_right_moves SetTheory.PGame.isEmpty_one_rightMoves
 -/
 
 /-! ### Pre-game order relations -/
@@ -429,164 +450,178 @@ instance isEmpty_one_rightMoves : IsEmpty (RightMoves 1) :=
 /-- The less or equal relation on pre-games.
 
 If `0 ≤ x`, then Left can win `x` as the second player. -/
-instance : LE PGame :=
-  ⟨Sym2.GameAdd.fix wf_isOption fun x y le =>
-      (∀ i, ¬le y (x.moveLeft i) (Sym2.GameAdd.snd_fst <| IsOption.moveLeft i)) ∧
-        ∀ j, ¬le (y.moveRight j) x (Sym2.GameAdd.fst_snd <| IsOption.moveRight j)⟩
+instance : LE SetTheory.PGame :=
+  ⟨Sym2.GameAdd.fix SetTheory.PGame.wf_isOption fun x y le =>
+      (∀ i, ¬le y (x.moveLeft i) (Sym2.GameAdd.snd_fst <| SetTheory.PGame.IsOption.moveLeft i)) ∧
+        ∀ j, ¬le (y.moveRight j) x (Sym2.GameAdd.fst_snd <| SetTheory.PGame.IsOption.moveRight j)⟩
 
-#print PGame.Lf /-
+#print SetTheory.PGame.Lf /-
 /-- The less or fuzzy relation on pre-games.
 
 If `0 ⧏ x`, then Left can win `x` as the first player. -/
-def Lf (x y : PGame) : Prop :=
+def SetTheory.PGame.Lf (x y : SetTheory.PGame) : Prop :=
   ¬y ≤ x
-#align pgame.lf PGame.Lf
+#align pgame.lf SetTheory.PGame.Lf
 -/
 
-scoped infixl:50 " ⧏ " => PGame.Lf
+scoped infixl:50 " ⧏ " => SetTheory.PGame.Lf
 
-#print PGame.not_le /-
+#print SetTheory.PGame.not_le /-
 @[simp]
-protected theorem not_le {x y : PGame} : ¬x ≤ y ↔ y ⧏ x :=
+protected theorem SetTheory.PGame.not_le {x y : SetTheory.PGame} : ¬x ≤ y ↔ y ⧏ x :=
   Iff.rfl
-#align pgame.not_le PGame.not_le
+#align pgame.not_le SetTheory.PGame.not_le
 -/
 
-#print PGame.not_lf /-
+#print SetTheory.PGame.not_lf /-
 @[simp]
-theorem not_lf {x y : PGame} : ¬x ⧏ y ↔ y ≤ x :=
+theorem SetTheory.PGame.not_lf {x y : SetTheory.PGame} : ¬x ⧏ y ↔ y ≤ x :=
   Classical.not_not
-#align pgame.not_lf PGame.not_lf
+#align pgame.not_lf SetTheory.PGame.not_lf
 -/
 
 #print LE.le.not_gf /-
-theorem LE.le.not_gf {x y : PGame} : x ≤ y → ¬y ⧏ x :=
-  not_lf.2
+theorem LE.le.not_gf {x y : SetTheory.PGame} : x ≤ y → ¬y ⧏ x :=
+  SetTheory.PGame.not_lf.2
 #align has_le.le.not_gf LE.le.not_gf
 -/
 
-#print PGame.Lf.not_ge /-
-theorem Lf.not_ge {x y : PGame} : x ⧏ y → ¬y ≤ x :=
+#print SetTheory.PGame.Lf.not_ge /-
+theorem SetTheory.PGame.Lf.not_ge {x y : SetTheory.PGame} : x ⧏ y → ¬y ≤ x :=
   id
-#align pgame.lf.not_ge PGame.Lf.not_ge
+#align pgame.lf.not_ge SetTheory.PGame.Lf.not_ge
 -/
 
-#print PGame.le_iff_forall_lf /-
+#print SetTheory.PGame.le_iff_forall_lf /-
 /-- Definition of `x ≤ y` on pre-games, in terms of `⧏`.
 
 The ordering here is chosen so that `and.left` refer to moves by Left, and `and.right` refer to
 moves by Right. -/
-theorem le_iff_forall_lf {x y : PGame} : x ≤ y ↔ (∀ i, x.moveLeft i ⧏ y) ∧ ∀ j, x ⧏ y.moveRight j :=
-  by unfold LE.le; rw [Sym2.GameAdd.fix_eq]; rfl
-#align pgame.le_iff_forall_lf PGame.le_iff_forall_lf
+theorem SetTheory.PGame.le_iff_forall_lf {x y : SetTheory.PGame} :
+    x ≤ y ↔ (∀ i, x.moveLeft i ⧏ y) ∧ ∀ j, x ⧏ y.moveRight j := by unfold LE.le;
+  rw [Sym2.GameAdd.fix_eq]; rfl
+#align pgame.le_iff_forall_lf SetTheory.PGame.le_iff_forall_lf
 -/
 
-#print PGame.mk_le_mk /-
+#print SetTheory.PGame.mk_le_mk /-
 /-- Definition of `x ≤ y` on pre-games built using the constructor. -/
 @[simp]
-theorem mk_le_mk {xl xr xL xR yl yr yL yR} :
-    mk xl xr xL xR ≤ mk yl yr yL yR ↔ (∀ i, xL i ⧏ mk yl yr yL yR) ∧ ∀ j, mk xl xr xL xR ⧏ yR j :=
-  le_iff_forall_lf
-#align pgame.mk_le_mk PGame.mk_le_mk
+theorem SetTheory.PGame.mk_le_mk {xl xr xL xR yl yr yL yR} :
+    SetTheory.PGame.mk xl xr xL xR ≤ SetTheory.PGame.mk yl yr yL yR ↔
+      (∀ i, xL i ⧏ SetTheory.PGame.mk yl yr yL yR) ∧ ∀ j, SetTheory.PGame.mk xl xr xL xR ⧏ yR j :=
+  SetTheory.PGame.le_iff_forall_lf
+#align pgame.mk_le_mk SetTheory.PGame.mk_le_mk
 -/
 
-#print PGame.le_of_forall_lf /-
-theorem le_of_forall_lf {x y : PGame} (h₁ : ∀ i, x.moveLeft i ⧏ y) (h₂ : ∀ j, x ⧏ y.moveRight j) :
-    x ≤ y :=
-  le_iff_forall_lf.2 ⟨h₁, h₂⟩
-#align pgame.le_of_forall_lf PGame.le_of_forall_lf
+#print SetTheory.PGame.le_of_forall_lf /-
+theorem SetTheory.PGame.le_of_forall_lf {x y : SetTheory.PGame} (h₁ : ∀ i, x.moveLeft i ⧏ y)
+    (h₂ : ∀ j, x ⧏ y.moveRight j) : x ≤ y :=
+  SetTheory.PGame.le_iff_forall_lf.2 ⟨h₁, h₂⟩
+#align pgame.le_of_forall_lf SetTheory.PGame.le_of_forall_lf
 -/
 
-#print PGame.lf_iff_exists_le /-
+#print SetTheory.PGame.lf_iff_exists_le /-
 /-- Definition of `x ⧏ y` on pre-games, in terms of `≤`.
 
 The ordering here is chosen so that `or.inl` refer to moves by Left, and `or.inr` refer to
 moves by Right. -/
-theorem lf_iff_exists_le {x y : PGame} : x ⧏ y ↔ (∃ i, x ≤ y.moveLeft i) ∨ ∃ j, x.moveRight j ≤ y :=
-  by rw [lf, le_iff_forall_lf, not_and_or]; simp
-#align pgame.lf_iff_exists_le PGame.lf_iff_exists_le
+theorem SetTheory.PGame.lf_iff_exists_le {x y : SetTheory.PGame} :
+    x ⧏ y ↔ (∃ i, x ≤ y.moveLeft i) ∨ ∃ j, x.moveRight j ≤ y := by
+  rw [lf, le_iff_forall_lf, not_and_or]; simp
+#align pgame.lf_iff_exists_le SetTheory.PGame.lf_iff_exists_le
 -/
 
-#print PGame.mk_lf_mk /-
+#print SetTheory.PGame.mk_lf_mk /-
 /-- Definition of `x ⧏ y` on pre-games built using the constructor. -/
 @[simp]
-theorem mk_lf_mk {xl xr xL xR yl yr yL yR} :
-    mk xl xr xL xR ⧏ mk yl yr yL yR ↔ (∃ i, mk xl xr xL xR ≤ yL i) ∨ ∃ j, xR j ≤ mk yl yr yL yR :=
-  lf_iff_exists_le
-#align pgame.mk_lf_mk PGame.mk_lf_mk
+theorem SetTheory.PGame.mk_lf_mk {xl xr xL xR yl yr yL yR} :
+    SetTheory.PGame.mk xl xr xL xR ⧏ SetTheory.PGame.mk yl yr yL yR ↔
+      (∃ i, SetTheory.PGame.mk xl xr xL xR ≤ yL i) ∨ ∃ j, xR j ≤ SetTheory.PGame.mk yl yr yL yR :=
+  SetTheory.PGame.lf_iff_exists_le
+#align pgame.mk_lf_mk SetTheory.PGame.mk_lf_mk
 -/
 
-#print PGame.le_or_gf /-
-theorem le_or_gf (x y : PGame) : x ≤ y ∨ y ⧏ x := by rw [← PGame.not_le]; apply em
-#align pgame.le_or_gf PGame.le_or_gf
+#print SetTheory.PGame.le_or_gf /-
+theorem SetTheory.PGame.le_or_gf (x y : SetTheory.PGame) : x ≤ y ∨ y ⧏ x := by
+  rw [← SetTheory.PGame.not_le]; apply em
+#align pgame.le_or_gf SetTheory.PGame.le_or_gf
 -/
 
-#print PGame.moveLeft_lf_of_le /-
-theorem moveLeft_lf_of_le {x y : PGame} (h : x ≤ y) (i) : x.moveLeft i ⧏ y :=
-  (le_iff_forall_lf.1 h).1 i
-#align pgame.move_left_lf_of_le PGame.moveLeft_lf_of_le
+#print SetTheory.PGame.moveLeft_lf_of_le /-
+theorem SetTheory.PGame.moveLeft_lf_of_le {x y : SetTheory.PGame} (h : x ≤ y) (i) :
+    x.moveLeft i ⧏ y :=
+  (SetTheory.PGame.le_iff_forall_lf.1 h).1 i
+#align pgame.move_left_lf_of_le SetTheory.PGame.moveLeft_lf_of_le
 -/
 
 alias _root_.has_le.le.move_left_lf := move_left_lf_of_le
 #align has_le.le.move_left_lf LE.le.moveLeft_lf
 
-#print PGame.lf_moveRight_of_le /-
-theorem lf_moveRight_of_le {x y : PGame} (h : x ≤ y) (j) : x ⧏ y.moveRight j :=
-  (le_iff_forall_lf.1 h).2 j
-#align pgame.lf_move_right_of_le PGame.lf_moveRight_of_le
+#print SetTheory.PGame.lf_moveRight_of_le /-
+theorem SetTheory.PGame.lf_moveRight_of_le {x y : SetTheory.PGame} (h : x ≤ y) (j) :
+    x ⧏ y.moveRight j :=
+  (SetTheory.PGame.le_iff_forall_lf.1 h).2 j
+#align pgame.lf_move_right_of_le SetTheory.PGame.lf_moveRight_of_le
 -/
 
 alias _root_.has_le.le.lf_move_right := lf_move_right_of_le
 #align has_le.le.lf_move_right LE.le.lf_moveRight
 
-#print PGame.lf_of_moveRight_le /-
-theorem lf_of_moveRight_le {x y : PGame} {j} (h : x.moveRight j ≤ y) : x ⧏ y :=
-  lf_iff_exists_le.2 <| Or.inr ⟨j, h⟩
-#align pgame.lf_of_move_right_le PGame.lf_of_moveRight_le
+#print SetTheory.PGame.lf_of_moveRight_le /-
+theorem SetTheory.PGame.lf_of_moveRight_le {x y : SetTheory.PGame} {j} (h : x.moveRight j ≤ y) :
+    x ⧏ y :=
+  SetTheory.PGame.lf_iff_exists_le.2 <| Or.inr ⟨j, h⟩
+#align pgame.lf_of_move_right_le SetTheory.PGame.lf_of_moveRight_le
 -/
 
-#print PGame.lf_of_le_moveLeft /-
-theorem lf_of_le_moveLeft {x y : PGame} {i} (h : x ≤ y.moveLeft i) : x ⧏ y :=
-  lf_iff_exists_le.2 <| Or.inl ⟨i, h⟩
-#align pgame.lf_of_le_move_left PGame.lf_of_le_moveLeft
+#print SetTheory.PGame.lf_of_le_moveLeft /-
+theorem SetTheory.PGame.lf_of_le_moveLeft {x y : SetTheory.PGame} {i} (h : x ≤ y.moveLeft i) :
+    x ⧏ y :=
+  SetTheory.PGame.lf_iff_exists_le.2 <| Or.inl ⟨i, h⟩
+#align pgame.lf_of_le_move_left SetTheory.PGame.lf_of_le_moveLeft
 -/
 
-#print PGame.lf_of_le_mk /-
-theorem lf_of_le_mk {xl xr xL xR y} : mk xl xr xL xR ≤ y → ∀ i, xL i ⧏ y :=
-  moveLeft_lf_of_le
-#align pgame.lf_of_le_mk PGame.lf_of_le_mk
+#print SetTheory.PGame.lf_of_le_mk /-
+theorem SetTheory.PGame.lf_of_le_mk {xl xr xL xR y} :
+    SetTheory.PGame.mk xl xr xL xR ≤ y → ∀ i, xL i ⧏ y :=
+  SetTheory.PGame.moveLeft_lf_of_le
+#align pgame.lf_of_le_mk SetTheory.PGame.lf_of_le_mk
 -/
 
-#print PGame.lf_of_mk_le /-
-theorem lf_of_mk_le {x yl yr yL yR} : x ≤ mk yl yr yL yR → ∀ j, x ⧏ yR j :=
-  lf_moveRight_of_le
-#align pgame.lf_of_mk_le PGame.lf_of_mk_le
+#print SetTheory.PGame.lf_of_mk_le /-
+theorem SetTheory.PGame.lf_of_mk_le {x yl yr yL yR} :
+    x ≤ SetTheory.PGame.mk yl yr yL yR → ∀ j, x ⧏ yR j :=
+  SetTheory.PGame.lf_moveRight_of_le
+#align pgame.lf_of_mk_le SetTheory.PGame.lf_of_mk_le
 -/
 
-#print PGame.mk_lf_of_le /-
-theorem mk_lf_of_le {xl xr y j} (xL) {xR : xr → PGame} : xR j ≤ y → mk xl xr xL xR ⧏ y :=
-  @lf_of_moveRight_le (mk _ _ _ _) y j
-#align pgame.mk_lf_of_le PGame.mk_lf_of_le
+#print SetTheory.PGame.mk_lf_of_le /-
+theorem SetTheory.PGame.mk_lf_of_le {xl xr y j} (xL) {xR : xr → SetTheory.PGame} :
+    xR j ≤ y → SetTheory.PGame.mk xl xr xL xR ⧏ y :=
+  @SetTheory.PGame.lf_of_moveRight_le (SetTheory.PGame.mk _ _ _ _) y j
+#align pgame.mk_lf_of_le SetTheory.PGame.mk_lf_of_le
 -/
 
-#print PGame.lf_mk_of_le /-
-theorem lf_mk_of_le {x yl yr} {yL : yl → PGame} (yR) {i} : x ≤ yL i → x ⧏ mk yl yr yL yR :=
-  @lf_of_le_moveLeft x (mk _ _ _ _) i
-#align pgame.lf_mk_of_le PGame.lf_mk_of_le
+#print SetTheory.PGame.lf_mk_of_le /-
+theorem SetTheory.PGame.lf_mk_of_le {x yl yr} {yL : yl → SetTheory.PGame} (yR) {i} :
+    x ≤ yL i → x ⧏ SetTheory.PGame.mk yl yr yL yR :=
+  @SetTheory.PGame.lf_of_le_moveLeft x (SetTheory.PGame.mk _ _ _ _) i
+#align pgame.lf_mk_of_le SetTheory.PGame.lf_mk_of_le
 -/
 
 /- We prove that `x ≤ y → y ≤ z ← x ≤ z` inductively, by also simultaneously proving its cyclic
 reorderings. This auxiliary lemma is used during said induction. -/
-private theorem le_trans_aux {x y z : PGame}
+private theorem le_trans_aux {x y z : SetTheory.PGame}
     (h₁ : ∀ {i}, y ≤ z → z ≤ x.moveLeft i → y ≤ x.moveLeft i)
     (h₂ : ∀ {j}, z.moveRight j ≤ x → x ≤ y → z.moveRight j ≤ y) (hxy : x ≤ y) (hyz : y ≤ z) :
     x ≤ z :=
-  le_of_forall_lf (fun i => PGame.not_le.1 fun h => (h₁ hyz h).not_gf <| hxy.moveLeft_lf i) fun j =>
-    PGame.not_le.1 fun h => (h₂ h hxy).not_gf <| hyz.lf_moveRight j
+  SetTheory.PGame.le_of_forall_lf
+    (fun i => SetTheory.PGame.not_le.1 fun h => (h₁ hyz h).not_gf <| hxy.moveLeft_lf i) fun j =>
+    SetTheory.PGame.not_le.1 fun h => (h₂ h hxy).not_gf <| hyz.lf_moveRight j
 
-instance : Preorder PGame :=
+instance : Preorder SetTheory.PGame :=
   {
-    PGame.hasLe with
+    SetTheory.PGame.hasLe with
     le_refl := fun x => by
       induction' x with _ _ _ _ IHl IHr
       exact
@@ -594,7 +629,7 @@ instance : Preorder PGame :=
     le_trans :=
       by
       suffices :
-        ∀ {x y z : PGame},
+        ∀ {x y z : SetTheory.PGame},
           (x ≤ y → y ≤ z → x ≤ z) ∧ (y ≤ z → z ≤ x → y ≤ x) ∧ (z ≤ x → x ≤ y → z ≤ y)
       exact fun x y z => this.1
       intro x y z
@@ -607,112 +642,116 @@ instance : Preorder PGame :=
           le_trans_aux (fun i => (IHzl i).1) fun j => (IHyr j).2.1⟩
     lt := fun x y => x ≤ y ∧ x ⧏ y }
 
-#print PGame.lt_iff_le_and_lf /-
-theorem lt_iff_le_and_lf {x y : PGame} : x < y ↔ x ≤ y ∧ x ⧏ y :=
+#print SetTheory.PGame.lt_iff_le_and_lf /-
+theorem SetTheory.PGame.lt_iff_le_and_lf {x y : SetTheory.PGame} : x < y ↔ x ≤ y ∧ x ⧏ y :=
   Iff.rfl
-#align pgame.lt_iff_le_and_lf PGame.lt_iff_le_and_lf
+#align pgame.lt_iff_le_and_lf SetTheory.PGame.lt_iff_le_and_lf
 -/
 
-#print PGame.lt_of_le_of_lf /-
-theorem lt_of_le_of_lf {x y : PGame} (h₁ : x ≤ y) (h₂ : x ⧏ y) : x < y :=
+#print SetTheory.PGame.lt_of_le_of_lf /-
+theorem SetTheory.PGame.lt_of_le_of_lf {x y : SetTheory.PGame} (h₁ : x ≤ y) (h₂ : x ⧏ y) : x < y :=
   ⟨h₁, h₂⟩
-#align pgame.lt_of_le_of_lf PGame.lt_of_le_of_lf
+#align pgame.lt_of_le_of_lf SetTheory.PGame.lt_of_le_of_lf
 -/
 
-#print PGame.lf_of_lt /-
-theorem lf_of_lt {x y : PGame} (h : x < y) : x ⧏ y :=
+#print SetTheory.PGame.lf_of_lt /-
+theorem SetTheory.PGame.lf_of_lt {x y : SetTheory.PGame} (h : x < y) : x ⧏ y :=
   h.2
-#align pgame.lf_of_lt PGame.lf_of_lt
+#align pgame.lf_of_lt SetTheory.PGame.lf_of_lt
 -/
 
 alias _root_.has_lt.lt.lf := lf_of_lt
 #align has_lt.lt.lf LT.lt.lf
 
-#print PGame.lf_irrefl /-
-theorem lf_irrefl (x : PGame) : ¬x ⧏ x :=
+#print SetTheory.PGame.lf_irrefl /-
+theorem SetTheory.PGame.lf_irrefl (x : SetTheory.PGame) : ¬x ⧏ x :=
   le_rfl.not_gf
-#align pgame.lf_irrefl PGame.lf_irrefl
+#align pgame.lf_irrefl SetTheory.PGame.lf_irrefl
 -/
 
 instance : IsIrrefl _ (· ⧏ ·) :=
-  ⟨lf_irrefl⟩
+  ⟨SetTheory.PGame.lf_irrefl⟩
 
-#print PGame.lf_of_le_of_lf /-
+#print SetTheory.PGame.lf_of_le_of_lf /-
 @[trans]
-theorem lf_of_le_of_lf {x y z : PGame} (h₁ : x ≤ y) (h₂ : y ⧏ z) : x ⧏ z := by
-  rw [← PGame.not_le] at h₂ ⊢; exact fun h₃ => h₂ (h₃.trans h₁)
-#align pgame.lf_of_le_of_lf PGame.lf_of_le_of_lf
+theorem SetTheory.PGame.lf_of_le_of_lf {x y z : SetTheory.PGame} (h₁ : x ≤ y) (h₂ : y ⧏ z) :
+    x ⧏ z := by rw [← SetTheory.PGame.not_le] at h₂ ⊢; exact fun h₃ => h₂ (h₃.trans h₁)
+#align pgame.lf_of_le_of_lf SetTheory.PGame.lf_of_le_of_lf
 -/
 
-#print PGame.lf_of_lf_of_le /-
+#print SetTheory.PGame.lf_of_lf_of_le /-
 @[trans]
-theorem lf_of_lf_of_le {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y ≤ z) : x ⧏ z := by
-  rw [← PGame.not_le] at h₁ ⊢; exact fun h₃ => h₁ (h₂.trans h₃)
-#align pgame.lf_of_lf_of_le PGame.lf_of_lf_of_le
+theorem SetTheory.PGame.lf_of_lf_of_le {x y z : SetTheory.PGame} (h₁ : x ⧏ y) (h₂ : y ≤ z) :
+    x ⧏ z := by rw [← SetTheory.PGame.not_le] at h₁ ⊢; exact fun h₃ => h₁ (h₂.trans h₃)
+#align pgame.lf_of_lf_of_le SetTheory.PGame.lf_of_lf_of_le
 -/
 
 alias _root_.has_le.le.trans_lf := lf_of_le_of_lf
 #align has_le.le.trans_lf LE.le.trans_lf
 
 alias lf.trans_le := lf_of_lf_of_le
-#align pgame.lf.trans_le PGame.Lf.trans_le
+#align pgame.lf.trans_le SetTheory.PGame.Lf.trans_le
 
-#print PGame.lf_of_lt_of_lf /-
+#print SetTheory.PGame.lf_of_lt_of_lf /-
 @[trans]
-theorem lf_of_lt_of_lf {x y z : PGame} (h₁ : x < y) (h₂ : y ⧏ z) : x ⧏ z :=
+theorem SetTheory.PGame.lf_of_lt_of_lf {x y z : SetTheory.PGame} (h₁ : x < y) (h₂ : y ⧏ z) :
+    x ⧏ z :=
   h₁.le.trans_lf h₂
-#align pgame.lf_of_lt_of_lf PGame.lf_of_lt_of_lf
+#align pgame.lf_of_lt_of_lf SetTheory.PGame.lf_of_lt_of_lf
 -/
 
-#print PGame.lf_of_lf_of_lt /-
+#print SetTheory.PGame.lf_of_lf_of_lt /-
 @[trans]
-theorem lf_of_lf_of_lt {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y < z) : x ⧏ z :=
+theorem SetTheory.PGame.lf_of_lf_of_lt {x y z : SetTheory.PGame} (h₁ : x ⧏ y) (h₂ : y < z) :
+    x ⧏ z :=
   h₁.trans_le h₂.le
-#align pgame.lf_of_lf_of_lt PGame.lf_of_lf_of_lt
+#align pgame.lf_of_lf_of_lt SetTheory.PGame.lf_of_lf_of_lt
 -/
 
 alias _root_.has_lt.lt.trans_lf := lf_of_lt_of_lf
 #align has_lt.lt.trans_lf LT.lt.trans_lf
 
 alias lf.trans_lt := lf_of_lf_of_lt
-#align pgame.lf.trans_lt PGame.Lf.trans_lt
+#align pgame.lf.trans_lt SetTheory.PGame.Lf.trans_lt
 
-#print PGame.moveLeft_lf /-
-theorem moveLeft_lf {x : PGame} : ∀ i, x.moveLeft i ⧏ x :=
+#print SetTheory.PGame.moveLeft_lf /-
+theorem SetTheory.PGame.moveLeft_lf {x : SetTheory.PGame} : ∀ i, x.moveLeft i ⧏ x :=
   le_rfl.moveLeft_lf
-#align pgame.move_left_lf PGame.moveLeft_lf
+#align pgame.move_left_lf SetTheory.PGame.moveLeft_lf
 -/
 
-#print PGame.lf_moveRight /-
-theorem lf_moveRight {x : PGame} : ∀ j, x ⧏ x.moveRight j :=
+#print SetTheory.PGame.lf_moveRight /-
+theorem SetTheory.PGame.lf_moveRight {x : SetTheory.PGame} : ∀ j, x ⧏ x.moveRight j :=
   le_rfl.lf_moveRight
-#align pgame.lf_move_right PGame.lf_moveRight
+#align pgame.lf_move_right SetTheory.PGame.lf_moveRight
 -/
 
-#print PGame.lf_mk /-
-theorem lf_mk {xl xr} (xL : xl → PGame) (xR : xr → PGame) (i) : xL i ⧏ mk xl xr xL xR :=
-  @moveLeft_lf (mk _ _ _ _) i
-#align pgame.lf_mk PGame.lf_mk
+#print SetTheory.PGame.lf_mk /-
+theorem SetTheory.PGame.lf_mk {xl xr} (xL : xl → SetTheory.PGame) (xR : xr → SetTheory.PGame) (i) :
+    xL i ⧏ SetTheory.PGame.mk xl xr xL xR :=
+  @SetTheory.PGame.moveLeft_lf (SetTheory.PGame.mk _ _ _ _) i
+#align pgame.lf_mk SetTheory.PGame.lf_mk
 -/
 
-#print PGame.mk_lf /-
-theorem mk_lf {xl xr} (xL : xl → PGame) (xR : xr → PGame) (j) : mk xl xr xL xR ⧏ xR j :=
-  @lf_moveRight (mk _ _ _ _) j
-#align pgame.mk_lf PGame.mk_lf
+#print SetTheory.PGame.mk_lf /-
+theorem SetTheory.PGame.mk_lf {xl xr} (xL : xl → SetTheory.PGame) (xR : xr → SetTheory.PGame) (j) :
+    SetTheory.PGame.mk xl xr xL xR ⧏ xR j :=
+  @SetTheory.PGame.lf_moveRight (SetTheory.PGame.mk _ _ _ _) j
+#align pgame.mk_lf SetTheory.PGame.mk_lf
 -/
 
-#print PGame.le_of_forall_lt /-
+#print SetTheory.PGame.le_of_forall_lt /-
 /-- This special case of `pgame.le_of_forall_lf` is useful when dealing with surreals, where `<` is
 preferred over `⧏`. -/
-theorem le_of_forall_lt {x y : PGame} (h₁ : ∀ i, x.moveLeft i < y) (h₂ : ∀ j, x < y.moveRight j) :
-    x ≤ y :=
-  le_of_forall_lf (fun i => (h₁ i).Lf) fun i => (h₂ i).Lf
-#align pgame.le_of_forall_lt PGame.le_of_forall_lt
+theorem SetTheory.PGame.le_of_forall_lt {x y : SetTheory.PGame} (h₁ : ∀ i, x.moveLeft i < y)
+    (h₂ : ∀ j, x < y.moveRight j) : x ≤ y :=
+  SetTheory.PGame.le_of_forall_lf (fun i => (h₁ i).Lf) fun i => (h₂ i).Lf
+#align pgame.le_of_forall_lt SetTheory.PGame.le_of_forall_lt
 -/
 
-#print PGame.le_def /-
+#print SetTheory.PGame.le_def /-
 /-- The definition of `x ≤ y` on pre-games, in terms of `≤` two moves later. -/
-theorem le_def {x y : PGame} :
+theorem SetTheory.PGame.le_def {x y : SetTheory.PGame} :
     x ≤ y ↔
       (∀ i, (∃ i', x.moveLeft i ≤ y.moveLeft i') ∨ ∃ j, (x.moveLeft i).moveRight j ≤ y) ∧
         ∀ j, (∃ i, x ≤ (y.moveRight j).moveLeft i) ∨ ∃ j', x.moveRight j' ≤ y.moveRight j :=
@@ -720,12 +759,12 @@ theorem le_def {x y : PGame} :
   conv =>
     lhs
     simp only [lf_iff_exists_le]
-#align pgame.le_def PGame.le_def
+#align pgame.le_def SetTheory.PGame.le_def
 -/
 
-#print PGame.lf_def /-
+#print SetTheory.PGame.lf_def /-
 /-- The definition of `x ⧏ y` on pre-games, in terms of `⧏` two moves later. -/
-theorem lf_def {x y : PGame} :
+theorem SetTheory.PGame.lf_def {x y : SetTheory.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' :=
@@ -733,809 +772,847 @@ theorem lf_def {x y : PGame} :
   conv =>
     lhs
     simp only [le_iff_forall_lf]
-#align pgame.lf_def PGame.lf_def
+#align pgame.lf_def SetTheory.PGame.lf_def
 -/
 
-#print PGame.zero_le_lf /-
+#print SetTheory.PGame.zero_le_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]; simp
-#align pgame.zero_le_lf PGame.zero_le_lf
+theorem SetTheory.PGame.zero_le_lf {x : SetTheory.PGame} : 0 ≤ x ↔ ∀ j, 0 ⧏ x.moveRight j := by
+  rw [le_iff_forall_lf]; simp
+#align pgame.zero_le_lf SetTheory.PGame.zero_le_lf
 -/
 
-#print PGame.le_zero_lf /-
+#print SetTheory.PGame.le_zero_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]; simp
-#align pgame.le_zero_lf PGame.le_zero_lf
+theorem SetTheory.PGame.le_zero_lf {x : SetTheory.PGame} : x ≤ 0 ↔ ∀ i, x.moveLeft i ⧏ 0 := by
+  rw [le_iff_forall_lf]; simp
+#align pgame.le_zero_lf SetTheory.PGame.le_zero_lf
 -/
 
-#print PGame.zero_lf_le /-
+#print SetTheory.PGame.zero_lf_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]; simp
-#align pgame.zero_lf_le PGame.zero_lf_le
+theorem SetTheory.PGame.zero_lf_le {x : SetTheory.PGame} : 0 ⧏ x ↔ ∃ i, 0 ≤ x.moveLeft i := by
+  rw [lf_iff_exists_le]; simp
+#align pgame.zero_lf_le SetTheory.PGame.zero_lf_le
 -/
 
-#print PGame.lf_zero_le /-
+#print SetTheory.PGame.lf_zero_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]; simp
-#align pgame.lf_zero_le PGame.lf_zero_le
+theorem SetTheory.PGame.lf_zero_le {x : SetTheory.PGame} : x ⧏ 0 ↔ ∃ j, x.moveRight j ≤ 0 := by
+  rw [lf_iff_exists_le]; simp
+#align pgame.lf_zero_le SetTheory.PGame.lf_zero_le
 -/
 
-#print PGame.zero_le /-
+#print SetTheory.PGame.zero_le /-
 /-- 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];
-  simp
-#align pgame.zero_le PGame.zero_le
+theorem SetTheory.PGame.zero_le {x : SetTheory.PGame} :
+    0 ≤ x ↔ ∀ j, ∃ i, 0 ≤ (x.moveRight j).moveLeft i := by rw [le_def]; simp
+#align pgame.zero_le SetTheory.PGame.zero_le
 -/
 
-#print PGame.le_zero /-
+#print SetTheory.PGame.le_zero /-
 /-- 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];
-  simp
-#align pgame.le_zero PGame.le_zero
+theorem SetTheory.PGame.le_zero {x : SetTheory.PGame} :
+    x ≤ 0 ↔ ∀ i, ∃ j, (x.moveLeft i).moveRight j ≤ 0 := by rw [le_def]; simp
+#align pgame.le_zero SetTheory.PGame.le_zero
 -/
 
-#print PGame.zero_lf /-
+#print SetTheory.PGame.zero_lf /-
 /-- 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];
-  simp
-#align pgame.zero_lf PGame.zero_lf
+theorem SetTheory.PGame.zero_lf {x : SetTheory.PGame} :
+    0 ⧏ x ↔ ∃ i, ∀ j, 0 ⧏ (x.moveLeft i).moveRight j := by rw [lf_def]; simp
+#align pgame.zero_lf SetTheory.PGame.zero_lf
 -/
 
-#print PGame.lf_zero /-
+#print SetTheory.PGame.lf_zero /-
 /-- 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];
-  simp
-#align pgame.lf_zero PGame.lf_zero
+theorem SetTheory.PGame.lf_zero {x : SetTheory.PGame} :
+    x ⧏ 0 ↔ ∃ j, ∀ i, (x.moveRight j).moveLeft i ⧏ 0 := by rw [lf_def]; simp
+#align pgame.lf_zero SetTheory.PGame.lf_zero
 -/
 
-#print PGame.zero_le_of_isEmpty_rightMoves /-
+#print SetTheory.PGame.zero_le_of_isEmpty_rightMoves /-
 @[simp]
-theorem zero_le_of_isEmpty_rightMoves (x : PGame) [IsEmpty x.RightMoves] : 0 ≤ x :=
-  zero_le.2 isEmptyElim
-#align pgame.zero_le_of_is_empty_right_moves PGame.zero_le_of_isEmpty_rightMoves
+theorem SetTheory.PGame.zero_le_of_isEmpty_rightMoves (x : SetTheory.PGame) [IsEmpty x.RightMoves] :
+    0 ≤ x :=
+  SetTheory.PGame.zero_le.2 isEmptyElim
+#align pgame.zero_le_of_is_empty_right_moves SetTheory.PGame.zero_le_of_isEmpty_rightMoves
 -/
 
-#print PGame.le_zero_of_isEmpty_leftMoves /-
+#print SetTheory.PGame.le_zero_of_isEmpty_leftMoves /-
 @[simp]
-theorem le_zero_of_isEmpty_leftMoves (x : PGame) [IsEmpty x.LeftMoves] : x ≤ 0 :=
-  le_zero.2 isEmptyElim
-#align pgame.le_zero_of_is_empty_left_moves PGame.le_zero_of_isEmpty_leftMoves
+theorem SetTheory.PGame.le_zero_of_isEmpty_leftMoves (x : SetTheory.PGame) [IsEmpty x.LeftMoves] :
+    x ≤ 0 :=
+  SetTheory.PGame.le_zero.2 isEmptyElim
+#align pgame.le_zero_of_is_empty_left_moves SetTheory.PGame.le_zero_of_isEmpty_leftMoves
 -/
 
-#print PGame.rightResponse /-
+#print SetTheory.PGame.rightResponse /-
 /-- Given a game won by the right player when they play second, provide a response to any move by
 left. -/
-noncomputable def rightResponse {x : PGame} (h : x ≤ 0) (i : x.LeftMoves) :
-    (x.moveLeft i).RightMoves :=
-  Classical.choose <| (le_zero.1 h) i
-#align pgame.right_response PGame.rightResponse
+noncomputable def SetTheory.PGame.rightResponse {x : SetTheory.PGame} (h : x ≤ 0)
+    (i : x.LeftMoves) : (x.moveLeft i).RightMoves :=
+  Classical.choose <| (SetTheory.PGame.le_zero.1 h) i
+#align pgame.right_response SetTheory.PGame.rightResponse
 -/
 
-#print PGame.rightResponse_spec /-
+#print SetTheory.PGame.rightResponse_spec /-
 /-- Show that the response for right provided by `right_response` preserves the right-player-wins
 condition. -/
-theorem rightResponse_spec {x : PGame} (h : x ≤ 0) (i : x.LeftMoves) :
-    (x.moveLeft i).moveRight (rightResponse h i) ≤ 0 :=
-  Classical.choose_spec <| (le_zero.1 h) i
-#align pgame.right_response_spec PGame.rightResponse_spec
+theorem SetTheory.PGame.rightResponse_spec {x : SetTheory.PGame} (h : x ≤ 0) (i : x.LeftMoves) :
+    (x.moveLeft i).moveRight (SetTheory.PGame.rightResponse h i) ≤ 0 :=
+  Classical.choose_spec <| (SetTheory.PGame.le_zero.1 h) i
+#align pgame.right_response_spec SetTheory.PGame.rightResponse_spec
 -/
 
-#print PGame.leftResponse /-
+#print SetTheory.PGame.leftResponse /-
 /-- Given a game won by the left player when they play second, provide a response to any move by
 right. -/
-noncomputable def leftResponse {x : PGame} (h : 0 ≤ x) (j : x.RightMoves) :
-    (x.moveRight j).LeftMoves :=
-  Classical.choose <| (zero_le.1 h) j
-#align pgame.left_response PGame.leftResponse
+noncomputable def SetTheory.PGame.leftResponse {x : SetTheory.PGame} (h : 0 ≤ x)
+    (j : x.RightMoves) : (x.moveRight j).LeftMoves :=
+  Classical.choose <| (SetTheory.PGame.zero_le.1 h) j
+#align pgame.left_response SetTheory.PGame.leftResponse
 -/
 
-#print PGame.leftResponse_spec /-
+#print SetTheory.PGame.leftResponse_spec /-
 /-- Show that the response for left provided by `left_response` preserves the left-player-wins
 condition. -/
-theorem leftResponse_spec {x : PGame} (h : 0 ≤ x) (j : x.RightMoves) :
-    0 ≤ (x.moveRight j).moveLeft (leftResponse h j) :=
-  Classical.choose_spec <| (zero_le.1 h) j
-#align pgame.left_response_spec PGame.leftResponse_spec
+theorem SetTheory.PGame.leftResponse_spec {x : SetTheory.PGame} (h : 0 ≤ x) (j : x.RightMoves) :
+    0 ≤ (x.moveRight j).moveLeft (SetTheory.PGame.leftResponse h j) :=
+  Classical.choose_spec <| (SetTheory.PGame.zero_le.1 h) j
+#align pgame.left_response_spec SetTheory.PGame.leftResponse_spec
 -/
 
 /-- An explicit upper bound for a family of pre-games, whose left moves are the union of the left
 moves of all the pre-games in the family. -/
-def upperBound {ι : Type u} (f : ι → PGame.{u}) : PGame :=
-  ⟨Σ i, (f i).LeftMoves, PEmpty, fun x => moveLeft _ x.2, PEmpty.elim⟩
-#align pgame.upper_bound PGame.upperBound
+def SetTheory.PGame.upperBound {ι : Type u} (f : ι → SetTheory.PGame.{u}) : SetTheory.PGame :=
+  ⟨Σ i, (f i).LeftMoves, PEmpty, fun x => SetTheory.PGame.moveLeft _ x.2, PEmpty.elim⟩
+#align pgame.upper_bound SetTheory.PGame.upperBound
 
-instance upperBound_rightMoves_empty {ι : Type u} (f : ι → PGame.{u}) :
-    IsEmpty (upperBound f).RightMoves :=
+instance SetTheory.PGame.upperBound_rightMoves_empty {ι : Type u} (f : ι → SetTheory.PGame.{u}) :
+    IsEmpty (SetTheory.PGame.upperBound f).RightMoves :=
   PEmpty.isEmpty
-#align pgame.upper_bound_right_moves_empty PGame.upperBound_rightMoves_empty
+#align pgame.upper_bound_right_moves_empty SetTheory.PGame.upperBound_rightMoves_empty
 
-theorem le_upperBound {ι : Type u} (f : ι → PGame.{u}) (i : ι) : f i ≤ upperBound f :=
+theorem SetTheory.PGame.le_upperBound {ι : Type u} (f : ι → SetTheory.PGame.{u}) (i : ι) :
+    f i ≤ SetTheory.PGame.upperBound f :=
   by
   rw [upper_bound, le_iff_forall_lf]
   dsimp
   simp only [and_true_iff, IsEmpty.forall_iff]
   exact fun j => @move_left_lf (upper_bound f) ⟨i, j⟩
-#align pgame.le_upper_bound PGame.le_upperBound
+#align pgame.le_upper_bound SetTheory.PGame.le_upperBound
 
-theorem upperBound_mem_upperBounds (s : Set PGame.{u}) [Small.{u} s] :
-    upperBound (Subtype.val ∘ (equivShrink s).symm) ∈ upperBounds s := fun i hi => by
-  simpa using le_upper_bound (Subtype.val ∘ (equivShrink s).symm) (equivShrink s ⟨i, hi⟩)
-#align pgame.upper_bound_mem_upper_bounds PGame.upperBound_mem_upperBounds
+theorem SetTheory.PGame.upperBound_mem_upperBounds (s : Set SetTheory.PGame.{u}) [Small.{u} s] :
+    SetTheory.PGame.upperBound (Subtype.val ∘ (equivShrink s).symm) ∈ upperBounds s := fun i hi =>
+  by simpa using le_upper_bound (Subtype.val ∘ (equivShrink s).symm) (equivShrink s ⟨i, hi⟩)
+#align pgame.upper_bound_mem_upper_bounds SetTheory.PGame.upperBound_mem_upperBounds
 
 /-- A small set `s` of pre-games is bounded above. -/
-theorem bddAbove_of_small (s : Set PGame.{u}) [Small.{u} s] : BddAbove s :=
-  ⟨_, upperBound_mem_upperBounds s⟩
-#align pgame.bdd_above_of_small PGame.bddAbove_of_small
+theorem SetTheory.PGame.bddAbove_of_small (s : Set SetTheory.PGame.{u}) [Small.{u} s] :
+    BddAbove s :=
+  ⟨_, SetTheory.PGame.upperBound_mem_upperBounds s⟩
+#align pgame.bdd_above_of_small SetTheory.PGame.bddAbove_of_small
 
 /-- An explicit lower bound for a family of pre-games, whose right moves are the union of the right
 moves of all the pre-games in the family. -/
-def lowerBound {ι : Type u} (f : ι → PGame.{u}) : PGame :=
-  ⟨PEmpty, Σ i, (f i).RightMoves, PEmpty.elim, fun x => moveRight _ x.2⟩
-#align pgame.lower_bound PGame.lowerBound
+def SetTheory.PGame.lowerBound {ι : Type u} (f : ι → SetTheory.PGame.{u}) : SetTheory.PGame :=
+  ⟨PEmpty, Σ i, (f i).RightMoves, PEmpty.elim, fun x => SetTheory.PGame.moveRight _ x.2⟩
+#align pgame.lower_bound SetTheory.PGame.lowerBound
 
-instance lowerBound_leftMoves_empty {ι : Type u} (f : ι → PGame.{u}) :
-    IsEmpty (lowerBound f).LeftMoves :=
+instance SetTheory.PGame.lowerBound_leftMoves_empty {ι : Type u} (f : ι → SetTheory.PGame.{u}) :
+    IsEmpty (SetTheory.PGame.lowerBound f).LeftMoves :=
   PEmpty.isEmpty
-#align pgame.lower_bound_left_moves_empty PGame.lowerBound_leftMoves_empty
+#align pgame.lower_bound_left_moves_empty SetTheory.PGame.lowerBound_leftMoves_empty
 
-theorem lowerBound_le {ι : Type u} (f : ι → PGame.{u}) (i : ι) : lowerBound f ≤ f i :=
+theorem SetTheory.PGame.lowerBound_le {ι : Type u} (f : ι → SetTheory.PGame.{u}) (i : ι) :
+    SetTheory.PGame.lowerBound f ≤ f i :=
   by
   rw [lower_bound, le_iff_forall_lf]
   dsimp
   simp only [IsEmpty.forall_iff, true_and_iff]
   exact fun j => @lf_move_right (lower_bound f) ⟨i, j⟩
-#align pgame.lower_bound_le PGame.lowerBound_le
+#align pgame.lower_bound_le SetTheory.PGame.lowerBound_le
 
-theorem lowerBound_mem_lowerBounds (s : Set PGame.{u}) [Small.{u} s] :
-    lowerBound (Subtype.val ∘ (equivShrink s).symm) ∈ lowerBounds s := fun i hi => by
-  simpa using lower_bound_le (Subtype.val ∘ (equivShrink s).symm) (equivShrink s ⟨i, hi⟩)
-#align pgame.lower_bound_mem_lower_bounds PGame.lowerBound_mem_lowerBounds
+theorem SetTheory.PGame.lowerBound_mem_lowerBounds (s : Set SetTheory.PGame.{u}) [Small.{u} s] :
+    SetTheory.PGame.lowerBound (Subtype.val ∘ (equivShrink s).symm) ∈ lowerBounds s := fun i hi =>
+  by simpa using lower_bound_le (Subtype.val ∘ (equivShrink s).symm) (equivShrink s ⟨i, hi⟩)
+#align pgame.lower_bound_mem_lower_bounds SetTheory.PGame.lowerBound_mem_lowerBounds
 
 /-- A small set `s` of pre-games is bounded below. -/
-theorem bddBelow_of_small (s : Set PGame.{u}) [Small.{u} s] : BddBelow s :=
-  ⟨_, lowerBound_mem_lowerBounds s⟩
-#align pgame.bdd_below_of_small PGame.bddBelow_of_small
+theorem SetTheory.PGame.bddBelow_of_small (s : Set SetTheory.PGame.{u}) [Small.{u} s] :
+    BddBelow s :=
+  ⟨_, SetTheory.PGame.lowerBound_mem_lowerBounds s⟩
+#align pgame.bdd_below_of_small SetTheory.PGame.bddBelow_of_small
 
-#print PGame.Equiv /-
+#print SetTheory.PGame.Equiv /-
 /-- The equivalence relation on pre-games. Two pre-games `x`, `y` are equivalent if `x ≤ y` and
 `y ≤ x`.
 
 If `x ≈ 0`, then the second player can always win `x`. -/
-def Equiv (x y : PGame) : Prop :=
+def SetTheory.PGame.Equiv (x y : SetTheory.PGame) : Prop :=
   x ≤ y ∧ y ≤ x
-#align pgame.equiv PGame.Equiv
+#align pgame.equiv SetTheory.PGame.Equiv
 -/
 
-scoped infixl:0 " ≈ " => PGame.Equiv
+scoped infixl:0 " ≈ " => SetTheory.PGame.Equiv
 
 instance : IsEquiv _ (· ≈ ·) where
   refl x := ⟨le_rfl, le_rfl⟩
   trans := fun x y z ⟨xy, yx⟩ ⟨yz, zy⟩ => ⟨xy.trans yz, zy.trans yx⟩
   symm x y := And.symm
 
-#print PGame.Equiv.le /-
-theorem Equiv.le {x y : PGame} (h : x ≈ y) : x ≤ y :=
+#print SetTheory.PGame.Equiv.le /-
+theorem SetTheory.PGame.Equiv.le {x y : SetTheory.PGame} (h : x ≈ y) : x ≤ y :=
   h.1
-#align pgame.equiv.le PGame.Equiv.le
+#align pgame.equiv.le SetTheory.PGame.Equiv.le
 -/
 
-#print PGame.Equiv.ge /-
-theorem Equiv.ge {x y : PGame} (h : x ≈ y) : y ≤ x :=
+#print SetTheory.PGame.Equiv.ge /-
+theorem SetTheory.PGame.Equiv.ge {x y : SetTheory.PGame} (h : x ≈ y) : y ≤ x :=
   h.2
-#align pgame.equiv.ge PGame.Equiv.ge
+#align pgame.equiv.ge SetTheory.PGame.Equiv.ge
 -/
 
-#print PGame.equiv_rfl /-
+#print SetTheory.PGame.equiv_rfl /-
 @[refl, simp]
-theorem equiv_rfl {x} : x ≈ x :=
+theorem SetTheory.PGame.equiv_rfl {x} : x ≈ x :=
   refl x
-#align pgame.equiv_rfl PGame.equiv_rfl
+#align pgame.equiv_rfl SetTheory.PGame.equiv_rfl
 -/
 
-#print PGame.equiv_refl /-
-theorem equiv_refl (x) : x ≈ x :=
+#print SetTheory.PGame.equiv_refl /-
+theorem SetTheory.PGame.equiv_refl (x) : x ≈ x :=
   refl x
-#align pgame.equiv_refl PGame.equiv_refl
+#align pgame.equiv_refl SetTheory.PGame.equiv_refl
 -/
 
-#print PGame.Equiv.symm /-
+#print SetTheory.PGame.Equiv.symm /-
 @[symm]
-protected theorem Equiv.symm {x y} : (x ≈ y) → (y ≈ x) :=
+protected theorem SetTheory.PGame.Equiv.symm {x y} : (x ≈ y) → (y ≈ x) :=
   symm
-#align pgame.equiv.symm PGame.Equiv.symm
+#align pgame.equiv.symm SetTheory.PGame.Equiv.symm
 -/
 
-#print PGame.Equiv.trans /-
+#print SetTheory.PGame.Equiv.trans /-
 @[trans]
-protected theorem Equiv.trans {x y z} : (x ≈ y) → (y ≈ z) → (x ≈ z) :=
+protected theorem SetTheory.PGame.Equiv.trans {x y z} : (x ≈ y) → (y ≈ z) → (x ≈ z) :=
   trans
-#align pgame.equiv.trans PGame.Equiv.trans
+#align pgame.equiv.trans SetTheory.PGame.Equiv.trans
 -/
 
-#print PGame.equiv_comm /-
-protected theorem equiv_comm {x y} : (x ≈ y) ↔ (y ≈ x) :=
+#print SetTheory.PGame.equiv_comm /-
+protected theorem SetTheory.PGame.equiv_comm {x y} : (x ≈ y) ↔ (y ≈ x) :=
   comm
-#align pgame.equiv_comm PGame.equiv_comm
+#align pgame.equiv_comm SetTheory.PGame.equiv_comm
 -/
 
-#print PGame.equiv_of_eq /-
-theorem equiv_of_eq {x y} (h : x = y) : x ≈ y := by subst h
-#align pgame.equiv_of_eq PGame.equiv_of_eq
+#print SetTheory.PGame.equiv_of_eq /-
+theorem SetTheory.PGame.equiv_of_eq {x y} (h : x = y) : x ≈ y := by subst h
+#align pgame.equiv_of_eq SetTheory.PGame.equiv_of_eq
 -/
 
-#print PGame.le_of_le_of_equiv /-
+#print SetTheory.PGame.le_of_le_of_equiv /-
 @[trans]
-theorem le_of_le_of_equiv {x y z} (h₁ : x ≤ y) (h₂ : y ≈ z) : x ≤ z :=
+theorem SetTheory.PGame.le_of_le_of_equiv {x y z} (h₁ : x ≤ y) (h₂ : y ≈ z) : x ≤ z :=
   h₁.trans h₂.1
-#align pgame.le_of_le_of_equiv PGame.le_of_le_of_equiv
+#align pgame.le_of_le_of_equiv SetTheory.PGame.le_of_le_of_equiv
 -/
 
-#print PGame.le_of_equiv_of_le /-
+#print SetTheory.PGame.le_of_equiv_of_le /-
 @[trans]
-theorem le_of_equiv_of_le {x y z} (h₁ : x ≈ y) : y ≤ z → x ≤ z :=
+theorem SetTheory.PGame.le_of_equiv_of_le {x y z} (h₁ : x ≈ y) : y ≤ z → x ≤ z :=
   h₁.1.trans
-#align pgame.le_of_equiv_of_le PGame.le_of_equiv_of_le
+#align pgame.le_of_equiv_of_le SetTheory.PGame.le_of_equiv_of_le
 -/
 
-#print PGame.Lf.not_equiv /-
-theorem Lf.not_equiv {x y} (h : x ⧏ y) : ¬(x ≈ y) := fun h' => h.not_ge h'.2
-#align pgame.lf.not_equiv PGame.Lf.not_equiv
+#print SetTheory.PGame.Lf.not_equiv /-
+theorem SetTheory.PGame.Lf.not_equiv {x y} (h : x ⧏ y) : ¬(x ≈ y) := fun h' => h.not_ge h'.2
+#align pgame.lf.not_equiv SetTheory.PGame.Lf.not_equiv
 -/
 
-#print PGame.Lf.not_equiv' /-
-theorem Lf.not_equiv' {x y} (h : x ⧏ y) : ¬(y ≈ x) := fun h' => h.not_ge h'.1
-#align pgame.lf.not_equiv' PGame.Lf.not_equiv'
+#print SetTheory.PGame.Lf.not_equiv' /-
+theorem SetTheory.PGame.Lf.not_equiv' {x y} (h : x ⧏ y) : ¬(y ≈ x) := fun h' => h.not_ge h'.1
+#align pgame.lf.not_equiv' SetTheory.PGame.Lf.not_equiv'
 -/
 
-#print PGame.Lf.not_gt /-
-theorem Lf.not_gt {x y} (h : x ⧏ y) : ¬y < x := fun h' => h.not_ge h'.le
-#align pgame.lf.not_gt PGame.Lf.not_gt
+#print SetTheory.PGame.Lf.not_gt /-
+theorem SetTheory.PGame.Lf.not_gt {x y} (h : x ⧏ y) : ¬y < x := fun h' => h.not_ge h'.le
+#align pgame.lf.not_gt SetTheory.PGame.Lf.not_gt
 -/
 
-#print PGame.le_congr_imp /-
-theorem le_congr_imp {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) (h : x₁ ≤ y₁) : x₂ ≤ y₂ :=
+#print SetTheory.PGame.le_congr_imp /-
+theorem SetTheory.PGame.le_congr_imp {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) (h : x₁ ≤ y₁) :
+    x₂ ≤ y₂ :=
   hx.2.trans (h.trans hy.1)
-#align pgame.le_congr_imp PGame.le_congr_imp
+#align pgame.le_congr_imp SetTheory.PGame.le_congr_imp
 -/
 
-#print PGame.le_congr /-
-theorem le_congr {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ≤ y₁ ↔ x₂ ≤ y₂ :=
-  ⟨le_congr_imp hx hy, le_congr_imp hx.symm hy.symm⟩
-#align pgame.le_congr PGame.le_congr
+#print SetTheory.PGame.le_congr /-
+theorem SetTheory.PGame.le_congr {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ≤ y₁ ↔ x₂ ≤ y₂ :=
+  ⟨SetTheory.PGame.le_congr_imp hx hy, SetTheory.PGame.le_congr_imp hx.symm hy.symm⟩
+#align pgame.le_congr SetTheory.PGame.le_congr
 -/
 
-#print PGame.le_congr_left /-
-theorem le_congr_left {x₁ x₂ y} (hx : x₁ ≈ x₂) : x₁ ≤ y ↔ x₂ ≤ y :=
-  le_congr hx equiv_rfl
-#align pgame.le_congr_left PGame.le_congr_left
+#print SetTheory.PGame.le_congr_left /-
+theorem SetTheory.PGame.le_congr_left {x₁ x₂ y} (hx : x₁ ≈ x₂) : x₁ ≤ y ↔ x₂ ≤ y :=
+  SetTheory.PGame.le_congr hx SetTheory.PGame.equiv_rfl
+#align pgame.le_congr_left SetTheory.PGame.le_congr_left
 -/
 
-#print PGame.le_congr_right /-
-theorem le_congr_right {x y₁ y₂} (hy : y₁ ≈ y₂) : x ≤ y₁ ↔ x ≤ y₂ :=
-  le_congr equiv_rfl hy
-#align pgame.le_congr_right PGame.le_congr_right
+#print SetTheory.PGame.le_congr_right /-
+theorem SetTheory.PGame.le_congr_right {x y₁ y₂} (hy : y₁ ≈ y₂) : x ≤ y₁ ↔ x ≤ y₂ :=
+  SetTheory.PGame.le_congr SetTheory.PGame.equiv_rfl hy
+#align pgame.le_congr_right SetTheory.PGame.le_congr_right
 -/
 
-#print PGame.lf_congr /-
-theorem lf_congr {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ⧏ y₁ ↔ x₂ ⧏ y₂ :=
-  PGame.not_le.symm.trans <| (not_congr (le_congr hy hx)).trans PGame.not_le
-#align pgame.lf_congr PGame.lf_congr
+#print SetTheory.PGame.lf_congr /-
+theorem SetTheory.PGame.lf_congr {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ⧏ y₁ ↔ x₂ ⧏ y₂ :=
+  SetTheory.PGame.not_le.symm.trans <|
+    (not_congr (SetTheory.PGame.le_congr hy hx)).trans SetTheory.PGame.not_le
+#align pgame.lf_congr SetTheory.PGame.lf_congr
 -/
 
-#print PGame.lf_congr_imp /-
-theorem lf_congr_imp {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ⧏ y₁ → x₂ ⧏ y₂ :=
-  (lf_congr hx hy).1
-#align pgame.lf_congr_imp PGame.lf_congr_imp
+#print SetTheory.PGame.lf_congr_imp /-
+theorem SetTheory.PGame.lf_congr_imp {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) :
+    x₁ ⧏ y₁ → x₂ ⧏ y₂ :=
+  (SetTheory.PGame.lf_congr hx hy).1
+#align pgame.lf_congr_imp SetTheory.PGame.lf_congr_imp
 -/
 
-#print PGame.lf_congr_left /-
-theorem lf_congr_left {x₁ x₂ y} (hx : x₁ ≈ x₂) : x₁ ⧏ y ↔ x₂ ⧏ y :=
-  lf_congr hx equiv_rfl
-#align pgame.lf_congr_left PGame.lf_congr_left
+#print SetTheory.PGame.lf_congr_left /-
+theorem SetTheory.PGame.lf_congr_left {x₁ x₂ y} (hx : x₁ ≈ x₂) : x₁ ⧏ y ↔ x₂ ⧏ y :=
+  SetTheory.PGame.lf_congr hx SetTheory.PGame.equiv_rfl
+#align pgame.lf_congr_left SetTheory.PGame.lf_congr_left
 -/
 
-#print PGame.lf_congr_right /-
-theorem lf_congr_right {x y₁ y₂} (hy : y₁ ≈ y₂) : x ⧏ y₁ ↔ x ⧏ y₂ :=
-  lf_congr equiv_rfl hy
-#align pgame.lf_congr_right PGame.lf_congr_right
+#print SetTheory.PGame.lf_congr_right /-
+theorem SetTheory.PGame.lf_congr_right {x y₁ y₂} (hy : y₁ ≈ y₂) : x ⧏ y₁ ↔ x ⧏ y₂ :=
+  SetTheory.PGame.lf_congr SetTheory.PGame.equiv_rfl hy
+#align pgame.lf_congr_right SetTheory.PGame.lf_congr_right
 -/
 
-#print PGame.lf_of_lf_of_equiv /-
+#print SetTheory.PGame.lf_of_lf_of_equiv /-
 @[trans]
-theorem lf_of_lf_of_equiv {x y z} (h₁ : x ⧏ y) (h₂ : y ≈ z) : x ⧏ z :=
-  lf_congr_imp equiv_rfl h₂ h₁
-#align pgame.lf_of_lf_of_equiv PGame.lf_of_lf_of_equiv
+theorem SetTheory.PGame.lf_of_lf_of_equiv {x y z} (h₁ : x ⧏ y) (h₂ : y ≈ z) : x ⧏ z :=
+  SetTheory.PGame.lf_congr_imp SetTheory.PGame.equiv_rfl h₂ h₁
+#align pgame.lf_of_lf_of_equiv SetTheory.PGame.lf_of_lf_of_equiv
 -/
 
-#print PGame.lf_of_equiv_of_lf /-
+#print SetTheory.PGame.lf_of_equiv_of_lf /-
 @[trans]
-theorem lf_of_equiv_of_lf {x y z} (h₁ : x ≈ y) : y ⧏ z → x ⧏ z :=
-  lf_congr_imp h₁.symm equiv_rfl
-#align pgame.lf_of_equiv_of_lf PGame.lf_of_equiv_of_lf
+theorem SetTheory.PGame.lf_of_equiv_of_lf {x y z} (h₁ : x ≈ y) : y ⧏ z → x ⧏ z :=
+  SetTheory.PGame.lf_congr_imp h₁.symm SetTheory.PGame.equiv_rfl
+#align pgame.lf_of_equiv_of_lf SetTheory.PGame.lf_of_equiv_of_lf
 -/
 
-#print PGame.lt_of_lt_of_equiv /-
+#print SetTheory.PGame.lt_of_lt_of_equiv /-
 @[trans]
-theorem lt_of_lt_of_equiv {x y z} (h₁ : x < y) (h₂ : y ≈ z) : x < z :=
+theorem SetTheory.PGame.lt_of_lt_of_equiv {x y z} (h₁ : x < y) (h₂ : y ≈ z) : x < z :=
   h₁.trans_le h₂.1
-#align pgame.lt_of_lt_of_equiv PGame.lt_of_lt_of_equiv
+#align pgame.lt_of_lt_of_equiv SetTheory.PGame.lt_of_lt_of_equiv
 -/
 
-#print PGame.lt_of_equiv_of_lt /-
+#print SetTheory.PGame.lt_of_equiv_of_lt /-
 @[trans]
-theorem lt_of_equiv_of_lt {x y z} (h₁ : x ≈ y) : y < z → x < z :=
+theorem SetTheory.PGame.lt_of_equiv_of_lt {x y z} (h₁ : x ≈ y) : y < z → x < z :=
   h₁.1.trans_lt
-#align pgame.lt_of_equiv_of_lt PGame.lt_of_equiv_of_lt
+#align pgame.lt_of_equiv_of_lt SetTheory.PGame.lt_of_equiv_of_lt
 -/
 
-#print PGame.lt_congr_imp /-
-theorem lt_congr_imp {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) (h : x₁ < y₁) : x₂ < y₂ :=
+#print SetTheory.PGame.lt_congr_imp /-
+theorem SetTheory.PGame.lt_congr_imp {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) (h : x₁ < y₁) :
+    x₂ < y₂ :=
   hx.2.trans_lt (h.trans_le hy.1)
-#align pgame.lt_congr_imp PGame.lt_congr_imp
+#align pgame.lt_congr_imp SetTheory.PGame.lt_congr_imp
 -/
 
-#print PGame.lt_congr /-
-theorem lt_congr {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ < y₁ ↔ x₂ < y₂ :=
-  ⟨lt_congr_imp hx hy, lt_congr_imp hx.symm hy.symm⟩
-#align pgame.lt_congr PGame.lt_congr
+#print SetTheory.PGame.lt_congr /-
+theorem SetTheory.PGame.lt_congr {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ < y₁ ↔ x₂ < y₂ :=
+  ⟨SetTheory.PGame.lt_congr_imp hx hy, SetTheory.PGame.lt_congr_imp hx.symm hy.symm⟩
+#align pgame.lt_congr SetTheory.PGame.lt_congr
 -/
 
-#print PGame.lt_congr_left /-
-theorem lt_congr_left {x₁ x₂ y} (hx : x₁ ≈ x₂) : x₁ < y ↔ x₂ < y :=
-  lt_congr hx equiv_rfl
-#align pgame.lt_congr_left PGame.lt_congr_left
+#print SetTheory.PGame.lt_congr_left /-
+theorem SetTheory.PGame.lt_congr_left {x₁ x₂ y} (hx : x₁ ≈ x₂) : x₁ < y ↔ x₂ < y :=
+  SetTheory.PGame.lt_congr hx SetTheory.PGame.equiv_rfl
+#align pgame.lt_congr_left SetTheory.PGame.lt_congr_left
 -/
 
-#print PGame.lt_congr_right /-
-theorem lt_congr_right {x y₁ y₂} (hy : y₁ ≈ y₂) : x < y₁ ↔ x < y₂ :=
-  lt_congr equiv_rfl hy
-#align pgame.lt_congr_right PGame.lt_congr_right
+#print SetTheory.PGame.lt_congr_right /-
+theorem SetTheory.PGame.lt_congr_right {x y₁ y₂} (hy : y₁ ≈ y₂) : x < y₁ ↔ x < y₂ :=
+  SetTheory.PGame.lt_congr SetTheory.PGame.equiv_rfl hy
+#align pgame.lt_congr_right SetTheory.PGame.lt_congr_right
 -/
 
-#print PGame.lt_or_equiv_of_le /-
-theorem lt_or_equiv_of_le {x y : PGame} (h : x ≤ y) : x < y ∨ (x ≈ y) :=
-  and_or_left.mp ⟨h, (em <| y ≤ x).symm.imp_left PGame.not_le.1⟩
-#align pgame.lt_or_equiv_of_le PGame.lt_or_equiv_of_le
+#print SetTheory.PGame.lt_or_equiv_of_le /-
+theorem SetTheory.PGame.lt_or_equiv_of_le {x y : SetTheory.PGame} (h : x ≤ y) : x < y ∨ (x ≈ y) :=
+  and_or_left.mp ⟨h, (em <| y ≤ x).symm.imp_left SetTheory.PGame.not_le.1⟩
+#align pgame.lt_or_equiv_of_le SetTheory.PGame.lt_or_equiv_of_le
 -/
 
-#print PGame.lf_or_equiv_or_gf /-
-theorem lf_or_equiv_or_gf (x y : PGame) : x ⧏ y ∨ (x ≈ y) ∨ y ⧏ x :=
+#print SetTheory.PGame.lf_or_equiv_or_gf /-
+theorem SetTheory.PGame.lf_or_equiv_or_gf (x y : SetTheory.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'
+    cases' lt_or_equiv_of_le (SetTheory.PGame.not_lf.1 h) with h' h'
     · exact Or.inr h'.lf
     · exact Or.inl h'.symm
-#align pgame.lf_or_equiv_or_gf PGame.lf_or_equiv_or_gf
+#align pgame.lf_or_equiv_or_gf SetTheory.PGame.lf_or_equiv_or_gf
 -/
 
-#print PGame.equiv_congr_left /-
-theorem equiv_congr_left {y₁ y₂} : (y₁ ≈ y₂) ↔ ∀ x₁, (x₁ ≈ y₁) ↔ (x₁ ≈ y₂) :=
-  ⟨fun h x₁ => ⟨fun h' => h'.trans h, fun h' => h'.trans h.symm⟩, fun h => (h y₁).1 <| equiv_rfl⟩
-#align pgame.equiv_congr_left PGame.equiv_congr_left
+#print SetTheory.PGame.equiv_congr_left /-
+theorem SetTheory.PGame.equiv_congr_left {y₁ y₂} : (y₁ ≈ y₂) ↔ ∀ x₁, (x₁ ≈ y₁) ↔ (x₁ ≈ y₂) :=
+  ⟨fun h x₁ => ⟨fun h' => h'.trans h, fun h' => h'.trans h.symm⟩, fun h =>
+    (h y₁).1 <| SetTheory.PGame.equiv_rfl⟩
+#align pgame.equiv_congr_left SetTheory.PGame.equiv_congr_left
 -/
 
-#print PGame.equiv_congr_right /-
-theorem equiv_congr_right {x₁ x₂} : (x₁ ≈ x₂) ↔ ∀ y₁, (x₁ ≈ y₁) ↔ (x₂ ≈ y₁) :=
-  ⟨fun h y₁ => ⟨fun h' => h.symm.trans h', fun h' => h.trans h'⟩, fun h => (h x₂).2 <| equiv_rfl⟩
-#align pgame.equiv_congr_right PGame.equiv_congr_right
+#print SetTheory.PGame.equiv_congr_right /-
+theorem SetTheory.PGame.equiv_congr_right {x₁ x₂} : (x₁ ≈ x₂) ↔ ∀ y₁, (x₁ ≈ y₁) ↔ (x₂ ≈ y₁) :=
+  ⟨fun h y₁ => ⟨fun h' => h.symm.trans h', fun h' => h.trans h'⟩, fun h =>
+    (h x₂).2 <| SetTheory.PGame.equiv_rfl⟩
+#align pgame.equiv_congr_right SetTheory.PGame.equiv_congr_right
 -/
 
-#print PGame.equiv_of_mk_equiv /-
-theorem equiv_of_mk_equiv {x y : PGame} (L : x.LeftMoves ≃ y.LeftMoves)
+#print SetTheory.PGame.equiv_of_mk_equiv /-
+theorem SetTheory.PGame.equiv_of_mk_equiv {x y : SetTheory.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
   fconstructor <;> 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 simpa using (hl (L.symm i)).2⟩, fun j => Or.inr ⟨_, (hr j).2⟩⟩
-#align pgame.equiv_of_mk_equiv PGame.equiv_of_mk_equiv
+#align pgame.equiv_of_mk_equiv SetTheory.PGame.equiv_of_mk_equiv
 -/
 
-#print PGame.Fuzzy /-
+#print SetTheory.PGame.Fuzzy /-
 /-- The fuzzy, confused, or incomparable relation on pre-games.
 
 If `x ‖ 0`, then the first player can always win `x`. -/
-def Fuzzy (x y : PGame) : Prop :=
+def SetTheory.PGame.Fuzzy (x y : SetTheory.PGame) : Prop :=
   x ⧏ y ∧ y ⧏ x
-#align pgame.fuzzy PGame.Fuzzy
+#align pgame.fuzzy SetTheory.PGame.Fuzzy
 -/
 
-scoped infixl:50 " ‖ " => PGame.Fuzzy
+scoped infixl:50 " ‖ " => SetTheory.PGame.Fuzzy
 
-#print PGame.Fuzzy.swap /-
+#print SetTheory.PGame.Fuzzy.swap /-
 @[symm]
-theorem Fuzzy.swap {x y : PGame} : x ‖ y → y ‖ x :=
+theorem SetTheory.PGame.Fuzzy.swap {x y : SetTheory.PGame} : x ‖ y → y ‖ x :=
   And.symm
-#align pgame.fuzzy.swap PGame.Fuzzy.swap
+#align pgame.fuzzy.swap SetTheory.PGame.Fuzzy.swap
 -/
 
 instance : IsSymm _ (· ‖ ·) :=
-  ⟨fun x y => Fuzzy.swap⟩
+  ⟨fun x y => SetTheory.PGame.Fuzzy.swap⟩
 
-#print PGame.Fuzzy.swap_iff /-
-theorem Fuzzy.swap_iff {x y : PGame} : x ‖ y ↔ y ‖ x :=
-  ⟨Fuzzy.swap, Fuzzy.swap⟩
-#align pgame.fuzzy.swap_iff PGame.Fuzzy.swap_iff
+#print SetTheory.PGame.Fuzzy.swap_iff /-
+theorem SetTheory.PGame.Fuzzy.swap_iff {x y : SetTheory.PGame} : x ‖ y ↔ y ‖ x :=
+  ⟨SetTheory.PGame.Fuzzy.swap, SetTheory.PGame.Fuzzy.swap⟩
+#align pgame.fuzzy.swap_iff SetTheory.PGame.Fuzzy.swap_iff
 -/
 
-#print PGame.fuzzy_irrefl /-
-theorem fuzzy_irrefl (x : PGame) : ¬x ‖ x := fun h => lf_irrefl x h.1
-#align pgame.fuzzy_irrefl PGame.fuzzy_irrefl
+#print SetTheory.PGame.fuzzy_irrefl /-
+theorem SetTheory.PGame.fuzzy_irrefl (x : SetTheory.PGame) : ¬x ‖ x := fun h =>
+  SetTheory.PGame.lf_irrefl x h.1
+#align pgame.fuzzy_irrefl SetTheory.PGame.fuzzy_irrefl
 -/
 
 instance : IsIrrefl _ (· ‖ ·) :=
-  ⟨fuzzy_irrefl⟩
+  ⟨SetTheory.PGame.fuzzy_irrefl⟩
 
-#print PGame.lf_iff_lt_or_fuzzy /-
-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]; tauto
-#align pgame.lf_iff_lt_or_fuzzy PGame.lf_iff_lt_or_fuzzy
+#print SetTheory.PGame.lf_iff_lt_or_fuzzy /-
+theorem SetTheory.PGame.lf_iff_lt_or_fuzzy {x y : SetTheory.PGame} : x ⧏ y ↔ x < y ∨ x ‖ y := by
+  simp only [lt_iff_le_and_lf, fuzzy, ← SetTheory.PGame.not_le]; tauto
+#align pgame.lf_iff_lt_or_fuzzy SetTheory.PGame.lf_iff_lt_or_fuzzy
 -/
 
-#print PGame.lf_of_fuzzy /-
-theorem lf_of_fuzzy {x y : PGame} (h : x ‖ y) : x ⧏ y :=
-  lf_iff_lt_or_fuzzy.2 (Or.inr h)
-#align pgame.lf_of_fuzzy PGame.lf_of_fuzzy
+#print SetTheory.PGame.lf_of_fuzzy /-
+theorem SetTheory.PGame.lf_of_fuzzy {x y : SetTheory.PGame} (h : x ‖ y) : x ⧏ y :=
+  SetTheory.PGame.lf_iff_lt_or_fuzzy.2 (Or.inr h)
+#align pgame.lf_of_fuzzy SetTheory.PGame.lf_of_fuzzy
 -/
 
 alias fuzzy.lf := lf_of_fuzzy
-#align pgame.fuzzy.lf PGame.Fuzzy.lf
+#align pgame.fuzzy.lf SetTheory.PGame.Fuzzy.lf
 
-#print PGame.lt_or_fuzzy_of_lf /-
-theorem lt_or_fuzzy_of_lf {x y : PGame} : x ⧏ y → x < y ∨ x ‖ y :=
-  lf_iff_lt_or_fuzzy.1
-#align pgame.lt_or_fuzzy_of_lf PGame.lt_or_fuzzy_of_lf
+#print SetTheory.PGame.lt_or_fuzzy_of_lf /-
+theorem SetTheory.PGame.lt_or_fuzzy_of_lf {x y : SetTheory.PGame} : x ⧏ y → x < y ∨ x ‖ y :=
+  SetTheory.PGame.lf_iff_lt_or_fuzzy.1
+#align pgame.lt_or_fuzzy_of_lf SetTheory.PGame.lt_or_fuzzy_of_lf
 -/
 
-#print PGame.Fuzzy.not_equiv /-
-theorem Fuzzy.not_equiv {x y : PGame} (h : x ‖ y) : ¬(x ≈ y) := fun h' => h'.1.not_gf h.2
-#align pgame.fuzzy.not_equiv PGame.Fuzzy.not_equiv
+#print SetTheory.PGame.Fuzzy.not_equiv /-
+theorem SetTheory.PGame.Fuzzy.not_equiv {x y : SetTheory.PGame} (h : x ‖ y) : ¬(x ≈ y) := fun h' =>
+  h'.1.not_gf h.2
+#align pgame.fuzzy.not_equiv SetTheory.PGame.Fuzzy.not_equiv
 -/
 
-#print PGame.Fuzzy.not_equiv' /-
-theorem Fuzzy.not_equiv' {x y : PGame} (h : x ‖ y) : ¬(y ≈ x) := fun h' => h'.2.not_gf h.2
-#align pgame.fuzzy.not_equiv' PGame.Fuzzy.not_equiv'
+#print SetTheory.PGame.Fuzzy.not_equiv' /-
+theorem SetTheory.PGame.Fuzzy.not_equiv' {x y : SetTheory.PGame} (h : x ‖ y) : ¬(y ≈ x) := fun h' =>
+  h'.2.not_gf h.2
+#align pgame.fuzzy.not_equiv' SetTheory.PGame.Fuzzy.not_equiv'
 -/
 
-#print PGame.not_fuzzy_of_le /-
-theorem not_fuzzy_of_le {x y : PGame} (h : x ≤ y) : ¬x ‖ y := fun h' => h'.2.not_ge h
-#align pgame.not_fuzzy_of_le PGame.not_fuzzy_of_le
+#print SetTheory.PGame.not_fuzzy_of_le /-
+theorem SetTheory.PGame.not_fuzzy_of_le {x y : SetTheory.PGame} (h : x ≤ y) : ¬x ‖ y := fun h' =>
+  h'.2.not_ge h
+#align pgame.not_fuzzy_of_le SetTheory.PGame.not_fuzzy_of_le
 -/
 
-#print PGame.not_fuzzy_of_ge /-
-theorem not_fuzzy_of_ge {x y : PGame} (h : y ≤ x) : ¬x ‖ y := fun h' => h'.1.not_ge h
-#align pgame.not_fuzzy_of_ge PGame.not_fuzzy_of_ge
+#print SetTheory.PGame.not_fuzzy_of_ge /-
+theorem SetTheory.PGame.not_fuzzy_of_ge {x y : SetTheory.PGame} (h : y ≤ x) : ¬x ‖ y := fun h' =>
+  h'.1.not_ge h
+#align pgame.not_fuzzy_of_ge SetTheory.PGame.not_fuzzy_of_ge
 -/
 
-#print PGame.Equiv.not_fuzzy /-
-theorem Equiv.not_fuzzy {x y : PGame} (h : x ≈ y) : ¬x ‖ y :=
-  not_fuzzy_of_le h.1
-#align pgame.equiv.not_fuzzy PGame.Equiv.not_fuzzy
+#print SetTheory.PGame.Equiv.not_fuzzy /-
+theorem SetTheory.PGame.Equiv.not_fuzzy {x y : SetTheory.PGame} (h : x ≈ y) : ¬x ‖ y :=
+  SetTheory.PGame.not_fuzzy_of_le h.1
+#align pgame.equiv.not_fuzzy SetTheory.PGame.Equiv.not_fuzzy
 -/
 
-#print PGame.Equiv.not_fuzzy' /-
-theorem Equiv.not_fuzzy' {x y : PGame} (h : x ≈ y) : ¬y ‖ x :=
-  not_fuzzy_of_le h.2
-#align pgame.equiv.not_fuzzy' PGame.Equiv.not_fuzzy'
+#print SetTheory.PGame.Equiv.not_fuzzy' /-
+theorem SetTheory.PGame.Equiv.not_fuzzy' {x y : SetTheory.PGame} (h : x ≈ y) : ¬y ‖ x :=
+  SetTheory.PGame.not_fuzzy_of_le h.2
+#align pgame.equiv.not_fuzzy' SetTheory.PGame.Equiv.not_fuzzy'
 -/
 
-#print PGame.fuzzy_congr /-
-theorem fuzzy_congr {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ‖ y₁ ↔ x₂ ‖ y₂ :=
+#print SetTheory.PGame.fuzzy_congr /-
+theorem SetTheory.PGame.fuzzy_congr {x₁ y₁ x₂ y₂ : SetTheory.PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) :
+    x₁ ‖ y₁ ↔ x₂ ‖ y₂ :=
   show _ ∧ _ ↔ _ ∧ _ by rw [lf_congr hx hy, lf_congr hy hx]
-#align pgame.fuzzy_congr PGame.fuzzy_congr
+#align pgame.fuzzy_congr SetTheory.PGame.fuzzy_congr
 -/
 
-#print PGame.fuzzy_congr_imp /-
-theorem fuzzy_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ‖ y₁ → x₂ ‖ y₂ :=
-  (fuzzy_congr hx hy).1
-#align pgame.fuzzy_congr_imp PGame.fuzzy_congr_imp
+#print SetTheory.PGame.fuzzy_congr_imp /-
+theorem SetTheory.PGame.fuzzy_congr_imp {x₁ y₁ x₂ y₂ : SetTheory.PGame} (hx : x₁ ≈ x₂)
+    (hy : y₁ ≈ y₂) : x₁ ‖ y₁ → x₂ ‖ y₂ :=
+  (SetTheory.PGame.fuzzy_congr hx hy).1
+#align pgame.fuzzy_congr_imp SetTheory.PGame.fuzzy_congr_imp
 -/
 
-#print PGame.fuzzy_congr_left /-
-theorem fuzzy_congr_left {x₁ x₂ y} (hx : x₁ ≈ x₂) : x₁ ‖ y ↔ x₂ ‖ y :=
-  fuzzy_congr hx equiv_rfl
-#align pgame.fuzzy_congr_left PGame.fuzzy_congr_left
+#print SetTheory.PGame.fuzzy_congr_left /-
+theorem SetTheory.PGame.fuzzy_congr_left {x₁ x₂ y} (hx : x₁ ≈ x₂) : x₁ ‖ y ↔ x₂ ‖ y :=
+  SetTheory.PGame.fuzzy_congr hx SetTheory.PGame.equiv_rfl
+#align pgame.fuzzy_congr_left SetTheory.PGame.fuzzy_congr_left
 -/
 
-#print PGame.fuzzy_congr_right /-
-theorem fuzzy_congr_right {x y₁ y₂} (hy : y₁ ≈ y₂) : x ‖ y₁ ↔ x ‖ y₂ :=
-  fuzzy_congr equiv_rfl hy
-#align pgame.fuzzy_congr_right PGame.fuzzy_congr_right
+#print SetTheory.PGame.fuzzy_congr_right /-
+theorem SetTheory.PGame.fuzzy_congr_right {x y₁ y₂} (hy : y₁ ≈ y₂) : x ‖ y₁ ↔ x ‖ y₂ :=
+  SetTheory.PGame.fuzzy_congr SetTheory.PGame.equiv_rfl hy
+#align pgame.fuzzy_congr_right SetTheory.PGame.fuzzy_congr_right
 -/
 
-#print PGame.fuzzy_of_fuzzy_of_equiv /-
+#print SetTheory.PGame.fuzzy_of_fuzzy_of_equiv /-
 @[trans]
-theorem fuzzy_of_fuzzy_of_equiv {x y z} (h₁ : x ‖ y) (h₂ : y ≈ z) : x ‖ z :=
-  (fuzzy_congr_right h₂).1 h₁
-#align pgame.fuzzy_of_fuzzy_of_equiv PGame.fuzzy_of_fuzzy_of_equiv
+theorem SetTheory.PGame.fuzzy_of_fuzzy_of_equiv {x y z} (h₁ : x ‖ y) (h₂ : y ≈ z) : x ‖ z :=
+  (SetTheory.PGame.fuzzy_congr_right h₂).1 h₁
+#align pgame.fuzzy_of_fuzzy_of_equiv SetTheory.PGame.fuzzy_of_fuzzy_of_equiv
 -/
 
-#print PGame.fuzzy_of_equiv_of_fuzzy /-
+#print SetTheory.PGame.fuzzy_of_equiv_of_fuzzy /-
 @[trans]
-theorem fuzzy_of_equiv_of_fuzzy {x y z} (h₁ : x ≈ y) (h₂ : y ‖ z) : x ‖ z :=
-  (fuzzy_congr_left h₁).2 h₂
-#align pgame.fuzzy_of_equiv_of_fuzzy PGame.fuzzy_of_equiv_of_fuzzy
+theorem SetTheory.PGame.fuzzy_of_equiv_of_fuzzy {x y z} (h₁ : x ≈ y) (h₂ : y ‖ z) : x ‖ z :=
+  (SetTheory.PGame.fuzzy_congr_left h₁).2 h₂
+#align pgame.fuzzy_of_equiv_of_fuzzy SetTheory.PGame.fuzzy_of_equiv_of_fuzzy
 -/
 
-#print PGame.lt_or_equiv_or_gt_or_fuzzy /-
+#print SetTheory.PGame.lt_or_equiv_or_gt_or_fuzzy /-
 /-- 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 :=
+theorem SetTheory.PGame.lt_or_equiv_or_gt_or_fuzzy (x y : SetTheory.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; exact ⟨h₂, h₁⟩
-#align pgame.lt_or_equiv_or_gt_or_fuzzy PGame.lt_or_equiv_or_gt_or_fuzzy
+#align pgame.lt_or_equiv_or_gt_or_fuzzy SetTheory.PGame.lt_or_equiv_or_gt_or_fuzzy
 -/
 
-#print PGame.lt_or_equiv_or_gf /-
-theorem lt_or_equiv_or_gf (x y : PGame) : x < y ∨ (x ≈ y) ∨ y ⧏ x :=
+#print SetTheory.PGame.lt_or_equiv_or_gf /-
+theorem SetTheory.PGame.lt_or_equiv_or_gf (x y : SetTheory.PGame) : x < y ∨ (x ≈ y) ∨ y ⧏ x :=
   by
   rw [lf_iff_lt_or_fuzzy, fuzzy.swap_iff]
   exact lt_or_equiv_or_gt_or_fuzzy x y
-#align pgame.lt_or_equiv_or_gf PGame.lt_or_equiv_or_gf
+#align pgame.lt_or_equiv_or_gf SetTheory.PGame.lt_or_equiv_or_gf
 -/
 
 /-! ### Relabellings -/
 
 
-#print PGame.Relabelling /-
+#print SetTheory.PGame.Relabelling /-
 /-- `relabelling x y` says that `x` and `y` are really the same game, just dressed up differently.
 Specifically, there is a bijection between the moves for Left in `x` and in `y`, and similarly
 for Right, and under these bijections we inductively have `relabelling`s for the consequent games.
 -/
-inductive Relabelling : PGame.{u} → PGame.{u} → Type (u + 1)
+inductive SetTheory.PGame.Relabelling : SetTheory.PGame.{u} → SetTheory.PGame.{u} → Type (u + 1)
   |
   mk :
-    ∀ {x y : PGame} (L : x.LeftMoves ≃ y.LeftMoves) (R : x.RightMoves ≃ y.RightMoves),
+    ∀ {x y : SetTheory.PGame} (L : x.LeftMoves ≃ y.LeftMoves) (R : x.RightMoves ≃ y.RightMoves),
       (∀ i, relabelling (x.moveLeft i) (y.moveLeft (L i))) →
         (∀ j, relabelling (x.moveRight j) (y.moveRight (R j))) → relabelling x y
-#align pgame.relabelling PGame.Relabelling
+#align pgame.relabelling SetTheory.PGame.Relabelling
 -/
 
-scoped infixl:50 " ≡r " => PGame.Relabelling
+scoped infixl:50 " ≡r " => SetTheory.PGame.Relabelling
 
 namespace Relabelling
 
-variable {x y : PGame.{u}}
+variable {x y : SetTheory.PGame.{u}}
 
-#print PGame.Relabelling.mk' /-
+#print SetTheory.PGame.Relabelling.mk' /-
 /-- 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 :=
+def SetTheory.PGame.Relabelling.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 simpa using hR (R.symm j)⟩
-#align pgame.relabelling.mk' PGame.Relabelling.mk'
+#align pgame.relabelling.mk' SetTheory.PGame.Relabelling.mk'
 -/
 
-#print PGame.Relabelling.leftMovesEquiv /-
+#print SetTheory.PGame.Relabelling.leftMovesEquiv /-
 /-- The equivalence between left moves of `x` and `y` given by the relabelling. -/
-def leftMovesEquiv : ∀ r : x ≡r y, x.LeftMoves ≃ y.LeftMoves
+def SetTheory.PGame.Relabelling.leftMovesEquiv : ∀ r : x ≡r y, x.LeftMoves ≃ y.LeftMoves
   | ⟨L, R, hL, hR⟩ => L
-#align pgame.relabelling.left_moves_equiv PGame.Relabelling.leftMovesEquiv
+#align pgame.relabelling.left_moves_equiv SetTheory.PGame.Relabelling.leftMovesEquiv
 -/
 
-#print PGame.Relabelling.mk_leftMovesEquiv /-
+#print SetTheory.PGame.Relabelling.mk_leftMovesEquiv /-
 @[simp]
-theorem mk_leftMovesEquiv {x y L R hL hR} : (@Relabelling.mk x y L R hL hR).leftMovesEquiv = L :=
+theorem SetTheory.PGame.Relabelling.mk_leftMovesEquiv {x y L R hL hR} :
+    (@SetTheory.PGame.Relabelling.mk x y L R hL hR).leftMovesEquiv = L :=
   rfl
-#align pgame.relabelling.mk_left_moves_equiv PGame.Relabelling.mk_leftMovesEquiv
+#align pgame.relabelling.mk_left_moves_equiv SetTheory.PGame.Relabelling.mk_leftMovesEquiv
 -/
 
-#print PGame.Relabelling.mk'_leftMovesEquiv /-
+#print SetTheory.PGame.Relabelling.mk'_leftMovesEquiv /-
 @[simp]
-theorem mk'_leftMovesEquiv {x y L R hL hR} :
-    (@Relabelling.mk' x y L R hL hR).leftMovesEquiv = L.symm :=
+theorem SetTheory.PGame.Relabelling.mk'_leftMovesEquiv {x y L R hL hR} :
+    (@SetTheory.PGame.Relabelling.mk' x y L R hL hR).leftMovesEquiv = L.symm :=
   rfl
-#align pgame.relabelling.mk'_left_moves_equiv PGame.Relabelling.mk'_leftMovesEquiv
+#align pgame.relabelling.mk'_left_moves_equiv SetTheory.PGame.Relabelling.mk'_leftMovesEquiv
 -/
 
-#print PGame.Relabelling.rightMovesEquiv /-
+#print SetTheory.PGame.Relabelling.rightMovesEquiv /-
 /-- The equivalence between right moves of `x` and `y` given by the relabelling. -/
-def rightMovesEquiv : ∀ r : x ≡r y, x.RightMoves ≃ y.RightMoves
+def SetTheory.PGame.Relabelling.rightMovesEquiv : ∀ r : x ≡r y, x.RightMoves ≃ y.RightMoves
   | ⟨L, R, hL, hR⟩ => R
-#align pgame.relabelling.right_moves_equiv PGame.Relabelling.rightMovesEquiv
+#align pgame.relabelling.right_moves_equiv SetTheory.PGame.Relabelling.rightMovesEquiv
 -/
 
-#print PGame.Relabelling.mk_rightMovesEquiv /-
+#print SetTheory.PGame.Relabelling.mk_rightMovesEquiv /-
 @[simp]
-theorem mk_rightMovesEquiv {x y L R hL hR} : (@Relabelling.mk x y L R hL hR).rightMovesEquiv = R :=
+theorem SetTheory.PGame.Relabelling.mk_rightMovesEquiv {x y L R hL hR} :
+    (@SetTheory.PGame.Relabelling.mk x y L R hL hR).rightMovesEquiv = R :=
   rfl
-#align pgame.relabelling.mk_right_moves_equiv PGame.Relabelling.mk_rightMovesEquiv
+#align pgame.relabelling.mk_right_moves_equiv SetTheory.PGame.Relabelling.mk_rightMovesEquiv
 -/
 
-#print PGame.Relabelling.mk'_rightMovesEquiv /-
+#print SetTheory.PGame.Relabelling.mk'_rightMovesEquiv /-
 @[simp]
-theorem mk'_rightMovesEquiv {x y L R hL hR} :
-    (@Relabelling.mk' x y L R hL hR).rightMovesEquiv = R.symm :=
+theorem SetTheory.PGame.Relabelling.mk'_rightMovesEquiv {x y L R hL hR} :
+    (@SetTheory.PGame.Relabelling.mk' x y L R hL hR).rightMovesEquiv = R.symm :=
   rfl
-#align pgame.relabelling.mk'_right_moves_equiv PGame.Relabelling.mk'_rightMovesEquiv
+#align pgame.relabelling.mk'_right_moves_equiv SetTheory.PGame.Relabelling.mk'_rightMovesEquiv
 -/
 
-#print PGame.Relabelling.moveLeft /-
+#print SetTheory.PGame.Relabelling.moveLeft /-
 /-- A left move of `x` is a relabelling of a left move of `y`. -/
-def moveLeft : ∀ (r : x ≡r y) (i : x.LeftMoves), x.moveLeft i ≡r y.moveLeft (r.leftMovesEquiv i)
+def SetTheory.PGame.Relabelling.moveLeft :
+    ∀ (r : x ≡r y) (i : x.LeftMoves), x.moveLeft i ≡r y.moveLeft (r.leftMovesEquiv i)
   | ⟨L, R, hL, hR⟩ => hL
-#align pgame.relabelling.move_left PGame.Relabelling.moveLeft
+#align pgame.relabelling.move_left SetTheory.PGame.Relabelling.moveLeft
 -/
 
-#print PGame.Relabelling.moveLeftSymm /-
+#print SetTheory.PGame.Relabelling.moveLeftSymm /-
 /-- A left move of `y` is a relabelling of a left move of `x`. -/
-def moveLeftSymm :
+def SetTheory.PGame.Relabelling.moveLeftSymm :
     ∀ (r : x ≡r y) (i : y.LeftMoves), x.moveLeft (r.leftMovesEquiv.symm i) ≡r y.moveLeft i
   | ⟨L, R, hL, hR⟩, i => by simpa using hL (L.symm i)
-#align pgame.relabelling.move_left_symm PGame.Relabelling.moveLeftSymm
+#align pgame.relabelling.move_left_symm SetTheory.PGame.Relabelling.moveLeftSymm
 -/
 
-#print PGame.Relabelling.moveRight /-
+#print SetTheory.PGame.Relabelling.moveRight /-
 /-- A right move of `x` is a relabelling of a right move of `y`. -/
-def moveRight :
+def SetTheory.PGame.Relabelling.moveRight :
     ∀ (r : x ≡r y) (i : x.RightMoves), x.moveRight i ≡r y.moveRight (r.rightMovesEquiv i)
   | ⟨L, R, hL, hR⟩ => hR
-#align pgame.relabelling.move_right PGame.Relabelling.moveRight
+#align pgame.relabelling.move_right SetTheory.PGame.Relabelling.moveRight
 -/
 
-#print PGame.Relabelling.moveRightSymm /-
+#print SetTheory.PGame.Relabelling.moveRightSymm /-
 /-- A right move of `y` is a relabelling of a right move of `x`. -/
-def moveRightSymm :
+def SetTheory.PGame.Relabelling.moveRightSymm :
     ∀ (r : x ≡r y) (i : y.RightMoves), x.moveRight (r.rightMovesEquiv.symm i) ≡r y.moveRight i
   | ⟨L, R, hL, hR⟩, i => by simpa using hR (R.symm i)
-#align pgame.relabelling.move_right_symm PGame.Relabelling.moveRightSymm
+#align pgame.relabelling.move_right_symm SetTheory.PGame.Relabelling.moveRightSymm
 -/
 
-#print PGame.Relabelling.refl /-
+#print SetTheory.PGame.Relabelling.refl /-
 /-- The identity relabelling. -/
 @[refl]
-def refl : ∀ x : PGame, x ≡r x
+def SetTheory.PGame.Relabelling.refl : ∀ x : SetTheory.PGame, x ≡r x
   | x => ⟨Equiv.refl _, Equiv.refl _, fun i => refl _, fun j => refl _⟩
 decreasing_by pgame_wf_tac
-#align pgame.relabelling.refl PGame.Relabelling.refl
+#align pgame.relabelling.refl SetTheory.PGame.Relabelling.refl
 -/
 
-instance (x : PGame) : Inhabited (x ≡r x) :=
-  ⟨refl _⟩
+instance (x : SetTheory.PGame) : Inhabited (x ≡r x) :=
+  ⟨SetTheory.PGame.Relabelling.refl _⟩
 
-#print PGame.Relabelling.symm /-
+#print SetTheory.PGame.Relabelling.symm /-
 /-- Flip a relabelling. -/
 @[symm]
-def symm : ∀ {x y : PGame}, x ≡r y → y ≡r x
-  | x, y, ⟨L, R, hL, hR⟩ => mk' L R (fun i => (hL i).symm) fun j => (hR j).symm
-#align pgame.relabelling.symm PGame.Relabelling.symm
+def SetTheory.PGame.Relabelling.symm : ∀ {x y : SetTheory.PGame}, x ≡r y → y ≡r x
+  | x, y, ⟨L, R, hL, hR⟩ =>
+    SetTheory.PGame.Relabelling.mk' L R (fun i => (hL i).symm) fun j => (hR j).symm
+#align pgame.relabelling.symm SetTheory.PGame.Relabelling.symm
 -/
 
-#print PGame.Relabelling.le /-
-theorem le : ∀ {x y : PGame} (r : x ≡r y), x ≤ y
+#print SetTheory.PGame.Relabelling.le /-
+theorem SetTheory.PGame.Relabelling.le : ∀ {x y : SetTheory.PGame} (r : x ≡r y), x ≤ y
   | x, y, r =>
-    le_def.2 ⟨fun i => Or.inl ⟨_, (r.moveLeft i).le⟩, fun j => Or.inr ⟨_, (r.moveRightSymm j).le⟩⟩
+    SetTheory.PGame.le_def.2
+      ⟨fun i => Or.inl ⟨_, (r.moveLeft i).le⟩, fun j => Or.inr ⟨_, (r.moveRightSymm j).le⟩⟩
 decreasing_by pgame_wf_tac
-#align pgame.relabelling.le PGame.Relabelling.le
+#align pgame.relabelling.le SetTheory.PGame.Relabelling.le
 -/
 
-#print PGame.Relabelling.ge /-
-theorem ge {x y : PGame} (r : x ≡r y) : y ≤ x :=
+#print SetTheory.PGame.Relabelling.ge /-
+theorem SetTheory.PGame.Relabelling.ge {x y : SetTheory.PGame} (r : x ≡r y) : y ≤ x :=
   r.symm.le
-#align pgame.relabelling.ge PGame.Relabelling.ge
+#align pgame.relabelling.ge SetTheory.PGame.Relabelling.ge
 -/
 
-#print PGame.Relabelling.equiv /-
+#print SetTheory.PGame.Relabelling.equiv /-
 /-- A relabelling lets us prove equivalence of games. -/
-theorem equiv (r : x ≡r y) : x ≈ y :=
+theorem SetTheory.PGame.Relabelling.equiv (r : x ≡r y) : x ≈ y :=
   ⟨r.le, r.ge⟩
-#align pgame.relabelling.equiv PGame.Relabelling.equiv
+#align pgame.relabelling.equiv SetTheory.PGame.Relabelling.equiv
 -/
 
-#print PGame.Relabelling.trans /-
+#print SetTheory.PGame.Relabelling.trans /-
 /-- Transitivity of relabelling. -/
 @[trans]
-def trans : ∀ {x y z : PGame}, x ≡r y → y ≡r z → x ≡r z
+def SetTheory.PGame.Relabelling.trans : ∀ {x y z : SetTheory.PGame}, x ≡r y → y ≡r z → x ≡r z
   | x, y, z, ⟨L₁, R₁, hL₁, hR₁⟩, ⟨L₂, R₂, hL₂, hR₂⟩ =>
     ⟨L₁.trans L₂, R₁.trans R₂, fun i => (hL₁ i).trans (hL₂ _), fun j => (hR₁ j).trans (hR₂ _)⟩
-#align pgame.relabelling.trans PGame.Relabelling.trans
+#align pgame.relabelling.trans SetTheory.PGame.Relabelling.trans
 -/
 
-#print PGame.Relabelling.isEmpty /-
+#print SetTheory.PGame.Relabelling.isEmpty /-
 /-- Any game without left or right moves is a relabelling of 0. -/
-def isEmpty (x : PGame) [IsEmpty x.LeftMoves] [IsEmpty x.RightMoves] : x ≡r 0 :=
+def SetTheory.PGame.Relabelling.isEmpty (x : SetTheory.PGame) [IsEmpty x.LeftMoves]
+    [IsEmpty x.RightMoves] : x ≡r 0 :=
   ⟨Equiv.equivPEmpty _, Equiv.equivOfIsEmpty _ _, isEmptyElim, isEmptyElim⟩
-#align pgame.relabelling.is_empty PGame.Relabelling.isEmpty
+#align pgame.relabelling.is_empty SetTheory.PGame.Relabelling.isEmpty
 -/
 
 end Relabelling
 
-#print PGame.Equiv.isEmpty /-
-theorem Equiv.isEmpty (x : PGame) [IsEmpty x.LeftMoves] [IsEmpty x.RightMoves] : x ≈ 0 :=
-  (Relabelling.isEmpty x).Equiv
-#align pgame.equiv.is_empty PGame.Equiv.isEmpty
+#print SetTheory.PGame.Equiv.isEmpty /-
+theorem SetTheory.PGame.Equiv.isEmpty (x : SetTheory.PGame) [IsEmpty x.LeftMoves]
+    [IsEmpty x.RightMoves] : x ≈ 0 :=
+  (SetTheory.PGame.Relabelling.isEmpty x).Equiv
+#align pgame.equiv.is_empty SetTheory.PGame.Equiv.isEmpty
 -/
 
-instance {x y : PGame} : Coe (x ≡r y) (x ≈ y) :=
-  ⟨Relabelling.equiv⟩
+instance {x y : SetTheory.PGame} : Coe (x ≡r y) (x ≈ y) :=
+  ⟨SetTheory.PGame.Relabelling.equiv⟩
 
-#print PGame.relabel /-
+#print SetTheory.PGame.relabel /-
 /-- Replace the types indexing the next moves for Left and Right by equivalent types. -/
-def relabel {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves) : PGame :=
+def SetTheory.PGame.relabel {x : SetTheory.PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves)
+    (er : xr' ≃ x.RightMoves) : SetTheory.PGame :=
   ⟨xl', xr', x.moveLeft ∘ el, x.moveRight ∘ er⟩
-#align pgame.relabel PGame.relabel
+#align pgame.relabel SetTheory.PGame.relabel
 -/
 
-#print PGame.relabel_moveLeft' /-
+#print SetTheory.PGame.relabel_moveLeft' /-
 @[simp]
-theorem relabel_moveLeft' {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
-    (i : xl') : moveLeft (relabel el er) i = x.moveLeft (el i) :=
+theorem SetTheory.PGame.relabel_moveLeft' {x : SetTheory.PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves)
+    (er : xr' ≃ x.RightMoves) (i : xl') :
+    SetTheory.PGame.moveLeft (SetTheory.PGame.relabel el er) i = x.moveLeft (el i) :=
   rfl
-#align pgame.relabel_move_left' PGame.relabel_moveLeft'
+#align pgame.relabel_move_left' SetTheory.PGame.relabel_moveLeft'
 -/
 
-#print PGame.relabel_moveLeft /-
+#print SetTheory.PGame.relabel_moveLeft /-
 @[simp]
-theorem relabel_moveLeft {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
-    (i : x.LeftMoves) : moveLeft (relabel el er) (el.symm i) = x.moveLeft i := by simp
-#align pgame.relabel_move_left PGame.relabel_moveLeft
+theorem SetTheory.PGame.relabel_moveLeft {x : SetTheory.PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves)
+    (er : xr' ≃ x.RightMoves) (i : x.LeftMoves) :
+    SetTheory.PGame.moveLeft (SetTheory.PGame.relabel el er) (el.symm i) = x.moveLeft i := by simp
+#align pgame.relabel_move_left SetTheory.PGame.relabel_moveLeft
 -/
 
-#print PGame.relabel_moveRight' /-
+#print SetTheory.PGame.relabel_moveRight' /-
 @[simp]
-theorem relabel_moveRight' {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
-    (j : xr') : moveRight (relabel el er) j = x.moveRight (er j) :=
+theorem SetTheory.PGame.relabel_moveRight' {x : SetTheory.PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves)
+    (er : xr' ≃ x.RightMoves) (j : xr') :
+    SetTheory.PGame.moveRight (SetTheory.PGame.relabel el er) j = x.moveRight (er j) :=
   rfl
-#align pgame.relabel_move_right' PGame.relabel_moveRight'
+#align pgame.relabel_move_right' SetTheory.PGame.relabel_moveRight'
 -/
 
-#print PGame.relabel_moveRight /-
+#print SetTheory.PGame.relabel_moveRight /-
 @[simp]
-theorem relabel_moveRight {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
-    (j : x.RightMoves) : moveRight (relabel el er) (er.symm j) = x.moveRight j := by simp
-#align pgame.relabel_move_right PGame.relabel_moveRight
+theorem SetTheory.PGame.relabel_moveRight {x : SetTheory.PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves)
+    (er : xr' ≃ x.RightMoves) (j : x.RightMoves) :
+    SetTheory.PGame.moveRight (SetTheory.PGame.relabel el er) (er.symm j) = x.moveRight j := by simp
+#align pgame.relabel_move_right SetTheory.PGame.relabel_moveRight
 -/
 
-#print PGame.relabelRelabelling /-
+#print SetTheory.PGame.relabelRelabelling /-
 /-- The game obtained by relabelling the next moves is a relabelling of the original game. -/
-def relabelRelabelling {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves) :
-    x ≡r relabel el er :=
-  Relabelling.mk' el er (fun i => by simp) fun j => by simp
-#align pgame.relabel_relabelling PGame.relabelRelabelling
+def SetTheory.PGame.relabelRelabelling {x : SetTheory.PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves)
+    (er : xr' ≃ x.RightMoves) : x ≡r SetTheory.PGame.relabel el er :=
+  SetTheory.PGame.Relabelling.mk' el er (fun i => by simp) fun j => by simp
+#align pgame.relabel_relabelling SetTheory.PGame.relabelRelabelling
 -/
 
 /-! ### Negation -/
 
 
-#print PGame.neg /-
+#print SetTheory.PGame.neg /-
 /-- The negation of `{L | R}` is `{-R | -L}`. -/
-def neg : PGame → PGame
+def SetTheory.PGame.neg : SetTheory.PGame → SetTheory.PGame
   | ⟨l, r, L, R⟩ => ⟨r, l, fun i => neg (R i), fun i => neg (L i)⟩
-#align pgame.neg PGame.neg
+#align pgame.neg SetTheory.PGame.neg
 -/
 
-instance : Neg PGame :=
-  ⟨neg⟩
+instance : Neg SetTheory.PGame :=
+  ⟨SetTheory.PGame.neg⟩
 
-#print PGame.neg_def /-
+#print SetTheory.PGame.neg_def /-
 @[simp]
-theorem neg_def {xl xr xL xR} : -mk xl xr xL xR = mk xr xl (fun j => -xR j) fun i => -xL i :=
+theorem SetTheory.PGame.neg_def {xl xr xL xR} :
+    -SetTheory.PGame.mk xl xr xL xR = SetTheory.PGame.mk xr xl (fun j => -xR j) fun i => -xL i :=
   rfl
-#align pgame.neg_def PGame.neg_def
+#align pgame.neg_def SetTheory.PGame.neg_def
 -/
 
-instance : InvolutiveNeg PGame :=
-  { PGame.hasNeg with
+instance : InvolutiveNeg SetTheory.PGame :=
+  { SetTheory.PGame.hasNeg with
     neg_neg := fun x => by
       induction' x with xl xr xL xR ihL ihR
       simp_rw [neg_def, ihL, ihR]
       exact ⟨rfl, rfl, HEq.rfl, HEq.rfl⟩ }
 
-instance : NegZeroClass PGame :=
-  { PGame.hasZero, PGame.hasNeg with
+instance : NegZeroClass SetTheory.PGame :=
+  { SetTheory.PGame.hasZero, SetTheory.PGame.hasNeg with
     neg_zero := by
       dsimp [Zero.zero, Neg.neg, neg]
       congr <;> funext i <;> cases i }
 
-#print PGame.neg_ofLists /-
+#print SetTheory.PGame.neg_ofLists /-
 @[simp]
-theorem neg_ofLists (L R : List PGame) :
-    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) :=
+theorem SetTheory.PGame.neg_ofLists (L R : List SetTheory.PGame) :
+    -SetTheory.PGame.ofLists L R =
+      SetTheory.PGame.ofLists (R.map fun x => -x) (L.map fun x => -x) :=
   by
   simp only [of_lists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and_iff]
   constructor;
@@ -1549,115 +1626,118 @@ theorem neg_ofLists (L R : List PGame) :
           (b.down : ℕ) = ↑c.down :=
         by rintro m n rfl b c rfl; rfl
       exact this (List.length_map _ _).symm ha
-#align pgame.neg_of_lists PGame.neg_ofLists
+#align pgame.neg_of_lists SetTheory.PGame.neg_ofLists
 -/
 
-#print PGame.isOption_neg /-
-theorem isOption_neg {x y : PGame} : IsOption x (-y) ↔ IsOption (-x) y :=
+#print SetTheory.PGame.isOption_neg /-
+theorem SetTheory.PGame.isOption_neg {x y : SetTheory.PGame} :
+    SetTheory.PGame.IsOption x (-y) ↔ SetTheory.PGame.IsOption (-x) y :=
   by
   rw [is_option_iff, is_option_iff, or_comm']
   cases y; apply or_congr <;> · apply exists_congr; intro; rw [neg_eq_iff_eq_neg]; rfl
-#align pgame.is_option_neg PGame.isOption_neg
+#align pgame.is_option_neg SetTheory.PGame.isOption_neg
 -/
 
-#print PGame.isOption_neg_neg /-
+#print SetTheory.PGame.isOption_neg_neg /-
 @[simp]
-theorem isOption_neg_neg {x y : PGame} : IsOption (-x) (-y) ↔ IsOption x y := by
+theorem SetTheory.PGame.isOption_neg_neg {x y : SetTheory.PGame} :
+    SetTheory.PGame.IsOption (-x) (-y) ↔ SetTheory.PGame.IsOption x y := by
   rw [is_option_neg, neg_neg]
-#align pgame.is_option_neg_neg PGame.isOption_neg_neg
+#align pgame.is_option_neg_neg SetTheory.PGame.isOption_neg_neg
 -/
 
-#print PGame.leftMoves_neg /-
-theorem leftMoves_neg : ∀ x : PGame, (-x).LeftMoves = x.RightMoves
+#print SetTheory.PGame.leftMoves_neg /-
+theorem SetTheory.PGame.leftMoves_neg : ∀ x : SetTheory.PGame, (-x).LeftMoves = x.RightMoves
   | ⟨_, _, _, _⟩ => rfl
-#align pgame.left_moves_neg PGame.leftMoves_neg
+#align pgame.left_moves_neg SetTheory.PGame.leftMoves_neg
 -/
 
-#print PGame.rightMoves_neg /-
-theorem rightMoves_neg : ∀ x : PGame, (-x).RightMoves = x.LeftMoves
+#print SetTheory.PGame.rightMoves_neg /-
+theorem SetTheory.PGame.rightMoves_neg : ∀ x : SetTheory.PGame, (-x).RightMoves = x.LeftMoves
   | ⟨_, _, _, _⟩ => rfl
-#align pgame.right_moves_neg PGame.rightMoves_neg
+#align pgame.right_moves_neg SetTheory.PGame.rightMoves_neg
 -/
 
-#print PGame.toLeftMovesNeg /-
+#print SetTheory.PGame.toLeftMovesNeg /-
 /-- Turns a right move for `x` into a left move for `-x` and vice versa.
 
 Even though these types are the same (not definitionally so), this is the preferred way to convert
 between them. -/
-def toLeftMovesNeg {x : PGame} : x.RightMoves ≃ (-x).LeftMoves :=
-  Equiv.cast (leftMoves_neg x).symm
-#align pgame.to_left_moves_neg PGame.toLeftMovesNeg
+def SetTheory.PGame.toLeftMovesNeg {x : SetTheory.PGame} : x.RightMoves ≃ (-x).LeftMoves :=
+  Equiv.cast (SetTheory.PGame.leftMoves_neg x).symm
+#align pgame.to_left_moves_neg SetTheory.PGame.toLeftMovesNeg
 -/
 
-#print PGame.toRightMovesNeg /-
+#print SetTheory.PGame.toRightMovesNeg /-
 /-- Turns a left move for `x` into a right move for `-x` and vice versa.
 
 Even though these types are the same (not definitionally so), this is the preferred way to convert
 between them. -/
-def toRightMovesNeg {x : PGame} : x.LeftMoves ≃ (-x).RightMoves :=
-  Equiv.cast (rightMoves_neg x).symm
-#align pgame.to_right_moves_neg PGame.toRightMovesNeg
+def SetTheory.PGame.toRightMovesNeg {x : SetTheory.PGame} : x.LeftMoves ≃ (-x).RightMoves :=
+  Equiv.cast (SetTheory.PGame.rightMoves_neg x).symm
+#align pgame.to_right_moves_neg SetTheory.PGame.toRightMovesNeg
 -/
 
-#print PGame.moveLeft_neg /-
-theorem moveLeft_neg {x : PGame} (i) : (-x).moveLeft (toLeftMovesNeg i) = -x.moveRight i := by
-  cases x; rfl
-#align pgame.move_left_neg PGame.moveLeft_neg
+#print SetTheory.PGame.moveLeft_neg /-
+theorem SetTheory.PGame.moveLeft_neg {x : SetTheory.PGame} (i) :
+    (-x).moveLeft (SetTheory.PGame.toLeftMovesNeg i) = -x.moveRight i := by cases x; rfl
+#align pgame.move_left_neg SetTheory.PGame.moveLeft_neg
 -/
 
-#print PGame.moveLeft_neg' /-
+#print SetTheory.PGame.moveLeft_neg' /-
 @[simp]
-theorem moveLeft_neg' {x : PGame} (i) : (-x).moveLeft i = -x.moveRight (toLeftMovesNeg.symm i) := by
-  cases x; rfl
-#align pgame.move_left_neg' PGame.moveLeft_neg'
+theorem SetTheory.PGame.moveLeft_neg' {x : SetTheory.PGame} (i) :
+    (-x).moveLeft i = -x.moveRight (SetTheory.PGame.toLeftMovesNeg.symm i) := by cases x; rfl
+#align pgame.move_left_neg' SetTheory.PGame.moveLeft_neg'
 -/
 
-#print PGame.moveRight_neg /-
-theorem moveRight_neg {x : PGame} (i) : (-x).moveRight (toRightMovesNeg i) = -x.moveLeft i := by
-  cases x; rfl
-#align pgame.move_right_neg PGame.moveRight_neg
+#print SetTheory.PGame.moveRight_neg /-
+theorem SetTheory.PGame.moveRight_neg {x : SetTheory.PGame} (i) :
+    (-x).moveRight (SetTheory.PGame.toRightMovesNeg i) = -x.moveLeft i := by cases x; rfl
+#align pgame.move_right_neg SetTheory.PGame.moveRight_neg
 -/
 
-#print PGame.moveRight_neg' /-
+#print SetTheory.PGame.moveRight_neg' /-
 @[simp]
-theorem moveRight_neg' {x : PGame} (i) : (-x).moveRight i = -x.moveLeft (toRightMovesNeg.symm i) :=
-  by cases x; rfl
-#align pgame.move_right_neg' PGame.moveRight_neg'
+theorem SetTheory.PGame.moveRight_neg' {x : SetTheory.PGame} (i) :
+    (-x).moveRight i = -x.moveLeft (SetTheory.PGame.toRightMovesNeg.symm i) := by cases x; rfl
+#align pgame.move_right_neg' SetTheory.PGame.moveRight_neg'
 -/
 
-#print PGame.moveLeft_neg_symm /-
-theorem moveLeft_neg_symm {x : PGame} (i) :
-    x.moveLeft (toRightMovesNeg.symm i) = -(-x).moveRight i := by simp
-#align pgame.move_left_neg_symm PGame.moveLeft_neg_symm
+#print SetTheory.PGame.moveLeft_neg_symm /-
+theorem SetTheory.PGame.moveLeft_neg_symm {x : SetTheory.PGame} (i) :
+    x.moveLeft (SetTheory.PGame.toRightMovesNeg.symm i) = -(-x).moveRight i := by simp
+#align pgame.move_left_neg_symm SetTheory.PGame.moveLeft_neg_symm
 -/
 
-#print PGame.moveLeft_neg_symm' /-
-theorem moveLeft_neg_symm' {x : PGame} (i) : x.moveLeft i = -(-x).moveRight (toRightMovesNeg i) :=
-  by simp
-#align pgame.move_left_neg_symm' PGame.moveLeft_neg_symm'
+#print SetTheory.PGame.moveLeft_neg_symm' /-
+theorem SetTheory.PGame.moveLeft_neg_symm' {x : SetTheory.PGame} (i) :
+    x.moveLeft i = -(-x).moveRight (SetTheory.PGame.toRightMovesNeg i) := by simp
+#align pgame.move_left_neg_symm' SetTheory.PGame.moveLeft_neg_symm'
 -/
 
-#print PGame.moveRight_neg_symm /-
-theorem moveRight_neg_symm {x : PGame} (i) :
-    x.moveRight (toLeftMovesNeg.symm i) = -(-x).moveLeft i := by simp
-#align pgame.move_right_neg_symm PGame.moveRight_neg_symm
+#print SetTheory.PGame.moveRight_neg_symm /-
+theorem SetTheory.PGame.moveRight_neg_symm {x : SetTheory.PGame} (i) :
+    x.moveRight (SetTheory.PGame.toLeftMovesNeg.symm i) = -(-x).moveLeft i := by simp
+#align pgame.move_right_neg_symm SetTheory.PGame.moveRight_neg_symm
 -/
 
-#print PGame.moveRight_neg_symm' /-
-theorem moveRight_neg_symm' {x : PGame} (i) : x.moveRight i = -(-x).moveLeft (toLeftMovesNeg i) :=
-  by simp
-#align pgame.move_right_neg_symm' PGame.moveRight_neg_symm'
+#print SetTheory.PGame.moveRight_neg_symm' /-
+theorem SetTheory.PGame.moveRight_neg_symm' {x : SetTheory.PGame} (i) :
+    x.moveRight i = -(-x).moveLeft (SetTheory.PGame.toLeftMovesNeg i) := by simp
+#align pgame.move_right_neg_symm' SetTheory.PGame.moveRight_neg_symm'
 -/
 
-#print PGame.Relabelling.negCongr /-
+#print SetTheory.PGame.Relabelling.negCongr /-
 /-- If `x` has the same moves as `y`, then `-x` has the sames moves as `-y`. -/
-def Relabelling.negCongr : ∀ {x y : PGame}, x ≡r y → -x ≡r -y
+def SetTheory.PGame.Relabelling.negCongr : ∀ {x y : SetTheory.PGame}, x ≡r y → -x ≡r -y
   | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩, ⟨L, R, hL, hR⟩ =>
     ⟨R, L, fun j => (hR j).negCongr, fun i => (hL i).negCongr⟩
-#align pgame.relabelling.neg_congr PGame.Relabelling.negCongr
+#align pgame.relabelling.neg_congr SetTheory.PGame.Relabelling.negCongr
 -/
 
-private theorem neg_le_lf_neg_iff : ∀ {x y : PGame.{u}}, (-y ≤ -x ↔ x ≤ y) ∧ (-y ⧏ -x ↔ x ⧏ y)
+private theorem neg_le_lf_neg_iff :
+    ∀ {x y : SetTheory.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]
@@ -1666,148 +1746,164 @@ private theorem neg_le_lf_neg_iff : ∀ {x y : PGame.{u}}, (-y ≤ -x ↔ x ≤
     · rw [or_comm']; apply or_congr <;> exact exists_congr fun _ => neg_le_lf_neg_iff.1
 decreasing_by pgame_wf_tac
 
-#print PGame.neg_le_neg_iff /-
+#print SetTheory.PGame.neg_le_neg_iff /-
 @[simp]
-theorem neg_le_neg_iff {x y : PGame} : -y ≤ -x ↔ x ≤ y :=
+theorem SetTheory.PGame.neg_le_neg_iff {x y : SetTheory.PGame} : -y ≤ -x ↔ x ≤ y :=
   neg_le_lf_neg_iff.1
-#align pgame.neg_le_neg_iff PGame.neg_le_neg_iff
+#align pgame.neg_le_neg_iff SetTheory.PGame.neg_le_neg_iff
 -/
 
-#print PGame.neg_lf_neg_iff /-
+#print SetTheory.PGame.neg_lf_neg_iff /-
 @[simp]
-theorem neg_lf_neg_iff {x y : PGame} : -y ⧏ -x ↔ x ⧏ y :=
+theorem SetTheory.PGame.neg_lf_neg_iff {x y : SetTheory.PGame} : -y ⧏ -x ↔ x ⧏ y :=
   neg_le_lf_neg_iff.2
-#align pgame.neg_lf_neg_iff PGame.neg_lf_neg_iff
+#align pgame.neg_lf_neg_iff SetTheory.PGame.neg_lf_neg_iff
 -/
 
-#print PGame.neg_lt_neg_iff /-
+#print SetTheory.PGame.neg_lt_neg_iff /-
 @[simp]
-theorem neg_lt_neg_iff {x y : PGame} : -y < -x ↔ x < y := by
+theorem SetTheory.PGame.neg_lt_neg_iff {x y : SetTheory.PGame} : -y < -x ↔ x < y := by
   rw [lt_iff_le_and_lf, lt_iff_le_and_lf, neg_le_neg_iff, neg_lf_neg_iff]
-#align pgame.neg_lt_neg_iff PGame.neg_lt_neg_iff
+#align pgame.neg_lt_neg_iff SetTheory.PGame.neg_lt_neg_iff
 -/
 
-#print PGame.neg_equiv_neg_iff /-
+#print SetTheory.PGame.neg_equiv_neg_iff /-
 @[simp]
-theorem neg_equiv_neg_iff {x y : PGame} : (-x ≈ -y) ↔ (x ≈ y) := by
+theorem SetTheory.PGame.neg_equiv_neg_iff {x y : SetTheory.PGame} : (-x ≈ -y) ↔ (x ≈ y) := by
   rw [Equiv, Equiv, neg_le_neg_iff, neg_le_neg_iff, and_comm]
-#align pgame.neg_equiv_neg_iff PGame.neg_equiv_neg_iff
+#align pgame.neg_equiv_neg_iff SetTheory.PGame.neg_equiv_neg_iff
 -/
 
-#print PGame.neg_fuzzy_neg_iff /-
+#print SetTheory.PGame.neg_fuzzy_neg_iff /-
 @[simp]
-theorem neg_fuzzy_neg_iff {x y : PGame} : -x ‖ -y ↔ x ‖ y := by
+theorem SetTheory.PGame.neg_fuzzy_neg_iff {x y : SetTheory.PGame} : -x ‖ -y ↔ x ‖ y := by
   rw [fuzzy, fuzzy, neg_lf_neg_iff, neg_lf_neg_iff, and_comm]
-#align pgame.neg_fuzzy_neg_iff PGame.neg_fuzzy_neg_iff
+#align pgame.neg_fuzzy_neg_iff SetTheory.PGame.neg_fuzzy_neg_iff
 -/
 
-#print PGame.neg_le_iff /-
-theorem neg_le_iff {x y : PGame} : -y ≤ x ↔ -x ≤ y := by rw [← neg_neg x, neg_le_neg_iff, neg_neg]
-#align pgame.neg_le_iff PGame.neg_le_iff
+#print SetTheory.PGame.neg_le_iff /-
+theorem SetTheory.PGame.neg_le_iff {x y : SetTheory.PGame} : -y ≤ x ↔ -x ≤ y := by
+  rw [← neg_neg x, neg_le_neg_iff, neg_neg]
+#align pgame.neg_le_iff SetTheory.PGame.neg_le_iff
 -/
 
-#print PGame.neg_lf_iff /-
-theorem neg_lf_iff {x y : PGame} : -y ⧏ x ↔ -x ⧏ y := by rw [← neg_neg x, neg_lf_neg_iff, neg_neg]
-#align pgame.neg_lf_iff PGame.neg_lf_iff
+#print SetTheory.PGame.neg_lf_iff /-
+theorem SetTheory.PGame.neg_lf_iff {x y : SetTheory.PGame} : -y ⧏ x ↔ -x ⧏ y := by
+  rw [← neg_neg x, neg_lf_neg_iff, neg_neg]
+#align pgame.neg_lf_iff SetTheory.PGame.neg_lf_iff
 -/
 
-#print PGame.neg_lt_iff /-
-theorem neg_lt_iff {x y : PGame} : -y < x ↔ -x < y := by rw [← neg_neg x, neg_lt_neg_iff, neg_neg]
-#align pgame.neg_lt_iff PGame.neg_lt_iff
+#print SetTheory.PGame.neg_lt_iff /-
+theorem SetTheory.PGame.neg_lt_iff {x y : SetTheory.PGame} : -y < x ↔ -x < y := by
+  rw [← neg_neg x, neg_lt_neg_iff, neg_neg]
+#align pgame.neg_lt_iff SetTheory.PGame.neg_lt_iff
 -/
 
-#print PGame.neg_equiv_iff /-
-theorem neg_equiv_iff {x y : PGame} : (-x ≈ y) ↔ (x ≈ -y) := by
+#print SetTheory.PGame.neg_equiv_iff /-
+theorem SetTheory.PGame.neg_equiv_iff {x y : SetTheory.PGame} : (-x ≈ y) ↔ (x ≈ -y) := by
   rw [← neg_neg y, neg_equiv_neg_iff, neg_neg]
-#align pgame.neg_equiv_iff PGame.neg_equiv_iff
+#align pgame.neg_equiv_iff SetTheory.PGame.neg_equiv_iff
 -/
 
-#print PGame.neg_fuzzy_iff /-
-theorem neg_fuzzy_iff {x y : PGame} : -x ‖ y ↔ x ‖ -y := by
+#print SetTheory.PGame.neg_fuzzy_iff /-
+theorem SetTheory.PGame.neg_fuzzy_iff {x y : SetTheory.PGame} : -x ‖ y ↔ x ‖ -y := by
   rw [← neg_neg y, neg_fuzzy_neg_iff, neg_neg]
-#align pgame.neg_fuzzy_iff PGame.neg_fuzzy_iff
+#align pgame.neg_fuzzy_iff SetTheory.PGame.neg_fuzzy_iff
 -/
 
-#print PGame.le_neg_iff /-
-theorem le_neg_iff {x y : PGame} : y ≤ -x ↔ x ≤ -y := by rw [← neg_neg x, neg_le_neg_iff, neg_neg]
-#align pgame.le_neg_iff PGame.le_neg_iff
+#print SetTheory.PGame.le_neg_iff /-
+theorem SetTheory.PGame.le_neg_iff {x y : SetTheory.PGame} : y ≤ -x ↔ x ≤ -y := by
+  rw [← neg_neg x, neg_le_neg_iff, neg_neg]
+#align pgame.le_neg_iff SetTheory.PGame.le_neg_iff
 -/
 
-#print PGame.lf_neg_iff /-
-theorem lf_neg_iff {x y : PGame} : y ⧏ -x ↔ x ⧏ -y := by rw [← neg_neg x, neg_lf_neg_iff, neg_neg]
-#align pgame.lf_neg_iff PGame.lf_neg_iff
+#print SetTheory.PGame.lf_neg_iff /-
+theorem SetTheory.PGame.lf_neg_iff {x y : SetTheory.PGame} : y ⧏ -x ↔ x ⧏ -y := by
+  rw [← neg_neg x, neg_lf_neg_iff, neg_neg]
+#align pgame.lf_neg_iff SetTheory.PGame.lf_neg_iff
 -/
 
-#print PGame.lt_neg_iff /-
-theorem lt_neg_iff {x y : PGame} : y < -x ↔ x < -y := by rw [← neg_neg x, neg_lt_neg_iff, neg_neg]
-#align pgame.lt_neg_iff PGame.lt_neg_iff
+#print SetTheory.PGame.lt_neg_iff /-
+theorem SetTheory.PGame.lt_neg_iff {x y : SetTheory.PGame} : y < -x ↔ x < -y := by
+  rw [← neg_neg x, neg_lt_neg_iff, neg_neg]
+#align pgame.lt_neg_iff SetTheory.PGame.lt_neg_iff
 -/
 
-#print PGame.neg_le_zero_iff /-
+#print SetTheory.PGame.neg_le_zero_iff /-
 @[simp]
-theorem neg_le_zero_iff {x : PGame} : -x ≤ 0 ↔ 0 ≤ x := by rw [neg_le_iff, neg_zero]
-#align pgame.neg_le_zero_iff PGame.neg_le_zero_iff
+theorem SetTheory.PGame.neg_le_zero_iff {x : SetTheory.PGame} : -x ≤ 0 ↔ 0 ≤ x := by
+  rw [neg_le_iff, neg_zero]
+#align pgame.neg_le_zero_iff SetTheory.PGame.neg_le_zero_iff
 -/
 
-#print PGame.zero_le_neg_iff /-
+#print SetTheory.PGame.zero_le_neg_iff /-
 @[simp]
-theorem zero_le_neg_iff {x : PGame} : 0 ≤ -x ↔ x ≤ 0 := by rw [le_neg_iff, neg_zero]
-#align pgame.zero_le_neg_iff PGame.zero_le_neg_iff
+theorem SetTheory.PGame.zero_le_neg_iff {x : SetTheory.PGame} : 0 ≤ -x ↔ x ≤ 0 := by
+  rw [le_neg_iff, neg_zero]
+#align pgame.zero_le_neg_iff SetTheory.PGame.zero_le_neg_iff
 -/
 
-#print PGame.neg_lf_zero_iff /-
+#print SetTheory.PGame.neg_lf_zero_iff /-
 @[simp]
-theorem neg_lf_zero_iff {x : PGame} : -x ⧏ 0 ↔ 0 ⧏ x := by rw [neg_lf_iff, neg_zero]
-#align pgame.neg_lf_zero_iff PGame.neg_lf_zero_iff
+theorem SetTheory.PGame.neg_lf_zero_iff {x : SetTheory.PGame} : -x ⧏ 0 ↔ 0 ⧏ x := by
+  rw [neg_lf_iff, neg_zero]
+#align pgame.neg_lf_zero_iff SetTheory.PGame.neg_lf_zero_iff
 -/
 
-#print PGame.zero_lf_neg_iff /-
+#print SetTheory.PGame.zero_lf_neg_iff /-
 @[simp]
-theorem zero_lf_neg_iff {x : PGame} : 0 ⧏ -x ↔ x ⧏ 0 := by rw [lf_neg_iff, neg_zero]
-#align pgame.zero_lf_neg_iff PGame.zero_lf_neg_iff
+theorem SetTheory.PGame.zero_lf_neg_iff {x : SetTheory.PGame} : 0 ⧏ -x ↔ x ⧏ 0 := by
+  rw [lf_neg_iff, neg_zero]
+#align pgame.zero_lf_neg_iff SetTheory.PGame.zero_lf_neg_iff
 -/
 
-#print PGame.neg_lt_zero_iff /-
+#print SetTheory.PGame.neg_lt_zero_iff /-
 @[simp]
-theorem neg_lt_zero_iff {x : PGame} : -x < 0 ↔ 0 < x := by rw [neg_lt_iff, neg_zero]
-#align pgame.neg_lt_zero_iff PGame.neg_lt_zero_iff
+theorem SetTheory.PGame.neg_lt_zero_iff {x : SetTheory.PGame} : -x < 0 ↔ 0 < x := by
+  rw [neg_lt_iff, neg_zero]
+#align pgame.neg_lt_zero_iff SetTheory.PGame.neg_lt_zero_iff
 -/
 
-#print PGame.zero_lt_neg_iff /-
+#print SetTheory.PGame.zero_lt_neg_iff /-
 @[simp]
-theorem zero_lt_neg_iff {x : PGame} : 0 < -x ↔ x < 0 := by rw [lt_neg_iff, neg_zero]
-#align pgame.zero_lt_neg_iff PGame.zero_lt_neg_iff
+theorem SetTheory.PGame.zero_lt_neg_iff {x : SetTheory.PGame} : 0 < -x ↔ x < 0 := by
+  rw [lt_neg_iff, neg_zero]
+#align pgame.zero_lt_neg_iff SetTheory.PGame.zero_lt_neg_iff
 -/
 
-#print PGame.neg_equiv_zero_iff /-
+#print SetTheory.PGame.neg_equiv_zero_iff /-
 @[simp]
-theorem neg_equiv_zero_iff {x : PGame} : (-x ≈ 0) ↔ (x ≈ 0) := by rw [neg_equiv_iff, neg_zero]
-#align pgame.neg_equiv_zero_iff PGame.neg_equiv_zero_iff
+theorem SetTheory.PGame.neg_equiv_zero_iff {x : SetTheory.PGame} : (-x ≈ 0) ↔ (x ≈ 0) := by
+  rw [neg_equiv_iff, neg_zero]
+#align pgame.neg_equiv_zero_iff SetTheory.PGame.neg_equiv_zero_iff
 -/
 
-#print PGame.neg_fuzzy_zero_iff /-
+#print SetTheory.PGame.neg_fuzzy_zero_iff /-
 @[simp]
-theorem neg_fuzzy_zero_iff {x : PGame} : -x ‖ 0 ↔ x ‖ 0 := by rw [neg_fuzzy_iff, neg_zero]
-#align pgame.neg_fuzzy_zero_iff PGame.neg_fuzzy_zero_iff
+theorem SetTheory.PGame.neg_fuzzy_zero_iff {x : SetTheory.PGame} : -x ‖ 0 ↔ x ‖ 0 := by
+  rw [neg_fuzzy_iff, neg_zero]
+#align pgame.neg_fuzzy_zero_iff SetTheory.PGame.neg_fuzzy_zero_iff
 -/
 
-#print PGame.zero_equiv_neg_iff /-
+#print SetTheory.PGame.zero_equiv_neg_iff /-
 @[simp]
-theorem zero_equiv_neg_iff {x : PGame} : (0 ≈ -x) ↔ (0 ≈ x) := by rw [← neg_equiv_iff, neg_zero]
-#align pgame.zero_equiv_neg_iff PGame.zero_equiv_neg_iff
+theorem SetTheory.PGame.zero_equiv_neg_iff {x : SetTheory.PGame} : (0 ≈ -x) ↔ (0 ≈ x) := by
+  rw [← neg_equiv_iff, neg_zero]
+#align pgame.zero_equiv_neg_iff SetTheory.PGame.zero_equiv_neg_iff
 -/
 
-#print PGame.zero_fuzzy_neg_iff /-
+#print SetTheory.PGame.zero_fuzzy_neg_iff /-
 @[simp]
-theorem zero_fuzzy_neg_iff {x : PGame} : 0 ‖ -x ↔ 0 ‖ x := by rw [← neg_fuzzy_iff, neg_zero]
-#align pgame.zero_fuzzy_neg_iff PGame.zero_fuzzy_neg_iff
+theorem SetTheory.PGame.zero_fuzzy_neg_iff {x : SetTheory.PGame} : 0 ‖ -x ↔ 0 ‖ x := by
+  rw [← neg_fuzzy_iff, neg_zero]
+#align pgame.zero_fuzzy_neg_iff SetTheory.PGame.zero_fuzzy_neg_iff
 -/
 
 /-! ### Addition and subtraction -/
 
 
 /-- The sum of `x = {xL | xR}` and `y = {yL | yR}` is `{xL + y, x + yL | xR + y, x + yR}`. -/
-instance : Add PGame.{u} :=
+instance : Add SetTheory.PGame.{u} :=
   ⟨fun x y => by
     induction' x with xl xr xL xR IHxl IHxr generalizing y
     induction' y with yl yr yL yR IHyl IHyr
@@ -1819,198 +1915,211 @@ instance : Add PGame.{u} :=
     · exact IHyr⟩
 
 /-- The pre-game `((0+1)+⋯)+1`. -/
-instance : NatCast PGame :=
+instance : NatCast SetTheory.PGame :=
   ⟨Nat.unaryCast⟩
 
-#print PGame.nat_succ /-
+#print SetTheory.PGame.nat_succ /-
 @[simp]
-protected theorem nat_succ (n : ℕ) : ((n + 1 : ℕ) : PGame) = n + 1 :=
+protected theorem SetTheory.PGame.nat_succ (n : ℕ) : ((n + 1 : ℕ) : SetTheory.PGame) = n + 1 :=
   rfl
-#align pgame.nat_succ PGame.nat_succ
+#align pgame.nat_succ SetTheory.PGame.nat_succ
 -/
 
-#print PGame.isEmpty_leftMoves_add /-
-instance isEmpty_leftMoves_add (x y : PGame.{u}) [IsEmpty x.LeftMoves] [IsEmpty y.LeftMoves] :
-    IsEmpty (x + y).LeftMoves := by
+#print SetTheory.PGame.isEmpty_leftMoves_add /-
+instance SetTheory.PGame.isEmpty_leftMoves_add (x y : SetTheory.PGame.{u}) [IsEmpty x.LeftMoves]
+    [IsEmpty y.LeftMoves] : IsEmpty (x + y).LeftMoves :=
+  by
   cases x; cases y
   apply isEmpty_sum.2 ⟨_, _⟩
   assumption'
-#align pgame.is_empty_left_moves_add PGame.isEmpty_leftMoves_add
+#align pgame.is_empty_left_moves_add SetTheory.PGame.isEmpty_leftMoves_add
 -/
 
-#print PGame.isEmpty_rightMoves_add /-
-instance isEmpty_rightMoves_add (x y : PGame.{u}) [IsEmpty x.RightMoves] [IsEmpty y.RightMoves] :
-    IsEmpty (x + y).RightMoves := by
+#print SetTheory.PGame.isEmpty_rightMoves_add /-
+instance SetTheory.PGame.isEmpty_rightMoves_add (x y : SetTheory.PGame.{u}) [IsEmpty x.RightMoves]
+    [IsEmpty y.RightMoves] : IsEmpty (x + y).RightMoves :=
+  by
   cases x; cases y
   apply isEmpty_sum.2 ⟨_, _⟩
   assumption'
-#align pgame.is_empty_right_moves_add PGame.isEmpty_rightMoves_add
+#align pgame.is_empty_right_moves_add SetTheory.PGame.isEmpty_rightMoves_add
 -/
 
-#print PGame.addZeroRelabelling /-
+#print SetTheory.PGame.addZeroRelabelling /-
 /-- `x + 0` has exactly the same moves as `x`. -/
-def addZeroRelabelling : ∀ x : PGame.{u}, x + 0 ≡r x
+def SetTheory.PGame.addZeroRelabelling : ∀ x : SetTheory.PGame.{u}, x + 0 ≡r x
   | ⟨xl, xr, xL, xR⟩ => by
     refine' ⟨Equiv.sumEmpty xl PEmpty, Equiv.sumEmpty xr PEmpty, _, _⟩ <;> rintro (⟨i⟩ | ⟨⟨⟩⟩) <;>
       apply add_zero_relabelling
-#align pgame.add_zero_relabelling PGame.addZeroRelabelling
+#align pgame.add_zero_relabelling SetTheory.PGame.addZeroRelabelling
 -/
 
-#print PGame.add_zero_equiv /-
+#print SetTheory.PGame.add_zero_equiv /-
 /-- `x + 0` is equivalent to `x`. -/
-theorem add_zero_equiv (x : PGame.{u}) : x + 0 ≈ x :=
-  (addZeroRelabelling x).Equiv
-#align pgame.add_zero_equiv PGame.add_zero_equiv
+theorem SetTheory.PGame.add_zero_equiv (x : SetTheory.PGame.{u}) : x + 0 ≈ x :=
+  (SetTheory.PGame.addZeroRelabelling x).Equiv
+#align pgame.add_zero_equiv SetTheory.PGame.add_zero_equiv
 -/
 
-#print PGame.zeroAddRelabelling /-
+#print SetTheory.PGame.zeroAddRelabelling /-
 /-- `0 + x` has exactly the same moves as `x`. -/
-def zeroAddRelabelling : ∀ x : PGame.{u}, 0 + x ≡r x
+def SetTheory.PGame.zeroAddRelabelling : ∀ x : SetTheory.PGame.{u}, 0 + x ≡r x
   | ⟨xl, xr, xL, xR⟩ => by
     refine' ⟨Equiv.emptySum PEmpty xl, Equiv.emptySum PEmpty xr, _, _⟩ <;> rintro (⟨⟨⟩⟩ | ⟨i⟩) <;>
       apply zero_add_relabelling
-#align pgame.zero_add_relabelling PGame.zeroAddRelabelling
+#align pgame.zero_add_relabelling SetTheory.PGame.zeroAddRelabelling
 -/
 
-#print PGame.zero_add_equiv /-
+#print SetTheory.PGame.zero_add_equiv /-
 /-- `0 + x` is equivalent to `x`. -/
-theorem zero_add_equiv (x : PGame.{u}) : 0 + x ≈ x :=
-  (zeroAddRelabelling x).Equiv
-#align pgame.zero_add_equiv PGame.zero_add_equiv
+theorem SetTheory.PGame.zero_add_equiv (x : SetTheory.PGame.{u}) : 0 + x ≈ x :=
+  (SetTheory.PGame.zeroAddRelabelling x).Equiv
+#align pgame.zero_add_equiv SetTheory.PGame.zero_add_equiv
 -/
 
-#print PGame.leftMoves_add /-
-theorem leftMoves_add : ∀ x y : PGame.{u}, (x + y).LeftMoves = Sum x.LeftMoves y.LeftMoves
+#print SetTheory.PGame.leftMoves_add /-
+theorem SetTheory.PGame.leftMoves_add :
+    ∀ x y : SetTheory.PGame.{u}, (x + y).LeftMoves = Sum x.LeftMoves y.LeftMoves
   | ⟨_, _, _, _⟩, ⟨_, _, _, _⟩ => rfl
-#align pgame.left_moves_add PGame.leftMoves_add
+#align pgame.left_moves_add SetTheory.PGame.leftMoves_add
 -/
 
-#print PGame.rightMoves_add /-
-theorem rightMoves_add : ∀ x y : PGame.{u}, (x + y).RightMoves = Sum x.RightMoves y.RightMoves
+#print SetTheory.PGame.rightMoves_add /-
+theorem SetTheory.PGame.rightMoves_add :
+    ∀ x y : SetTheory.PGame.{u}, (x + y).RightMoves = Sum x.RightMoves y.RightMoves
   | ⟨_, _, _, _⟩, ⟨_, _, _, _⟩ => rfl
-#align pgame.right_moves_add PGame.rightMoves_add
+#align pgame.right_moves_add SetTheory.PGame.rightMoves_add
 -/
 
-#print PGame.toLeftMovesAdd /-
+#print SetTheory.PGame.toLeftMovesAdd /-
 /-- Converts a left move for `x` or `y` into a left move for `x + y` and vice versa.
 
 Even though these types are the same (not definitionally so), this is the preferred way to convert
 between them. -/
-def toLeftMovesAdd {x y : PGame} : Sum x.LeftMoves y.LeftMoves ≃ (x + y).LeftMoves :=
-  Equiv.cast (leftMoves_add x y).symm
-#align pgame.to_left_moves_add PGame.toLeftMovesAdd
+def SetTheory.PGame.toLeftMovesAdd {x y : SetTheory.PGame} :
+    Sum x.LeftMoves y.LeftMoves ≃ (x + y).LeftMoves :=
+  Equiv.cast (SetTheory.PGame.leftMoves_add x y).symm
+#align pgame.to_left_moves_add SetTheory.PGame.toLeftMovesAdd
 -/
 
-#print PGame.toRightMovesAdd /-
+#print SetTheory.PGame.toRightMovesAdd /-
 /-- Converts a right move for `x` or `y` into a right move for `x + y` and vice versa.
 
 Even though these types are the same (not definitionally so), this is the preferred way to convert
 between them. -/
-def toRightMovesAdd {x y : PGame} : Sum x.RightMoves y.RightMoves ≃ (x + y).RightMoves :=
-  Equiv.cast (rightMoves_add x y).symm
-#align pgame.to_right_moves_add PGame.toRightMovesAdd
+def SetTheory.PGame.toRightMovesAdd {x y : SetTheory.PGame} :
+    Sum x.RightMoves y.RightMoves ≃ (x + y).RightMoves :=
+  Equiv.cast (SetTheory.PGame.rightMoves_add x y).symm
+#align pgame.to_right_moves_add SetTheory.PGame.toRightMovesAdd
 -/
 
-#print PGame.mk_add_moveLeft_inl /-
+#print SetTheory.PGame.mk_add_moveLeft_inl /-
 @[simp]
-theorem mk_add_moveLeft_inl {xl xr yl yr} {xL xR yL yR} {i} :
-    (mk xl xr xL xR + mk yl yr yL yR).moveLeft (Sum.inl i) =
-      (mk xl xr xL xR).moveLeft i + mk yl yr yL yR :=
+theorem SetTheory.PGame.mk_add_moveLeft_inl {xl xr yl yr} {xL xR yL yR} {i} :
+    (SetTheory.PGame.mk xl xr xL xR + SetTheory.PGame.mk yl yr yL yR).moveLeft (Sum.inl i) =
+      (SetTheory.PGame.mk xl xr xL xR).moveLeft i + SetTheory.PGame.mk yl yr yL yR :=
   rfl
-#align pgame.mk_add_move_left_inl PGame.mk_add_moveLeft_inl
+#align pgame.mk_add_move_left_inl SetTheory.PGame.mk_add_moveLeft_inl
 -/
 
-#print PGame.add_moveLeft_inl /-
+#print SetTheory.PGame.add_moveLeft_inl /-
 @[simp]
-theorem add_moveLeft_inl {x : PGame} (y : PGame) (i) :
-    (x + y).moveLeft (toLeftMovesAdd (Sum.inl i)) = x.moveLeft i + y := by cases x; cases y; rfl
-#align pgame.add_move_left_inl PGame.add_moveLeft_inl
+theorem SetTheory.PGame.add_moveLeft_inl {x : SetTheory.PGame} (y : SetTheory.PGame) (i) :
+    (x + y).moveLeft (SetTheory.PGame.toLeftMovesAdd (Sum.inl i)) = x.moveLeft i + y := by cases x;
+  cases y; rfl
+#align pgame.add_move_left_inl SetTheory.PGame.add_moveLeft_inl
 -/
 
-#print PGame.mk_add_moveRight_inl /-
+#print SetTheory.PGame.mk_add_moveRight_inl /-
 @[simp]
-theorem mk_add_moveRight_inl {xl xr yl yr} {xL xR yL yR} {i} :
-    (mk xl xr xL xR + mk yl yr yL yR).moveRight (Sum.inl i) =
-      (mk xl xr xL xR).moveRight i + mk yl yr yL yR :=
+theorem SetTheory.PGame.mk_add_moveRight_inl {xl xr yl yr} {xL xR yL yR} {i} :
+    (SetTheory.PGame.mk xl xr xL xR + SetTheory.PGame.mk yl yr yL yR).moveRight (Sum.inl i) =
+      (SetTheory.PGame.mk xl xr xL xR).moveRight i + SetTheory.PGame.mk yl yr yL yR :=
   rfl
-#align pgame.mk_add_move_right_inl PGame.mk_add_moveRight_inl
+#align pgame.mk_add_move_right_inl SetTheory.PGame.mk_add_moveRight_inl
 -/
 
-#print PGame.add_moveRight_inl /-
+#print SetTheory.PGame.add_moveRight_inl /-
 @[simp]
-theorem add_moveRight_inl {x : PGame} (y : PGame) (i) :
-    (x + y).moveRight (toRightMovesAdd (Sum.inl i)) = x.moveRight i + y := by cases x; cases y; rfl
-#align pgame.add_move_right_inl PGame.add_moveRight_inl
+theorem SetTheory.PGame.add_moveRight_inl {x : SetTheory.PGame} (y : SetTheory.PGame) (i) :
+    (x + y).moveRight (SetTheory.PGame.toRightMovesAdd (Sum.inl i)) = x.moveRight i + y := by
+  cases x; cases y; rfl
+#align pgame.add_move_right_inl SetTheory.PGame.add_moveRight_inl
 -/
 
-#print PGame.mk_add_moveLeft_inr /-
+#print SetTheory.PGame.mk_add_moveLeft_inr /-
 @[simp]
-theorem mk_add_moveLeft_inr {xl xr yl yr} {xL xR yL yR} {i} :
-    (mk xl xr xL xR + mk yl yr yL yR).moveLeft (Sum.inr i) =
-      mk xl xr xL xR + (mk yl yr yL yR).moveLeft i :=
+theorem SetTheory.PGame.mk_add_moveLeft_inr {xl xr yl yr} {xL xR yL yR} {i} :
+    (SetTheory.PGame.mk xl xr xL xR + SetTheory.PGame.mk yl yr yL yR).moveLeft (Sum.inr i) =
+      SetTheory.PGame.mk xl xr xL xR + (SetTheory.PGame.mk yl yr yL yR).moveLeft i :=
   rfl
-#align pgame.mk_add_move_left_inr PGame.mk_add_moveLeft_inr
+#align pgame.mk_add_move_left_inr SetTheory.PGame.mk_add_moveLeft_inr
 -/
 
-#print PGame.add_moveLeft_inr /-
+#print SetTheory.PGame.add_moveLeft_inr /-
 @[simp]
-theorem add_moveLeft_inr (x : PGame) {y : PGame} (i) :
-    (x + y).moveLeft (toLeftMovesAdd (Sum.inr i)) = x + y.moveLeft i := by cases x; cases y; rfl
-#align pgame.add_move_left_inr PGame.add_moveLeft_inr
+theorem SetTheory.PGame.add_moveLeft_inr (x : SetTheory.PGame) {y : SetTheory.PGame} (i) :
+    (x + y).moveLeft (SetTheory.PGame.toLeftMovesAdd (Sum.inr i)) = x + y.moveLeft i := by cases x;
+  cases y; rfl
+#align pgame.add_move_left_inr SetTheory.PGame.add_moveLeft_inr
 -/
 
-#print PGame.mk_add_moveRight_inr /-
+#print SetTheory.PGame.mk_add_moveRight_inr /-
 @[simp]
-theorem mk_add_moveRight_inr {xl xr yl yr} {xL xR yL yR} {i} :
-    (mk xl xr xL xR + mk yl yr yL yR).moveRight (Sum.inr i) =
-      mk xl xr xL xR + (mk yl yr yL yR).moveRight i :=
+theorem SetTheory.PGame.mk_add_moveRight_inr {xl xr yl yr} {xL xR yL yR} {i} :
+    (SetTheory.PGame.mk xl xr xL xR + SetTheory.PGame.mk yl yr yL yR).moveRight (Sum.inr i) =
+      SetTheory.PGame.mk xl xr xL xR + (SetTheory.PGame.mk yl yr yL yR).moveRight i :=
   rfl
-#align pgame.mk_add_move_right_inr PGame.mk_add_moveRight_inr
+#align pgame.mk_add_move_right_inr SetTheory.PGame.mk_add_moveRight_inr
 -/
 
-#print PGame.add_moveRight_inr /-
+#print SetTheory.PGame.add_moveRight_inr /-
 @[simp]
-theorem add_moveRight_inr (x : PGame) {y : PGame} (i) :
-    (x + y).moveRight (toRightMovesAdd (Sum.inr i)) = x + y.moveRight i := by cases x; cases y; rfl
-#align pgame.add_move_right_inr PGame.add_moveRight_inr
+theorem SetTheory.PGame.add_moveRight_inr (x : SetTheory.PGame) {y : SetTheory.PGame} (i) :
+    (x + y).moveRight (SetTheory.PGame.toRightMovesAdd (Sum.inr i)) = x + y.moveRight i := by
+  cases x; cases y; rfl
+#align pgame.add_move_right_inr SetTheory.PGame.add_moveRight_inr
 -/
 
-#print PGame.leftMoves_add_cases /-
-theorem leftMoves_add_cases {x y : PGame} (k) {P : (x + y).LeftMoves → Prop}
-    (hl : ∀ i, P <| toLeftMovesAdd (Sum.inl i)) (hr : ∀ i, P <| toLeftMovesAdd (Sum.inr i)) : P k :=
+#print SetTheory.PGame.leftMoves_add_cases /-
+theorem SetTheory.PGame.leftMoves_add_cases {x y : SetTheory.PGame} (k)
+    {P : (x + y).LeftMoves → Prop} (hl : ∀ i, P <| SetTheory.PGame.toLeftMovesAdd (Sum.inl i))
+    (hr : ∀ i, P <| SetTheory.PGame.toLeftMovesAdd (Sum.inr i)) : P k :=
   by
   rw [← to_left_moves_add.apply_symm_apply k]
   cases' to_left_moves_add.symm k with i i
   · exact hl i
   · exact hr i
-#align pgame.left_moves_add_cases PGame.leftMoves_add_cases
+#align pgame.left_moves_add_cases SetTheory.PGame.leftMoves_add_cases
 -/
 
-#print PGame.rightMoves_add_cases /-
-theorem rightMoves_add_cases {x y : PGame} (k) {P : (x + y).RightMoves → Prop}
-    (hl : ∀ j, P <| toRightMovesAdd (Sum.inl j)) (hr : ∀ j, P <| toRightMovesAdd (Sum.inr j)) :
-    P k := by
+#print SetTheory.PGame.rightMoves_add_cases /-
+theorem SetTheory.PGame.rightMoves_add_cases {x y : SetTheory.PGame} (k)
+    {P : (x + y).RightMoves → Prop} (hl : ∀ j, P <| SetTheory.PGame.toRightMovesAdd (Sum.inl j))
+    (hr : ∀ j, P <| SetTheory.PGame.toRightMovesAdd (Sum.inr j)) : P k :=
+  by
   rw [← to_right_moves_add.apply_symm_apply k]
   cases' to_right_moves_add.symm k with i i
   · exact hl i
   · exact hr i
-#align pgame.right_moves_add_cases PGame.rightMoves_add_cases
+#align pgame.right_moves_add_cases SetTheory.PGame.rightMoves_add_cases
 -/
 
-#print PGame.isEmpty_nat_rightMoves /-
-instance isEmpty_nat_rightMoves : ∀ n : ℕ, IsEmpty (RightMoves n)
+#print SetTheory.PGame.isEmpty_nat_rightMoves /-
+instance SetTheory.PGame.isEmpty_nat_rightMoves : ∀ n : ℕ, IsEmpty (SetTheory.PGame.RightMoves n)
   | 0 => PEmpty.isEmpty
   | n + 1 => by
     haveI := is_empty_nat_right_moves n
-    rw [PGame.nat_succ, right_moves_add]
+    rw [SetTheory.PGame.nat_succ, right_moves_add]
     infer_instance
-#align pgame.is_empty_nat_right_moves PGame.isEmpty_nat_rightMoves
+#align pgame.is_empty_nat_right_moves SetTheory.PGame.isEmpty_nat_rightMoves
 -/
 
-#print PGame.Relabelling.addCongr /-
+#print SetTheory.PGame.Relabelling.addCongr /-
 /-- If `w` has the same moves as `x` and `y` has the same moves as `z`,
 then `w + y` has the same moves as `x + z`. -/
-def Relabelling.addCongr : ∀ {w x y z : PGame.{u}}, w ≡r x → y ≡r z → w + y ≡r x + z
+def SetTheory.PGame.Relabelling.addCongr :
+    ∀ {w x y z : SetTheory.PGame.{u}}, w ≡r x → y ≡r z → w + y ≡r x + z
   | ⟨wl, wr, wL, wR⟩, ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩, ⟨zl, zr, zL, zR⟩, ⟨L₁, R₁, hL₁, hR₁⟩,
     ⟨L₂, R₂, hL₂, hR₂⟩ =>
     by
@@ -2022,30 +2131,31 @@ def Relabelling.addCongr : ∀ {w x y z : PGame.{u}}, w ≡r x → y ≡r z →
     · exact (hR₁ i).addCongr Hyz
     · exact Hwx.add_congr (hR₂ j)
 decreasing_by pgame_wf_tac
-#align pgame.relabelling.add_congr PGame.Relabelling.addCongr
+#align pgame.relabelling.add_congr SetTheory.PGame.Relabelling.addCongr
 -/
 
-instance : Sub PGame :=
+instance : Sub SetTheory.PGame :=
   ⟨fun x y => x + -y⟩
 
-#print PGame.sub_zero /-
+#print SetTheory.PGame.sub_zero /-
 @[simp]
-theorem sub_zero (x : PGame) : x - 0 = x + 0 :=
+theorem SetTheory.PGame.sub_zero (x : SetTheory.PGame) : x - 0 = x + 0 :=
   show x + -0 = x + 0 by rw [neg_zero]
-#align pgame.sub_zero PGame.sub_zero
+#align pgame.sub_zero SetTheory.PGame.sub_zero
 -/
 
-#print PGame.Relabelling.subCongr /-
+#print SetTheory.PGame.Relabelling.subCongr /-
 /-- If `w` has the same moves as `x` and `y` has the same moves as `z`,
 then `w - y` has the same moves as `x - z`. -/
-def Relabelling.subCongr {w x y z : PGame} (h₁ : w ≡r x) (h₂ : y ≡r z) : w - y ≡r x - z :=
+def SetTheory.PGame.Relabelling.subCongr {w x y z : SetTheory.PGame} (h₁ : w ≡r x) (h₂ : y ≡r z) :
+    w - y ≡r x - z :=
   h₁.addCongr h₂.negCongr
-#align pgame.relabelling.sub_congr PGame.Relabelling.subCongr
+#align pgame.relabelling.sub_congr SetTheory.PGame.Relabelling.subCongr
 -/
 
-#print PGame.negAddRelabelling /-
+#print SetTheory.PGame.negAddRelabelling /-
 /-- `-(x + y)` has exactly the same moves as `-x + -y`. -/
-def negAddRelabelling : ∀ x y : PGame, -(x + y) ≡r -x + -y
+def SetTheory.PGame.negAddRelabelling : ∀ x y : SetTheory.PGame, -(x + y) ≡r -x + -y
   | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩ =>
     by
     refine' ⟨Equiv.refl _, Equiv.refl _, _, _⟩
@@ -2054,40 +2164,40 @@ def negAddRelabelling : ∀ x y : PGame, -(x + y) ≡r -x + -y
         Sum.casesOn j (fun j => neg_add_relabelling _ _) fun j =>
           neg_add_relabelling ⟨xl, xr, xL, xR⟩ _
 decreasing_by pgame_wf_tac
-#align pgame.neg_add_relabelling PGame.negAddRelabelling
+#align pgame.neg_add_relabelling SetTheory.PGame.negAddRelabelling
 -/
 
-#print PGame.neg_add_le /-
-theorem neg_add_le {x y : PGame} : -(x + y) ≤ -x + -y :=
-  (negAddRelabelling x y).le
-#align pgame.neg_add_le PGame.neg_add_le
+#print SetTheory.PGame.neg_add_le /-
+theorem SetTheory.PGame.neg_add_le {x y : SetTheory.PGame} : -(x + y) ≤ -x + -y :=
+  (SetTheory.PGame.negAddRelabelling x y).le
+#align pgame.neg_add_le SetTheory.PGame.neg_add_le
 -/
 
-#print PGame.addCommRelabelling /-
+#print SetTheory.PGame.addCommRelabelling /-
 /-- `x + y` has exactly the same moves as `y + x`. -/
-def addCommRelabelling : ∀ x y : PGame.{u}, x + y ≡r y + x
+def SetTheory.PGame.addCommRelabelling : ∀ x y : SetTheory.PGame.{u}, x + y ≡r y + x
   | mk xl xr xL xR, mk yl yr yL yR => by
     refine' ⟨Equiv.sumComm _ _, Equiv.sumComm _ _, _, _⟩ <;> rintro (_ | _) <;>
       · dsimp [left_moves_add, right_moves_add]; apply add_comm_relabelling
 decreasing_by pgame_wf_tac
-#align pgame.add_comm_relabelling PGame.addCommRelabelling
+#align pgame.add_comm_relabelling SetTheory.PGame.addCommRelabelling
 -/
 
-#print PGame.add_comm_le /-
-theorem add_comm_le {x y : PGame} : x + y ≤ y + x :=
-  (addCommRelabelling x y).le
-#align pgame.add_comm_le PGame.add_comm_le
+#print SetTheory.PGame.add_comm_le /-
+theorem SetTheory.PGame.add_comm_le {x y : SetTheory.PGame} : x + y ≤ y + x :=
+  (SetTheory.PGame.addCommRelabelling x y).le
+#align pgame.add_comm_le SetTheory.PGame.add_comm_le
 -/
 
-#print PGame.add_comm_equiv /-
-theorem add_comm_equiv {x y : PGame} : x + y ≈ y + x :=
-  (addCommRelabelling x y).Equiv
-#align pgame.add_comm_equiv PGame.add_comm_equiv
+#print SetTheory.PGame.add_comm_equiv /-
+theorem SetTheory.PGame.add_comm_equiv {x y : SetTheory.PGame} : x + y ≈ y + x :=
+  (SetTheory.PGame.addCommRelabelling x y).Equiv
+#align pgame.add_comm_equiv SetTheory.PGame.add_comm_equiv
 -/
 
-#print PGame.addAssocRelabelling /-
+#print SetTheory.PGame.addAssocRelabelling /-
 /-- `(x + y) + z` has exactly the same moves as `x + (y + z)`. -/
-def addAssocRelabelling : ∀ x y z : PGame.{u}, x + y + z ≡r x + (y + z)
+def SetTheory.PGame.addAssocRelabelling : ∀ x y z : SetTheory.PGame.{u}, x + y + z ≡r x + (y + z)
   | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩, ⟨zl, zr, zL, zR⟩ =>
     by
     refine' ⟨Equiv.sumAssoc _ _ _, Equiv.sumAssoc _ _ _, _, _⟩
@@ -2099,19 +2209,19 @@ def addAssocRelabelling : ∀ x y z : PGame.{u}, x + y + z ≡r x + (y + z)
       · apply add_assoc_relabelling ⟨xl, xr, xL, xR⟩
       · apply add_assoc_relabelling ⟨xl, xr, xL, xR⟩ ⟨yl, yr, yL, yR⟩
 decreasing_by pgame_wf_tac
-#align pgame.add_assoc_relabelling PGame.addAssocRelabelling
+#align pgame.add_assoc_relabelling SetTheory.PGame.addAssocRelabelling
 -/
 
-#print PGame.add_assoc_equiv /-
-theorem add_assoc_equiv {x y z : PGame} : x + y + z ≈ x + (y + z) :=
-  (addAssocRelabelling x y z).Equiv
-#align pgame.add_assoc_equiv PGame.add_assoc_equiv
+#print SetTheory.PGame.add_assoc_equiv /-
+theorem SetTheory.PGame.add_assoc_equiv {x y z : SetTheory.PGame} : x + y + z ≈ x + (y + z) :=
+  (SetTheory.PGame.addAssocRelabelling x y z).Equiv
+#align pgame.add_assoc_equiv SetTheory.PGame.add_assoc_equiv
 -/
 
-#print PGame.add_left_neg_le_zero /-
-theorem add_left_neg_le_zero : ∀ x : PGame, -x + x ≤ 0
+#print SetTheory.PGame.add_left_neg_le_zero /-
+theorem SetTheory.PGame.add_left_neg_le_zero : ∀ x : SetTheory.PGame, -x + x ≤ 0
   | ⟨xl, xr, xL, xR⟩ =>
-    le_zero.2 fun i => by
+    SetTheory.PGame.le_zero.2 fun i => by
       cases i
       · -- If Left played in -x, Right responds with the same move in x.
         refine' ⟨@to_right_moves_add _ ⟨_, _, _, _⟩ (Sum.inr i), _⟩
@@ -2122,48 +2232,48 @@ theorem add_left_neg_le_zero : ∀ x : PGame, -x + x ≤ 0
         refine' ⟨@to_right_moves_add ⟨_, _, _, _⟩ _ (Sum.inl i), _⟩
         convert @add_left_neg_le_zero (xL i)
         apply add_move_right_inl
-#align pgame.add_left_neg_le_zero PGame.add_left_neg_le_zero
+#align pgame.add_left_neg_le_zero SetTheory.PGame.add_left_neg_le_zero
 -/
 
-#print PGame.zero_le_add_left_neg /-
-theorem zero_le_add_left_neg (x : PGame) : 0 ≤ -x + x :=
+#print SetTheory.PGame.zero_le_add_left_neg /-
+theorem SetTheory.PGame.zero_le_add_left_neg (x : SetTheory.PGame) : 0 ≤ -x + x :=
   by
   rw [← neg_le_neg_iff, neg_zero]
   exact neg_add_le.trans (add_left_neg_le_zero _)
-#align pgame.zero_le_add_left_neg PGame.zero_le_add_left_neg
+#align pgame.zero_le_add_left_neg SetTheory.PGame.zero_le_add_left_neg
 -/
 
-#print PGame.add_left_neg_equiv /-
-theorem add_left_neg_equiv (x : PGame) : -x + x ≈ 0 :=
-  ⟨add_left_neg_le_zero x, zero_le_add_left_neg x⟩
-#align pgame.add_left_neg_equiv PGame.add_left_neg_equiv
+#print SetTheory.PGame.add_left_neg_equiv /-
+theorem SetTheory.PGame.add_left_neg_equiv (x : SetTheory.PGame) : -x + x ≈ 0 :=
+  ⟨SetTheory.PGame.add_left_neg_le_zero x, SetTheory.PGame.zero_le_add_left_neg x⟩
+#align pgame.add_left_neg_equiv SetTheory.PGame.add_left_neg_equiv
 -/
 
-#print PGame.add_right_neg_le_zero /-
-theorem add_right_neg_le_zero (x : PGame) : x + -x ≤ 0 :=
-  add_comm_le.trans (add_left_neg_le_zero x)
-#align pgame.add_right_neg_le_zero PGame.add_right_neg_le_zero
+#print SetTheory.PGame.add_right_neg_le_zero /-
+theorem SetTheory.PGame.add_right_neg_le_zero (x : SetTheory.PGame) : x + -x ≤ 0 :=
+  SetTheory.PGame.add_comm_le.trans (SetTheory.PGame.add_left_neg_le_zero x)
+#align pgame.add_right_neg_le_zero SetTheory.PGame.add_right_neg_le_zero
 -/
 
-#print PGame.zero_le_add_right_neg /-
-theorem zero_le_add_right_neg (x : PGame) : 0 ≤ x + -x :=
-  (zero_le_add_left_neg x).trans add_comm_le
-#align pgame.zero_le_add_right_neg PGame.zero_le_add_right_neg
+#print SetTheory.PGame.zero_le_add_right_neg /-
+theorem SetTheory.PGame.zero_le_add_right_neg (x : SetTheory.PGame) : 0 ≤ x + -x :=
+  (SetTheory.PGame.zero_le_add_left_neg x).trans SetTheory.PGame.add_comm_le
+#align pgame.zero_le_add_right_neg SetTheory.PGame.zero_le_add_right_neg
 -/
 
-#print PGame.add_right_neg_equiv /-
-theorem add_right_neg_equiv (x : PGame) : x + -x ≈ 0 :=
-  ⟨add_right_neg_le_zero x, zero_le_add_right_neg x⟩
-#align pgame.add_right_neg_equiv PGame.add_right_neg_equiv
+#print SetTheory.PGame.add_right_neg_equiv /-
+theorem SetTheory.PGame.add_right_neg_equiv (x : SetTheory.PGame) : x + -x ≈ 0 :=
+  ⟨SetTheory.PGame.add_right_neg_le_zero x, SetTheory.PGame.zero_le_add_right_neg x⟩
+#align pgame.add_right_neg_equiv SetTheory.PGame.add_right_neg_equiv
 -/
 
-#print PGame.sub_self_equiv /-
-theorem sub_self_equiv : ∀ x, x - x ≈ 0 :=
-  add_right_neg_equiv
-#align pgame.sub_self_equiv PGame.sub_self_equiv
+#print SetTheory.PGame.sub_self_equiv /-
+theorem SetTheory.PGame.sub_self_equiv : ∀ x, x - x ≈ 0 :=
+  SetTheory.PGame.add_right_neg_equiv
+#align pgame.sub_self_equiv SetTheory.PGame.sub_self_equiv
 -/
 
-private theorem add_le_add_right' : ∀ {x y z : PGame} (h : x ≤ y), x + z ≤ y + z
+private theorem add_le_add_right' : ∀ {x y z : SetTheory.PGame} (h : x ≤ y), x + z ≤ y + z
   | mk xl xr xL xR, mk yl yr yL yR, mk zl zr zL zR => fun h =>
     by
     refine' le_def.2 ⟨fun i => _, fun i => _⟩ <;> cases i
@@ -2185,214 +2295,227 @@ private theorem add_le_add_right' : ∀ {x y z : PGame} (h : x ≤ y), x + z ≤
     · exact Or.inr ⟨@to_right_moves_add _ ⟨_, _, _, _⟩ (Sum.inr i), add_le_add_right' h⟩
 decreasing_by pgame_wf_tac
 
-#print PGame.covariantClass_swap_add_le /-
-instance covariantClass_swap_add_le : CovariantClass PGame PGame (swap (· + ·)) (· ≤ ·) :=
+#print SetTheory.PGame.covariantClass_swap_add_le /-
+instance SetTheory.PGame.covariantClass_swap_add_le :
+    CovariantClass SetTheory.PGame SetTheory.PGame (swap (· + ·)) (· ≤ ·) :=
   ⟨fun x y z => add_le_add_right'⟩
-#align pgame.covariant_class_swap_add_le PGame.covariantClass_swap_add_le
+#align pgame.covariant_class_swap_add_le SetTheory.PGame.covariantClass_swap_add_le
 -/
 
-#print PGame.covariantClass_add_le /-
-instance covariantClass_add_le : CovariantClass PGame PGame (· + ·) (· ≤ ·) :=
-  ⟨fun x y z h => (add_comm_le.trans (add_le_add_right h x)).trans add_comm_le⟩
-#align pgame.covariant_class_add_le PGame.covariantClass_add_le
+#print SetTheory.PGame.covariantClass_add_le /-
+instance SetTheory.PGame.covariantClass_add_le :
+    CovariantClass SetTheory.PGame SetTheory.PGame (· + ·) (· ≤ ·) :=
+  ⟨fun x y z h =>
+    (SetTheory.PGame.add_comm_le.trans (add_le_add_right h x)).trans SetTheory.PGame.add_comm_le⟩
+#align pgame.covariant_class_add_le SetTheory.PGame.covariantClass_add_le
 -/
 
-#print PGame.add_lf_add_right /-
-theorem add_lf_add_right {y z : PGame} (h : y ⧏ z) (x) : y + x ⧏ z + x :=
-  suffices z + x ≤ y + x → z ≤ y by rw [← PGame.not_le] at h ⊢; exact mt this h
+#print SetTheory.PGame.add_lf_add_right /-
+theorem SetTheory.PGame.add_lf_add_right {y z : SetTheory.PGame} (h : y ⧏ z) (x) : y + x ⧏ z + x :=
+  suffices z + x ≤ y + x → z ≤ y by rw [← SetTheory.PGame.not_le] at h ⊢; exact mt this h
   fun w =>
   calc
-    z ≤ z + 0 := (addZeroRelabelling _).symm.le
-    _ ≤ z + (x + -x) := (add_le_add_left (zero_le_add_right_neg x) _)
-    _ ≤ z + x + -x := (addAssocRelabelling _ _ _).symm.le
+    z ≤ z + 0 := (SetTheory.PGame.addZeroRelabelling _).symm.le
+    _ ≤ z + (x + -x) := (add_le_add_left (SetTheory.PGame.zero_le_add_right_neg x) _)
+    _ ≤ z + x + -x := (SetTheory.PGame.addAssocRelabelling _ _ _).symm.le
     _ ≤ y + x + -x := (add_le_add_right w _)
-    _ ≤ y + (x + -x) := (addAssocRelabelling _ _ _).le
-    _ ≤ y + 0 := (add_le_add_left (add_right_neg_le_zero x) _)
-    _ ≤ y := (addZeroRelabelling _).le
-#align pgame.add_lf_add_right PGame.add_lf_add_right
+    _ ≤ y + (x + -x) := (SetTheory.PGame.addAssocRelabelling _ _ _).le
+    _ ≤ y + 0 := (add_le_add_left (SetTheory.PGame.add_right_neg_le_zero x) _)
+    _ ≤ y := (SetTheory.PGame.addZeroRelabelling _).le
+#align pgame.add_lf_add_right SetTheory.PGame.add_lf_add_right
 -/
 
-#print PGame.add_lf_add_left /-
-theorem add_lf_add_left {y z : PGame} (h : y ⧏ z) (x) : x + y ⧏ x + z := by
-  rw [lf_congr add_comm_equiv add_comm_equiv]; apply add_lf_add_right h
-#align pgame.add_lf_add_left PGame.add_lf_add_left
+#print SetTheory.PGame.add_lf_add_left /-
+theorem SetTheory.PGame.add_lf_add_left {y z : SetTheory.PGame} (h : y ⧏ z) (x) : x + y ⧏ x + z :=
+  by rw [lf_congr add_comm_equiv add_comm_equiv]; apply add_lf_add_right h
+#align pgame.add_lf_add_left SetTheory.PGame.add_lf_add_left
 -/
 
-#print PGame.covariantClass_swap_add_lt /-
-instance covariantClass_swap_add_lt : CovariantClass PGame PGame (swap (· + ·)) (· < ·) :=
-  ⟨fun x y z h => ⟨add_le_add_right h.1 x, add_lf_add_right h.2 x⟩⟩
-#align pgame.covariant_class_swap_add_lt PGame.covariantClass_swap_add_lt
+#print SetTheory.PGame.covariantClass_swap_add_lt /-
+instance SetTheory.PGame.covariantClass_swap_add_lt :
+    CovariantClass SetTheory.PGame SetTheory.PGame (swap (· + ·)) (· < ·) :=
+  ⟨fun x y z h => ⟨add_le_add_right h.1 x, SetTheory.PGame.add_lf_add_right h.2 x⟩⟩
+#align pgame.covariant_class_swap_add_lt SetTheory.PGame.covariantClass_swap_add_lt
 -/
 
-#print PGame.covariantClass_add_lt /-
-instance covariantClass_add_lt : CovariantClass PGame PGame (· + ·) (· < ·) :=
-  ⟨fun x y z h => ⟨add_le_add_left h.1 x, add_lf_add_left h.2 x⟩⟩
-#align pgame.covariant_class_add_lt PGame.covariantClass_add_lt
+#print SetTheory.PGame.covariantClass_add_lt /-
+instance SetTheory.PGame.covariantClass_add_lt :
+    CovariantClass SetTheory.PGame SetTheory.PGame (· + ·) (· < ·) :=
+  ⟨fun x y z h => ⟨add_le_add_left h.1 x, SetTheory.PGame.add_lf_add_left h.2 x⟩⟩
+#align pgame.covariant_class_add_lt SetTheory.PGame.covariantClass_add_lt
 -/
 
-#print PGame.add_lf_add_of_lf_of_le /-
-theorem add_lf_add_of_lf_of_le {w x y z : PGame} (hwx : w ⧏ x) (hyz : y ≤ z) : w + y ⧏ x + z :=
-  lf_of_lf_of_le (add_lf_add_right hwx y) (add_le_add_left hyz x)
-#align pgame.add_lf_add_of_lf_of_le PGame.add_lf_add_of_lf_of_le
+#print SetTheory.PGame.add_lf_add_of_lf_of_le /-
+theorem SetTheory.PGame.add_lf_add_of_lf_of_le {w x y z : SetTheory.PGame} (hwx : w ⧏ x)
+    (hyz : y ≤ z) : w + y ⧏ x + z :=
+  SetTheory.PGame.lf_of_lf_of_le (SetTheory.PGame.add_lf_add_right hwx y) (add_le_add_left hyz x)
+#align pgame.add_lf_add_of_lf_of_le SetTheory.PGame.add_lf_add_of_lf_of_le
 -/
 
-#print PGame.add_lf_add_of_le_of_lf /-
-theorem add_lf_add_of_le_of_lf {w x y z : PGame} (hwx : w ≤ x) (hyz : y ⧏ z) : w + y ⧏ x + z :=
-  lf_of_le_of_lf (add_le_add_right hwx y) (add_lf_add_left hyz x)
-#align pgame.add_lf_add_of_le_of_lf PGame.add_lf_add_of_le_of_lf
+#print SetTheory.PGame.add_lf_add_of_le_of_lf /-
+theorem SetTheory.PGame.add_lf_add_of_le_of_lf {w x y z : SetTheory.PGame} (hwx : w ≤ x)
+    (hyz : y ⧏ z) : w + y ⧏ x + z :=
+  SetTheory.PGame.lf_of_le_of_lf (add_le_add_right hwx y) (SetTheory.PGame.add_lf_add_left hyz x)
+#align pgame.add_lf_add_of_le_of_lf SetTheory.PGame.add_lf_add_of_le_of_lf
 -/
 
-#print PGame.add_congr /-
-theorem add_congr {w x y z : PGame} (h₁ : w ≈ x) (h₂ : y ≈ z) : w + y ≈ x + z :=
+#print SetTheory.PGame.add_congr /-
+theorem SetTheory.PGame.add_congr {w x y z : SetTheory.PGame} (h₁ : w ≈ x) (h₂ : y ≈ z) :
+    w + y ≈ x + z :=
   ⟨(add_le_add_left h₂.1 w).trans (add_le_add_right h₁.1 z),
     (add_le_add_left h₂.2 x).trans (add_le_add_right h₁.2 y)⟩
-#align pgame.add_congr PGame.add_congr
+#align pgame.add_congr SetTheory.PGame.add_congr
 -/
 
-#print PGame.add_congr_left /-
-theorem add_congr_left {x y z : PGame} (h : x ≈ y) : x + z ≈ y + z :=
-  add_congr h equiv_rfl
-#align pgame.add_congr_left PGame.add_congr_left
+#print SetTheory.PGame.add_congr_left /-
+theorem SetTheory.PGame.add_congr_left {x y z : SetTheory.PGame} (h : x ≈ y) : x + z ≈ y + z :=
+  SetTheory.PGame.add_congr h SetTheory.PGame.equiv_rfl
+#align pgame.add_congr_left SetTheory.PGame.add_congr_left
 -/
 
-#print PGame.add_congr_right /-
-theorem add_congr_right {x y z : PGame} : (y ≈ z) → (x + y ≈ x + z) :=
-  add_congr equiv_rfl
-#align pgame.add_congr_right PGame.add_congr_right
+#print SetTheory.PGame.add_congr_right /-
+theorem SetTheory.PGame.add_congr_right {x y z : SetTheory.PGame} : (y ≈ z) → (x + y ≈ x + z) :=
+  SetTheory.PGame.add_congr SetTheory.PGame.equiv_rfl
+#align pgame.add_congr_right SetTheory.PGame.add_congr_right
 -/
 
-#print PGame.sub_congr /-
-theorem sub_congr {w x y z : PGame} (h₁ : w ≈ x) (h₂ : y ≈ z) : w - y ≈ x - z :=
-  add_congr h₁ (neg_equiv_neg_iff.2 h₂)
-#align pgame.sub_congr PGame.sub_congr
+#print SetTheory.PGame.sub_congr /-
+theorem SetTheory.PGame.sub_congr {w x y z : SetTheory.PGame} (h₁ : w ≈ x) (h₂ : y ≈ z) :
+    w - y ≈ x - z :=
+  SetTheory.PGame.add_congr h₁ (SetTheory.PGame.neg_equiv_neg_iff.2 h₂)
+#align pgame.sub_congr SetTheory.PGame.sub_congr
 -/
 
-#print PGame.sub_congr_left /-
-theorem sub_congr_left {x y z : PGame} (h : x ≈ y) : x - z ≈ y - z :=
-  sub_congr h equiv_rfl
-#align pgame.sub_congr_left PGame.sub_congr_left
+#print SetTheory.PGame.sub_congr_left /-
+theorem SetTheory.PGame.sub_congr_left {x y z : SetTheory.PGame} (h : x ≈ y) : x - z ≈ y - z :=
+  SetTheory.PGame.sub_congr h SetTheory.PGame.equiv_rfl
+#align pgame.sub_congr_left SetTheory.PGame.sub_congr_left
 -/
 
-#print PGame.sub_congr_right /-
-theorem sub_congr_right {x y z : PGame} : (y ≈ z) → (x - y ≈ x - z) :=
-  sub_congr equiv_rfl
-#align pgame.sub_congr_right PGame.sub_congr_right
+#print SetTheory.PGame.sub_congr_right /-
+theorem SetTheory.PGame.sub_congr_right {x y z : SetTheory.PGame} : (y ≈ z) → (x - y ≈ x - z) :=
+  SetTheory.PGame.sub_congr SetTheory.PGame.equiv_rfl
+#align pgame.sub_congr_right SetTheory.PGame.sub_congr_right
 -/
 
-#print PGame.le_iff_sub_nonneg /-
-theorem le_iff_sub_nonneg {x y : PGame} : x ≤ y ↔ 0 ≤ y - x :=
-  ⟨fun h => (zero_le_add_right_neg x).trans (add_le_add_right h _), fun h =>
+#print SetTheory.PGame.le_iff_sub_nonneg /-
+theorem SetTheory.PGame.le_iff_sub_nonneg {x y : SetTheory.PGame} : x ≤ y ↔ 0 ≤ y - x :=
+  ⟨fun h => (SetTheory.PGame.zero_le_add_right_neg x).trans (add_le_add_right h _), fun h =>
     calc
-      x ≤ 0 + x := (zeroAddRelabelling x).symm.le
+      x ≤ 0 + x := (SetTheory.PGame.zeroAddRelabelling x).symm.le
       _ ≤ y - x + x := (add_le_add_right h _)
-      _ ≤ y + (-x + x) := (addAssocRelabelling _ _ _).le
-      _ ≤ y + 0 := (add_le_add_left (add_left_neg_le_zero x) _)
-      _ ≤ y := (addZeroRelabelling y).le⟩
-#align pgame.le_iff_sub_nonneg PGame.le_iff_sub_nonneg
+      _ ≤ y + (-x + x) := (SetTheory.PGame.addAssocRelabelling _ _ _).le
+      _ ≤ y + 0 := (add_le_add_left (SetTheory.PGame.add_left_neg_le_zero x) _)
+      _ ≤ y := (SetTheory.PGame.addZeroRelabelling y).le⟩
+#align pgame.le_iff_sub_nonneg SetTheory.PGame.le_iff_sub_nonneg
 -/
 
-#print PGame.lf_iff_sub_zero_lf /-
-theorem lf_iff_sub_zero_lf {x y : PGame} : x ⧏ y ↔ 0 ⧏ y - x :=
-  ⟨fun h => (zero_le_add_right_neg x).trans_lf (add_lf_add_right h _), fun h =>
+#print SetTheory.PGame.lf_iff_sub_zero_lf /-
+theorem SetTheory.PGame.lf_iff_sub_zero_lf {x y : SetTheory.PGame} : x ⧏ y ↔ 0 ⧏ y - x :=
+  ⟨fun h =>
+    (SetTheory.PGame.zero_le_add_right_neg x).trans_lf (SetTheory.PGame.add_lf_add_right h _),
+    fun h =>
     calc
-      x ≤ 0 + x := (zeroAddRelabelling x).symm.le
-      _ ⧏ y - x + x := (add_lf_add_right h _)
-      _ ≤ y + (-x + x) := (addAssocRelabelling _ _ _).le
-      _ ≤ y + 0 := (add_le_add_left (add_left_neg_le_zero x) _)
-      _ ≤ y := (addZeroRelabelling y).le⟩
-#align pgame.lf_iff_sub_zero_lf PGame.lf_iff_sub_zero_lf
--/
-
-#print PGame.lt_iff_sub_pos /-
-theorem lt_iff_sub_pos {x y : PGame} : x < y ↔ 0 < y - x :=
-  ⟨fun h => lt_of_le_of_lt (zero_le_add_right_neg x) (add_lt_add_right h _), fun h =>
+      x ≤ 0 + x := (SetTheory.PGame.zeroAddRelabelling x).symm.le
+      _ ⧏ y - x + x := (SetTheory.PGame.add_lf_add_right h _)
+      _ ≤ y + (-x + x) := (SetTheory.PGame.addAssocRelabelling _ _ _).le
+      _ ≤ y + 0 := (add_le_add_left (SetTheory.PGame.add_left_neg_le_zero x) _)
+      _ ≤ y := (SetTheory.PGame.addZeroRelabelling y).le⟩
+#align pgame.lf_iff_sub_zero_lf SetTheory.PGame.lf_iff_sub_zero_lf
+-/
+
+#print SetTheory.PGame.lt_iff_sub_pos /-
+theorem SetTheory.PGame.lt_iff_sub_pos {x y : SetTheory.PGame} : x < y ↔ 0 < y - x :=
+  ⟨fun h => lt_of_le_of_lt (SetTheory.PGame.zero_le_add_right_neg x) (add_lt_add_right h _),
+    fun h =>
     calc
-      x ≤ 0 + x := (zeroAddRelabelling x).symm.le
+      x ≤ 0 + x := (SetTheory.PGame.zeroAddRelabelling x).symm.le
       _ < y - x + x := (add_lt_add_right h _)
-      _ ≤ y + (-x + x) := (addAssocRelabelling _ _ _).le
-      _ ≤ y + 0 := (add_le_add_left (add_left_neg_le_zero x) _)
-      _ ≤ y := (addZeroRelabelling y).le⟩
-#align pgame.lt_iff_sub_pos PGame.lt_iff_sub_pos
+      _ ≤ y + (-x + x) := (SetTheory.PGame.addAssocRelabelling _ _ _).le
+      _ ≤ y + 0 := (add_le_add_left (SetTheory.PGame.add_left_neg_le_zero x) _)
+      _ ≤ y := (SetTheory.PGame.addZeroRelabelling y).le⟩
+#align pgame.lt_iff_sub_pos SetTheory.PGame.lt_iff_sub_pos
 -/
 
 /-! ### Special pre-games -/
 
 
-#print PGame.star /-
+#print SetTheory.PGame.star /-
 /-- The pre-game `star`, which is fuzzy with zero. -/
-def star : PGame.{u} :=
+def SetTheory.PGame.star : SetTheory.PGame.{u} :=
   ⟨PUnit, PUnit, fun _ => 0, fun _ => 0⟩
-#align pgame.star PGame.star
+#align pgame.star SetTheory.PGame.star
 -/
 
-#print PGame.star_leftMoves /-
+#print SetTheory.PGame.star_leftMoves /-
 @[simp]
-theorem star_leftMoves : star.LeftMoves = PUnit :=
+theorem SetTheory.PGame.star_leftMoves : SetTheory.PGame.star.LeftMoves = PUnit :=
   rfl
-#align pgame.star_left_moves PGame.star_leftMoves
+#align pgame.star_left_moves SetTheory.PGame.star_leftMoves
 -/
 
-#print PGame.star_rightMoves /-
+#print SetTheory.PGame.star_rightMoves /-
 @[simp]
-theorem star_rightMoves : star.RightMoves = PUnit :=
+theorem SetTheory.PGame.star_rightMoves : SetTheory.PGame.star.RightMoves = PUnit :=
   rfl
-#align pgame.star_right_moves PGame.star_rightMoves
+#align pgame.star_right_moves SetTheory.PGame.star_rightMoves
 -/
 
-#print PGame.star_moveLeft /-
+#print SetTheory.PGame.star_moveLeft /-
 @[simp]
-theorem star_moveLeft (x) : star.moveLeft x = 0 :=
+theorem SetTheory.PGame.star_moveLeft (x) : SetTheory.PGame.star.moveLeft x = 0 :=
   rfl
-#align pgame.star_move_left PGame.star_moveLeft
+#align pgame.star_move_left SetTheory.PGame.star_moveLeft
 -/
 
-#print PGame.star_moveRight /-
+#print SetTheory.PGame.star_moveRight /-
 @[simp]
-theorem star_moveRight (x) : star.moveRight x = 0 :=
+theorem SetTheory.PGame.star_moveRight (x) : SetTheory.PGame.star.moveRight x = 0 :=
   rfl
-#align pgame.star_move_right PGame.star_moveRight
+#align pgame.star_move_right SetTheory.PGame.star_moveRight
 -/
 
-#print PGame.uniqueStarLeftMoves /-
-instance uniqueStarLeftMoves : Unique star.LeftMoves :=
+#print SetTheory.PGame.uniqueStarLeftMoves /-
+instance SetTheory.PGame.uniqueStarLeftMoves : Unique SetTheory.PGame.star.LeftMoves :=
   PUnit.unique
-#align pgame.unique_star_left_moves PGame.uniqueStarLeftMoves
+#align pgame.unique_star_left_moves SetTheory.PGame.uniqueStarLeftMoves
 -/
 
-#print PGame.uniqueStarRightMoves /-
-instance uniqueStarRightMoves : Unique star.RightMoves :=
+#print SetTheory.PGame.uniqueStarRightMoves /-
+instance SetTheory.PGame.uniqueStarRightMoves : Unique SetTheory.PGame.star.RightMoves :=
   PUnit.unique
-#align pgame.unique_star_right_moves PGame.uniqueStarRightMoves
+#align pgame.unique_star_right_moves SetTheory.PGame.uniqueStarRightMoves
 -/
 
-#print PGame.star_fuzzy_zero /-
-theorem star_fuzzy_zero : star ‖ 0 :=
+#print SetTheory.PGame.star_fuzzy_zero /-
+theorem SetTheory.PGame.star_fuzzy_zero : SetTheory.PGame.star ‖ 0 :=
   ⟨by rw [lf_zero]; use default; rintro ⟨⟩, by rw [zero_lf]; use default; rintro ⟨⟩⟩
-#align pgame.star_fuzzy_zero PGame.star_fuzzy_zero
+#align pgame.star_fuzzy_zero SetTheory.PGame.star_fuzzy_zero
 -/
 
-#print PGame.neg_star /-
+#print SetTheory.PGame.neg_star /-
 @[simp]
-theorem neg_star : -star = star := by simp [star]
-#align pgame.neg_star PGame.neg_star
+theorem SetTheory.PGame.neg_star : -SetTheory.PGame.star = SetTheory.PGame.star := by simp [star]
+#align pgame.neg_star SetTheory.PGame.neg_star
 -/
 
-#print PGame.zero_lt_one /-
+#print SetTheory.PGame.zero_lt_one /-
 @[simp]
-protected theorem zero_lt_one : (0 : PGame) < 1 :=
-  lt_of_le_of_lf (zero_le_of_isEmpty_rightMoves 1) (zero_lf_le.2 ⟨default, le_rfl⟩)
-#align pgame.zero_lt_one PGame.zero_lt_one
+protected theorem SetTheory.PGame.zero_lt_one : (0 : SetTheory.PGame) < 1 :=
+  SetTheory.PGame.lt_of_le_of_lf (SetTheory.PGame.zero_le_of_isEmpty_rightMoves 1)
+    (SetTheory.PGame.zero_lf_le.2 ⟨default, le_rfl⟩)
+#align pgame.zero_lt_one SetTheory.PGame.zero_lt_one
 -/
 
-instance : ZeroLEOneClass PGame :=
-  ⟨PGame.zero_lt_one.le⟩
+instance : ZeroLEOneClass SetTheory.PGame :=
+  ⟨SetTheory.PGame.zero_lt_one.le⟩
 
-#print PGame.zero_lf_one /-
+#print SetTheory.PGame.zero_lf_one /-
 @[simp]
-theorem zero_lf_one : (0 : PGame) ⧏ 1 :=
-  PGame.zero_lt_one.Lf
-#align pgame.zero_lf_one PGame.zero_lf_one
+theorem SetTheory.PGame.zero_lf_one : (0 : SetTheory.PGame) ⧏ 1 :=
+  SetTheory.PGame.zero_lt_one.Lf
+#align pgame.zero_lf_one SetTheory.PGame.zero_lf_one
 -/
 
-end PGame
+end SetTheory.PGame
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

@@ -527,7 +527,7 @@ theorem moveLeft_lf_of_le {x y : PGame} (h : x ≤ y) (i) : x.moveLeft i ⧏ y :
 #align pgame.move_left_lf_of_le PGame.moveLeft_lf_of_le
 -/
 
-alias move_left_lf_of_le ← _root_.has_le.le.move_left_lf
+alias _root_.has_le.le.move_left_lf := move_left_lf_of_le
 #align has_le.le.move_left_lf LE.le.moveLeft_lf
 
 #print PGame.lf_moveRight_of_le /-
@@ -536,7 +536,7 @@ theorem lf_moveRight_of_le {x y : PGame} (h : x ≤ y) (j) : x ⧏ y.moveRight j
 #align pgame.lf_move_right_of_le PGame.lf_moveRight_of_le
 -/
 
-alias lf_move_right_of_le ← _root_.has_le.le.lf_move_right
+alias _root_.has_le.le.lf_move_right := lf_move_right_of_le
 #align has_le.le.lf_move_right LE.le.lf_moveRight
 
 #print PGame.lf_of_moveRight_le /-
@@ -625,7 +625,7 @@ theorem lf_of_lt {x y : PGame} (h : x < y) : x ⧏ y :=
 #align pgame.lf_of_lt PGame.lf_of_lt
 -/
 
-alias lf_of_lt ← _root_.has_lt.lt.lf
+alias _root_.has_lt.lt.lf := lf_of_lt
 #align has_lt.lt.lf LT.lt.lf
 
 #print PGame.lf_irrefl /-
@@ -651,10 +651,10 @@ theorem lf_of_lf_of_le {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y ≤ z) : x ⧏
 #align pgame.lf_of_lf_of_le PGame.lf_of_lf_of_le
 -/
 
-alias lf_of_le_of_lf ← _root_.has_le.le.trans_lf
+alias _root_.has_le.le.trans_lf := lf_of_le_of_lf
 #align has_le.le.trans_lf LE.le.trans_lf
 
-alias lf_of_lf_of_le ← lf.trans_le
+alias lf.trans_le := lf_of_lf_of_le
 #align pgame.lf.trans_le PGame.Lf.trans_le
 
 #print PGame.lf_of_lt_of_lf /-
@@ -671,10 +671,10 @@ theorem lf_of_lf_of_lt {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y < z) : x ⧏ z
 #align pgame.lf_of_lf_of_lt PGame.lf_of_lf_of_lt
 -/
 
-alias lf_of_lt_of_lf ← _root_.has_lt.lt.trans_lf
+alias _root_.has_lt.lt.trans_lf := lf_of_lt_of_lf
 #align has_lt.lt.trans_lf LT.lt.trans_lf
 
-alias lf_of_lf_of_lt ← lf.trans_lt
+alias lf.trans_lt := lf_of_lf_of_lt
 #align pgame.lf.trans_lt PGame.Lf.trans_lt
 
 #print PGame.moveLeft_lf /-
@@ -1180,7 +1180,7 @@ theorem lf_of_fuzzy {x y : PGame} (h : x ‖ y) : x ⧏ y :=
 #align pgame.lf_of_fuzzy PGame.lf_of_fuzzy
 -/
 
-alias lf_of_fuzzy ← fuzzy.lf
+alias fuzzy.lf := lf_of_fuzzy
 #align pgame.fuzzy.lf PGame.Fuzzy.lf
 
 #print PGame.lt_or_fuzzy_of_lf /-

mathlib commit https://github.com/leanprover-community/mathlib/commit/63721b2c3eba6c325ecf8ae8cca27155a4f6306f

@@ -6,9 +6,10 @@ Authors: Reid Barton, Mario Carneiro, Isabel Longbottom, Scott Morrison
 import Mathbin.Data.Fin.Basic
 import Mathbin.Data.List.Basic
 import Mathbin.Logic.Relation
+import Mathbin.Logic.Small.Basic
 import Mathbin.Order.GameAdd
 
-#align_import set_theory.game.pgame from "leanprover-community/mathlib"@"33c67ae661dd8988516ff7f247b0be3018cdd952"
+#align_import set_theory.game.pgame from "leanprover-community/mathlib"@"8900d545017cd21961daa2a1734bb658ef52c618"
 
 /-!
 # Combinatorial (pre-)games.
@@ -837,6 +838,64 @@ theorem leftResponse_spec {x : PGame} (h : 0 ≤ x) (j : x.RightMoves) :
 #align pgame.left_response_spec PGame.leftResponse_spec
 -/
 
+/-- An explicit upper bound for a family of pre-games, whose left moves are the union of the left
+moves of all the pre-games in the family. -/
+def upperBound {ι : Type u} (f : ι → PGame.{u}) : PGame :=
+  ⟨Σ i, (f i).LeftMoves, PEmpty, fun x => moveLeft _ x.2, PEmpty.elim⟩
+#align pgame.upper_bound PGame.upperBound
+
+instance upperBound_rightMoves_empty {ι : Type u} (f : ι → PGame.{u}) :
+    IsEmpty (upperBound f).RightMoves :=
+  PEmpty.isEmpty
+#align pgame.upper_bound_right_moves_empty PGame.upperBound_rightMoves_empty
+
+theorem le_upperBound {ι : Type u} (f : ι → PGame.{u}) (i : ι) : f i ≤ upperBound f :=
+  by
+  rw [upper_bound, le_iff_forall_lf]
+  dsimp
+  simp only [and_true_iff, IsEmpty.forall_iff]
+  exact fun j => @move_left_lf (upper_bound f) ⟨i, j⟩
+#align pgame.le_upper_bound PGame.le_upperBound
+
+theorem upperBound_mem_upperBounds (s : Set PGame.{u}) [Small.{u} s] :
+    upperBound (Subtype.val ∘ (equivShrink s).symm) ∈ upperBounds s := fun i hi => by
+  simpa using le_upper_bound (Subtype.val ∘ (equivShrink s).symm) (equivShrink s ⟨i, hi⟩)
+#align pgame.upper_bound_mem_upper_bounds PGame.upperBound_mem_upperBounds
+
+/-- A small set `s` of pre-games is bounded above. -/
+theorem bddAbove_of_small (s : Set PGame.{u}) [Small.{u} s] : BddAbove s :=
+  ⟨_, upperBound_mem_upperBounds s⟩
+#align pgame.bdd_above_of_small PGame.bddAbove_of_small
+
+/-- An explicit lower bound for a family of pre-games, whose right moves are the union of the right
+moves of all the pre-games in the family. -/
+def lowerBound {ι : Type u} (f : ι → PGame.{u}) : PGame :=
+  ⟨PEmpty, Σ i, (f i).RightMoves, PEmpty.elim, fun x => moveRight _ x.2⟩
+#align pgame.lower_bound PGame.lowerBound
+
+instance lowerBound_leftMoves_empty {ι : Type u} (f : ι → PGame.{u}) :
+    IsEmpty (lowerBound f).LeftMoves :=
+  PEmpty.isEmpty
+#align pgame.lower_bound_left_moves_empty PGame.lowerBound_leftMoves_empty
+
+theorem lowerBound_le {ι : Type u} (f : ι → PGame.{u}) (i : ι) : lowerBound f ≤ f i :=
+  by
+  rw [lower_bound, le_iff_forall_lf]
+  dsimp
+  simp only [IsEmpty.forall_iff, true_and_iff]
+  exact fun j => @lf_move_right (lower_bound f) ⟨i, j⟩
+#align pgame.lower_bound_le PGame.lowerBound_le
+
+theorem lowerBound_mem_lowerBounds (s : Set PGame.{u}) [Small.{u} s] :
+    lowerBound (Subtype.val ∘ (equivShrink s).symm) ∈ lowerBounds s := fun i hi => by
+  simpa using lower_bound_le (Subtype.val ∘ (equivShrink s).symm) (equivShrink s ⟨i, hi⟩)
+#align pgame.lower_bound_mem_lower_bounds PGame.lowerBound_mem_lowerBounds
+
+/-- A small set `s` of pre-games is bounded below. -/
+theorem bddBelow_of_small (s : Set PGame.{u}) [Small.{u} s] : BddBelow s :=
+  ⟨_, lowerBound_mem_lowerBounds s⟩
+#align pgame.bdd_below_of_small PGame.bddBelow_of_small
+
 #print PGame.Equiv /-
 /-- The equivalence relation on pre-games. Two pre-games `x`, `y` are equivalent if `x ≤ y` and
 `y ≤ x`.

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

@@ -2,17 +2,14 @@
 Copyright (c) 2019 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Reid Barton, Mario Carneiro, Isabel Longbottom, Scott Morrison
-
-! This file was ported from Lean 3 source module set_theory.game.pgame
-! leanprover-community/mathlib commit 33c67ae661dd8988516ff7f247b0be3018cdd952
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Fin.Basic
 import Mathbin.Data.List.Basic
 import Mathbin.Logic.Relation
 import Mathbin.Order.GameAdd
 
+#align_import set_theory.game.pgame from "leanprover-community/mathlib"@"33c67ae661dd8988516ff7f247b0be3018cdd952"
+
 /-!
 # Combinatorial (pre-)games.
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

@@ -445,7 +445,6 @@ def Lf (x y : PGame) : Prop :=
 #align pgame.lf PGame.Lf
 -/
 
--- mathport name: pgame.lf
 scoped infixl:50 " ⧏ " => PGame.Lf
 
 #print PGame.not_le /-
@@ -610,17 +609,23 @@ instance : Preorder PGame :=
           le_trans_aux (fun i => (IHzl i).1) fun j => (IHyr j).2.1⟩
     lt := fun x y => x ≤ y ∧ x ⧏ y }
 
+#print PGame.lt_iff_le_and_lf /-
 theorem lt_iff_le_and_lf {x y : PGame} : x < y ↔ x ≤ y ∧ x ⧏ y :=
   Iff.rfl
 #align pgame.lt_iff_le_and_lf PGame.lt_iff_le_and_lf
+-/
 
+#print PGame.lt_of_le_of_lf /-
 theorem lt_of_le_of_lf {x y : PGame} (h₁ : x ≤ y) (h₂ : x ⧏ y) : x < y :=
   ⟨h₁, h₂⟩
 #align pgame.lt_of_le_of_lf PGame.lt_of_le_of_lf
+-/
 
+#print PGame.lf_of_lt /-
 theorem lf_of_lt {x y : PGame} (h : x < y) : x ⧏ y :=
   h.2
 #align pgame.lf_of_lt PGame.lf_of_lt
+-/
 
 alias lf_of_lt ← _root_.has_lt.lt.lf
 #align has_lt.lt.lf LT.lt.lf
@@ -654,15 +659,19 @@ alias lf_of_le_of_lf ← _root_.has_le.le.trans_lf
 alias lf_of_lf_of_le ← lf.trans_le
 #align pgame.lf.trans_le PGame.Lf.trans_le
 
+#print PGame.lf_of_lt_of_lf /-
 @[trans]
 theorem lf_of_lt_of_lf {x y z : PGame} (h₁ : x < y) (h₂ : y ⧏ z) : x ⧏ z :=
   h₁.le.trans_lf h₂
 #align pgame.lf_of_lt_of_lf PGame.lf_of_lt_of_lf
+-/
 
+#print PGame.lf_of_lf_of_lt /-
 @[trans]
 theorem lf_of_lf_of_lt {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y < z) : x ⧏ z :=
   h₁.trans_le h₂.le
 #align pgame.lf_of_lf_of_lt PGame.lf_of_lf_of_lt
+-/
 
 alias lf_of_lt_of_lf ← _root_.has_lt.lt.trans_lf
 #align has_lt.lt.trans_lf LT.lt.trans_lf
@@ -694,12 +703,14 @@ theorem mk_lf {xl xr} (xL : xl → PGame) (xR : xr → PGame) (j) : mk xl xr xL
 #align pgame.mk_lf PGame.mk_lf
 -/
 
+#print PGame.le_of_forall_lt /-
 /-- This special case of `pgame.le_of_forall_lf` is useful when dealing with surreals, where `<` is
 preferred over `⧏`. -/
 theorem le_of_forall_lt {x y : PGame} (h₁ : ∀ i, x.moveLeft i < y) (h₂ : ∀ j, x < y.moveRight j) :
     x ≤ y :=
   le_of_forall_lf (fun i => (h₁ i).Lf) fun i => (h₂ i).Lf
 #align pgame.le_of_forall_lt PGame.le_of_forall_lt
+-/
 
 #print PGame.le_def /-
 /-- The definition of `x ≤ y` on pre-games, in terms of `≤` two moves later. -/
@@ -839,7 +850,6 @@ def Equiv (x y : PGame) : Prop :=
 #align pgame.equiv PGame.Equiv
 -/
 
--- mathport name: pgame.equiv
 scoped infixl:0 " ≈ " => PGame.Equiv
 
 instance : IsEquiv _ (· ≈ ·) where
@@ -921,8 +931,10 @@ theorem Lf.not_equiv' {x y} (h : x ⧏ y) : ¬(y ≈ x) := fun h' => h.not_ge h'
 #align pgame.lf.not_equiv' PGame.Lf.not_equiv'
 -/
 
+#print PGame.Lf.not_gt /-
 theorem Lf.not_gt {x y} (h : x ⧏ y) : ¬y < x := fun h' => h.not_ge h'.le
 #align pgame.lf.not_gt PGame.Lf.not_gt
+-/
 
 #print PGame.le_congr_imp /-
 theorem le_congr_imp {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) (h : x₁ ≤ y₁) : x₂ ≤ y₂ :=
@@ -986,35 +998,49 @@ theorem lf_of_equiv_of_lf {x y z} (h₁ : x ≈ y) : y ⧏ z → x ⧏ z :=
 #align pgame.lf_of_equiv_of_lf PGame.lf_of_equiv_of_lf
 -/
 
+#print PGame.lt_of_lt_of_equiv /-
 @[trans]
 theorem lt_of_lt_of_equiv {x y z} (h₁ : x < y) (h₂ : y ≈ z) : x < z :=
   h₁.trans_le h₂.1
 #align pgame.lt_of_lt_of_equiv PGame.lt_of_lt_of_equiv
+-/
 
+#print PGame.lt_of_equiv_of_lt /-
 @[trans]
 theorem lt_of_equiv_of_lt {x y z} (h₁ : x ≈ y) : y < z → x < z :=
   h₁.1.trans_lt
 #align pgame.lt_of_equiv_of_lt PGame.lt_of_equiv_of_lt
+-/
 
+#print PGame.lt_congr_imp /-
 theorem lt_congr_imp {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) (h : x₁ < y₁) : x₂ < y₂ :=
   hx.2.trans_lt (h.trans_le hy.1)
 #align pgame.lt_congr_imp PGame.lt_congr_imp
+-/
 
+#print PGame.lt_congr /-
 theorem lt_congr {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ < y₁ ↔ x₂ < y₂ :=
   ⟨lt_congr_imp hx hy, lt_congr_imp hx.symm hy.symm⟩
 #align pgame.lt_congr PGame.lt_congr
+-/
 
+#print PGame.lt_congr_left /-
 theorem lt_congr_left {x₁ x₂ y} (hx : x₁ ≈ x₂) : x₁ < y ↔ x₂ < y :=
   lt_congr hx equiv_rfl
 #align pgame.lt_congr_left PGame.lt_congr_left
+-/
 
+#print PGame.lt_congr_right /-
 theorem lt_congr_right {x y₁ y₂} (hy : y₁ ≈ y₂) : x < y₁ ↔ x < y₂ :=
   lt_congr equiv_rfl hy
 #align pgame.lt_congr_right PGame.lt_congr_right
+-/
 
+#print PGame.lt_or_equiv_of_le /-
 theorem lt_or_equiv_of_le {x y : PGame} (h : x ≤ y) : x < y ∨ (x ≈ y) :=
   and_or_left.mp ⟨h, (em <| y ≤ x).symm.imp_left PGame.not_le.1⟩
 #align pgame.lt_or_equiv_of_le PGame.lt_or_equiv_of_le
+-/
 
 #print PGame.lf_or_equiv_or_gf /-
 theorem lf_or_equiv_or_gf (x y : PGame) : x ⧏ y ∨ (x ≈ y) ∨ y ⧏ x :=
@@ -1060,7 +1086,6 @@ def Fuzzy (x y : PGame) : Prop :=
 #align pgame.fuzzy PGame.Fuzzy
 -/
 
--- mathport name: pgame.fuzzy
 scoped infixl:50 " ‖ " => PGame.Fuzzy
 
 #print PGame.Fuzzy.swap /-
@@ -1087,9 +1112,11 @@ theorem fuzzy_irrefl (x : PGame) : ¬x ‖ x := fun h => lf_irrefl x h.1
 instance : IsIrrefl _ (· ‖ ·) :=
   ⟨fuzzy_irrefl⟩
 
+#print PGame.lf_iff_lt_or_fuzzy /-
 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]; tauto
 #align pgame.lf_iff_lt_or_fuzzy PGame.lf_iff_lt_or_fuzzy
+-/
 
 #print PGame.lf_of_fuzzy /-
 theorem lf_of_fuzzy {x y : PGame} (h : x ‖ y) : x ⧏ y :=
@@ -1100,9 +1127,11 @@ theorem lf_of_fuzzy {x y : PGame} (h : x ‖ y) : x ⧏ y :=
 alias lf_of_fuzzy ← fuzzy.lf
 #align pgame.fuzzy.lf PGame.Fuzzy.lf
 
+#print PGame.lt_or_fuzzy_of_lf /-
 theorem lt_or_fuzzy_of_lf {x y : PGame} : x ⧏ y → x < y ∨ x ‖ y :=
   lf_iff_lt_or_fuzzy.1
 #align pgame.lt_or_fuzzy_of_lf PGame.lt_or_fuzzy_of_lf
+-/
 
 #print PGame.Fuzzy.not_equiv /-
 theorem Fuzzy.not_equiv {x y : PGame} (h : x ‖ y) : ¬(x ≈ y) := fun h' => h'.1.not_gf h.2
@@ -1174,6 +1203,7 @@ theorem fuzzy_of_equiv_of_fuzzy {x y z} (h₁ : x ≈ y) (h₂ : y ‖ z) : x 
 #align pgame.fuzzy_of_equiv_of_fuzzy PGame.fuzzy_of_equiv_of_fuzzy
 -/
 
+#print PGame.lt_or_equiv_or_gt_or_fuzzy /-
 /-- 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
@@ -1183,12 +1213,15 @@ theorem lt_or_equiv_or_gt_or_fuzzy (x y : PGame) : x < y ∨ (x ≈ y) ∨ y < x
   · right; right; left; exact ⟨h₂, h₁⟩
   · right; right; right; exact ⟨h₂, h₁⟩
 #align pgame.lt_or_equiv_or_gt_or_fuzzy PGame.lt_or_equiv_or_gt_or_fuzzy
+-/
 
+#print PGame.lt_or_equiv_or_gf /-
 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]
   exact lt_or_equiv_or_gt_or_fuzzy x y
 #align pgame.lt_or_equiv_or_gf PGame.lt_or_equiv_or_gf
+-/
 
 /-! ### Relabellings -/
 
@@ -1207,7 +1240,6 @@ inductive Relabelling : PGame.{u} → PGame.{u} → Type (u + 1)
 #align pgame.relabelling PGame.Relabelling
 -/
 
--- mathport name: pgame.relabelling
 scoped infixl:50 " ≡r " => PGame.Relabelling
 
 namespace Relabelling
@@ -1592,10 +1624,12 @@ theorem neg_lf_neg_iff {x y : PGame} : -y ⧏ -x ↔ x ⧏ y :=
 #align pgame.neg_lf_neg_iff PGame.neg_lf_neg_iff
 -/
 
+#print PGame.neg_lt_neg_iff /-
 @[simp]
 theorem neg_lt_neg_iff {x y : PGame} : -y < -x ↔ x < y := by
   rw [lt_iff_le_and_lf, lt_iff_le_and_lf, neg_le_neg_iff, neg_lf_neg_iff]
 #align pgame.neg_lt_neg_iff PGame.neg_lt_neg_iff
+-/
 
 #print PGame.neg_equiv_neg_iff /-
 @[simp]
@@ -1621,8 +1655,10 @@ theorem neg_lf_iff {x y : PGame} : -y ⧏ x ↔ -x ⧏ y := by rw [← neg_neg x
 #align pgame.neg_lf_iff PGame.neg_lf_iff
 -/
 
+#print PGame.neg_lt_iff /-
 theorem neg_lt_iff {x y : PGame} : -y < x ↔ -x < y := by rw [← neg_neg x, neg_lt_neg_iff, neg_neg]
 #align pgame.neg_lt_iff PGame.neg_lt_iff
+-/
 
 #print PGame.neg_equiv_iff /-
 theorem neg_equiv_iff {x y : PGame} : (-x ≈ y) ↔ (x ≈ -y) := by
@@ -1646,8 +1682,10 @@ theorem lf_neg_iff {x y : PGame} : y ⧏ -x ↔ x ⧏ -y := by rw [← neg_neg x
 #align pgame.lf_neg_iff PGame.lf_neg_iff
 -/
 
+#print PGame.lt_neg_iff /-
 theorem lt_neg_iff {x y : PGame} : y < -x ↔ x < -y := by rw [← neg_neg x, neg_lt_neg_iff, neg_neg]
 #align pgame.lt_neg_iff PGame.lt_neg_iff
+-/
 
 #print PGame.neg_le_zero_iff /-
 @[simp]
@@ -1673,13 +1711,17 @@ theorem zero_lf_neg_iff {x : PGame} : 0 ⧏ -x ↔ x ⧏ 0 := by rw [lf_neg_iff,
 #align pgame.zero_lf_neg_iff PGame.zero_lf_neg_iff
 -/
 
+#print PGame.neg_lt_zero_iff /-
 @[simp]
 theorem neg_lt_zero_iff {x : PGame} : -x < 0 ↔ 0 < x := by rw [neg_lt_iff, neg_zero]
 #align pgame.neg_lt_zero_iff PGame.neg_lt_zero_iff
+-/
 
+#print PGame.zero_lt_neg_iff /-
 @[simp]
 theorem zero_lt_neg_iff {x : PGame} : 0 < -x ↔ x < 0 := by rw [lt_neg_iff, neg_zero]
 #align pgame.zero_lt_neg_iff PGame.zero_lt_neg_iff
+-/
 
 #print PGame.neg_equiv_zero_iff /-
 @[simp]
@@ -2120,13 +2162,17 @@ theorem add_lf_add_left {y z : PGame} (h : y ⧏ z) (x) : x + y ⧏ x + z := by
 #align pgame.add_lf_add_left PGame.add_lf_add_left
 -/
 
+#print PGame.covariantClass_swap_add_lt /-
 instance covariantClass_swap_add_lt : CovariantClass PGame PGame (swap (· + ·)) (· < ·) :=
   ⟨fun x y z h => ⟨add_le_add_right h.1 x, add_lf_add_right h.2 x⟩⟩
 #align pgame.covariant_class_swap_add_lt PGame.covariantClass_swap_add_lt
+-/
 
+#print PGame.covariantClass_add_lt /-
 instance covariantClass_add_lt : CovariantClass PGame PGame (· + ·) (· < ·) :=
   ⟨fun x y z h => ⟨add_le_add_left h.1 x, add_lf_add_left h.2 x⟩⟩
 #align pgame.covariant_class_add_lt PGame.covariantClass_add_lt
+-/
 
 #print PGame.add_lf_add_of_lf_of_le /-
 theorem add_lf_add_of_lf_of_le {w x y z : PGame} (hwx : w ⧏ x) (hyz : y ≤ z) : w + y ⧏ x + z :=
@@ -2201,6 +2247,7 @@ theorem lf_iff_sub_zero_lf {x y : PGame} : x ⧏ y ↔ 0 ⧏ y - x :=
 #align pgame.lf_iff_sub_zero_lf PGame.lf_iff_sub_zero_lf
 -/
 
+#print PGame.lt_iff_sub_pos /-
 theorem lt_iff_sub_pos {x y : PGame} : x < y ↔ 0 < y - x :=
   ⟨fun h => lt_of_le_of_lt (zero_le_add_right_neg x) (add_lt_add_right h _), fun h =>
     calc
@@ -2210,6 +2257,7 @@ theorem lt_iff_sub_pos {x y : PGame} : x < y ↔ 0 < y - x :=
       _ ≤ y + 0 := (add_le_add_left (add_left_neg_le_zero x) _)
       _ ≤ y := (addZeroRelabelling y).le⟩
 #align pgame.lt_iff_sub_pos PGame.lt_iff_sub_pos
+-/
 
 /-! ### Special pre-games -/
 
@@ -2273,10 +2321,12 @@ theorem neg_star : -star = star := by simp [star]
 #align pgame.neg_star PGame.neg_star
 -/
 
+#print PGame.zero_lt_one /-
 @[simp]
 protected theorem zero_lt_one : (0 : PGame) < 1 :=
   lt_of_le_of_lf (zero_le_of_isEmpty_rightMoves 1) (zero_lf_le.2 ⟨default, le_rfl⟩)
 #align pgame.zero_lt_one PGame.zero_lt_one
+-/
 
 instance : ZeroLEOneClass PGame :=
   ⟨PGame.zero_lt_one.le⟩

mathlib commit https://github.com/leanprover-community/mathlib/commit/7e5137f579de09a059a5ce98f364a04e221aabf0

@@ -346,7 +346,7 @@ theorem Subsequent.mk_right {xl xr} (xL : xl → PGame) (xR : xr → PGame) (j :
 #align pgame.subsequent.mk_right PGame.Subsequent.mk_right
 -/
 
-/- ./././Mathport/Syntax/Translate/Expr.lean:330:4: warning: unsupported (TODO): `[tacs] -/
+/- ./././Mathport/Syntax/Translate/Expr.lean:336:4: warning: unsupported (TODO): `[tacs] -/
 /-- A local tactic for proving well-foundedness of recursive definitions involving pregames. -/
 unsafe def pgame_wf_tac :=
   sorry
@@ -2111,7 +2111,6 @@ theorem add_lf_add_right {y z : PGame} (h : y ⧏ z) (x) : y + x ⧏ z + x :=
     _ ≤ y + (x + -x) := (addAssocRelabelling _ _ _).le
     _ ≤ y + 0 := (add_le_add_left (add_right_neg_le_zero x) _)
     _ ≤ y := (addZeroRelabelling _).le
-    
 #align pgame.add_lf_add_right PGame.add_lf_add_right
 -/
 
@@ -2186,8 +2185,7 @@ theorem le_iff_sub_nonneg {x y : PGame} : x ≤ y ↔ 0 ≤ y - x :=
       _ ≤ y - x + x := (add_le_add_right h _)
       _ ≤ y + (-x + x) := (addAssocRelabelling _ _ _).le
       _ ≤ y + 0 := (add_le_add_left (add_left_neg_le_zero x) _)
-      _ ≤ y := (addZeroRelabelling y).le
-      ⟩
+      _ ≤ y := (addZeroRelabelling y).le⟩
 #align pgame.le_iff_sub_nonneg PGame.le_iff_sub_nonneg
 -/
 
@@ -2199,8 +2197,7 @@ theorem lf_iff_sub_zero_lf {x y : PGame} : x ⧏ y ↔ 0 ⧏ y - x :=
       _ ⧏ y - x + x := (add_lf_add_right h _)
       _ ≤ y + (-x + x) := (addAssocRelabelling _ _ _).le
       _ ≤ y + 0 := (add_le_add_left (add_left_neg_le_zero x) _)
-      _ ≤ y := (addZeroRelabelling y).le
-      ⟩
+      _ ≤ y := (addZeroRelabelling y).le⟩
 #align pgame.lf_iff_sub_zero_lf PGame.lf_iff_sub_zero_lf
 -/
 
@@ -2211,8 +2208,7 @@ theorem lt_iff_sub_pos {x y : PGame} : x < y ↔ 0 < y - x :=
       _ < y - x + x := (add_lt_add_right h _)
       _ ≤ y + (-x + x) := (addAssocRelabelling _ _ _).le
       _ ≤ y + 0 := (add_le_add_left (add_left_neg_le_zero x) _)
-      _ ≤ y := (addZeroRelabelling y).le
-      ⟩
+      _ ≤ y := (addZeroRelabelling y).le⟩
 #align pgame.lt_iff_sub_pos PGame.lt_iff_sub_pos
 
 /-! ### Special pre-games -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

@@ -2017,12 +2017,12 @@ theorem add_left_neg_le_zero : ∀ x : PGame, -x + x ≤ 0
       cases i
       · -- If Left played in -x, Right responds with the same move in x.
         refine' ⟨@to_right_moves_add _ ⟨_, _, _, _⟩ (Sum.inr i), _⟩
-        convert@add_left_neg_le_zero (xR i)
+        convert @add_left_neg_le_zero (xR i)
         apply add_move_right_inr
       · -- If Left in x, Right responds with the same move in -x.
         dsimp
         refine' ⟨@to_right_moves_add ⟨_, _, _, _⟩ _ (Sum.inl i), _⟩
-        convert@add_left_neg_le_zero (xL i)
+        convert @add_left_neg_le_zero (xL i)
         apply add_move_right_inl
 #align pgame.add_left_neg_le_zero PGame.add_left_neg_le_zero
 -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

@@ -637,14 +637,14 @@ instance : IsIrrefl _ (· ⧏ ·) :=
 #print PGame.lf_of_le_of_lf /-
 @[trans]
 theorem lf_of_le_of_lf {x y z : PGame} (h₁ : x ≤ y) (h₂ : y ⧏ z) : x ⧏ z := by
-  rw [← PGame.not_le] at h₂⊢; exact fun h₃ => h₂ (h₃.trans h₁)
+  rw [← PGame.not_le] at h₂ ⊢; exact fun h₃ => h₂ (h₃.trans h₁)
 #align pgame.lf_of_le_of_lf PGame.lf_of_le_of_lf
 -/
 
 #print PGame.lf_of_lf_of_le /-
 @[trans]
 theorem lf_of_lf_of_le {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y ≤ z) : x ⧏ z := by
-  rw [← PGame.not_le] at h₁⊢; exact fun h₃ => h₁ (h₂.trans h₃)
+  rw [← PGame.not_le] at h₁ ⊢; exact fun h₃ => h₁ (h₂.trans h₃)
 #align pgame.lf_of_lf_of_le PGame.lf_of_lf_of_le
 -/
 
@@ -1302,7 +1302,8 @@ def moveRightSymm :
 /-- The identity relabelling. -/
 @[refl]
 def refl : ∀ x : PGame, x ≡r x
-  | x => ⟨Equiv.refl _, Equiv.refl _, fun i => refl _, fun j => refl _⟩decreasing_by pgame_wf_tac
+  | x => ⟨Equiv.refl _, Equiv.refl _, fun i => refl _, fun j => refl _⟩
+decreasing_by pgame_wf_tac
 #align pgame.relabelling.refl PGame.Relabelling.refl
 -/
 
@@ -1320,10 +1321,8 @@ def symm : ∀ {x y : PGame}, x ≡r y → y ≡r x
 #print PGame.Relabelling.le /-
 theorem le : ∀ {x y : PGame} (r : x ≡r y), x ≤ y
   | x, y, r =>
-    le_def.2
-      ⟨fun i => Or.inl ⟨_, (r.moveLeft i).le⟩, fun j =>
-        Or.inr ⟨_, (r.moveRightSymm j).le⟩⟩decreasing_by
-  pgame_wf_tac
+    le_def.2 ⟨fun i => Or.inl ⟨_, (r.moveLeft i).le⟩, fun j => Or.inr ⟨_, (r.moveRightSymm j).le⟩⟩
+decreasing_by pgame_wf_tac
 #align pgame.relabelling.le PGame.Relabelling.le
 -/
 
@@ -1469,7 +1468,7 @@ theorem neg_ofLists (L R : List PGame) :
 theorem isOption_neg {x y : PGame} : IsOption x (-y) ↔ IsOption (-x) y :=
   by
   rw [is_option_iff, is_option_iff, or_comm']
-  cases y; apply or_congr <;> · apply exists_congr; intro ; rw [neg_eq_iff_eq_neg]; rfl
+  cases y; apply or_congr <;> · apply exists_congr; intro; rw [neg_eq_iff_eq_neg]; rfl
 #align pgame.is_option_neg PGame.isOption_neg
 -/
 
@@ -1576,8 +1575,8 @@ private theorem neg_le_lf_neg_iff : ∀ {x y : PGame.{u}}, (-y ≤ -x ↔ x ≤
     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 <;> exact exists_congr fun _ => neg_le_lf_neg_iff.1decreasing_by
-  pgame_wf_tac
+    · rw [or_comm']; apply or_congr <;> exact exists_congr fun _ => neg_le_lf_neg_iff.1
+decreasing_by pgame_wf_tac
 
 #print PGame.neg_le_neg_iff /-
 @[simp]
@@ -1923,7 +1922,8 @@ def Relabelling.addCongr : ∀ {w x y z : PGame.{u}}, w ≡r x → y ≡r z →
     · exact (hL₁ i).addCongr Hyz
     · exact Hwx.add_congr (hL₂ j)
     · exact (hR₁ i).addCongr Hyz
-    · exact Hwx.add_congr (hR₂ j)decreasing_by pgame_wf_tac
+    · exact Hwx.add_congr (hR₂ j)
+decreasing_by pgame_wf_tac
 #align pgame.relabelling.add_congr PGame.Relabelling.addCongr
 -/
 
@@ -1954,8 +1954,8 @@ def negAddRelabelling : ∀ x y : PGame, -(x + y) ≡r -x + -y
     all_goals
       exact fun j =>
         Sum.casesOn j (fun j => neg_add_relabelling _ _) fun j =>
-          neg_add_relabelling ⟨xl, xr, xL, xR⟩ _ decreasing_by
-  pgame_wf_tac
+          neg_add_relabelling ⟨xl, xr, xL, xR⟩ _
+decreasing_by pgame_wf_tac
 #align pgame.neg_add_relabelling PGame.negAddRelabelling
 -/
 
@@ -1970,8 +1970,8 @@ theorem neg_add_le {x y : PGame} : -(x + y) ≤ -x + -y :=
 def addCommRelabelling : ∀ x y : PGame.{u}, x + y ≡r y + x
   | mk xl xr xL xR, mk yl yr yL yR => by
     refine' ⟨Equiv.sumComm _ _, Equiv.sumComm _ _, _, _⟩ <;> rintro (_ | _) <;>
-      · dsimp [left_moves_add, right_moves_add]; apply add_comm_relabelling decreasing_by
-  pgame_wf_tac
+      · dsimp [left_moves_add, right_moves_add]; apply add_comm_relabelling
+decreasing_by pgame_wf_tac
 #align pgame.add_comm_relabelling PGame.addCommRelabelling
 -/
 
@@ -1994,11 +1994,13 @@ def addAssocRelabelling : ∀ x y z : PGame.{u}, x + y + z ≡r x + (y + z)
     by
     refine' ⟨Equiv.sumAssoc _ _ _, Equiv.sumAssoc _ _ _, _, _⟩
     all_goals
-      first |rintro (⟨i | i⟩ | i)|rintro (j | ⟨j | j⟩)
+      first
+      | rintro (⟨i | i⟩ | i)
+      | rintro (j | ⟨j | j⟩)
       · apply add_assoc_relabelling
       · apply add_assoc_relabelling ⟨xl, xr, xL, xR⟩
-      · apply add_assoc_relabelling ⟨xl, xr, xL, xR⟩ ⟨yl, yr, yL, yR⟩decreasing_by
-  pgame_wf_tac
+      · apply add_assoc_relabelling ⟨xl, xr, xL, xR⟩ ⟨yl, yr, yL, yR⟩
+decreasing_by pgame_wf_tac
 #align pgame.add_assoc_relabelling PGame.addAssocRelabelling
 -/
 
@@ -2067,7 +2069,7 @@ private theorem add_le_add_right' : ∀ {x y z : PGame} (h : x ≤ y), x + z ≤
   | mk xl xr xL xR, mk yl yr yL yR, mk zl zr zL zR => fun h =>
     by
     refine' le_def.2 ⟨fun i => _, fun i => _⟩ <;> cases i
-    · rw [le_def] at h
+    · rw [le_def] at h 
       cases h
       rcases h_left i with (⟨i', ih⟩ | ⟨j, jh⟩)
       · exact Or.inl ⟨to_left_moves_add (Sum.inl i'), add_le_add_right' ih⟩
@@ -2075,17 +2077,15 @@ private theorem add_le_add_right' : ∀ {x y z : PGame} (h : x ≤ y), x + z ≤
         convert add_le_add_right' jh
         apply add_move_right_inl
     · exact Or.inl ⟨@to_left_moves_add _ ⟨_, _, _, _⟩ (Sum.inr i), add_le_add_right' h⟩
-    · rw [le_def] at h
+    · rw [le_def] at h 
       cases h
       rcases h_right i with (⟨i, ih⟩ | ⟨j', jh⟩)
       · refine' Or.inl ⟨to_left_moves_add (Sum.inl i), _⟩
         convert add_le_add_right' ih
         apply add_move_left_inl
       · exact Or.inr ⟨to_right_moves_add (Sum.inl j'), add_le_add_right' jh⟩
-    ·
-      exact
-        Or.inr ⟨@to_right_moves_add _ ⟨_, _, _, _⟩ (Sum.inr i), add_le_add_right' h⟩decreasing_by
-  pgame_wf_tac
+    · exact Or.inr ⟨@to_right_moves_add _ ⟨_, _, _, _⟩ (Sum.inr i), add_le_add_right' h⟩
+decreasing_by pgame_wf_tac
 
 #print PGame.covariantClass_swap_add_le /-
 instance covariantClass_swap_add_le : CovariantClass PGame PGame (swap (· + ·)) (· ≤ ·) :=
@@ -2101,7 +2101,7 @@ instance covariantClass_add_le : CovariantClass PGame PGame (· + ·) (· ≤ ·
 
 #print PGame.add_lf_add_right /-
 theorem add_lf_add_right {y z : PGame} (h : y ⧏ z) (x) : y + x ⧏ z + x :=
-  suffices z + x ≤ y + x → z ≤ y by rw [← PGame.not_le] at h⊢; exact mt this h
+  suffices z + x ≤ y + x → z ≤ y by rw [← PGame.not_le] at h ⊢; exact mt this h
   fun w =>
   calc
     z ≤ z + 0 := (addZeroRelabelling _).symm.le

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -610,42 +610,18 @@ instance : Preorder PGame :=
           le_trans_aux (fun i => (IHzl i).1) fun j => (IHyr j).2.1⟩
     lt := fun x y => x ≤ y ∧ x ⧏ y }
 
-/- warning: pgame.lt_iff_le_and_lf -> PGame.lt_iff_le_and_lf is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) (And (LE.le.{succ u1} PGame.{u1} PGame.hasLe.{u1} x y) (PGame.Lf.{u1} x y))
-but is expected to have type
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) (And (LE.le.{succ u1} PGame.{u1} PGame.le.{u1} x y) (PGame.Lf.{u1} x y))
-Case conversion may be inaccurate. Consider using '#align pgame.lt_iff_le_and_lf PGame.lt_iff_le_and_lfₓ'. -/
 theorem lt_iff_le_and_lf {x y : PGame} : x < y ↔ x ≤ y ∧ x ⧏ y :=
   Iff.rfl
 #align pgame.lt_iff_le_and_lf PGame.lt_iff_le_and_lf
 
-/- warning: pgame.lt_of_le_of_lf -> PGame.lt_of_le_of_lf is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, (LE.le.{succ u1} PGame.{u1} PGame.hasLe.{u1} x y) -> (PGame.Lf.{u1} x y) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y)
-but is expected to have type
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, (LE.le.{succ u1} PGame.{u1} PGame.le.{u1} x y) -> (PGame.Lf.{u1} x y) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y)
-Case conversion may be inaccurate. Consider using '#align pgame.lt_of_le_of_lf PGame.lt_of_le_of_lfₓ'. -/
 theorem lt_of_le_of_lf {x y : PGame} (h₁ : x ≤ y) (h₂ : x ⧏ y) : x < y :=
   ⟨h₁, h₂⟩
 #align pgame.lt_of_le_of_lf PGame.lt_of_le_of_lf
 
-/- warning: pgame.lf_of_lt -> PGame.lf_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) -> (PGame.Lf.{u1} x y)
-but is expected to have type
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) -> (PGame.Lf.{u1} x y)
-Case conversion may be inaccurate. Consider using '#align pgame.lf_of_lt PGame.lf_of_ltₓ'. -/
 theorem lf_of_lt {x y : PGame} (h : x < y) : x ⧏ y :=
   h.2
 #align pgame.lf_of_lt PGame.lf_of_lt
 
-/- warning: has_lt.lt.lf -> LT.lt.lf is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) -> (PGame.Lf.{u1} x y)
-but is expected to have type
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) -> (PGame.Lf.{u1} x y)
-Case conversion may be inaccurate. Consider using '#align has_lt.lt.lf LT.lt.lfₓ'. -/
 alias lf_of_lt ← _root_.has_lt.lt.lf
 #align has_lt.lt.lf LT.lt.lf
 
@@ -678,43 +654,19 @@ alias lf_of_le_of_lf ← _root_.has_le.le.trans_lf
 alias lf_of_lf_of_le ← lf.trans_le
 #align pgame.lf.trans_le PGame.Lf.trans_le
 
-/- warning: pgame.lf_of_lt_of_lf -> PGame.lf_of_lt_of_lf is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) -> (PGame.Lf.{u1} y z) -> (PGame.Lf.{u1} x z)
-but is expected to have type
-  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) -> (PGame.Lf.{u1} y z) -> (PGame.Lf.{u1} x z)
-Case conversion may be inaccurate. Consider using '#align pgame.lf_of_lt_of_lf PGame.lf_of_lt_of_lfₓ'. -/
 @[trans]
 theorem lf_of_lt_of_lf {x y z : PGame} (h₁ : x < y) (h₂ : y ⧏ z) : x ⧏ z :=
   h₁.le.trans_lf h₂
 #align pgame.lf_of_lt_of_lf PGame.lf_of_lt_of_lf
 
-/- warning: pgame.lf_of_lf_of_lt -> PGame.lf_of_lf_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (PGame.Lf.{u1} x y) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) y z) -> (PGame.Lf.{u1} x z)
-but is expected to have type
-  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (PGame.Lf.{u1} x y) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) y z) -> (PGame.Lf.{u1} x z)
-Case conversion may be inaccurate. Consider using '#align pgame.lf_of_lf_of_lt PGame.lf_of_lf_of_ltₓ'. -/
 @[trans]
 theorem lf_of_lf_of_lt {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y < z) : x ⧏ z :=
   h₁.trans_le h₂.le
 #align pgame.lf_of_lf_of_lt PGame.lf_of_lf_of_lt
 
-/- warning: has_lt.lt.trans_lf -> LT.lt.trans_lf is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) -> (PGame.Lf.{u1} y z) -> (PGame.Lf.{u1} x z)
-but is expected to have type
-  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) -> (PGame.Lf.{u1} y z) -> (PGame.Lf.{u1} x z)
-Case conversion may be inaccurate. Consider using '#align has_lt.lt.trans_lf LT.lt.trans_lfₓ'. -/
 alias lf_of_lt_of_lf ← _root_.has_lt.lt.trans_lf
 #align has_lt.lt.trans_lf LT.lt.trans_lf
 
-/- warning: pgame.lf.trans_lt -> PGame.Lf.trans_lt is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (PGame.Lf.{u1} x y) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) y z) -> (PGame.Lf.{u1} x z)
-but is expected to have type
-  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (PGame.Lf.{u1} x y) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) y z) -> (PGame.Lf.{u1} x z)
-Case conversion may be inaccurate. Consider using '#align pgame.lf.trans_lt PGame.Lf.trans_ltₓ'. -/
 alias lf_of_lf_of_lt ← lf.trans_lt
 #align pgame.lf.trans_lt PGame.Lf.trans_lt
 
@@ -742,12 +694,6 @@ theorem mk_lf {xl xr} (xL : xl → PGame) (xR : xr → PGame) (j) : mk xl xr xL
 #align pgame.mk_lf PGame.mk_lf
 -/
 
-/- warning: pgame.le_of_forall_lt -> PGame.le_of_forall_lt is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, (forall (i : PGame.LeftMoves.{u1} x), LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) (PGame.moveLeft.{u1} x i) y) -> (forall (j : PGame.RightMoves.{u1} y), LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x (PGame.moveRight.{u1} y j)) -> (LE.le.{succ u1} PGame.{u1} PGame.hasLe.{u1} x y)
-but is expected to have type
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, (forall (i : PGame.LeftMoves.{u1} x), LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) (PGame.moveLeft.{u1} x i) y) -> (forall (j : PGame.RightMoves.{u1} y), LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x (PGame.moveRight.{u1} y j)) -> (LE.le.{succ u1} PGame.{u1} PGame.le.{u1} x y)
-Case conversion may be inaccurate. Consider using '#align pgame.le_of_forall_lt PGame.le_of_forall_ltₓ'. -/
 /-- This special case of `pgame.le_of_forall_lf` is useful when dealing with surreals, where `<` is
 preferred over `⧏`. -/
 theorem le_of_forall_lt {x y : PGame} (h₁ : ∀ i, x.moveLeft i < y) (h₂ : ∀ j, x < y.moveRight j) :
@@ -975,12 +921,6 @@ theorem Lf.not_equiv' {x y} (h : x ⧏ y) : ¬(y ≈ x) := fun h' => h.not_ge h'
 #align pgame.lf.not_equiv' PGame.Lf.not_equiv'
 -/
 
-/- warning: pgame.lf.not_gt -> PGame.Lf.not_gt is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, (PGame.Lf.{u1} x y) -> (Not (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) y x))
-but is expected to have type
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, (PGame.Lf.{u1} x y) -> (Not (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) y x))
-Case conversion may be inaccurate. Consider using '#align pgame.lf.not_gt PGame.Lf.not_gtₓ'. -/
 theorem Lf.not_gt {x y} (h : x ⧏ y) : ¬y < x := fun h' => h.not_ge h'.le
 #align pgame.lf.not_gt PGame.Lf.not_gt
 
@@ -1046,74 +986,32 @@ theorem lf_of_equiv_of_lf {x y z} (h₁ : x ≈ y) : y ⧏ z → x ⧏ z :=
 #align pgame.lf_of_equiv_of_lf PGame.lf_of_equiv_of_lf
 -/
 
-/- warning: pgame.lt_of_lt_of_equiv -> PGame.lt_of_lt_of_equiv is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) -> (PGame.Equiv.{u1} y z) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x z)
-but is expected to have type
-  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) -> (PGame.Equiv.{u1} y z) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x z)
-Case conversion may be inaccurate. Consider using '#align pgame.lt_of_lt_of_equiv PGame.lt_of_lt_of_equivₓ'. -/
 @[trans]
 theorem lt_of_lt_of_equiv {x y z} (h₁ : x < y) (h₂ : y ≈ z) : x < z :=
   h₁.trans_le h₂.1
 #align pgame.lt_of_lt_of_equiv PGame.lt_of_lt_of_equiv
 
-/- warning: pgame.lt_of_equiv_of_lt -> PGame.lt_of_equiv_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (PGame.Equiv.{u1} x y) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) y z) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x z)
-but is expected to have type
-  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (PGame.Equiv.{u1} x y) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) y z) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x z)
-Case conversion may be inaccurate. Consider using '#align pgame.lt_of_equiv_of_lt PGame.lt_of_equiv_of_ltₓ'. -/
 @[trans]
 theorem lt_of_equiv_of_lt {x y z} (h₁ : x ≈ y) : y < z → x < z :=
   h₁.1.trans_lt
 #align pgame.lt_of_equiv_of_lt PGame.lt_of_equiv_of_lt
 
-/- warning: pgame.lt_congr_imp -> PGame.lt_congr_imp is a dubious translation:
-lean 3 declaration is
-  forall {x₁ : PGame.{u1}} {y₁ : PGame.{u1}} {x₂ : PGame.{u1}} {y₂ : PGame.{u1}}, (PGame.Equiv.{u1} x₁ x₂) -> (PGame.Equiv.{u1} y₁ y₂) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x₁ y₁) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x₂ y₂)
-but is expected to have type
-  forall {x₁ : PGame.{u1}} {y₁ : PGame.{u1}} {x₂ : PGame.{u1}} {y₂ : PGame.{u1}}, (PGame.Equiv.{u1} x₁ x₂) -> (PGame.Equiv.{u1} y₁ y₂) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x₁ y₁) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x₂ y₂)
-Case conversion may be inaccurate. Consider using '#align pgame.lt_congr_imp PGame.lt_congr_impₓ'. -/
 theorem lt_congr_imp {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) (h : x₁ < y₁) : x₂ < y₂ :=
   hx.2.trans_lt (h.trans_le hy.1)
 #align pgame.lt_congr_imp PGame.lt_congr_imp
 
-/- warning: pgame.lt_congr -> PGame.lt_congr is a dubious translation:
-lean 3 declaration is
-  forall {x₁ : PGame.{u1}} {y₁ : PGame.{u1}} {x₂ : PGame.{u1}} {y₂ : PGame.{u1}}, (PGame.Equiv.{u1} x₁ x₂) -> (PGame.Equiv.{u1} y₁ y₂) -> (Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x₁ y₁) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x₂ y₂))
-but is expected to have type
-  forall {x₁ : PGame.{u1}} {y₁ : PGame.{u1}} {x₂ : PGame.{u1}} {y₂ : PGame.{u1}}, (PGame.Equiv.{u1} x₁ x₂) -> (PGame.Equiv.{u1} y₁ y₂) -> (Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x₁ y₁) (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x₂ y₂))
-Case conversion may be inaccurate. Consider using '#align pgame.lt_congr PGame.lt_congrₓ'. -/
 theorem lt_congr {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ < y₁ ↔ x₂ < y₂ :=
   ⟨lt_congr_imp hx hy, lt_congr_imp hx.symm hy.symm⟩
 #align pgame.lt_congr PGame.lt_congr
 
-/- warning: pgame.lt_congr_left -> PGame.lt_congr_left is a dubious translation:
-lean 3 declaration is
-  forall {x₁ : PGame.{u1}} {x₂ : PGame.{u1}} {y : PGame.{u1}}, (PGame.Equiv.{u1} x₁ x₂) -> (Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x₁ y) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x₂ y))
-but is expected to have type
-  forall {x₁ : PGame.{u1}} {x₂ : PGame.{u1}} {y : PGame.{u1}}, (PGame.Equiv.{u1} x₁ x₂) -> (Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x₁ y) (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x₂ y))
-Case conversion may be inaccurate. Consider using '#align pgame.lt_congr_left PGame.lt_congr_leftₓ'. -/
 theorem lt_congr_left {x₁ x₂ y} (hx : x₁ ≈ x₂) : x₁ < y ↔ x₂ < y :=
   lt_congr hx equiv_rfl
 #align pgame.lt_congr_left PGame.lt_congr_left
 
-/- warning: pgame.lt_congr_right -> PGame.lt_congr_right is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}} {y₁ : PGame.{u1}} {y₂ : PGame.{u1}}, (PGame.Equiv.{u1} y₁ y₂) -> (Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y₁) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y₂))
-but is expected to have type
-  forall {x : PGame.{u1}} {y₁ : PGame.{u1}} {y₂ : PGame.{u1}}, (PGame.Equiv.{u1} y₁ y₂) -> (Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y₁) (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y₂))
-Case conversion may be inaccurate. Consider using '#align pgame.lt_congr_right PGame.lt_congr_rightₓ'. -/
 theorem lt_congr_right {x y₁ y₂} (hy : y₁ ≈ y₂) : x < y₁ ↔ x < y₂ :=
   lt_congr equiv_rfl hy
 #align pgame.lt_congr_right PGame.lt_congr_right
 
-/- warning: pgame.lt_or_equiv_of_le -> PGame.lt_or_equiv_of_le is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, (LE.le.{succ u1} PGame.{u1} PGame.hasLe.{u1} x y) -> (Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) (PGame.Equiv.{u1} x y))
-but is expected to have type
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, (LE.le.{succ u1} PGame.{u1} PGame.le.{u1} x y) -> (Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) (PGame.Equiv.{u1} x y))
-Case conversion may be inaccurate. Consider using '#align pgame.lt_or_equiv_of_le PGame.lt_or_equiv_of_leₓ'. -/
 theorem lt_or_equiv_of_le {x y : PGame} (h : x ≤ y) : x < y ∨ (x ≈ y) :=
   and_or_left.mp ⟨h, (em <| y ≤ x).symm.imp_left PGame.not_le.1⟩
 #align pgame.lt_or_equiv_of_le PGame.lt_or_equiv_of_le
@@ -1189,12 +1087,6 @@ theorem fuzzy_irrefl (x : PGame) : ¬x ‖ x := fun h => lf_irrefl x h.1
 instance : IsIrrefl _ (· ‖ ·) :=
   ⟨fuzzy_irrefl⟩
 
-/- warning: pgame.lf_iff_lt_or_fuzzy -> PGame.lf_iff_lt_or_fuzzy is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (PGame.Lf.{u1} x y) (Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) (PGame.Fuzzy.{u1} x y))
-but is expected to have type
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (PGame.Lf.{u1} x y) (Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) (PGame.Fuzzy.{u1} x y))
-Case conversion may be inaccurate. Consider using '#align pgame.lf_iff_lt_or_fuzzy PGame.lf_iff_lt_or_fuzzyₓ'. -/
 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]; tauto
 #align pgame.lf_iff_lt_or_fuzzy PGame.lf_iff_lt_or_fuzzy
@@ -1208,12 +1100,6 @@ theorem lf_of_fuzzy {x y : PGame} (h : x ‖ y) : x ⧏ y :=
 alias lf_of_fuzzy ← fuzzy.lf
 #align pgame.fuzzy.lf PGame.Fuzzy.lf
 
-/- warning: pgame.lt_or_fuzzy_of_lf -> PGame.lt_or_fuzzy_of_lf is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, (PGame.Lf.{u1} x y) -> (Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) (PGame.Fuzzy.{u1} x y))
-but is expected to have type
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, (PGame.Lf.{u1} x y) -> (Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) (PGame.Fuzzy.{u1} x y))
-Case conversion may be inaccurate. Consider using '#align pgame.lt_or_fuzzy_of_lf PGame.lt_or_fuzzy_of_lfₓ'. -/
 theorem lt_or_fuzzy_of_lf {x y : PGame} : x ⧏ y → x < y ∨ x ‖ y :=
   lf_iff_lt_or_fuzzy.1
 #align pgame.lt_or_fuzzy_of_lf PGame.lt_or_fuzzy_of_lf
@@ -1288,12 +1174,6 @@ theorem fuzzy_of_equiv_of_fuzzy {x y z} (h₁ : x ≈ y) (h₂ : y ‖ z) : x 
 #align pgame.fuzzy_of_equiv_of_fuzzy PGame.fuzzy_of_equiv_of_fuzzy
 -/
 
-/- warning: pgame.lt_or_equiv_or_gt_or_fuzzy -> PGame.lt_or_equiv_or_gt_or_fuzzy is a dubious translation:
-lean 3 declaration is
-  forall (x : PGame.{u1}) (y : PGame.{u1}), Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) (Or (PGame.Equiv.{u1} x y) (Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) y x) (PGame.Fuzzy.{u1} x y)))
-but is expected to have type
-  forall (x : PGame.{u1}) (y : PGame.{u1}), Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) (Or (PGame.Equiv.{u1} x y) (Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) y x) (PGame.Fuzzy.{u1} x y)))
-Case conversion may be inaccurate. Consider using '#align pgame.lt_or_equiv_or_gt_or_fuzzy PGame.lt_or_equiv_or_gt_or_fuzzyₓ'. -/
 /-- 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
@@ -1304,12 +1184,6 @@ theorem lt_or_equiv_or_gt_or_fuzzy (x y : PGame) : x < y ∨ (x ≈ y) ∨ y < x
   · right; right; right; exact ⟨h₂, h₁⟩
 #align pgame.lt_or_equiv_or_gt_or_fuzzy PGame.lt_or_equiv_or_gt_or_fuzzy
 
-/- warning: pgame.lt_or_equiv_or_gf -> PGame.lt_or_equiv_or_gf is a dubious translation:
-lean 3 declaration is
-  forall (x : PGame.{u1}) (y : PGame.{u1}), Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) (Or (PGame.Equiv.{u1} x y) (PGame.Lf.{u1} y x))
-but is expected to have type
-  forall (x : PGame.{u1}) (y : PGame.{u1}), Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) (Or (PGame.Equiv.{u1} x y) (PGame.Lf.{u1} y x))
-Case conversion may be inaccurate. Consider using '#align pgame.lt_or_equiv_or_gf PGame.lt_or_equiv_or_gfₓ'. -/
 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]
@@ -1719,12 +1593,6 @@ theorem neg_lf_neg_iff {x y : PGame} : -y ⧏ -x ↔ x ⧏ y :=
 #align pgame.neg_lf_neg_iff PGame.neg_lf_neg_iff
 -/
 
-/- warning: pgame.neg_lt_neg_iff -> PGame.neg_lt_neg_iff is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) (Neg.neg.{succ u1} PGame.{u1} PGame.hasNeg.{u1} y) (Neg.neg.{succ u1} PGame.{u1} PGame.hasNeg.{u1} x)) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y)
-but is expected to have type
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) (Neg.neg.{succ u1} PGame.{u1} PGame.instNegPGame.{u1} y) (Neg.neg.{succ u1} PGame.{u1} PGame.instNegPGame.{u1} x)) (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y)
-Case conversion may be inaccurate. Consider using '#align pgame.neg_lt_neg_iff PGame.neg_lt_neg_iffₓ'. -/
 @[simp]
 theorem neg_lt_neg_iff {x y : PGame} : -y < -x ↔ x < y := by
   rw [lt_iff_le_and_lf, lt_iff_le_and_lf, neg_le_neg_iff, neg_lf_neg_iff]
@@ -1754,12 +1622,6 @@ theorem neg_lf_iff {x y : PGame} : -y ⧏ x ↔ -x ⧏ y := by rw [← neg_neg x
 #align pgame.neg_lf_iff PGame.neg_lf_iff
 -/
 
-/- warning: pgame.neg_lt_iff -> PGame.neg_lt_iff is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) (Neg.neg.{succ u1} PGame.{u1} PGame.hasNeg.{u1} y) x) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) (Neg.neg.{succ u1} PGame.{u1} PGame.hasNeg.{u1} x) y)
-but is expected to have type
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) (Neg.neg.{succ u1} PGame.{u1} PGame.instNegPGame.{u1} y) x) (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) (Neg.neg.{succ u1} PGame.{u1} PGame.instNegPGame.{u1} x) y)
-Case conversion may be inaccurate. Consider using '#align pgame.neg_lt_iff PGame.neg_lt_iffₓ'. -/
 theorem neg_lt_iff {x y : PGame} : -y < x ↔ -x < y := by rw [← neg_neg x, neg_lt_neg_iff, neg_neg]
 #align pgame.neg_lt_iff PGame.neg_lt_iff
 
@@ -1785,12 +1647,6 @@ theorem lf_neg_iff {x y : PGame} : y ⧏ -x ↔ x ⧏ -y := by rw [← neg_neg x
 #align pgame.lf_neg_iff PGame.lf_neg_iff
 -/
 
-/- warning: pgame.lt_neg_iff -> PGame.lt_neg_iff is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) y (Neg.neg.{succ u1} PGame.{u1} PGame.hasNeg.{u1} x)) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x (Neg.neg.{succ u1} PGame.{u1} PGame.hasNeg.{u1} y))
-but is expected to have type
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) y (Neg.neg.{succ u1} PGame.{u1} PGame.instNegPGame.{u1} x)) (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x (Neg.neg.{succ u1} PGame.{u1} PGame.instNegPGame.{u1} y))
-Case conversion may be inaccurate. Consider using '#align pgame.lt_neg_iff PGame.lt_neg_iffₓ'. -/
 theorem lt_neg_iff {x y : PGame} : y < -x ↔ x < -y := by rw [← neg_neg x, neg_lt_neg_iff, neg_neg]
 #align pgame.lt_neg_iff PGame.lt_neg_iff
 
@@ -1818,22 +1674,10 @@ theorem zero_lf_neg_iff {x : PGame} : 0 ⧏ -x ↔ x ⧏ 0 := by rw [lf_neg_iff,
 #align pgame.zero_lf_neg_iff PGame.zero_lf_neg_iff
 -/
 
-/- warning: pgame.neg_lt_zero_iff -> PGame.neg_lt_zero_iff is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) (Neg.neg.{succ u1} PGame.{u1} PGame.hasNeg.{u1} x) (OfNat.ofNat.{succ u1} PGame.{u1} 0 (OfNat.mk.{succ u1} PGame.{u1} 0 (Zero.zero.{succ u1} PGame.{u1} PGame.hasZero.{u1})))) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) (OfNat.ofNat.{succ u1} PGame.{u1} 0 (OfNat.mk.{succ u1} PGame.{u1} 0 (Zero.zero.{succ u1} PGame.{u1} PGame.hasZero.{u1}))) x)
-but is expected to have type
-  forall {x : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) (Neg.neg.{succ u1} PGame.{u1} PGame.instNegPGame.{u1} x) (OfNat.ofNat.{succ u1} PGame.{u1} 0 (Zero.toOfNat0.{succ u1} PGame.{u1} PGame.instZeroPGame.{u1}))) (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) (OfNat.ofNat.{succ u1} PGame.{u1} 0 (Zero.toOfNat0.{succ u1} PGame.{u1} PGame.instZeroPGame.{u1})) x)
-Case conversion may be inaccurate. Consider using '#align pgame.neg_lt_zero_iff PGame.neg_lt_zero_iffₓ'. -/
 @[simp]
 theorem neg_lt_zero_iff {x : PGame} : -x < 0 ↔ 0 < x := by rw [neg_lt_iff, neg_zero]
 #align pgame.neg_lt_zero_iff PGame.neg_lt_zero_iff
 
-/- warning: pgame.zero_lt_neg_iff -> PGame.zero_lt_neg_iff is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) (OfNat.ofNat.{succ u1} PGame.{u1} 0 (OfNat.mk.{succ u1} PGame.{u1} 0 (Zero.zero.{succ u1} PGame.{u1} PGame.hasZero.{u1}))) (Neg.neg.{succ u1} PGame.{u1} PGame.hasNeg.{u1} x)) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x (OfNat.ofNat.{succ u1} PGame.{u1} 0 (OfNat.mk.{succ u1} PGame.{u1} 0 (Zero.zero.{succ u1} PGame.{u1} PGame.hasZero.{u1}))))
-but is expected to have type
-  forall {x : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) (OfNat.ofNat.{succ u1} PGame.{u1} 0 (Zero.toOfNat0.{succ u1} PGame.{u1} PGame.instZeroPGame.{u1})) (Neg.neg.{succ u1} PGame.{u1} PGame.instNegPGame.{u1} x)) (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x (OfNat.ofNat.{succ u1} PGame.{u1} 0 (Zero.toOfNat0.{succ u1} PGame.{u1} PGame.instZeroPGame.{u1})))
-Case conversion may be inaccurate. Consider using '#align pgame.zero_lt_neg_iff PGame.zero_lt_neg_iffₓ'. -/
 @[simp]
 theorem zero_lt_neg_iff {x : PGame} : 0 < -x ↔ x < 0 := by rw [lt_neg_iff, neg_zero]
 #align pgame.zero_lt_neg_iff PGame.zero_lt_neg_iff
@@ -2277,22 +2121,10 @@ theorem add_lf_add_left {y z : PGame} (h : y ⧏ z) (x) : x + y ⧏ x + z := by
 #align pgame.add_lf_add_left PGame.add_lf_add_left
 -/
 
-/- warning: pgame.covariant_class_swap_add_lt -> PGame.covariantClass_swap_add_lt is a dubious translation:
-lean 3 declaration is
-  CovariantClass.{succ u1, succ u1} PGame.{u1} PGame.{u1} (Function.swap.{succ (succ u1), succ (succ u1), succ (succ u1)} PGame.{u1} PGame.{u1} (fun (ᾰ : PGame.{u1}) (ᾰ : PGame.{u1}) => PGame.{u1}) (HAdd.hAdd.{succ u1, succ u1, succ u1} PGame.{u1} PGame.{u1} PGame.{u1} (instHAdd.{succ u1} PGame.{u1} PGame.hasAdd.{u1}))) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}))
-but is expected to have type
-  CovariantClass.{succ u1, succ u1} PGame.{u1} PGame.{u1} (Function.swap.{succ (succ u1), succ (succ u1), succ (succ u1)} PGame.{u1} PGame.{u1} (fun (ᾰ : PGame.{u1}) (ᾰ : PGame.{u1}) => PGame.{u1}) (fun (x._@.Mathlib.SetTheory.Game.PGame._hyg.22024 : PGame.{u1}) (x._@.Mathlib.SetTheory.Game.PGame._hyg.22026 : PGame.{u1}) => HAdd.hAdd.{succ u1, succ u1, succ u1} PGame.{u1} PGame.{u1} PGame.{u1} (instHAdd.{succ u1} PGame.{u1} PGame.instAddPGame.{u1}) x._@.Mathlib.SetTheory.Game.PGame._hyg.22024 x._@.Mathlib.SetTheory.Game.PGame._hyg.22026)) (fun (x._@.Mathlib.SetTheory.Game.PGame._hyg.22039 : PGame.{u1}) (x._@.Mathlib.SetTheory.Game.PGame._hyg.22041 : PGame.{u1}) => LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x._@.Mathlib.SetTheory.Game.PGame._hyg.22039 x._@.Mathlib.SetTheory.Game.PGame._hyg.22041)
-Case conversion may be inaccurate. Consider using '#align pgame.covariant_class_swap_add_lt PGame.covariantClass_swap_add_ltₓ'. -/
 instance covariantClass_swap_add_lt : CovariantClass PGame PGame (swap (· + ·)) (· < ·) :=
   ⟨fun x y z h => ⟨add_le_add_right h.1 x, add_lf_add_right h.2 x⟩⟩
 #align pgame.covariant_class_swap_add_lt PGame.covariantClass_swap_add_lt
 
-/- warning: pgame.covariant_class_add_lt -> PGame.covariantClass_add_lt is a dubious translation:
-lean 3 declaration is
-  CovariantClass.{succ u1, succ u1} PGame.{u1} PGame.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} PGame.{u1} PGame.{u1} PGame.{u1} (instHAdd.{succ u1} PGame.{u1} PGame.hasAdd.{u1})) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}))
-but is expected to have type
-  CovariantClass.{succ u1, succ u1} PGame.{u1} PGame.{u1} (fun (x._@.Mathlib.SetTheory.Game.PGame._hyg.22077 : PGame.{u1}) (x._@.Mathlib.SetTheory.Game.PGame._hyg.22079 : PGame.{u1}) => HAdd.hAdd.{succ u1, succ u1, succ u1} PGame.{u1} PGame.{u1} PGame.{u1} (instHAdd.{succ u1} PGame.{u1} PGame.instAddPGame.{u1}) x._@.Mathlib.SetTheory.Game.PGame._hyg.22077 x._@.Mathlib.SetTheory.Game.PGame._hyg.22079) (fun (x._@.Mathlib.SetTheory.Game.PGame._hyg.22092 : PGame.{u1}) (x._@.Mathlib.SetTheory.Game.PGame._hyg.22094 : PGame.{u1}) => LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x._@.Mathlib.SetTheory.Game.PGame._hyg.22092 x._@.Mathlib.SetTheory.Game.PGame._hyg.22094)
-Case conversion may be inaccurate. Consider using '#align pgame.covariant_class_add_lt PGame.covariantClass_add_ltₓ'. -/
 instance covariantClass_add_lt : CovariantClass PGame PGame (· + ·) (· < ·) :=
   ⟨fun x y z h => ⟨add_le_add_left h.1 x, add_lf_add_left h.2 x⟩⟩
 #align pgame.covariant_class_add_lt PGame.covariantClass_add_lt
@@ -2372,12 +2204,6 @@ theorem lf_iff_sub_zero_lf {x y : PGame} : x ⧏ y ↔ 0 ⧏ y - x :=
 #align pgame.lf_iff_sub_zero_lf PGame.lf_iff_sub_zero_lf
 -/
 
-/- warning: pgame.lt_iff_sub_pos -> PGame.lt_iff_sub_pos is a dubious translation:
-lean 3 declaration is
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) (OfNat.ofNat.{succ u1} PGame.{u1} 0 (OfNat.mk.{succ u1} PGame.{u1} 0 (Zero.zero.{succ u1} PGame.{u1} PGame.hasZero.{u1}))) (HSub.hSub.{succ u1, succ u1, succ u1} PGame.{u1} PGame.{u1} PGame.{u1} (instHSub.{succ u1} PGame.{u1} PGame.hasSub.{u1}) y x))
-but is expected to have type
-  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) (OfNat.ofNat.{succ u1} PGame.{u1} 0 (Zero.toOfNat0.{succ u1} PGame.{u1} PGame.instZeroPGame.{u1})) (HSub.hSub.{succ u1, succ u1, succ u1} PGame.{u1} PGame.{u1} PGame.{u1} (instHSub.{succ u1} PGame.{u1} PGame.instSubPGame.{u1}) y x))
-Case conversion may be inaccurate. Consider using '#align pgame.lt_iff_sub_pos PGame.lt_iff_sub_posₓ'. -/
 theorem lt_iff_sub_pos {x y : PGame} : x < y ↔ 0 < y - x :=
   ⟨fun h => lt_of_le_of_lt (zero_le_add_right_neg x) (add_lt_add_right h _), fun h =>
     calc
@@ -2451,12 +2277,6 @@ theorem neg_star : -star = star := by simp [star]
 #align pgame.neg_star PGame.neg_star
 -/
 
-/- warning: pgame.zero_lt_one -> PGame.zero_lt_one is a dubious translation:
-lean 3 declaration is
-  LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) (OfNat.ofNat.{succ u1} PGame.{u1} 0 (OfNat.mk.{succ u1} PGame.{u1} 0 (Zero.zero.{succ u1} PGame.{u1} PGame.hasZero.{u1}))) (OfNat.ofNat.{succ u1} PGame.{u1} 1 (OfNat.mk.{succ u1} PGame.{u1} 1 (One.one.{succ u1} PGame.{u1} PGame.hasOne.{u1})))
-but is expected to have type
-  LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) (OfNat.ofNat.{succ u1} PGame.{u1} 0 (Zero.toOfNat0.{succ u1} PGame.{u1} PGame.instZeroPGame.{u1})) (OfNat.ofNat.{succ u1} PGame.{u1} 1 (One.toOfNat1.{succ u1} PGame.{u1} PGame.instOnePGame.{u1}))
-Case conversion may be inaccurate. Consider using '#align pgame.zero_lt_one PGame.zero_lt_oneₓ'. -/
 @[simp]
 protected theorem zero_lt_one : (0 : PGame) < 1 :=
   lt_of_le_of_lf (zero_le_of_isEmpty_rightMoves 1) (zero_lf_le.2 ⟨default, le_rfl⟩)

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -480,10 +480,7 @@ theorem Lf.not_ge {x y : PGame} : x ⧏ y → ¬y ≤ x :=
 The ordering here is chosen so that `and.left` refer to moves by Left, and `and.right` refer to
 moves by Right. -/
 theorem le_iff_forall_lf {x y : PGame} : x ≤ y ↔ (∀ i, x.moveLeft i ⧏ y) ∧ ∀ j, x ⧏ y.moveRight j :=
-  by
-  unfold LE.le
-  rw [Sym2.GameAdd.fix_eq]
-  rfl
+  by unfold LE.le; rw [Sym2.GameAdd.fix_eq]; rfl
 #align pgame.le_iff_forall_lf PGame.le_iff_forall_lf
 -/
 
@@ -509,9 +506,7 @@ theorem le_of_forall_lf {x y : PGame} (h₁ : ∀ i, x.moveLeft i ⧏ y) (h₂ :
 The ordering here is chosen so that `or.inl` refer to moves by Left, and `or.inr` refer to
 moves by Right. -/
 theorem lf_iff_exists_le {x y : PGame} : x ⧏ y ↔ (∃ i, x ≤ y.moveLeft i) ∨ ∃ j, x.moveRight j ≤ y :=
-  by
-  rw [lf, le_iff_forall_lf, not_and_or]
-  simp
+  by rw [lf, le_iff_forall_lf, not_and_or]; simp
 #align pgame.lf_iff_exists_le PGame.lf_iff_exists_le
 -/
 
@@ -525,10 +520,7 @@ theorem mk_lf_mk {xl xr xL xR yl yr yL yR} :
 -/
 
 #print PGame.le_or_gf /-
-theorem le_or_gf (x y : PGame) : x ≤ y ∨ y ⧏ x :=
-  by
-  rw [← PGame.not_le]
-  apply em
+theorem le_or_gf (x y : PGame) : x ≤ y ∨ y ⧏ x := by rw [← PGame.not_le]; apply em
 #align pgame.le_or_gf PGame.le_or_gf
 -/
 
@@ -668,19 +660,15 @@ instance : IsIrrefl _ (· ⧏ ·) :=
 
 #print PGame.lf_of_le_of_lf /-
 @[trans]
-theorem lf_of_le_of_lf {x y z : PGame} (h₁ : x ≤ y) (h₂ : y ⧏ z) : x ⧏ z :=
-  by
-  rw [← PGame.not_le] at h₂⊢
-  exact fun h₃ => h₂ (h₃.trans h₁)
+theorem lf_of_le_of_lf {x y z : PGame} (h₁ : x ≤ y) (h₂ : y ⧏ z) : x ⧏ z := by
+  rw [← PGame.not_le] at h₂⊢; exact fun h₃ => h₂ (h₃.trans h₁)
 #align pgame.lf_of_le_of_lf PGame.lf_of_le_of_lf
 -/
 
 #print PGame.lf_of_lf_of_le /-
 @[trans]
-theorem lf_of_lf_of_le {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y ≤ z) : x ⧏ z :=
-  by
-  rw [← PGame.not_le] at h₁⊢
-  exact fun h₃ => h₁ (h₂.trans h₃)
+theorem lf_of_lf_of_le {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y ≤ z) : x ⧏ z := by
+  rw [← PGame.not_le] at h₁⊢; exact fun h₃ => h₁ (h₂.trans h₃)
 #align pgame.lf_of_lf_of_le PGame.lf_of_lf_of_le
 -/
 
@@ -773,8 +761,7 @@ theorem le_def {x y : PGame} :
     x ≤ y ↔
       (∀ i, (∃ i', x.moveLeft i ≤ y.moveLeft i') ∨ ∃ j, (x.moveLeft i).moveRight j ≤ y) ∧
         ∀ j, (∃ i, x ≤ (y.moveRight j).moveLeft i) ∨ ∃ j', x.moveRight j' ≤ y.moveRight j :=
-  by
-  rw [le_iff_forall_lf]
+  by rw [le_iff_forall_lf];
   conv =>
     lhs
     simp only [lf_iff_exists_le]
@@ -787,8 +774,7 @@ 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]
+  by rw [lf_iff_exists_le];
   conv =>
     lhs
     simp only [le_iff_forall_lf]
@@ -797,72 +783,52 @@ theorem lf_def {x y : PGame} :
 
 #print PGame.zero_le_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]
-  simp
+theorem zero_le_lf {x : PGame} : 0 ≤ x ↔ ∀ j, 0 ⧏ x.moveRight j := by rw [le_iff_forall_lf]; simp
 #align pgame.zero_le_lf PGame.zero_le_lf
 -/
 
 #print PGame.le_zero_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]
-  simp
+theorem le_zero_lf {x : PGame} : x ≤ 0 ↔ ∀ i, x.moveLeft i ⧏ 0 := by rw [le_iff_forall_lf]; simp
 #align pgame.le_zero_lf PGame.le_zero_lf
 -/
 
 #print PGame.zero_lf_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]
-  simp
+theorem zero_lf_le {x : PGame} : 0 ⧏ x ↔ ∃ i, 0 ≤ x.moveLeft i := by rw [lf_iff_exists_le]; simp
 #align pgame.zero_lf_le PGame.zero_lf_le
 -/
 
 #print PGame.lf_zero_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]
-  simp
+theorem lf_zero_le {x : PGame} : x ⧏ 0 ↔ ∃ j, x.moveRight j ≤ 0 := by rw [lf_iff_exists_le]; simp
 #align pgame.lf_zero_le PGame.lf_zero_le
 -/
 
 #print PGame.zero_le /-
 /-- 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]
+theorem zero_le {x : PGame} : 0 ≤ x ↔ ∀ j, ∃ i, 0 ≤ (x.moveRight j).moveLeft i := by rw [le_def];
   simp
 #align pgame.zero_le PGame.zero_le
 -/
 
 #print PGame.le_zero /-
 /-- 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]
+theorem le_zero {x : PGame} : x ≤ 0 ↔ ∀ i, ∃ j, (x.moveLeft i).moveRight j ≤ 0 := by rw [le_def];
   simp
 #align pgame.le_zero PGame.le_zero
 -/
 
 #print PGame.zero_lf /-
 /-- 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]
+theorem zero_lf {x : PGame} : 0 ⧏ x ↔ ∃ i, ∀ j, 0 ⧏ (x.moveLeft i).moveRight j := by rw [lf_def];
   simp
 #align pgame.zero_lf PGame.zero_lf
 -/
 
 #print PGame.lf_zero /-
 /-- 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]
+theorem lf_zero {x : PGame} : x ⧏ 0 ↔ ∃ j, ∀ i, (x.moveRight j).moveLeft i ⧏ 0 := by rw [lf_def];
   simp
 #align pgame.lf_zero PGame.lf_zero
 -/
@@ -1229,10 +1195,8 @@ lean 3 declaration is
 but is expected to have type
   forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (PGame.Lf.{u1} x y) (Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) (PGame.Fuzzy.{u1} x y))
 Case conversion may be inaccurate. Consider using '#align pgame.lf_iff_lt_or_fuzzy PGame.lf_iff_lt_or_fuzzyₓ'. -/
-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]
-  tauto
+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]; tauto
 #align pgame.lf_iff_lt_or_fuzzy PGame.lf_iff_lt_or_fuzzy
 
 #print PGame.lf_of_fuzzy /-
@@ -1334,19 +1298,10 @@ Case conversion may be inaccurate. Consider using '#align pgame.lt_or_equiv_or_g
 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
-    exact ⟨h₂, h₁⟩
+  · right; left; exact ⟨h₁, h₂⟩
+  · left; exact ⟨h₁, h₂⟩
+  · right; right; left; exact ⟨h₂, h₁⟩
+  · right; right; right; exact ⟨h₂, h₁⟩
 #align pgame.lt_or_equiv_or_gt_or_fuzzy PGame.lt_or_equiv_or_gt_or_fuzzy
 
 /- warning: pgame.lt_or_equiv_or_gf -> PGame.lt_or_equiv_or_gf is a dubious translation:
@@ -1631,9 +1586,7 @@ theorem neg_ofLists (L R : List PGame) :
       have :
         ∀ {m n} (h₁ : m = n) {b : ULift (Fin m)} {c : ULift (Fin n)} (h₂ : HEq b c),
           (b.down : ℕ) = ↑c.down :=
-        by
-        rintro m n rfl b c rfl
-        rfl
+        by rintro m n rfl b c rfl; rfl
       exact this (List.length_map _ _).symm ha
 #align pgame.neg_of_lists PGame.neg_ofLists
 -/
@@ -1642,12 +1595,7 @@ theorem neg_ofLists (L R : List PGame) :
 theorem isOption_neg {x y : PGame} : IsOption x (-y) ↔ IsOption (-x) y :=
   by
   rw [is_option_iff, is_option_iff, or_comm']
-  cases y;
-  apply or_congr <;>
-    · apply exists_congr
-      intro
-      rw [neg_eq_iff_eq_neg]
-      rfl
+  cases y; apply or_congr <;> · apply exists_congr; intro ; rw [neg_eq_iff_eq_neg]; rfl
 #align pgame.is_option_neg PGame.isOption_neg
 -/
 
@@ -1691,36 +1639,28 @@ def toRightMovesNeg {x : PGame} : x.LeftMoves ≃ (-x).RightMoves :=
 -/
 
 #print PGame.moveLeft_neg /-
-theorem moveLeft_neg {x : PGame} (i) : (-x).moveLeft (toLeftMovesNeg i) = -x.moveRight i :=
-  by
-  cases x
-  rfl
+theorem moveLeft_neg {x : PGame} (i) : (-x).moveLeft (toLeftMovesNeg i) = -x.moveRight i := by
+  cases x; rfl
 #align pgame.move_left_neg PGame.moveLeft_neg
 -/
 
 #print PGame.moveLeft_neg' /-
 @[simp]
-theorem moveLeft_neg' {x : PGame} (i) : (-x).moveLeft i = -x.moveRight (toLeftMovesNeg.symm i) :=
-  by
-  cases x
-  rfl
+theorem moveLeft_neg' {x : PGame} (i) : (-x).moveLeft i = -x.moveRight (toLeftMovesNeg.symm i) := by
+  cases x; rfl
 #align pgame.move_left_neg' PGame.moveLeft_neg'
 -/
 
 #print PGame.moveRight_neg /-
-theorem moveRight_neg {x : PGame} (i) : (-x).moveRight (toRightMovesNeg i) = -x.moveLeft i :=
-  by
-  cases x
-  rfl
+theorem moveRight_neg {x : PGame} (i) : (-x).moveRight (toRightMovesNeg i) = -x.moveLeft i := by
+  cases x; rfl
 #align pgame.move_right_neg PGame.moveRight_neg
 -/
 
 #print PGame.moveRight_neg' /-
 @[simp]
 theorem moveRight_neg' {x : PGame} (i) : (-x).moveRight i = -x.moveLeft (toRightMovesNeg.symm i) :=
-  by
-  cases x
-  rfl
+  by cases x; rfl
 #align pgame.move_right_neg' PGame.moveRight_neg'
 -/
 
@@ -1761,10 +1701,9 @@ private theorem neg_le_lf_neg_iff : ∀ {x y : PGame.{u}}, (-y ≤ -x ↔ x ≤
     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 <;> exact exists_congr fun _ => neg_le_lf_neg_iff.1decreasing_by pgame_wf_tac
+    · rw [and_comm']; apply and_congr <;> exact forall_congr' fun _ => neg_le_lf_neg_iff.2
+    · rw [or_comm']; apply or_congr <;> exact exists_congr fun _ => neg_le_lf_neg_iff.1decreasing_by
+  pgame_wf_tac
 
 #print PGame.neg_le_neg_iff /-
 @[simp]
@@ -1952,8 +1891,7 @@ protected theorem nat_succ (n : ℕ) : ((n + 1 : ℕ) : PGame) = n + 1 :=
 #print PGame.isEmpty_leftMoves_add /-
 instance isEmpty_leftMoves_add (x y : PGame.{u}) [IsEmpty x.LeftMoves] [IsEmpty y.LeftMoves] :
     IsEmpty (x + y).LeftMoves := by
-  cases x
-  cases y
+  cases x; cases y
   apply isEmpty_sum.2 ⟨_, _⟩
   assumption'
 #align pgame.is_empty_left_moves_add PGame.isEmpty_leftMoves_add
@@ -1962,8 +1900,7 @@ instance isEmpty_leftMoves_add (x y : PGame.{u}) [IsEmpty x.LeftMoves] [IsEmpty
 #print PGame.isEmpty_rightMoves_add /-
 instance isEmpty_rightMoves_add (x y : PGame.{u}) [IsEmpty x.RightMoves] [IsEmpty y.RightMoves] :
     IsEmpty (x + y).RightMoves := by
-  cases x
-  cases y
+  cases x; cases y
   apply isEmpty_sum.2 ⟨_, _⟩
   assumption'
 #align pgame.is_empty_right_moves_add PGame.isEmpty_rightMoves_add
@@ -2045,11 +1982,7 @@ theorem mk_add_moveLeft_inl {xl xr yl yr} {xL xR yL yR} {i} :
 #print PGame.add_moveLeft_inl /-
 @[simp]
 theorem add_moveLeft_inl {x : PGame} (y : PGame) (i) :
-    (x + y).moveLeft (toLeftMovesAdd (Sum.inl i)) = x.moveLeft i + y :=
-  by
-  cases x
-  cases y
-  rfl
+    (x + y).moveLeft (toLeftMovesAdd (Sum.inl i)) = x.moveLeft i + y := by cases x; cases y; rfl
 #align pgame.add_move_left_inl PGame.add_moveLeft_inl
 -/
 
@@ -2065,11 +1998,7 @@ theorem mk_add_moveRight_inl {xl xr yl yr} {xL xR yL yR} {i} :
 #print PGame.add_moveRight_inl /-
 @[simp]
 theorem add_moveRight_inl {x : PGame} (y : PGame) (i) :
-    (x + y).moveRight (toRightMovesAdd (Sum.inl i)) = x.moveRight i + y :=
-  by
-  cases x
-  cases y
-  rfl
+    (x + y).moveRight (toRightMovesAdd (Sum.inl i)) = x.moveRight i + y := by cases x; cases y; rfl
 #align pgame.add_move_right_inl PGame.add_moveRight_inl
 -/
 
@@ -2085,11 +2014,7 @@ theorem mk_add_moveLeft_inr {xl xr yl yr} {xL xR yL yR} {i} :
 #print PGame.add_moveLeft_inr /-
 @[simp]
 theorem add_moveLeft_inr (x : PGame) {y : PGame} (i) :
-    (x + y).moveLeft (toLeftMovesAdd (Sum.inr i)) = x + y.moveLeft i :=
-  by
-  cases x
-  cases y
-  rfl
+    (x + y).moveLeft (toLeftMovesAdd (Sum.inr i)) = x + y.moveLeft i := by cases x; cases y; rfl
 #align pgame.add_move_left_inr PGame.add_moveLeft_inr
 -/
 
@@ -2105,11 +2030,7 @@ theorem mk_add_moveRight_inr {xl xr yl yr} {xL xR yL yR} {i} :
 #print PGame.add_moveRight_inr /-
 @[simp]
 theorem add_moveRight_inr (x : PGame) {y : PGame} (i) :
-    (x + y).moveRight (toRightMovesAdd (Sum.inr i)) = x + y.moveRight i :=
-  by
-  cases x
-  cases y
-  rfl
+    (x + y).moveRight (toRightMovesAdd (Sum.inr i)) = x + y.moveRight i := by cases x; cases y; rfl
 #align pgame.add_move_right_inr PGame.add_moveRight_inr
 -/
 
@@ -2205,8 +2126,7 @@ theorem neg_add_le {x y : PGame} : -(x + y) ≤ -x + -y :=
 def addCommRelabelling : ∀ x y : PGame.{u}, x + y ≡r y + x
   | mk xl xr xL xR, mk yl yr yL yR => by
     refine' ⟨Equiv.sumComm _ _, Equiv.sumComm _ _, _, _⟩ <;> rintro (_ | _) <;>
-      · dsimp [left_moves_add, right_moves_add]
-        apply add_comm_relabelling decreasing_by
+      · dsimp [left_moves_add, right_moves_add]; apply add_comm_relabelling decreasing_by
   pgame_wf_tac
 #align pgame.add_comm_relabelling PGame.addCommRelabelling
 -/
@@ -2337,9 +2257,7 @@ instance covariantClass_add_le : CovariantClass PGame PGame (· + ·) (· ≤ ·
 
 #print PGame.add_lf_add_right /-
 theorem add_lf_add_right {y z : PGame} (h : y ⧏ z) (x) : y + x ⧏ z + x :=
-  suffices z + x ≤ y + x → z ≤ y by
-    rw [← PGame.not_le] at h⊢
-    exact mt this h
+  suffices z + x ≤ y + x → z ≤ y by rw [← PGame.not_le] at h⊢; exact mt this h
   fun w =>
   calc
     z ≤ z + 0 := (addZeroRelabelling _).symm.le
@@ -2354,10 +2272,8 @@ theorem add_lf_add_right {y z : PGame} (h : y ⧏ z) (x) : y + x ⧏ z + x :=
 -/
 
 #print PGame.add_lf_add_left /-
-theorem add_lf_add_left {y z : PGame} (h : y ⧏ z) (x) : x + y ⧏ x + z :=
-  by
-  rw [lf_congr add_comm_equiv add_comm_equiv]
-  apply add_lf_add_right h
+theorem add_lf_add_left {y z : PGame} (h : y ⧏ z) (x) : x + y ⧏ x + z := by
+  rw [lf_congr add_comm_equiv add_comm_equiv]; apply add_lf_add_right h
 #align pgame.add_lf_add_left PGame.add_lf_add_left
 -/
 
@@ -2525,13 +2441,7 @@ instance uniqueStarRightMoves : Unique star.RightMoves :=
 
 #print PGame.star_fuzzy_zero /-
 theorem star_fuzzy_zero : star ‖ 0 :=
-  ⟨by
-    rw [lf_zero]
-    use default
-    rintro ⟨⟩, by
-    rw [zero_lf]
-    use default
-    rintro ⟨⟩⟩
+  ⟨by rw [lf_zero]; use default; rintro ⟨⟩, by rw [zero_lf]; use default; rintro ⟨⟩⟩
 #align pgame.star_fuzzy_zero PGame.star_fuzzy_zero
 -/
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -594,7 +594,6 @@ private theorem le_trans_aux {x y z : PGame}
     x ≤ z :=
   le_of_forall_lf (fun i => PGame.not_le.1 fun h => (h₁ hyz h).not_gf <| hxy.moveLeft_lf i) fun j =>
     PGame.not_le.1 fun h => (h₂ h hxy).not_gf <| hyz.lf_moveRight j
-#align pgame.le_trans_aux pgame.le_trans_aux
 
 instance : Preorder PGame :=
   {
@@ -1766,7 +1765,6 @@ private theorem neg_le_lf_neg_iff : ∀ {x y : PGame.{u}}, (-y ≤ -x ↔ x ≤
       apply and_congr <;> exact forall_congr' fun _ => neg_le_lf_neg_iff.2
     · rw [or_comm']
       apply or_congr <;> exact exists_congr fun _ => neg_le_lf_neg_iff.1decreasing_by pgame_wf_tac
-#align pgame.neg_le_lf_neg_iff pgame.neg_le_lf_neg_iff
 
 #print PGame.neg_le_neg_iff /-
 @[simp]
@@ -2324,7 +2322,6 @@ private theorem add_le_add_right' : ∀ {x y z : PGame} (h : x ≤ y), x + z ≤
       exact
         Or.inr ⟨@to_right_moves_add _ ⟨_, _, _, _⟩ (Sum.inr i), add_le_add_right' h⟩decreasing_by
   pgame_wf_tac
-#align pgame.add_le_add_right' pgame.add_le_add_right'
 
 #print PGame.covariantClass_swap_add_le /-
 instance covariantClass_swap_add_le : CovariantClass PGame PGame (swap (· + ·)) (· ≤ ·) :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/33c67ae661dd8988516ff7f247b0be3018cdd952

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Reid Barton, Mario Carneiro, Isabel Longbottom, Scott Morrison
 
 ! This file was ported from Lean 3 source module set_theory.game.pgame
-! leanprover-community/mathlib commit dc9e5ba64653e017743ba5d2c28e42f9f486bf99
+! leanprover-community/mathlib commit 33c67ae661dd8988516ff7f247b0be3018cdd952
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -16,6 +16,9 @@ import Mathbin.Order.GameAdd
 /-!
 # Combinatorial (pre-)games.
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 The basic theory of combinatorial games, following Conway's book `On Numbers and Games`. We
 construct "pregames", define an ordering and arithmetic operations on them, then show that the
 operations descend to "games", defined via the equivalence relation `p ≈ q ↔ p ≤ q ∧ q ≤ p`.

mathlib commit https://github.com/leanprover-community/mathlib/commit/95a87616d63b3cb49d3fe678d416fbe9c4217bf4

@@ -106,6 +106,7 @@ universe u
 /-! ### Pre-game moves -/
 
 
+#print PGame /-
 /-- The type of pre-games, before we have quotiented
   by equivalence (`pgame.setoid`). In ZFC, a combinatorial game is constructed from
   two sets of combinatorial games that have been constructed at an earlier
@@ -113,128 +114,172 @@ universe u
   inductively from two families of pre-games indexed over any type
   in Type u. The resulting type `pgame.{u}` lives in `Type (u+1)`,
   reflecting that it is a proper class in ZFC. -/
-inductive Pgame : Type (u + 1)
-  | mk : ∀ α β : Type u, (α → Pgame) → (β → Pgame) → Pgame
-#align pgame Pgame
+inductive PGame : Type (u + 1)
+  | mk : ∀ α β : Type u, (α → PGame) → (β → PGame) → PGame
+#align pgame PGame
+-/
 
-namespace Pgame
+namespace PGame
 
+#print PGame.LeftMoves /-
 /-- The indexing type for allowable moves by Left. -/
-def LeftMoves : Pgame → Type u
+def LeftMoves : PGame → Type u
   | mk l _ _ _ => l
-#align pgame.left_moves Pgame.LeftMoves
+#align pgame.left_moves PGame.LeftMoves
+-/
 
+#print PGame.RightMoves /-
 /-- The indexing type for allowable moves by Right. -/
-def RightMoves : Pgame → Type u
+def RightMoves : PGame → Type u
   | mk _ r _ _ => r
-#align pgame.right_moves Pgame.RightMoves
+#align pgame.right_moves PGame.RightMoves
+-/
 
+#print PGame.moveLeft /-
 /-- The new game after Left makes an allowed move. -/
-def moveLeft : ∀ g : Pgame, LeftMoves g → Pgame
+def moveLeft : ∀ g : PGame, LeftMoves g → PGame
   | mk l _ L _ => L
-#align pgame.move_left Pgame.moveLeft
+#align pgame.move_left PGame.moveLeft
+-/
 
+#print PGame.moveRight /-
 /-- The new game after Right makes an allowed move. -/
-def moveRight : ∀ g : Pgame, RightMoves g → Pgame
+def moveRight : ∀ g : PGame, RightMoves g → PGame
   | mk _ r _ R => R
-#align pgame.move_right Pgame.moveRight
+#align pgame.move_right PGame.moveRight
+-/
 
+#print PGame.leftMoves_mk /-
 @[simp]
-theorem leftMoves_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : Pgame).LeftMoves = xl :=
+theorem leftMoves_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).LeftMoves = xl :=
   rfl
-#align pgame.left_moves_mk Pgame.leftMoves_mk
+#align pgame.left_moves_mk PGame.leftMoves_mk
+-/
 
+#print PGame.moveLeft_mk /-
 @[simp]
-theorem moveLeft_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : Pgame).moveLeft = xL :=
+theorem moveLeft_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).moveLeft = xL :=
   rfl
-#align pgame.move_left_mk Pgame.moveLeft_mk
+#align pgame.move_left_mk PGame.moveLeft_mk
+-/
 
+#print PGame.rightMoves_mk /-
 @[simp]
-theorem rightMoves_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : Pgame).RightMoves = xr :=
+theorem rightMoves_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).RightMoves = xr :=
   rfl
-#align pgame.right_moves_mk Pgame.rightMoves_mk
+#align pgame.right_moves_mk PGame.rightMoves_mk
+-/
 
+#print PGame.moveRight_mk /-
 @[simp]
-theorem moveRight_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : Pgame).moveRight = xR :=
+theorem moveRight_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).moveRight = xR :=
   rfl
-#align pgame.move_right_mk Pgame.moveRight_mk
+#align pgame.move_right_mk PGame.moveRight_mk
+-/
 
+#print PGame.ofLists /-
 -- TODO define this at the level of games, as well, and perhaps also for finsets of games.
 /-- Construct a pre-game from list of pre-games describing the available moves for Left and Right.
 -/
-def ofLists (L R : List Pgame.{u}) : Pgame.{u} :=
+def ofLists (L R : List PGame.{u}) : PGame.{u} :=
   mk (ULift (Fin L.length)) (ULift (Fin R.length)) (fun i => L.nthLe i.down i.down.is_lt) fun j =>
     R.nthLe j.down j.down.Prop
-#align pgame.of_lists Pgame.ofLists
+#align pgame.of_lists PGame.ofLists
+-/
 
-theorem leftMoves_ofLists (L R : List Pgame) : (ofLists L R).LeftMoves = ULift (Fin L.length) :=
+#print PGame.leftMoves_ofLists /-
+theorem leftMoves_ofLists (L R : List PGame) : (ofLists L R).LeftMoves = ULift (Fin L.length) :=
   rfl
-#align pgame.left_moves_of_lists Pgame.leftMoves_ofLists
+#align pgame.left_moves_of_lists PGame.leftMoves_ofLists
+-/
 
-theorem rightMoves_ofLists (L R : List Pgame) : (ofLists L R).RightMoves = ULift (Fin R.length) :=
+#print PGame.rightMoves_ofLists /-
+theorem rightMoves_ofLists (L R : List PGame) : (ofLists L R).RightMoves = ULift (Fin R.length) :=
   rfl
-#align pgame.right_moves_of_lists Pgame.rightMoves_ofLists
+#align pgame.right_moves_of_lists PGame.rightMoves_ofLists
+-/
 
+#print PGame.toOfListsLeftMoves /-
 /-- Converts a number into a left move for `of_lists`. -/
-def toOfListsLeftMoves {L R : List Pgame} : Fin L.length ≃ (ofLists L R).LeftMoves :=
+def toOfListsLeftMoves {L R : List PGame} : Fin L.length ≃ (ofLists L R).LeftMoves :=
   ((Equiv.cast (leftMoves_ofLists L R).symm).trans Equiv.ulift).symm
-#align pgame.to_of_lists_left_moves Pgame.toOfListsLeftMoves
+#align pgame.to_of_lists_left_moves PGame.toOfListsLeftMoves
+-/
 
+#print PGame.toOfListsRightMoves /-
 /-- Converts a number into a right move for `of_lists`. -/
-def toOfListsRightMoves {L R : List Pgame} : Fin R.length ≃ (ofLists L R).RightMoves :=
+def toOfListsRightMoves {L R : List PGame} : Fin R.length ≃ (ofLists L R).RightMoves :=
   ((Equiv.cast (rightMoves_ofLists L R).symm).trans Equiv.ulift).symm
-#align pgame.to_of_lists_right_moves Pgame.toOfListsRightMoves
+#align pgame.to_of_lists_right_moves PGame.toOfListsRightMoves
+-/
 
-theorem ofLists_moveLeft {L R : List Pgame} (i : Fin L.length) :
+#print PGame.ofLists_moveLeft /-
+theorem ofLists_moveLeft {L R : List PGame} (i : Fin L.length) :
     (ofLists L R).moveLeft (toOfListsLeftMoves i) = L.nthLe i i.is_lt :=
   rfl
-#align pgame.of_lists_move_left Pgame.ofLists_moveLeft
+#align pgame.of_lists_move_left PGame.ofLists_moveLeft
+-/
 
+#print PGame.ofLists_moveLeft' /-
 @[simp]
-theorem ofLists_move_left' {L R : List Pgame} (i : (ofLists L R).LeftMoves) :
+theorem ofLists_moveLeft' {L R : List PGame} (i : (ofLists L R).LeftMoves) :
     (ofLists L R).moveLeft i =
       L.nthLe (toOfListsLeftMoves.symm i) (toOfListsLeftMoves.symm i).is_lt :=
   rfl
-#align pgame.of_lists_move_left' Pgame.ofLists_move_left'
+#align pgame.of_lists_move_left' PGame.ofLists_moveLeft'
+-/
 
-theorem ofLists_moveRight {L R : List Pgame} (i : Fin R.length) :
+#print PGame.ofLists_moveRight /-
+theorem ofLists_moveRight {L R : List PGame} (i : Fin R.length) :
     (ofLists L R).moveRight (toOfListsRightMoves i) = R.nthLe i i.is_lt :=
   rfl
-#align pgame.of_lists_move_right Pgame.ofLists_moveRight
+#align pgame.of_lists_move_right PGame.ofLists_moveRight
+-/
 
+#print PGame.ofLists_moveRight' /-
 @[simp]
-theorem ofLists_move_right' {L R : List Pgame} (i : (ofLists L R).RightMoves) :
+theorem ofLists_moveRight' {L R : List PGame} (i : (ofLists L R).RightMoves) :
     (ofLists L R).moveRight i =
       R.nthLe (toOfListsRightMoves.symm i) (toOfListsRightMoves.symm i).is_lt :=
   rfl
-#align pgame.of_lists_move_right' Pgame.ofLists_move_right'
+#align pgame.of_lists_move_right' PGame.ofLists_moveRight'
+-/
 
+#print PGame.moveRecOn /-
 /-- A variant of `pgame.rec_on` expressed in terms of `pgame.move_left` and `pgame.move_right`.
 
 Both this and `pgame.rec_on` describe Conway induction on games. -/
 @[elab_as_elim]
-def moveRecOn {C : Pgame → Sort _} (x : Pgame)
-    (IH : ∀ y : Pgame, (∀ i, C (y.moveLeft i)) → (∀ j, C (y.moveRight j)) → C y) : C x :=
+def moveRecOn {C : PGame → Sort _} (x : PGame)
+    (IH : ∀ y : PGame, (∀ i, C (y.moveLeft i)) → (∀ j, C (y.moveRight j)) → C y) : C x :=
   x.recOn fun yl yr yL yR => IH (mk yl yr yL yR)
-#align pgame.move_rec_on Pgame.moveRecOn
+#align pgame.move_rec_on PGame.moveRecOn
+-/
 
+#print PGame.IsOption /-
 /-- `is_option x y` means that `x` is either a left or right option for `y`. -/
 @[mk_iff]
-inductive IsOption : Pgame → Pgame → Prop
-  | move_left {x : Pgame} (i : x.LeftMoves) : is_option (x.moveLeft i) x
-  | move_right {x : Pgame} (i : x.RightMoves) : is_option (x.moveRight i) x
-#align pgame.is_option Pgame.IsOption
+inductive IsOption : PGame → PGame → Prop
+  | move_left {x : PGame} (i : x.LeftMoves) : is_option (x.moveLeft i) x
+  | move_right {x : PGame} (i : x.RightMoves) : is_option (x.moveRight i) x
+#align pgame.is_option PGame.IsOption
+-/
 
-theorem IsOption.mk_left {xl xr : Type u} (xL : xl → Pgame) (xR : xr → Pgame) (i : xl) :
+#print PGame.IsOption.mk_left /-
+theorem IsOption.mk_left {xl xr : Type u} (xL : xl → PGame) (xR : xr → PGame) (i : xl) :
     (xL i).IsOption (mk xl xr xL xR) :=
-  @IsOption.move_left (mk _ _ _ _) i
-#align pgame.is_option.mk_left Pgame.IsOption.mk_left
+  @IsOption.moveLeft (mk _ _ _ _) i
+#align pgame.is_option.mk_left PGame.IsOption.mk_left
+-/
 
-theorem IsOption.mk_right {xl xr : Type u} (xL : xl → Pgame) (xR : xr → Pgame) (i : xr) :
+#print PGame.IsOption.mk_right /-
+theorem IsOption.mk_right {xl xr : Type u} (xL : xl → PGame) (xR : xr → PGame) (i : xr) :
     (xR i).IsOption (mk xl xr xL xR) :=
-  @IsOption.move_right (mk _ _ _ _) i
-#align pgame.is_option.mk_right Pgame.IsOption.mk_right
+  @IsOption.moveRight (mk _ _ _ _) i
+#align pgame.is_option.mk_right PGame.IsOption.mk_right
+-/
 
+#print PGame.wf_isOption /-
 theorem wf_isOption : WellFounded IsOption :=
   ⟨fun x =>
     moveRecOn x fun x IHl IHr =>
@@ -242,46 +287,61 @@ theorem wf_isOption : WellFounded IsOption :=
         induction' h with _ i _ j
         · exact IHl i
         · exact IHr j⟩
-#align pgame.wf_is_option Pgame.wf_isOption
+#align pgame.wf_is_option PGame.wf_isOption
+-/
 
+#print PGame.Subsequent /-
 /-- `subsequent x y` says that `x` can be obtained by playing some nonempty sequence of moves from
 `y`. It is the transitive closure of `is_option`. -/
-def Subsequent : Pgame → Pgame → Prop :=
+def Subsequent : PGame → PGame → Prop :=
   TransGen IsOption
-#align pgame.subsequent Pgame.Subsequent
+#align pgame.subsequent PGame.Subsequent
+-/
 
 instance : IsTrans _ Subsequent :=
   TransGen.isTrans
 
+#print PGame.Subsequent.trans /-
 @[trans]
 theorem Subsequent.trans {x y z} : Subsequent x y → Subsequent y z → Subsequent x z :=
   TransGen.trans
-#align pgame.subsequent.trans Pgame.Subsequent.trans
+#align pgame.subsequent.trans PGame.Subsequent.trans
+-/
 
+#print PGame.wf_subsequent /-
 theorem wf_subsequent : WellFounded Subsequent :=
   wf_isOption.TransGen
-#align pgame.wf_subsequent Pgame.wf_subsequent
+#align pgame.wf_subsequent PGame.wf_subsequent
+-/
 
-instance : WellFoundedRelation Pgame :=
+instance : WellFoundedRelation PGame :=
   ⟨_, wf_subsequent⟩
 
-theorem Subsequent.moveLeft {x : Pgame} (i : x.LeftMoves) : Subsequent (x.moveLeft i) x :=
-  TransGen.single (IsOption.move_left i)
-#align pgame.subsequent.move_left Pgame.Subsequent.moveLeft
+#print PGame.Subsequent.moveLeft /-
+theorem Subsequent.moveLeft {x : PGame} (i : x.LeftMoves) : Subsequent (x.moveLeft i) x :=
+  TransGen.single (IsOption.moveLeft i)
+#align pgame.subsequent.move_left PGame.Subsequent.moveLeft
+-/
 
-theorem Subsequent.moveRight {x : Pgame} (j : x.RightMoves) : Subsequent (x.moveRight j) x :=
-  TransGen.single (IsOption.move_right j)
-#align pgame.subsequent.move_right Pgame.Subsequent.moveRight
+#print PGame.Subsequent.moveRight /-
+theorem Subsequent.moveRight {x : PGame} (j : x.RightMoves) : Subsequent (x.moveRight j) x :=
+  TransGen.single (IsOption.moveRight j)
+#align pgame.subsequent.move_right PGame.Subsequent.moveRight
+-/
 
-theorem Subsequent.mk_left {xl xr} (xL : xl → Pgame) (xR : xr → Pgame) (i : xl) :
+#print PGame.Subsequent.mk_left /-
+theorem Subsequent.mk_left {xl xr} (xL : xl → PGame) (xR : xr → PGame) (i : xl) :
     Subsequent (xL i) (mk xl xr xL xR) :=
   @Subsequent.moveLeft (mk _ _ _ _) i
-#align pgame.subsequent.mk_left Pgame.Subsequent.mk_left
+#align pgame.subsequent.mk_left PGame.Subsequent.mk_left
+-/
 
-theorem Subsequent.mk_right {xl xr} (xL : xl → Pgame) (xR : xr → Pgame) (j : xr) :
+#print PGame.Subsequent.mk_right /-
+theorem Subsequent.mk_right {xl xr} (xL : xl → PGame) (xR : xr → PGame) (j : xr) :
     Subsequent (xR j) (mk xl xr xL xR) :=
   @Subsequent.moveRight (mk _ _ _ _) j
-#align pgame.subsequent.mk_right Pgame.Subsequent.mk_right
+#align pgame.subsequent.mk_right PGame.Subsequent.mk_right
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:330:4: warning: unsupported (TODO): `[tacs] -/
 /-- A local tactic for proving well-foundedness of recursive definitions involving pregames. -/
@@ -293,56 +353,74 @@ unsafe def pgame_wf_tac :=
 
 
 /-- The pre-game `zero` is defined by `0 = { | }`. -/
-instance : Zero Pgame :=
+instance : Zero PGame :=
   ⟨⟨PEmpty, PEmpty, PEmpty.elim, PEmpty.elim⟩⟩
 
+#print PGame.zero_leftMoves /-
 @[simp]
 theorem zero_leftMoves : LeftMoves 0 = PEmpty :=
   rfl
-#align pgame.zero_left_moves Pgame.zero_leftMoves
+#align pgame.zero_left_moves PGame.zero_leftMoves
+-/
 
+#print PGame.zero_rightMoves /-
 @[simp]
 theorem zero_rightMoves : RightMoves 0 = PEmpty :=
   rfl
-#align pgame.zero_right_moves Pgame.zero_rightMoves
+#align pgame.zero_right_moves PGame.zero_rightMoves
+-/
 
+#print PGame.isEmpty_zero_leftMoves /-
 instance isEmpty_zero_leftMoves : IsEmpty (LeftMoves 0) :=
   PEmpty.isEmpty
-#align pgame.is_empty_zero_left_moves Pgame.isEmpty_zero_leftMoves
+#align pgame.is_empty_zero_left_moves PGame.isEmpty_zero_leftMoves
+-/
 
+#print PGame.isEmpty_zero_rightMoves /-
 instance isEmpty_zero_rightMoves : IsEmpty (RightMoves 0) :=
   PEmpty.isEmpty
-#align pgame.is_empty_zero_right_moves Pgame.isEmpty_zero_rightMoves
+#align pgame.is_empty_zero_right_moves PGame.isEmpty_zero_rightMoves
+-/
 
-instance : Inhabited Pgame :=
+instance : Inhabited PGame :=
   ⟨0⟩
 
 /-- The pre-game `one` is defined by `1 = { 0 | }`. -/
-instance : One Pgame :=
+instance : One PGame :=
   ⟨⟨PUnit, PEmpty, fun _ => 0, PEmpty.elim⟩⟩
 
+#print PGame.one_leftMoves /-
 @[simp]
 theorem one_leftMoves : LeftMoves 1 = PUnit :=
   rfl
-#align pgame.one_left_moves Pgame.one_leftMoves
+#align pgame.one_left_moves PGame.one_leftMoves
+-/
 
+#print PGame.one_moveLeft /-
 @[simp]
 theorem one_moveLeft (x) : moveLeft 1 x = 0 :=
   rfl
-#align pgame.one_move_left Pgame.one_moveLeft
+#align pgame.one_move_left PGame.one_moveLeft
+-/
 
+#print PGame.one_rightMoves /-
 @[simp]
 theorem one_rightMoves : RightMoves 1 = PEmpty :=
   rfl
-#align pgame.one_right_moves Pgame.one_rightMoves
+#align pgame.one_right_moves PGame.one_rightMoves
+-/
 
+#print PGame.uniqueOneLeftMoves /-
 instance uniqueOneLeftMoves : Unique (LeftMoves 1) :=
   PUnit.unique
-#align pgame.unique_one_left_moves Pgame.uniqueOneLeftMoves
+#align pgame.unique_one_left_moves PGame.uniqueOneLeftMoves
+-/
 
+#print PGame.isEmpty_one_rightMoves /-
 instance isEmpty_one_rightMoves : IsEmpty (RightMoves 1) :=
   PEmpty.isEmpty
-#align pgame.is_empty_one_right_moves Pgame.isEmpty_one_rightMoves
+#align pgame.is_empty_one_right_moves PGame.isEmpty_one_rightMoves
+-/
 
 /-! ### Pre-game order relations -/
 
@@ -350,136 +428,174 @@ instance isEmpty_one_rightMoves : IsEmpty (RightMoves 1) :=
 /-- The less or equal relation on pre-games.
 
 If `0 ≤ x`, then Left can win `x` as the second player. -/
-instance : LE Pgame :=
+instance : LE PGame :=
   ⟨Sym2.GameAdd.fix wf_isOption fun x y le =>
-      (∀ i, ¬le y (x.moveLeft i) (Sym2.GameAdd.snd_fst <| IsOption.move_left i)) ∧
-        ∀ j, ¬le (y.moveRight j) x (Sym2.GameAdd.fst_snd <| IsOption.move_right j)⟩
+      (∀ i, ¬le y (x.moveLeft i) (Sym2.GameAdd.snd_fst <| IsOption.moveLeft i)) ∧
+        ∀ j, ¬le (y.moveRight j) x (Sym2.GameAdd.fst_snd <| IsOption.moveRight j)⟩
 
+#print PGame.Lf /-
 /-- The less or fuzzy relation on pre-games.
 
 If `0 ⧏ x`, then Left can win `x` as the first player. -/
-def Lf (x y : Pgame) : Prop :=
+def Lf (x y : PGame) : Prop :=
   ¬y ≤ x
-#align pgame.lf Pgame.Lf
+#align pgame.lf PGame.Lf
+-/
 
 -- mathport name: pgame.lf
-scoped infixl:50 " ⧏ " => Pgame.Lf
+scoped infixl:50 " ⧏ " => PGame.Lf
 
+#print PGame.not_le /-
 @[simp]
-protected theorem not_le {x y : Pgame} : ¬x ≤ y ↔ y ⧏ x :=
+protected theorem not_le {x y : PGame} : ¬x ≤ y ↔ y ⧏ x :=
   Iff.rfl
-#align pgame.not_le Pgame.not_le
+#align pgame.not_le PGame.not_le
+-/
 
+#print PGame.not_lf /-
 @[simp]
-theorem not_lf {x y : Pgame} : ¬x ⧏ y ↔ y ≤ x :=
+theorem not_lf {x y : PGame} : ¬x ⧏ y ↔ y ≤ x :=
   Classical.not_not
-#align pgame.not_lf Pgame.not_lf
+#align pgame.not_lf PGame.not_lf
+-/
 
-theorem LE.le.not_gf {x y : Pgame} : x ≤ y → ¬y ⧏ x :=
+#print LE.le.not_gf /-
+theorem LE.le.not_gf {x y : PGame} : x ≤ y → ¬y ⧏ x :=
   not_lf.2
 #align has_le.le.not_gf LE.le.not_gf
+-/
 
-theorem Lf.not_ge {x y : Pgame} : x ⧏ y → ¬y ≤ x :=
+#print PGame.Lf.not_ge /-
+theorem Lf.not_ge {x y : PGame} : x ⧏ y → ¬y ≤ x :=
   id
-#align pgame.lf.not_ge Pgame.Lf.not_ge
+#align pgame.lf.not_ge PGame.Lf.not_ge
+-/
 
+#print PGame.le_iff_forall_lf /-
 /-- Definition of `x ≤ y` on pre-games, in terms of `⧏`.
 
 The ordering here is chosen so that `and.left` refer to moves by Left, and `and.right` refer to
 moves by Right. -/
-theorem le_iff_forall_lf {x y : Pgame} : x ≤ y ↔ (∀ i, x.moveLeft i ⧏ y) ∧ ∀ j, x ⧏ y.moveRight j :=
+theorem le_iff_forall_lf {x y : PGame} : x ≤ y ↔ (∀ i, x.moveLeft i ⧏ y) ∧ ∀ j, x ⧏ y.moveRight j :=
   by
   unfold LE.le
   rw [Sym2.GameAdd.fix_eq]
   rfl
-#align pgame.le_iff_forall_lf Pgame.le_iff_forall_lf
+#align pgame.le_iff_forall_lf PGame.le_iff_forall_lf
+-/
 
+#print PGame.mk_le_mk /-
 /-- Definition of `x ≤ y` on pre-games built using the constructor. -/
 @[simp]
 theorem mk_le_mk {xl xr xL xR yl yr yL yR} :
     mk xl xr xL xR ≤ mk yl yr yL yR ↔ (∀ i, xL i ⧏ mk yl yr yL yR) ∧ ∀ j, mk xl xr xL xR ⧏ yR j :=
   le_iff_forall_lf
-#align pgame.mk_le_mk Pgame.mk_le_mk
+#align pgame.mk_le_mk PGame.mk_le_mk
+-/
 
-theorem le_of_forall_lf {x y : Pgame} (h₁ : ∀ i, x.moveLeft i ⧏ y) (h₂ : ∀ j, x ⧏ y.moveRight j) :
+#print PGame.le_of_forall_lf /-
+theorem le_of_forall_lf {x y : PGame} (h₁ : ∀ i, x.moveLeft i ⧏ y) (h₂ : ∀ j, x ⧏ y.moveRight j) :
     x ≤ y :=
   le_iff_forall_lf.2 ⟨h₁, h₂⟩
-#align pgame.le_of_forall_lf Pgame.le_of_forall_lf
+#align pgame.le_of_forall_lf PGame.le_of_forall_lf
+-/
 
+#print PGame.lf_iff_exists_le /-
 /-- Definition of `x ⧏ y` on pre-games, in terms of `≤`.
 
 The ordering here is chosen so that `or.inl` refer to moves by Left, and `or.inr` refer to
 moves by Right. -/
-theorem lf_iff_exists_le {x y : Pgame} : x ⧏ y ↔ (∃ i, x ≤ y.moveLeft i) ∨ ∃ j, x.moveRight j ≤ y :=
+theorem lf_iff_exists_le {x y : PGame} : x ⧏ y ↔ (∃ i, x ≤ y.moveLeft i) ∨ ∃ j, x.moveRight j ≤ y :=
   by
   rw [lf, le_iff_forall_lf, not_and_or]
   simp
-#align pgame.lf_iff_exists_le Pgame.lf_iff_exists_le
+#align pgame.lf_iff_exists_le PGame.lf_iff_exists_le
+-/
 
+#print PGame.mk_lf_mk /-
 /-- Definition of `x ⧏ y` on pre-games built using the constructor. -/
 @[simp]
 theorem mk_lf_mk {xl xr xL xR yl yr yL yR} :
     mk xl xr xL xR ⧏ mk yl yr yL yR ↔ (∃ i, mk xl xr xL xR ≤ yL i) ∨ ∃ j, xR j ≤ mk yl yr yL yR :=
   lf_iff_exists_le
-#align pgame.mk_lf_mk Pgame.mk_lf_mk
+#align pgame.mk_lf_mk PGame.mk_lf_mk
+-/
 
-theorem le_or_gf (x y : Pgame) : x ≤ y ∨ y ⧏ x :=
+#print PGame.le_or_gf /-
+theorem le_or_gf (x y : PGame) : x ≤ y ∨ y ⧏ x :=
   by
-  rw [← Pgame.not_le]
+  rw [← PGame.not_le]
   apply em
-#align pgame.le_or_gf Pgame.le_or_gf
+#align pgame.le_or_gf PGame.le_or_gf
+-/
 
-theorem moveLeft_lf_of_le {x y : Pgame} (h : x ≤ y) (i) : x.moveLeft i ⧏ y :=
+#print PGame.moveLeft_lf_of_le /-
+theorem moveLeft_lf_of_le {x y : PGame} (h : x ≤ y) (i) : x.moveLeft i ⧏ y :=
   (le_iff_forall_lf.1 h).1 i
-#align pgame.move_left_lf_of_le Pgame.moveLeft_lf_of_le
+#align pgame.move_left_lf_of_le PGame.moveLeft_lf_of_le
+-/
 
 alias move_left_lf_of_le ← _root_.has_le.le.move_left_lf
 #align has_le.le.move_left_lf LE.le.moveLeft_lf
 
-theorem lf_moveRight_of_le {x y : Pgame} (h : x ≤ y) (j) : x ⧏ y.moveRight j :=
+#print PGame.lf_moveRight_of_le /-
+theorem lf_moveRight_of_le {x y : PGame} (h : x ≤ y) (j) : x ⧏ y.moveRight j :=
   (le_iff_forall_lf.1 h).2 j
-#align pgame.lf_move_right_of_le Pgame.lf_moveRight_of_le
+#align pgame.lf_move_right_of_le PGame.lf_moveRight_of_le
+-/
 
 alias lf_move_right_of_le ← _root_.has_le.le.lf_move_right
 #align has_le.le.lf_move_right LE.le.lf_moveRight
 
-theorem lf_of_moveRight_le {x y : Pgame} {j} (h : x.moveRight j ≤ y) : x ⧏ y :=
+#print PGame.lf_of_moveRight_le /-
+theorem lf_of_moveRight_le {x y : PGame} {j} (h : x.moveRight j ≤ y) : x ⧏ y :=
   lf_iff_exists_le.2 <| Or.inr ⟨j, h⟩
-#align pgame.lf_of_move_right_le Pgame.lf_of_moveRight_le
+#align pgame.lf_of_move_right_le PGame.lf_of_moveRight_le
+-/
 
-theorem lf_of_le_moveLeft {x y : Pgame} {i} (h : x ≤ y.moveLeft i) : x ⧏ y :=
+#print PGame.lf_of_le_moveLeft /-
+theorem lf_of_le_moveLeft {x y : PGame} {i} (h : x ≤ y.moveLeft i) : x ⧏ y :=
   lf_iff_exists_le.2 <| Or.inl ⟨i, h⟩
-#align pgame.lf_of_le_move_left Pgame.lf_of_le_moveLeft
+#align pgame.lf_of_le_move_left PGame.lf_of_le_moveLeft
+-/
 
+#print PGame.lf_of_le_mk /-
 theorem lf_of_le_mk {xl xr xL xR y} : mk xl xr xL xR ≤ y → ∀ i, xL i ⧏ y :=
   moveLeft_lf_of_le
-#align pgame.lf_of_le_mk Pgame.lf_of_le_mk
+#align pgame.lf_of_le_mk PGame.lf_of_le_mk
+-/
 
+#print PGame.lf_of_mk_le /-
 theorem lf_of_mk_le {x yl yr yL yR} : x ≤ mk yl yr yL yR → ∀ j, x ⧏ yR j :=
   lf_moveRight_of_le
-#align pgame.lf_of_mk_le Pgame.lf_of_mk_le
+#align pgame.lf_of_mk_le PGame.lf_of_mk_le
+-/
 
-theorem mk_lf_of_le {xl xr y j} (xL) {xR : xr → Pgame} : xR j ≤ y → mk xl xr xL xR ⧏ y :=
+#print PGame.mk_lf_of_le /-
+theorem mk_lf_of_le {xl xr y j} (xL) {xR : xr → PGame} : xR j ≤ y → mk xl xr xL xR ⧏ y :=
   @lf_of_moveRight_le (mk _ _ _ _) y j
-#align pgame.mk_lf_of_le Pgame.mk_lf_of_le
+#align pgame.mk_lf_of_le PGame.mk_lf_of_le
+-/
 
-theorem lf_mk_of_le {x yl yr} {yL : yl → Pgame} (yR) {i} : x ≤ yL i → x ⧏ mk yl yr yL yR :=
+#print PGame.lf_mk_of_le /-
+theorem lf_mk_of_le {x yl yr} {yL : yl → PGame} (yR) {i} : x ≤ yL i → x ⧏ mk yl yr yL yR :=
   @lf_of_le_moveLeft x (mk _ _ _ _) i
-#align pgame.lf_mk_of_le Pgame.lf_mk_of_le
+#align pgame.lf_mk_of_le PGame.lf_mk_of_le
+-/
 
 /- We prove that `x ≤ y → y ≤ z ← x ≤ z` inductively, by also simultaneously proving its cyclic
 reorderings. This auxiliary lemma is used during said induction. -/
-private theorem le_trans_aux {x y z : Pgame}
+private theorem le_trans_aux {x y z : PGame}
     (h₁ : ∀ {i}, y ≤ z → z ≤ x.moveLeft i → y ≤ x.moveLeft i)
     (h₂ : ∀ {j}, z.moveRight j ≤ x → x ≤ y → z.moveRight j ≤ y) (hxy : x ≤ y) (hyz : y ≤ z) :
     x ≤ z :=
-  le_of_forall_lf (fun i => Pgame.not_le.1 fun h => (h₁ hyz h).not_gf <| hxy.moveLeft_lf i) fun j =>
-    Pgame.not_le.1 fun h => (h₂ h hxy).not_gf <| hyz.lf_moveRight j
+  le_of_forall_lf (fun i => PGame.not_le.1 fun h => (h₁ hyz h).not_gf <| hxy.moveLeft_lf i) fun j =>
+    PGame.not_le.1 fun h => (h₂ h hxy).not_gf <| hyz.lf_moveRight j
 #align pgame.le_trans_aux pgame.le_trans_aux
 
-instance : Preorder Pgame :=
+instance : Preorder PGame :=
   {
-    Pgame.hasLe with
+    PGame.hasLe with
     le_refl := fun x => by
       induction' x with _ _ _ _ IHl IHr
       exact
@@ -487,7 +603,7 @@ instance : Preorder Pgame :=
     le_trans :=
       by
       suffices :
-        ∀ {x y z : Pgame},
+        ∀ {x y z : PGame},
           (x ≤ y → y ≤ z → x ≤ z) ∧ (y ≤ z → z ≤ x → y ≤ x) ∧ (z ≤ x → x ≤ y → z ≤ y)
       exact fun x y z => this.1
       intro x y z
@@ -500,89 +616,158 @@ instance : Preorder Pgame :=
           le_trans_aux (fun i => (IHzl i).1) fun j => (IHyr j).2.1⟩
     lt := fun x y => x ≤ y ∧ x ⧏ y }
 
-theorem lt_iff_le_and_lf {x y : Pgame} : x < y ↔ x ≤ y ∧ x ⧏ y :=
+/- warning: pgame.lt_iff_le_and_lf -> PGame.lt_iff_le_and_lf is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) (And (LE.le.{succ u1} PGame.{u1} PGame.hasLe.{u1} x y) (PGame.Lf.{u1} x y))
+but is expected to have type
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) (And (LE.le.{succ u1} PGame.{u1} PGame.le.{u1} x y) (PGame.Lf.{u1} x y))
+Case conversion may be inaccurate. Consider using '#align pgame.lt_iff_le_and_lf PGame.lt_iff_le_and_lfₓ'. -/
+theorem lt_iff_le_and_lf {x y : PGame} : x < y ↔ x ≤ y ∧ x ⧏ y :=
   Iff.rfl
-#align pgame.lt_iff_le_and_lf Pgame.lt_iff_le_and_lf
-
-theorem lt_of_le_of_lf {x y : Pgame} (h₁ : x ≤ y) (h₂ : x ⧏ y) : x < y :=
+#align pgame.lt_iff_le_and_lf PGame.lt_iff_le_and_lf
+
+/- warning: pgame.lt_of_le_of_lf -> PGame.lt_of_le_of_lf is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, (LE.le.{succ u1} PGame.{u1} PGame.hasLe.{u1} x y) -> (PGame.Lf.{u1} x y) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y)
+but is expected to have type
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, (LE.le.{succ u1} PGame.{u1} PGame.le.{u1} x y) -> (PGame.Lf.{u1} x y) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y)
+Case conversion may be inaccurate. Consider using '#align pgame.lt_of_le_of_lf PGame.lt_of_le_of_lfₓ'. -/
+theorem lt_of_le_of_lf {x y : PGame} (h₁ : x ≤ y) (h₂ : x ⧏ y) : x < y :=
   ⟨h₁, h₂⟩
-#align pgame.lt_of_le_of_lf Pgame.lt_of_le_of_lf
-
-theorem lf_of_lt {x y : Pgame} (h : x < y) : x ⧏ y :=
+#align pgame.lt_of_le_of_lf PGame.lt_of_le_of_lf
+
+/- warning: pgame.lf_of_lt -> PGame.lf_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) -> (PGame.Lf.{u1} x y)
+but is expected to have type
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) -> (PGame.Lf.{u1} x y)
+Case conversion may be inaccurate. Consider using '#align pgame.lf_of_lt PGame.lf_of_ltₓ'. -/
+theorem lf_of_lt {x y : PGame} (h : x < y) : x ⧏ y :=
   h.2
-#align pgame.lf_of_lt Pgame.lf_of_lt
-
+#align pgame.lf_of_lt PGame.lf_of_lt
+
+/- warning: has_lt.lt.lf -> LT.lt.lf is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) -> (PGame.Lf.{u1} x y)
+but is expected to have type
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) -> (PGame.Lf.{u1} x y)
+Case conversion may be inaccurate. Consider using '#align has_lt.lt.lf LT.lt.lfₓ'. -/
 alias lf_of_lt ← _root_.has_lt.lt.lf
 #align has_lt.lt.lf LT.lt.lf
 
-theorem lf_irrefl (x : Pgame) : ¬x ⧏ x :=
+#print PGame.lf_irrefl /-
+theorem lf_irrefl (x : PGame) : ¬x ⧏ x :=
   le_rfl.not_gf
-#align pgame.lf_irrefl Pgame.lf_irrefl
+#align pgame.lf_irrefl PGame.lf_irrefl
+-/
 
 instance : IsIrrefl _ (· ⧏ ·) :=
   ⟨lf_irrefl⟩
 
+#print PGame.lf_of_le_of_lf /-
 @[trans]
-theorem lf_of_le_of_lf {x y z : Pgame} (h₁ : x ≤ y) (h₂ : y ⧏ z) : x ⧏ z :=
+theorem lf_of_le_of_lf {x y z : PGame} (h₁ : x ≤ y) (h₂ : y ⧏ z) : x ⧏ z :=
   by
-  rw [← Pgame.not_le] at h₂⊢
+  rw [← PGame.not_le] at h₂⊢
   exact fun h₃ => h₂ (h₃.trans h₁)
-#align pgame.lf_of_le_of_lf Pgame.lf_of_le_of_lf
+#align pgame.lf_of_le_of_lf PGame.lf_of_le_of_lf
+-/
 
+#print PGame.lf_of_lf_of_le /-
 @[trans]
-theorem lf_of_lf_of_le {x y z : Pgame} (h₁ : x ⧏ y) (h₂ : y ≤ z) : x ⧏ z :=
+theorem lf_of_lf_of_le {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y ≤ z) : x ⧏ z :=
   by
-  rw [← Pgame.not_le] at h₁⊢
+  rw [← PGame.not_le] at h₁⊢
   exact fun h₃ => h₁ (h₂.trans h₃)
-#align pgame.lf_of_lf_of_le Pgame.lf_of_lf_of_le
+#align pgame.lf_of_lf_of_le PGame.lf_of_lf_of_le
+-/
 
 alias lf_of_le_of_lf ← _root_.has_le.le.trans_lf
 #align has_le.le.trans_lf LE.le.trans_lf
 
 alias lf_of_lf_of_le ← lf.trans_le
-#align pgame.lf.trans_le Pgame.Lf.trans_le
-
+#align pgame.lf.trans_le PGame.Lf.trans_le
+
+/- warning: pgame.lf_of_lt_of_lf -> PGame.lf_of_lt_of_lf is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) -> (PGame.Lf.{u1} y z) -> (PGame.Lf.{u1} x z)
+but is expected to have type
+  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) -> (PGame.Lf.{u1} y z) -> (PGame.Lf.{u1} x z)
+Case conversion may be inaccurate. Consider using '#align pgame.lf_of_lt_of_lf PGame.lf_of_lt_of_lfₓ'. -/
 @[trans]
-theorem lf_of_lt_of_lf {x y z : Pgame} (h₁ : x < y) (h₂ : y ⧏ z) : x ⧏ z :=
+theorem lf_of_lt_of_lf {x y z : PGame} (h₁ : x < y) (h₂ : y ⧏ z) : x ⧏ z :=
   h₁.le.trans_lf h₂
-#align pgame.lf_of_lt_of_lf Pgame.lf_of_lt_of_lf
-
+#align pgame.lf_of_lt_of_lf PGame.lf_of_lt_of_lf
+
+/- warning: pgame.lf_of_lf_of_lt -> PGame.lf_of_lf_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (PGame.Lf.{u1} x y) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) y z) -> (PGame.Lf.{u1} x z)
+but is expected to have type
+  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (PGame.Lf.{u1} x y) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) y z) -> (PGame.Lf.{u1} x z)
+Case conversion may be inaccurate. Consider using '#align pgame.lf_of_lf_of_lt PGame.lf_of_lf_of_ltₓ'. -/
 @[trans]
-theorem lf_of_lf_of_lt {x y z : Pgame} (h₁ : x ⧏ y) (h₂ : y < z) : x ⧏ z :=
+theorem lf_of_lf_of_lt {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y < z) : x ⧏ z :=
   h₁.trans_le h₂.le
-#align pgame.lf_of_lf_of_lt Pgame.lf_of_lf_of_lt
-
+#align pgame.lf_of_lf_of_lt PGame.lf_of_lf_of_lt
+
+/- warning: has_lt.lt.trans_lf -> LT.lt.trans_lf is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) -> (PGame.Lf.{u1} y z) -> (PGame.Lf.{u1} x z)
+but is expected to have type
+  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) -> (PGame.Lf.{u1} y z) -> (PGame.Lf.{u1} x z)
+Case conversion may be inaccurate. Consider using '#align has_lt.lt.trans_lf LT.lt.trans_lfₓ'. -/
 alias lf_of_lt_of_lf ← _root_.has_lt.lt.trans_lf
 #align has_lt.lt.trans_lf LT.lt.trans_lf
 
+/- warning: pgame.lf.trans_lt -> PGame.Lf.trans_lt is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (PGame.Lf.{u1} x y) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) y z) -> (PGame.Lf.{u1} x z)
+but is expected to have type
+  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (PGame.Lf.{u1} x y) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) y z) -> (PGame.Lf.{u1} x z)
+Case conversion may be inaccurate. Consider using '#align pgame.lf.trans_lt PGame.Lf.trans_ltₓ'. -/
 alias lf_of_lf_of_lt ← lf.trans_lt
-#align pgame.lf.trans_lt Pgame.Lf.trans_lt
+#align pgame.lf.trans_lt PGame.Lf.trans_lt
 
-theorem moveLeft_lf {x : Pgame} : ∀ i, x.moveLeft i ⧏ x :=
+#print PGame.moveLeft_lf /-
+theorem moveLeft_lf {x : PGame} : ∀ i, x.moveLeft i ⧏ x :=
   le_rfl.moveLeft_lf
-#align pgame.move_left_lf Pgame.moveLeft_lf
+#align pgame.move_left_lf PGame.moveLeft_lf
+-/
 
-theorem lf_moveRight {x : Pgame} : ∀ j, x ⧏ x.moveRight j :=
+#print PGame.lf_moveRight /-
+theorem lf_moveRight {x : PGame} : ∀ j, x ⧏ x.moveRight j :=
   le_rfl.lf_moveRight
-#align pgame.lf_move_right Pgame.lf_moveRight
+#align pgame.lf_move_right PGame.lf_moveRight
+-/
 
-theorem lf_mk {xl xr} (xL : xl → Pgame) (xR : xr → Pgame) (i) : xL i ⧏ mk xl xr xL xR :=
+#print PGame.lf_mk /-
+theorem lf_mk {xl xr} (xL : xl → PGame) (xR : xr → PGame) (i) : xL i ⧏ mk xl xr xL xR :=
   @moveLeft_lf (mk _ _ _ _) i
-#align pgame.lf_mk Pgame.lf_mk
+#align pgame.lf_mk PGame.lf_mk
+-/
 
-theorem mk_lf {xl xr} (xL : xl → Pgame) (xR : xr → Pgame) (j) : mk xl xr xL xR ⧏ xR j :=
+#print PGame.mk_lf /-
+theorem mk_lf {xl xr} (xL : xl → PGame) (xR : xr → PGame) (j) : mk xl xr xL xR ⧏ xR j :=
   @lf_moveRight (mk _ _ _ _) j
-#align pgame.mk_lf Pgame.mk_lf
+#align pgame.mk_lf PGame.mk_lf
+-/
 
+/- warning: pgame.le_of_forall_lt -> PGame.le_of_forall_lt is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, (forall (i : PGame.LeftMoves.{u1} x), LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) (PGame.moveLeft.{u1} x i) y) -> (forall (j : PGame.RightMoves.{u1} y), LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x (PGame.moveRight.{u1} y j)) -> (LE.le.{succ u1} PGame.{u1} PGame.hasLe.{u1} x y)
+but is expected to have type
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, (forall (i : PGame.LeftMoves.{u1} x), LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) (PGame.moveLeft.{u1} x i) y) -> (forall (j : PGame.RightMoves.{u1} y), LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x (PGame.moveRight.{u1} y j)) -> (LE.le.{succ u1} PGame.{u1} PGame.le.{u1} x y)
+Case conversion may be inaccurate. Consider using '#align pgame.le_of_forall_lt PGame.le_of_forall_ltₓ'. -/
 /-- This special case of `pgame.le_of_forall_lf` is useful when dealing with surreals, where `<` is
 preferred over `⧏`. -/
-theorem le_of_forall_lt {x y : Pgame} (h₁ : ∀ i, x.moveLeft i < y) (h₂ : ∀ j, x < y.moveRight j) :
+theorem le_of_forall_lt {x y : PGame} (h₁ : ∀ i, x.moveLeft i < y) (h₂ : ∀ j, x < y.moveRight j) :
     x ≤ y :=
   le_of_forall_lf (fun i => (h₁ i).Lf) fun i => (h₂ i).Lf
-#align pgame.le_of_forall_lt Pgame.le_of_forall_lt
+#align pgame.le_of_forall_lt PGame.le_of_forall_lt
 
+#print PGame.le_def /-
 /-- The definition of `x ≤ y` on pre-games, in terms of `≤` two moves later. -/
-theorem le_def {x y : Pgame} :
+theorem le_def {x y : PGame} :
     x ≤ y ↔
       (∀ i, (∃ i', x.moveLeft i ≤ y.moveLeft i') ∨ ∃ j, (x.moveLeft i).moveRight j ≤ y) ∧
         ∀ j, (∃ i, x ≤ (y.moveRight j).moveLeft i) ∨ ∃ j', x.moveRight j' ≤ y.moveRight j :=
@@ -591,10 +776,12 @@ theorem le_def {x y : Pgame} :
   conv =>
     lhs
     simp only [lf_iff_exists_le]
-#align pgame.le_def Pgame.le_def
+#align pgame.le_def PGame.le_def
+-/
 
+#print PGame.lf_def /-
 /-- The definition of `x ⧏ y` on pre-games, in terms of `⧏` two moves later. -/
-theorem lf_def {x y : Pgame} :
+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' :=
@@ -603,363 +790,546 @@ theorem lf_def {x y : Pgame} :
   conv =>
     lhs
     simp only [le_iff_forall_lf]
-#align pgame.lf_def Pgame.lf_def
+#align pgame.lf_def PGame.lf_def
+-/
 
+#print PGame.zero_le_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 :=
+theorem zero_le_lf {x : PGame} : 0 ≤ x ↔ ∀ j, 0 ⧏ x.moveRight j :=
   by
   rw [le_iff_forall_lf]
   simp
-#align pgame.zero_le_lf Pgame.zero_le_lf
+#align pgame.zero_le_lf PGame.zero_le_lf
+-/
 
+#print PGame.le_zero_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 :=
+theorem le_zero_lf {x : PGame} : x ≤ 0 ↔ ∀ i, x.moveLeft i ⧏ 0 :=
   by
   rw [le_iff_forall_lf]
   simp
-#align pgame.le_zero_lf Pgame.le_zero_lf
+#align pgame.le_zero_lf PGame.le_zero_lf
+-/
 
+#print PGame.zero_lf_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 :=
+theorem zero_lf_le {x : PGame} : 0 ⧏ x ↔ ∃ i, 0 ≤ x.moveLeft i :=
   by
   rw [lf_iff_exists_le]
   simp
-#align pgame.zero_lf_le Pgame.zero_lf_le
+#align pgame.zero_lf_le PGame.zero_lf_le
+-/
 
+#print PGame.lf_zero_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 :=
+theorem lf_zero_le {x : PGame} : x ⧏ 0 ↔ ∃ j, x.moveRight j ≤ 0 :=
   by
   rw [lf_iff_exists_le]
   simp
-#align pgame.lf_zero_le Pgame.lf_zero_le
+#align pgame.lf_zero_le PGame.lf_zero_le
+-/
 
+#print PGame.zero_le /-
 /-- 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 :=
+theorem zero_le {x : PGame} : 0 ≤ x ↔ ∀ j, ∃ i, 0 ≤ (x.moveRight j).moveLeft i :=
   by
   rw [le_def]
   simp
-#align pgame.zero_le Pgame.zero_le
+#align pgame.zero_le PGame.zero_le
+-/
 
+#print PGame.le_zero /-
 /-- 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 :=
+theorem le_zero {x : PGame} : x ≤ 0 ↔ ∀ i, ∃ j, (x.moveLeft i).moveRight j ≤ 0 :=
   by
   rw [le_def]
   simp
-#align pgame.le_zero Pgame.le_zero
+#align pgame.le_zero PGame.le_zero
+-/
 
+#print PGame.zero_lf /-
 /-- 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 :=
+theorem zero_lf {x : PGame} : 0 ⧏ x ↔ ∃ i, ∀ j, 0 ⧏ (x.moveLeft i).moveRight j :=
   by
   rw [lf_def]
   simp
-#align pgame.zero_lf Pgame.zero_lf
+#align pgame.zero_lf PGame.zero_lf
+-/
 
+#print PGame.lf_zero /-
 /-- 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 :=
+theorem lf_zero {x : PGame} : x ⧏ 0 ↔ ∃ j, ∀ i, (x.moveRight j).moveLeft i ⧏ 0 :=
   by
   rw [lf_def]
   simp
-#align pgame.lf_zero Pgame.lf_zero
+#align pgame.lf_zero PGame.lf_zero
+-/
 
+#print PGame.zero_le_of_isEmpty_rightMoves /-
 @[simp]
-theorem zero_le_of_isEmpty_rightMoves (x : Pgame) [IsEmpty x.RightMoves] : 0 ≤ x :=
+theorem zero_le_of_isEmpty_rightMoves (x : PGame) [IsEmpty x.RightMoves] : 0 ≤ x :=
   zero_le.2 isEmptyElim
-#align pgame.zero_le_of_is_empty_right_moves Pgame.zero_le_of_isEmpty_rightMoves
+#align pgame.zero_le_of_is_empty_right_moves PGame.zero_le_of_isEmpty_rightMoves
+-/
 
+#print PGame.le_zero_of_isEmpty_leftMoves /-
 @[simp]
-theorem le_zero_of_isEmpty_leftMoves (x : Pgame) [IsEmpty x.LeftMoves] : x ≤ 0 :=
+theorem le_zero_of_isEmpty_leftMoves (x : PGame) [IsEmpty x.LeftMoves] : x ≤ 0 :=
   le_zero.2 isEmptyElim
-#align pgame.le_zero_of_is_empty_left_moves Pgame.le_zero_of_isEmpty_leftMoves
+#align pgame.le_zero_of_is_empty_left_moves PGame.le_zero_of_isEmpty_leftMoves
+-/
 
+#print PGame.rightResponse /-
 /-- Given a game won by the right player when they play second, provide a response to any move by
 left. -/
-noncomputable def rightResponse {x : Pgame} (h : x ≤ 0) (i : x.LeftMoves) :
+noncomputable def rightResponse {x : PGame} (h : x ≤ 0) (i : x.LeftMoves) :
     (x.moveLeft i).RightMoves :=
   Classical.choose <| (le_zero.1 h) i
-#align pgame.right_response Pgame.rightResponse
+#align pgame.right_response PGame.rightResponse
+-/
 
+#print PGame.rightResponse_spec /-
 /-- Show that the response for right provided by `right_response` preserves the right-player-wins
 condition. -/
-theorem rightResponse_spec {x : Pgame} (h : x ≤ 0) (i : x.LeftMoves) :
+theorem rightResponse_spec {x : PGame} (h : x ≤ 0) (i : x.LeftMoves) :
     (x.moveLeft i).moveRight (rightResponse h i) ≤ 0 :=
   Classical.choose_spec <| (le_zero.1 h) i
-#align pgame.right_response_spec Pgame.rightResponse_spec
+#align pgame.right_response_spec PGame.rightResponse_spec
+-/
 
+#print PGame.leftResponse /-
 /-- Given a game won by the left player when they play second, provide a response to any move by
 right. -/
-noncomputable def leftResponse {x : Pgame} (h : 0 ≤ x) (j : x.RightMoves) :
+noncomputable def leftResponse {x : PGame} (h : 0 ≤ x) (j : x.RightMoves) :
     (x.moveRight j).LeftMoves :=
   Classical.choose <| (zero_le.1 h) j
-#align pgame.left_response Pgame.leftResponse
+#align pgame.left_response PGame.leftResponse
+-/
 
+#print PGame.leftResponse_spec /-
 /-- Show that the response for left provided by `left_response` preserves the left-player-wins
 condition. -/
-theorem leftResponse_spec {x : Pgame} (h : 0 ≤ x) (j : x.RightMoves) :
+theorem leftResponse_spec {x : PGame} (h : 0 ≤ x) (j : x.RightMoves) :
     0 ≤ (x.moveRight j).moveLeft (leftResponse h j) :=
   Classical.choose_spec <| (zero_le.1 h) j
-#align pgame.left_response_spec Pgame.leftResponse_spec
+#align pgame.left_response_spec PGame.leftResponse_spec
+-/
 
+#print PGame.Equiv /-
 /-- The equivalence relation on pre-games. Two pre-games `x`, `y` are equivalent if `x ≤ y` and
 `y ≤ x`.
 
 If `x ≈ 0`, then the second player can always win `x`. -/
-def Equiv (x y : Pgame) : Prop :=
+def Equiv (x y : PGame) : Prop :=
   x ≤ y ∧ y ≤ x
-#align pgame.equiv Pgame.Equiv
+#align pgame.equiv PGame.Equiv
+-/
 
 -- mathport name: pgame.equiv
-scoped infixl:0 " ≈ " => Pgame.Equiv
+scoped infixl:0 " ≈ " => PGame.Equiv
 
 instance : IsEquiv _ (· ≈ ·) where
   refl x := ⟨le_rfl, le_rfl⟩
   trans := fun x y z ⟨xy, yx⟩ ⟨yz, zy⟩ => ⟨xy.trans yz, zy.trans yx⟩
   symm x y := And.symm
 
-theorem Equiv.le {x y : Pgame} (h : x ≈ y) : x ≤ y :=
+#print PGame.Equiv.le /-
+theorem Equiv.le {x y : PGame} (h : x ≈ y) : x ≤ y :=
   h.1
-#align pgame.equiv.le Pgame.Equiv.le
+#align pgame.equiv.le PGame.Equiv.le
+-/
 
-theorem Equiv.ge {x y : Pgame} (h : x ≈ y) : y ≤ x :=
+#print PGame.Equiv.ge /-
+theorem Equiv.ge {x y : PGame} (h : x ≈ y) : y ≤ x :=
   h.2
-#align pgame.equiv.ge Pgame.Equiv.ge
+#align pgame.equiv.ge PGame.Equiv.ge
+-/
 
+#print PGame.equiv_rfl /-
 @[refl, simp]
 theorem equiv_rfl {x} : x ≈ x :=
   refl x
-#align pgame.equiv_rfl Pgame.equiv_rfl
+#align pgame.equiv_rfl PGame.equiv_rfl
+-/
 
+#print PGame.equiv_refl /-
 theorem equiv_refl (x) : x ≈ x :=
   refl x
-#align pgame.equiv_refl Pgame.equiv_refl
+#align pgame.equiv_refl PGame.equiv_refl
+-/
 
+#print PGame.Equiv.symm /-
 @[symm]
 protected theorem Equiv.symm {x y} : (x ≈ y) → (y ≈ x) :=
   symm
-#align pgame.equiv.symm Pgame.Equiv.symm
+#align pgame.equiv.symm PGame.Equiv.symm
+-/
 
+#print PGame.Equiv.trans /-
 @[trans]
 protected theorem Equiv.trans {x y z} : (x ≈ y) → (y ≈ z) → (x ≈ z) :=
   trans
-#align pgame.equiv.trans Pgame.Equiv.trans
+#align pgame.equiv.trans PGame.Equiv.trans
+-/
 
+#print PGame.equiv_comm /-
 protected theorem equiv_comm {x y} : (x ≈ y) ↔ (y ≈ x) :=
   comm
-#align pgame.equiv_comm Pgame.equiv_comm
+#align pgame.equiv_comm PGame.equiv_comm
+-/
 
+#print PGame.equiv_of_eq /-
 theorem equiv_of_eq {x y} (h : x = y) : x ≈ y := by subst h
-#align pgame.equiv_of_eq Pgame.equiv_of_eq
+#align pgame.equiv_of_eq PGame.equiv_of_eq
+-/
 
+#print PGame.le_of_le_of_equiv /-
 @[trans]
 theorem le_of_le_of_equiv {x y z} (h₁ : x ≤ y) (h₂ : y ≈ z) : x ≤ z :=
   h₁.trans h₂.1
-#align pgame.le_of_le_of_equiv Pgame.le_of_le_of_equiv
+#align pgame.le_of_le_of_equiv PGame.le_of_le_of_equiv
+-/
 
+#print PGame.le_of_equiv_of_le /-
 @[trans]
 theorem le_of_equiv_of_le {x y z} (h₁ : x ≈ y) : y ≤ z → x ≤ z :=
   h₁.1.trans
-#align pgame.le_of_equiv_of_le Pgame.le_of_equiv_of_le
+#align pgame.le_of_equiv_of_le PGame.le_of_equiv_of_le
+-/
 
+#print PGame.Lf.not_equiv /-
 theorem Lf.not_equiv {x y} (h : x ⧏ y) : ¬(x ≈ y) := fun h' => h.not_ge h'.2
-#align pgame.lf.not_equiv Pgame.Lf.not_equiv
+#align pgame.lf.not_equiv PGame.Lf.not_equiv
+-/
 
+#print PGame.Lf.not_equiv' /-
 theorem Lf.not_equiv' {x y} (h : x ⧏ y) : ¬(y ≈ x) := fun h' => h.not_ge h'.1
-#align pgame.lf.not_equiv' Pgame.Lf.not_equiv'
+#align pgame.lf.not_equiv' PGame.Lf.not_equiv'
+-/
 
+/- warning: pgame.lf.not_gt -> PGame.Lf.not_gt is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, (PGame.Lf.{u1} x y) -> (Not (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) y x))
+but is expected to have type
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, (PGame.Lf.{u1} x y) -> (Not (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) y x))
+Case conversion may be inaccurate. Consider using '#align pgame.lf.not_gt PGame.Lf.not_gtₓ'. -/
 theorem Lf.not_gt {x y} (h : x ⧏ y) : ¬y < x := fun h' => h.not_ge h'.le
-#align pgame.lf.not_gt Pgame.Lf.not_gt
+#align pgame.lf.not_gt PGame.Lf.not_gt
 
+#print PGame.le_congr_imp /-
 theorem le_congr_imp {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) (h : x₁ ≤ y₁) : x₂ ≤ y₂ :=
   hx.2.trans (h.trans hy.1)
-#align pgame.le_congr_imp Pgame.le_congr_imp
+#align pgame.le_congr_imp PGame.le_congr_imp
+-/
 
+#print PGame.le_congr /-
 theorem le_congr {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ≤ y₁ ↔ x₂ ≤ y₂ :=
   ⟨le_congr_imp hx hy, le_congr_imp hx.symm hy.symm⟩
-#align pgame.le_congr Pgame.le_congr
+#align pgame.le_congr PGame.le_congr
+-/
 
+#print PGame.le_congr_left /-
 theorem le_congr_left {x₁ x₂ y} (hx : x₁ ≈ x₂) : x₁ ≤ y ↔ x₂ ≤ y :=
   le_congr hx equiv_rfl
-#align pgame.le_congr_left Pgame.le_congr_left
+#align pgame.le_congr_left PGame.le_congr_left
+-/
 
+#print PGame.le_congr_right /-
 theorem le_congr_right {x y₁ y₂} (hy : y₁ ≈ y₂) : x ≤ y₁ ↔ x ≤ y₂ :=
   le_congr equiv_rfl hy
-#align pgame.le_congr_right Pgame.le_congr_right
+#align pgame.le_congr_right PGame.le_congr_right
+-/
 
+#print PGame.lf_congr /-
 theorem lf_congr {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ⧏ y₁ ↔ x₂ ⧏ y₂ :=
-  Pgame.not_le.symm.trans <| (not_congr (le_congr hy hx)).trans Pgame.not_le
-#align pgame.lf_congr Pgame.lf_congr
+  PGame.not_le.symm.trans <| (not_congr (le_congr hy hx)).trans PGame.not_le
+#align pgame.lf_congr PGame.lf_congr
+-/
 
+#print PGame.lf_congr_imp /-
 theorem lf_congr_imp {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ⧏ y₁ → x₂ ⧏ y₂ :=
   (lf_congr hx hy).1
-#align pgame.lf_congr_imp Pgame.lf_congr_imp
+#align pgame.lf_congr_imp PGame.lf_congr_imp
+-/
 
+#print PGame.lf_congr_left /-
 theorem lf_congr_left {x₁ x₂ y} (hx : x₁ ≈ x₂) : x₁ ⧏ y ↔ x₂ ⧏ y :=
   lf_congr hx equiv_rfl
-#align pgame.lf_congr_left Pgame.lf_congr_left
+#align pgame.lf_congr_left PGame.lf_congr_left
+-/
 
+#print PGame.lf_congr_right /-
 theorem lf_congr_right {x y₁ y₂} (hy : y₁ ≈ y₂) : x ⧏ y₁ ↔ x ⧏ y₂ :=
   lf_congr equiv_rfl hy
-#align pgame.lf_congr_right Pgame.lf_congr_right
+#align pgame.lf_congr_right PGame.lf_congr_right
+-/
 
+#print PGame.lf_of_lf_of_equiv /-
 @[trans]
 theorem lf_of_lf_of_equiv {x y z} (h₁ : x ⧏ y) (h₂ : y ≈ z) : x ⧏ z :=
   lf_congr_imp equiv_rfl h₂ h₁
-#align pgame.lf_of_lf_of_equiv Pgame.lf_of_lf_of_equiv
+#align pgame.lf_of_lf_of_equiv PGame.lf_of_lf_of_equiv
+-/
 
+#print PGame.lf_of_equiv_of_lf /-
 @[trans]
 theorem lf_of_equiv_of_lf {x y z} (h₁ : x ≈ y) : y ⧏ z → x ⧏ z :=
   lf_congr_imp h₁.symm equiv_rfl
-#align pgame.lf_of_equiv_of_lf Pgame.lf_of_equiv_of_lf
+#align pgame.lf_of_equiv_of_lf PGame.lf_of_equiv_of_lf
+-/
 
+/- warning: pgame.lt_of_lt_of_equiv -> PGame.lt_of_lt_of_equiv is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) -> (PGame.Equiv.{u1} y z) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x z)
+but is expected to have type
+  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) -> (PGame.Equiv.{u1} y z) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x z)
+Case conversion may be inaccurate. Consider using '#align pgame.lt_of_lt_of_equiv PGame.lt_of_lt_of_equivₓ'. -/
 @[trans]
 theorem lt_of_lt_of_equiv {x y z} (h₁ : x < y) (h₂ : y ≈ z) : x < z :=
   h₁.trans_le h₂.1
-#align pgame.lt_of_lt_of_equiv Pgame.lt_of_lt_of_equiv
-
+#align pgame.lt_of_lt_of_equiv PGame.lt_of_lt_of_equiv
+
+/- warning: pgame.lt_of_equiv_of_lt -> PGame.lt_of_equiv_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (PGame.Equiv.{u1} x y) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) y z) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x z)
+but is expected to have type
+  forall {x : PGame.{u1}} {y : PGame.{u1}} {z : PGame.{u1}}, (PGame.Equiv.{u1} x y) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) y z) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x z)
+Case conversion may be inaccurate. Consider using '#align pgame.lt_of_equiv_of_lt PGame.lt_of_equiv_of_ltₓ'. -/
 @[trans]
 theorem lt_of_equiv_of_lt {x y z} (h₁ : x ≈ y) : y < z → x < z :=
   h₁.1.trans_lt
-#align pgame.lt_of_equiv_of_lt Pgame.lt_of_equiv_of_lt
-
+#align pgame.lt_of_equiv_of_lt PGame.lt_of_equiv_of_lt
+
+/- warning: pgame.lt_congr_imp -> PGame.lt_congr_imp is a dubious translation:
+lean 3 declaration is
+  forall {x₁ : PGame.{u1}} {y₁ : PGame.{u1}} {x₂ : PGame.{u1}} {y₂ : PGame.{u1}}, (PGame.Equiv.{u1} x₁ x₂) -> (PGame.Equiv.{u1} y₁ y₂) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x₁ y₁) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x₂ y₂)
+but is expected to have type
+  forall {x₁ : PGame.{u1}} {y₁ : PGame.{u1}} {x₂ : PGame.{u1}} {y₂ : PGame.{u1}}, (PGame.Equiv.{u1} x₁ x₂) -> (PGame.Equiv.{u1} y₁ y₂) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x₁ y₁) -> (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x₂ y₂)
+Case conversion may be inaccurate. Consider using '#align pgame.lt_congr_imp PGame.lt_congr_impₓ'. -/
 theorem lt_congr_imp {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) (h : x₁ < y₁) : x₂ < y₂ :=
   hx.2.trans_lt (h.trans_le hy.1)
-#align pgame.lt_congr_imp Pgame.lt_congr_imp
-
+#align pgame.lt_congr_imp PGame.lt_congr_imp
+
+/- warning: pgame.lt_congr -> PGame.lt_congr is a dubious translation:
+lean 3 declaration is
+  forall {x₁ : PGame.{u1}} {y₁ : PGame.{u1}} {x₂ : PGame.{u1}} {y₂ : PGame.{u1}}, (PGame.Equiv.{u1} x₁ x₂) -> (PGame.Equiv.{u1} y₁ y₂) -> (Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x₁ y₁) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x₂ y₂))
+but is expected to have type
+  forall {x₁ : PGame.{u1}} {y₁ : PGame.{u1}} {x₂ : PGame.{u1}} {y₂ : PGame.{u1}}, (PGame.Equiv.{u1} x₁ x₂) -> (PGame.Equiv.{u1} y₁ y₂) -> (Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x₁ y₁) (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x₂ y₂))
+Case conversion may be inaccurate. Consider using '#align pgame.lt_congr PGame.lt_congrₓ'. -/
 theorem lt_congr {x₁ y₁ x₂ y₂} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ < y₁ ↔ x₂ < y₂ :=
   ⟨lt_congr_imp hx hy, lt_congr_imp hx.symm hy.symm⟩
-#align pgame.lt_congr Pgame.lt_congr
-
+#align pgame.lt_congr PGame.lt_congr
+
+/- warning: pgame.lt_congr_left -> PGame.lt_congr_left is a dubious translation:
+lean 3 declaration is
+  forall {x₁ : PGame.{u1}} {x₂ : PGame.{u1}} {y : PGame.{u1}}, (PGame.Equiv.{u1} x₁ x₂) -> (Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x₁ y) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x₂ y))
+but is expected to have type
+  forall {x₁ : PGame.{u1}} {x₂ : PGame.{u1}} {y : PGame.{u1}}, (PGame.Equiv.{u1} x₁ x₂) -> (Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x₁ y) (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x₂ y))
+Case conversion may be inaccurate. Consider using '#align pgame.lt_congr_left PGame.lt_congr_leftₓ'. -/
 theorem lt_congr_left {x₁ x₂ y} (hx : x₁ ≈ x₂) : x₁ < y ↔ x₂ < y :=
   lt_congr hx equiv_rfl
-#align pgame.lt_congr_left Pgame.lt_congr_left
-
+#align pgame.lt_congr_left PGame.lt_congr_left
+
+/- warning: pgame.lt_congr_right -> PGame.lt_congr_right is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}} {y₁ : PGame.{u1}} {y₂ : PGame.{u1}}, (PGame.Equiv.{u1} y₁ y₂) -> (Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y₁) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y₂))
+but is expected to have type
+  forall {x : PGame.{u1}} {y₁ : PGame.{u1}} {y₂ : PGame.{u1}}, (PGame.Equiv.{u1} y₁ y₂) -> (Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y₁) (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y₂))
+Case conversion may be inaccurate. Consider using '#align pgame.lt_congr_right PGame.lt_congr_rightₓ'. -/
 theorem lt_congr_right {x y₁ y₂} (hy : y₁ ≈ y₂) : x < y₁ ↔ x < y₂ :=
   lt_congr equiv_rfl hy
-#align pgame.lt_congr_right Pgame.lt_congr_right
-
-theorem lt_or_equiv_of_le {x y : Pgame} (h : x ≤ y) : x < y ∨ (x ≈ y) :=
-  and_or_left.mp ⟨h, (em <| y ≤ x).symm.imp_left Pgame.not_le.1⟩
-#align pgame.lt_or_equiv_of_le Pgame.lt_or_equiv_of_le
-
-theorem lf_or_equiv_or_gf (x y : Pgame) : x ⧏ y ∨ (x ≈ y) ∨ y ⧏ x :=
+#align pgame.lt_congr_right PGame.lt_congr_right
+
+/- warning: pgame.lt_or_equiv_of_le -> PGame.lt_or_equiv_of_le is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, (LE.le.{succ u1} PGame.{u1} PGame.hasLe.{u1} x y) -> (Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) (PGame.Equiv.{u1} x y))
+but is expected to have type
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, (LE.le.{succ u1} PGame.{u1} PGame.le.{u1} x y) -> (Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) (PGame.Equiv.{u1} x y))
+Case conversion may be inaccurate. Consider using '#align pgame.lt_or_equiv_of_le PGame.lt_or_equiv_of_leₓ'. -/
+theorem lt_or_equiv_of_le {x y : PGame} (h : x ≤ y) : x < y ∨ (x ≈ y) :=
+  and_or_left.mp ⟨h, (em <| y ≤ x).symm.imp_left PGame.not_le.1⟩
+#align pgame.lt_or_equiv_of_le PGame.lt_or_equiv_of_le
+
+#print PGame.lf_or_equiv_or_gf /-
+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'
+    cases' lt_or_equiv_of_le (PGame.not_lf.1 h) with h' h'
     · exact Or.inr h'.lf
     · exact Or.inl h'.symm
-#align pgame.lf_or_equiv_or_gf Pgame.lf_or_equiv_or_gf
+#align pgame.lf_or_equiv_or_gf PGame.lf_or_equiv_or_gf
+-/
 
+#print PGame.equiv_congr_left /-
 theorem equiv_congr_left {y₁ y₂} : (y₁ ≈ y₂) ↔ ∀ x₁, (x₁ ≈ y₁) ↔ (x₁ ≈ y₂) :=
   ⟨fun h x₁ => ⟨fun h' => h'.trans h, fun h' => h'.trans h.symm⟩, fun h => (h y₁).1 <| equiv_rfl⟩
-#align pgame.equiv_congr_left Pgame.equiv_congr_left
+#align pgame.equiv_congr_left PGame.equiv_congr_left
+-/
 
+#print PGame.equiv_congr_right /-
 theorem equiv_congr_right {x₁ x₂} : (x₁ ≈ x₂) ↔ ∀ y₁, (x₁ ≈ y₁) ↔ (x₂ ≈ y₁) :=
   ⟨fun h y₁ => ⟨fun h' => h.symm.trans h', fun h' => h.trans h'⟩, fun h => (h x₂).2 <| equiv_rfl⟩
-#align pgame.equiv_congr_right Pgame.equiv_congr_right
+#align pgame.equiv_congr_right PGame.equiv_congr_right
+-/
 
-theorem equiv_of_mk_equiv {x y : Pgame} (L : x.LeftMoves ≃ y.LeftMoves)
+#print PGame.equiv_of_mk_equiv /-
+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
   fconstructor <;> 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 simpa using (hl (L.symm i)).2⟩, fun j => Or.inr ⟨_, (hr j).2⟩⟩
-#align pgame.equiv_of_mk_equiv Pgame.equiv_of_mk_equiv
+#align pgame.equiv_of_mk_equiv PGame.equiv_of_mk_equiv
+-/
 
+#print PGame.Fuzzy /-
 /-- The fuzzy, confused, or incomparable relation on pre-games.
 
 If `x ‖ 0`, then the first player can always win `x`. -/
-def Fuzzy (x y : Pgame) : Prop :=
+def Fuzzy (x y : PGame) : Prop :=
   x ⧏ y ∧ y ⧏ x
-#align pgame.fuzzy Pgame.Fuzzy
+#align pgame.fuzzy PGame.Fuzzy
+-/
 
 -- mathport name: pgame.fuzzy
-scoped infixl:50 " ‖ " => Pgame.Fuzzy
+scoped infixl:50 " ‖ " => PGame.Fuzzy
 
+#print PGame.Fuzzy.swap /-
 @[symm]
-theorem Fuzzy.swap {x y : Pgame} : x ‖ y → y ‖ x :=
+theorem Fuzzy.swap {x y : PGame} : x ‖ y → y ‖ x :=
   And.symm
-#align pgame.fuzzy.swap Pgame.Fuzzy.swap
+#align pgame.fuzzy.swap PGame.Fuzzy.swap
+-/
 
 instance : IsSymm _ (· ‖ ·) :=
   ⟨fun x y => Fuzzy.swap⟩
 
-theorem Fuzzy.swap_iff {x y : Pgame} : x ‖ y ↔ y ‖ x :=
+#print PGame.Fuzzy.swap_iff /-
+theorem Fuzzy.swap_iff {x y : PGame} : x ‖ y ↔ y ‖ x :=
   ⟨Fuzzy.swap, Fuzzy.swap⟩
-#align pgame.fuzzy.swap_iff Pgame.Fuzzy.swap_iff
+#align pgame.fuzzy.swap_iff PGame.Fuzzy.swap_iff
+-/
 
-theorem fuzzy_irrefl (x : Pgame) : ¬x ‖ x := fun h => lf_irrefl x h.1
-#align pgame.fuzzy_irrefl Pgame.fuzzy_irrefl
+#print PGame.fuzzy_irrefl /-
+theorem fuzzy_irrefl (x : PGame) : ¬x ‖ x := fun h => lf_irrefl x h.1
+#align pgame.fuzzy_irrefl PGame.fuzzy_irrefl
+-/
 
 instance : IsIrrefl _ (· ‖ ·) :=
   ⟨fuzzy_irrefl⟩
 
-theorem lf_iff_lt_or_fuzzy {x y : Pgame} : x ⧏ y ↔ x < y ∨ x ‖ y :=
+/- warning: pgame.lf_iff_lt_or_fuzzy -> PGame.lf_iff_lt_or_fuzzy is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (PGame.Lf.{u1} x y) (Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) (PGame.Fuzzy.{u1} x y))
+but is expected to have type
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (PGame.Lf.{u1} x y) (Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) (PGame.Fuzzy.{u1} x y))
+Case conversion may be inaccurate. Consider using '#align pgame.lf_iff_lt_or_fuzzy PGame.lf_iff_lt_or_fuzzyₓ'. -/
+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]
+  simp only [lt_iff_le_and_lf, fuzzy, ← PGame.not_le]
   tauto
-#align pgame.lf_iff_lt_or_fuzzy Pgame.lf_iff_lt_or_fuzzy
+#align pgame.lf_iff_lt_or_fuzzy PGame.lf_iff_lt_or_fuzzy
 
-theorem lf_of_fuzzy {x y : Pgame} (h : x ‖ y) : x ⧏ y :=
+#print PGame.lf_of_fuzzy /-
+theorem lf_of_fuzzy {x y : PGame} (h : x ‖ y) : x ⧏ y :=
   lf_iff_lt_or_fuzzy.2 (Or.inr h)
-#align pgame.lf_of_fuzzy Pgame.lf_of_fuzzy
+#align pgame.lf_of_fuzzy PGame.lf_of_fuzzy
+-/
 
 alias lf_of_fuzzy ← fuzzy.lf
-#align pgame.fuzzy.lf Pgame.Fuzzy.lf
-
-theorem lt_or_fuzzy_of_lf {x y : Pgame} : x ⧏ y → x < y ∨ x ‖ y :=
+#align pgame.fuzzy.lf PGame.Fuzzy.lf
+
+/- warning: pgame.lt_or_fuzzy_of_lf -> PGame.lt_or_fuzzy_of_lf is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, (PGame.Lf.{u1} x y) -> (Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) (PGame.Fuzzy.{u1} x y))
+but is expected to have type
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, (PGame.Lf.{u1} x y) -> (Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) (PGame.Fuzzy.{u1} x y))
+Case conversion may be inaccurate. Consider using '#align pgame.lt_or_fuzzy_of_lf PGame.lt_or_fuzzy_of_lfₓ'. -/
+theorem lt_or_fuzzy_of_lf {x y : PGame} : x ⧏ y → x < y ∨ x ‖ y :=
   lf_iff_lt_or_fuzzy.1
-#align pgame.lt_or_fuzzy_of_lf Pgame.lt_or_fuzzy_of_lf
+#align pgame.lt_or_fuzzy_of_lf PGame.lt_or_fuzzy_of_lf
 
-theorem Fuzzy.not_equiv {x y : Pgame} (h : x ‖ y) : ¬(x ≈ y) := fun h' => h'.1.not_gf h.2
-#align pgame.fuzzy.not_equiv Pgame.Fuzzy.not_equiv
+#print PGame.Fuzzy.not_equiv /-
+theorem Fuzzy.not_equiv {x y : PGame} (h : x ‖ y) : ¬(x ≈ y) := fun h' => h'.1.not_gf h.2
+#align pgame.fuzzy.not_equiv PGame.Fuzzy.not_equiv
+-/
 
-theorem Fuzzy.not_equiv' {x y : Pgame} (h : x ‖ y) : ¬(y ≈ x) := fun h' => h'.2.not_gf h.2
-#align pgame.fuzzy.not_equiv' Pgame.Fuzzy.not_equiv'
+#print PGame.Fuzzy.not_equiv' /-
+theorem Fuzzy.not_equiv' {x y : PGame} (h : x ‖ y) : ¬(y ≈ x) := fun h' => h'.2.not_gf h.2
+#align pgame.fuzzy.not_equiv' PGame.Fuzzy.not_equiv'
+-/
 
-theorem not_fuzzy_of_le {x y : Pgame} (h : x ≤ y) : ¬x ‖ y := fun h' => h'.2.not_ge h
-#align pgame.not_fuzzy_of_le Pgame.not_fuzzy_of_le
+#print PGame.not_fuzzy_of_le /-
+theorem not_fuzzy_of_le {x y : PGame} (h : x ≤ y) : ¬x ‖ y := fun h' => h'.2.not_ge h
+#align pgame.not_fuzzy_of_le PGame.not_fuzzy_of_le
+-/
 
-theorem not_fuzzy_of_ge {x y : Pgame} (h : y ≤ x) : ¬x ‖ y := fun h' => h'.1.not_ge h
-#align pgame.not_fuzzy_of_ge Pgame.not_fuzzy_of_ge
+#print PGame.not_fuzzy_of_ge /-
+theorem not_fuzzy_of_ge {x y : PGame} (h : y ≤ x) : ¬x ‖ y := fun h' => h'.1.not_ge h
+#align pgame.not_fuzzy_of_ge PGame.not_fuzzy_of_ge
+-/
 
-theorem Equiv.not_fuzzy {x y : Pgame} (h : x ≈ y) : ¬x ‖ y :=
+#print PGame.Equiv.not_fuzzy /-
+theorem Equiv.not_fuzzy {x y : PGame} (h : x ≈ y) : ¬x ‖ y :=
   not_fuzzy_of_le h.1
-#align pgame.equiv.not_fuzzy Pgame.Equiv.not_fuzzy
+#align pgame.equiv.not_fuzzy PGame.Equiv.not_fuzzy
+-/
 
-theorem Equiv.not_fuzzy' {x y : Pgame} (h : x ≈ y) : ¬y ‖ x :=
+#print PGame.Equiv.not_fuzzy' /-
+theorem Equiv.not_fuzzy' {x y : PGame} (h : x ≈ y) : ¬y ‖ x :=
   not_fuzzy_of_le h.2
-#align pgame.equiv.not_fuzzy' Pgame.Equiv.not_fuzzy'
+#align pgame.equiv.not_fuzzy' PGame.Equiv.not_fuzzy'
+-/
 
-theorem fuzzy_congr {x₁ y₁ x₂ y₂ : Pgame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ‖ y₁ ↔ x₂ ‖ y₂ :=
+#print PGame.fuzzy_congr /-
+theorem fuzzy_congr {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ‖ y₁ ↔ x₂ ‖ y₂ :=
   show _ ∧ _ ↔ _ ∧ _ by rw [lf_congr hx hy, lf_congr hy hx]
-#align pgame.fuzzy_congr Pgame.fuzzy_congr
+#align pgame.fuzzy_congr PGame.fuzzy_congr
+-/
 
-theorem fuzzy_congr_imp {x₁ y₁ x₂ y₂ : Pgame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ‖ y₁ → x₂ ‖ y₂ :=
+#print PGame.fuzzy_congr_imp /-
+theorem fuzzy_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ‖ y₁ → x₂ ‖ y₂ :=
   (fuzzy_congr hx hy).1
-#align pgame.fuzzy_congr_imp Pgame.fuzzy_congr_imp
+#align pgame.fuzzy_congr_imp PGame.fuzzy_congr_imp
+-/
 
+#print PGame.fuzzy_congr_left /-
 theorem fuzzy_congr_left {x₁ x₂ y} (hx : x₁ ≈ x₂) : x₁ ‖ y ↔ x₂ ‖ y :=
   fuzzy_congr hx equiv_rfl
-#align pgame.fuzzy_congr_left Pgame.fuzzy_congr_left
+#align pgame.fuzzy_congr_left PGame.fuzzy_congr_left
+-/
 
+#print PGame.fuzzy_congr_right /-
 theorem fuzzy_congr_right {x y₁ y₂} (hy : y₁ ≈ y₂) : x ‖ y₁ ↔ x ‖ y₂ :=
   fuzzy_congr equiv_rfl hy
-#align pgame.fuzzy_congr_right Pgame.fuzzy_congr_right
+#align pgame.fuzzy_congr_right PGame.fuzzy_congr_right
+-/
 
+#print PGame.fuzzy_of_fuzzy_of_equiv /-
 @[trans]
 theorem fuzzy_of_fuzzy_of_equiv {x y z} (h₁ : x ‖ y) (h₂ : y ≈ z) : x ‖ z :=
   (fuzzy_congr_right h₂).1 h₁
-#align pgame.fuzzy_of_fuzzy_of_equiv Pgame.fuzzy_of_fuzzy_of_equiv
+#align pgame.fuzzy_of_fuzzy_of_equiv PGame.fuzzy_of_fuzzy_of_equiv
+-/
 
+#print PGame.fuzzy_of_equiv_of_fuzzy /-
 @[trans]
 theorem fuzzy_of_equiv_of_fuzzy {x y z} (h₁ : x ≈ y) (h₂ : y ‖ z) : x ‖ z :=
   (fuzzy_congr_left h₁).2 h₂
-#align pgame.fuzzy_of_equiv_of_fuzzy Pgame.fuzzy_of_equiv_of_fuzzy
+#align pgame.fuzzy_of_equiv_of_fuzzy PGame.fuzzy_of_equiv_of_fuzzy
+-/
 
+/- warning: pgame.lt_or_equiv_or_gt_or_fuzzy -> PGame.lt_or_equiv_or_gt_or_fuzzy is a dubious translation:
+lean 3 declaration is
+  forall (x : PGame.{u1}) (y : PGame.{u1}), Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) (Or (PGame.Equiv.{u1} x y) (Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) y x) (PGame.Fuzzy.{u1} x y)))
+but is expected to have type
+  forall (x : PGame.{u1}) (y : PGame.{u1}), Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) (Or (PGame.Equiv.{u1} x y) (Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) y x) (PGame.Fuzzy.{u1} x y)))
+Case conversion may be inaccurate. Consider using '#align pgame.lt_or_equiv_or_gt_or_fuzzy PGame.lt_or_equiv_or_gt_or_fuzzyₓ'. -/
 /-- 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 :=
+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
@@ -975,215 +1345,278 @@ theorem lt_or_equiv_or_gt_or_fuzzy (x y : Pgame) : x < y ∨ (x ≈ y) ∨ y < x
     right
     right
     exact ⟨h₂, h₁⟩
-#align pgame.lt_or_equiv_or_gt_or_fuzzy Pgame.lt_or_equiv_or_gt_or_fuzzy
-
-theorem lt_or_equiv_or_gf (x y : Pgame) : x < y ∨ (x ≈ y) ∨ y ⧏ x :=
+#align pgame.lt_or_equiv_or_gt_or_fuzzy PGame.lt_or_equiv_or_gt_or_fuzzy
+
+/- warning: pgame.lt_or_equiv_or_gf -> PGame.lt_or_equiv_or_gf is a dubious translation:
+lean 3 declaration is
+  forall (x : PGame.{u1}) (y : PGame.{u1}), Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) (Or (PGame.Equiv.{u1} x y) (PGame.Lf.{u1} y x))
+but is expected to have type
+  forall (x : PGame.{u1}) (y : PGame.{u1}), Or (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) (Or (PGame.Equiv.{u1} x y) (PGame.Lf.{u1} y x))
+Case conversion may be inaccurate. Consider using '#align pgame.lt_or_equiv_or_gf PGame.lt_or_equiv_or_gfₓ'. -/
+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]
   exact lt_or_equiv_or_gt_or_fuzzy x y
-#align pgame.lt_or_equiv_or_gf Pgame.lt_or_equiv_or_gf
+#align pgame.lt_or_equiv_or_gf PGame.lt_or_equiv_or_gf
 
 /-! ### Relabellings -/
 
 
+#print PGame.Relabelling /-
 /-- `relabelling x y` says that `x` and `y` are really the same game, just dressed up differently.
 Specifically, there is a bijection between the moves for Left in `x` and in `y`, and similarly
 for Right, and under these bijections we inductively have `relabelling`s for the consequent games.
 -/
-inductive Relabelling : Pgame.{u} → Pgame.{u} → Type (u + 1)
+inductive Relabelling : PGame.{u} → PGame.{u} → Type (u + 1)
   |
   mk :
-    ∀ {x y : Pgame} (L : x.LeftMoves ≃ y.LeftMoves) (R : x.RightMoves ≃ y.RightMoves),
+    ∀ {x y : PGame} (L : x.LeftMoves ≃ y.LeftMoves) (R : x.RightMoves ≃ y.RightMoves),
       (∀ i, relabelling (x.moveLeft i) (y.moveLeft (L i))) →
         (∀ j, relabelling (x.moveRight j) (y.moveRight (R j))) → relabelling x y
-#align pgame.relabelling Pgame.Relabelling
+#align pgame.relabelling PGame.Relabelling
+-/
 
 -- mathport name: pgame.relabelling
-scoped infixl:50 " ≡r " => Pgame.Relabelling
+scoped infixl:50 " ≡r " => PGame.Relabelling
 
 namespace Relabelling
 
-variable {x y : Pgame.{u}}
+variable {x y : PGame.{u}}
 
+#print PGame.Relabelling.mk' /-
 /-- 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 simpa using hR (R.symm j)⟩
-#align pgame.relabelling.mk' Pgame.Relabelling.mk'
+#align pgame.relabelling.mk' PGame.Relabelling.mk'
+-/
 
+#print PGame.Relabelling.leftMovesEquiv /-
 /-- The equivalence between left moves of `x` and `y` given by the relabelling. -/
 def leftMovesEquiv : ∀ r : x ≡r y, x.LeftMoves ≃ y.LeftMoves
   | ⟨L, R, hL, hR⟩ => L
-#align pgame.relabelling.left_moves_equiv Pgame.Relabelling.leftMovesEquiv
+#align pgame.relabelling.left_moves_equiv PGame.Relabelling.leftMovesEquiv
+-/
 
+#print PGame.Relabelling.mk_leftMovesEquiv /-
 @[simp]
 theorem mk_leftMovesEquiv {x y L R hL hR} : (@Relabelling.mk x y L R hL hR).leftMovesEquiv = L :=
   rfl
-#align pgame.relabelling.mk_left_moves_equiv Pgame.Relabelling.mk_leftMovesEquiv
+#align pgame.relabelling.mk_left_moves_equiv PGame.Relabelling.mk_leftMovesEquiv
+-/
 
+#print PGame.Relabelling.mk'_leftMovesEquiv /-
 @[simp]
 theorem mk'_leftMovesEquiv {x y L R hL hR} :
     (@Relabelling.mk' x y L R hL hR).leftMovesEquiv = L.symm :=
   rfl
-#align pgame.relabelling.mk'_left_moves_equiv Pgame.Relabelling.mk'_leftMovesEquiv
+#align pgame.relabelling.mk'_left_moves_equiv PGame.Relabelling.mk'_leftMovesEquiv
+-/
 
+#print PGame.Relabelling.rightMovesEquiv /-
 /-- The equivalence between right moves of `x` and `y` given by the relabelling. -/
 def rightMovesEquiv : ∀ r : x ≡r y, x.RightMoves ≃ y.RightMoves
   | ⟨L, R, hL, hR⟩ => R
-#align pgame.relabelling.right_moves_equiv Pgame.Relabelling.rightMovesEquiv
+#align pgame.relabelling.right_moves_equiv PGame.Relabelling.rightMovesEquiv
+-/
 
+#print PGame.Relabelling.mk_rightMovesEquiv /-
 @[simp]
 theorem mk_rightMovesEquiv {x y L R hL hR} : (@Relabelling.mk x y L R hL hR).rightMovesEquiv = R :=
   rfl
-#align pgame.relabelling.mk_right_moves_equiv Pgame.Relabelling.mk_rightMovesEquiv
+#align pgame.relabelling.mk_right_moves_equiv PGame.Relabelling.mk_rightMovesEquiv
+-/
 
+#print PGame.Relabelling.mk'_rightMovesEquiv /-
 @[simp]
 theorem mk'_rightMovesEquiv {x y L R hL hR} :
     (@Relabelling.mk' x y L R hL hR).rightMovesEquiv = R.symm :=
   rfl
-#align pgame.relabelling.mk'_right_moves_equiv Pgame.Relabelling.mk'_rightMovesEquiv
+#align pgame.relabelling.mk'_right_moves_equiv PGame.Relabelling.mk'_rightMovesEquiv
+-/
 
+#print PGame.Relabelling.moveLeft /-
 /-- A left move of `x` is a relabelling of a left move of `y`. -/
 def moveLeft : ∀ (r : x ≡r y) (i : x.LeftMoves), x.moveLeft i ≡r y.moveLeft (r.leftMovesEquiv i)
   | ⟨L, R, hL, hR⟩ => hL
-#align pgame.relabelling.move_left Pgame.Relabelling.moveLeft
+#align pgame.relabelling.move_left PGame.Relabelling.moveLeft
+-/
 
+#print PGame.Relabelling.moveLeftSymm /-
 /-- 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 simpa using hL (L.symm i)
-#align pgame.relabelling.move_left_symm Pgame.Relabelling.moveLeftSymm
+#align pgame.relabelling.move_left_symm PGame.Relabelling.moveLeftSymm
+-/
 
+#print PGame.Relabelling.moveRight /-
 /-- A right move of `x` is a relabelling of a right move of `y`. -/
 def moveRight :
     ∀ (r : x ≡r y) (i : x.RightMoves), x.moveRight i ≡r y.moveRight (r.rightMovesEquiv i)
   | ⟨L, R, hL, hR⟩ => hR
-#align pgame.relabelling.move_right Pgame.Relabelling.moveRight
+#align pgame.relabelling.move_right PGame.Relabelling.moveRight
+-/
 
+#print PGame.Relabelling.moveRightSymm /-
 /-- 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 simpa using hR (R.symm i)
-#align pgame.relabelling.move_right_symm Pgame.Relabelling.moveRightSymm
+#align pgame.relabelling.move_right_symm PGame.Relabelling.moveRightSymm
+-/
 
+#print PGame.Relabelling.refl /-
 /-- The identity relabelling. -/
 @[refl]
-def refl : ∀ x : Pgame, x ≡r x
+def refl : ∀ x : PGame, x ≡r x
   | x => ⟨Equiv.refl _, Equiv.refl _, fun i => refl _, fun j => refl _⟩decreasing_by pgame_wf_tac
-#align pgame.relabelling.refl Pgame.Relabelling.refl
+#align pgame.relabelling.refl PGame.Relabelling.refl
+-/
 
-instance (x : Pgame) : Inhabited (x ≡r x) :=
+instance (x : PGame) : Inhabited (x ≡r x) :=
   ⟨refl _⟩
 
+#print PGame.Relabelling.symm /-
 /-- Flip a relabelling. -/
 @[symm]
-def symm : ∀ {x y : Pgame}, x ≡r y → y ≡r x
+def symm : ∀ {x y : PGame}, x ≡r y → y ≡r x
   | x, y, ⟨L, R, hL, hR⟩ => mk' L R (fun i => (hL i).symm) fun j => (hR j).symm
-#align pgame.relabelling.symm Pgame.Relabelling.symm
+#align pgame.relabelling.symm PGame.Relabelling.symm
+-/
 
-theorem le : ∀ {x y : Pgame} (r : x ≡r y), x ≤ y
+#print PGame.Relabelling.le /-
+theorem le : ∀ {x y : PGame} (r : x ≡r y), x ≤ y
   | x, y, r =>
     le_def.2
       ⟨fun i => Or.inl ⟨_, (r.moveLeft i).le⟩, fun j =>
         Or.inr ⟨_, (r.moveRightSymm j).le⟩⟩decreasing_by
   pgame_wf_tac
-#align pgame.relabelling.le Pgame.Relabelling.le
+#align pgame.relabelling.le PGame.Relabelling.le
+-/
 
-theorem ge {x y : Pgame} (r : x ≡r y) : y ≤ x :=
+#print PGame.Relabelling.ge /-
+theorem ge {x y : PGame} (r : x ≡r y) : y ≤ x :=
   r.symm.le
-#align pgame.relabelling.ge Pgame.Relabelling.ge
+#align pgame.relabelling.ge PGame.Relabelling.ge
+-/
 
+#print PGame.Relabelling.equiv /-
 /-- A relabelling lets us prove equivalence of games. -/
 theorem equiv (r : x ≡r y) : x ≈ y :=
   ⟨r.le, r.ge⟩
-#align pgame.relabelling.equiv Pgame.Relabelling.equiv
+#align pgame.relabelling.equiv PGame.Relabelling.equiv
+-/
 
+#print PGame.Relabelling.trans /-
 /-- Transitivity of relabelling. -/
 @[trans]
-def trans : ∀ {x y z : Pgame}, x ≡r y → y ≡r z → x ≡r z
+def trans : ∀ {x y z : PGame}, x ≡r y → y ≡r z → x ≡r z
   | x, y, z, ⟨L₁, R₁, hL₁, hR₁⟩, ⟨L₂, R₂, hL₂, hR₂⟩ =>
     ⟨L₁.trans L₂, R₁.trans R₂, fun i => (hL₁ i).trans (hL₂ _), fun j => (hR₁ j).trans (hR₂ _)⟩
-#align pgame.relabelling.trans Pgame.Relabelling.trans
+#align pgame.relabelling.trans PGame.Relabelling.trans
+-/
 
+#print PGame.Relabelling.isEmpty /-
 /-- Any game without left or right moves is a relabelling of 0. -/
-def isEmpty (x : Pgame) [IsEmpty x.LeftMoves] [IsEmpty x.RightMoves] : x ≡r 0 :=
+def isEmpty (x : PGame) [IsEmpty x.LeftMoves] [IsEmpty x.RightMoves] : x ≡r 0 :=
   ⟨Equiv.equivPEmpty _, Equiv.equivOfIsEmpty _ _, isEmptyElim, isEmptyElim⟩
-#align pgame.relabelling.is_empty Pgame.Relabelling.isEmpty
+#align pgame.relabelling.is_empty PGame.Relabelling.isEmpty
+-/
 
 end Relabelling
 
-theorem Equiv.isEmpty (x : Pgame) [IsEmpty x.LeftMoves] [IsEmpty x.RightMoves] : x ≈ 0 :=
+#print PGame.Equiv.isEmpty /-
+theorem Equiv.isEmpty (x : PGame) [IsEmpty x.LeftMoves] [IsEmpty x.RightMoves] : x ≈ 0 :=
   (Relabelling.isEmpty x).Equiv
-#align pgame.equiv.is_empty Pgame.Equiv.isEmpty
+#align pgame.equiv.is_empty PGame.Equiv.isEmpty
+-/
 
-instance {x y : Pgame} : Coe (x ≡r y) (x ≈ y) :=
+instance {x y : PGame} : Coe (x ≡r y) (x ≈ y) :=
   ⟨Relabelling.equiv⟩
 
+#print PGame.relabel /-
 /-- Replace the types indexing the next moves for Left and Right by equivalent types. -/
-def relabel {x : Pgame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves) : Pgame :=
+def relabel {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves) : PGame :=
   ⟨xl', xr', x.moveLeft ∘ el, x.moveRight ∘ er⟩
-#align pgame.relabel Pgame.relabel
+#align pgame.relabel PGame.relabel
+-/
 
+#print PGame.relabel_moveLeft' /-
 @[simp]
-theorem relabel_move_left' {x : Pgame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
+theorem relabel_moveLeft' {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
     (i : xl') : moveLeft (relabel el er) i = x.moveLeft (el i) :=
   rfl
-#align pgame.relabel_move_left' Pgame.relabel_move_left'
+#align pgame.relabel_move_left' PGame.relabel_moveLeft'
+-/
 
+#print PGame.relabel_moveLeft /-
 @[simp]
-theorem relabel_moveLeft {x : Pgame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
+theorem relabel_moveLeft {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
     (i : x.LeftMoves) : moveLeft (relabel el er) (el.symm i) = x.moveLeft i := by simp
-#align pgame.relabel_move_left Pgame.relabel_moveLeft
+#align pgame.relabel_move_left PGame.relabel_moveLeft
+-/
 
+#print PGame.relabel_moveRight' /-
 @[simp]
-theorem relabel_move_right' {x : Pgame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
+theorem relabel_moveRight' {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
     (j : xr') : moveRight (relabel el er) j = x.moveRight (er j) :=
   rfl
-#align pgame.relabel_move_right' Pgame.relabel_move_right'
+#align pgame.relabel_move_right' PGame.relabel_moveRight'
+-/
 
+#print PGame.relabel_moveRight /-
 @[simp]
-theorem relabel_moveRight {x : Pgame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
+theorem relabel_moveRight {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
     (j : x.RightMoves) : moveRight (relabel el er) (er.symm j) = x.moveRight j := by simp
-#align pgame.relabel_move_right Pgame.relabel_moveRight
+#align pgame.relabel_move_right PGame.relabel_moveRight
+-/
 
+#print PGame.relabelRelabelling /-
 /-- The game obtained by relabelling the next moves is a relabelling of the original game. -/
-def relabelRelabelling {x : Pgame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves) :
+def relabelRelabelling {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves) :
     x ≡r relabel el er :=
   Relabelling.mk' el er (fun i => by simp) fun j => by simp
-#align pgame.relabel_relabelling Pgame.relabelRelabelling
+#align pgame.relabel_relabelling PGame.relabelRelabelling
+-/
 
 /-! ### Negation -/
 
 
+#print PGame.neg /-
 /-- The negation of `{L | R}` is `{-R | -L}`. -/
-def neg : Pgame → Pgame
+def neg : PGame → PGame
   | ⟨l, r, L, R⟩ => ⟨r, l, fun i => neg (R i), fun i => neg (L i)⟩
-#align pgame.neg Pgame.neg
+#align pgame.neg PGame.neg
+-/
 
-instance : Neg Pgame :=
+instance : Neg PGame :=
   ⟨neg⟩
 
+#print PGame.neg_def /-
 @[simp]
 theorem neg_def {xl xr xL xR} : -mk xl xr xL xR = mk xr xl (fun j => -xR j) fun i => -xL i :=
   rfl
-#align pgame.neg_def Pgame.neg_def
+#align pgame.neg_def PGame.neg_def
+-/
 
-instance : InvolutiveNeg Pgame :=
-  { Pgame.hasNeg with
+instance : InvolutiveNeg PGame :=
+  { PGame.hasNeg with
     neg_neg := fun x => by
       induction' x with xl xr xL xR ihL ihR
       simp_rw [neg_def, ihL, ihR]
       exact ⟨rfl, rfl, HEq.rfl, HEq.rfl⟩ }
 
-instance : NegZeroClass Pgame :=
-  { Pgame.hasZero, Pgame.hasNeg with
+instance : NegZeroClass PGame :=
+  { PGame.hasZero, PGame.hasNeg with
     neg_zero := by
       dsimp [Zero.zero, Neg.neg, neg]
       congr <;> funext i <;> cases i }
 
+#print PGame.neg_ofLists /-
 @[simp]
-theorem neg_ofLists (L R : List Pgame) :
+theorem neg_ofLists (L R : List PGame) :
     -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) :=
   by
   simp only [of_lists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and_iff]
@@ -1200,9 +1633,11 @@ theorem neg_ofLists (L R : List Pgame) :
         rintro m n rfl b c rfl
         rfl
       exact this (List.length_map _ _).symm ha
-#align pgame.neg_of_lists Pgame.neg_ofLists
+#align pgame.neg_of_lists PGame.neg_ofLists
+-/
 
-theorem isOption_neg {x y : Pgame} : IsOption x (-y) ↔ IsOption (-x) y :=
+#print PGame.isOption_neg /-
+theorem isOption_neg {x y : PGame} : IsOption x (-y) ↔ IsOption (-x) y :=
   by
   rw [is_option_iff, is_option_iff, or_comm']
   cases y;
@@ -1211,86 +1646,115 @@ theorem isOption_neg {x y : Pgame} : IsOption x (-y) ↔ IsOption (-x) y :=
       intro
       rw [neg_eq_iff_eq_neg]
       rfl
-#align pgame.is_option_neg Pgame.isOption_neg
+#align pgame.is_option_neg PGame.isOption_neg
+-/
 
+#print PGame.isOption_neg_neg /-
 @[simp]
-theorem isOption_neg_neg {x y : Pgame} : IsOption (-x) (-y) ↔ IsOption x y := by
+theorem isOption_neg_neg {x y : PGame} : IsOption (-x) (-y) ↔ IsOption x y := by
   rw [is_option_neg, neg_neg]
-#align pgame.is_option_neg_neg Pgame.isOption_neg_neg
+#align pgame.is_option_neg_neg PGame.isOption_neg_neg
+-/
 
-theorem leftMoves_neg : ∀ x : Pgame, (-x).LeftMoves = x.RightMoves
+#print PGame.leftMoves_neg /-
+theorem leftMoves_neg : ∀ x : PGame, (-x).LeftMoves = x.RightMoves
   | ⟨_, _, _, _⟩ => rfl
-#align pgame.left_moves_neg Pgame.leftMoves_neg
+#align pgame.left_moves_neg PGame.leftMoves_neg
+-/
 
-theorem rightMoves_neg : ∀ x : Pgame, (-x).RightMoves = x.LeftMoves
+#print PGame.rightMoves_neg /-
+theorem rightMoves_neg : ∀ x : PGame, (-x).RightMoves = x.LeftMoves
   | ⟨_, _, _, _⟩ => rfl
-#align pgame.right_moves_neg Pgame.rightMoves_neg
+#align pgame.right_moves_neg PGame.rightMoves_neg
+-/
 
+#print PGame.toLeftMovesNeg /-
 /-- Turns a right move for `x` into a left move for `-x` and vice versa.
 
 Even though these types are the same (not definitionally so), this is the preferred way to convert
 between them. -/
-def toLeftMovesNeg {x : Pgame} : x.RightMoves ≃ (-x).LeftMoves :=
+def toLeftMovesNeg {x : PGame} : x.RightMoves ≃ (-x).LeftMoves :=
   Equiv.cast (leftMoves_neg x).symm
-#align pgame.to_left_moves_neg Pgame.toLeftMovesNeg
+#align pgame.to_left_moves_neg PGame.toLeftMovesNeg
+-/
 
+#print PGame.toRightMovesNeg /-
 /-- Turns a left move for `x` into a right move for `-x` and vice versa.
 
 Even though these types are the same (not definitionally so), this is the preferred way to convert
 between them. -/
-def toRightMovesNeg {x : Pgame} : x.LeftMoves ≃ (-x).RightMoves :=
+def toRightMovesNeg {x : PGame} : x.LeftMoves ≃ (-x).RightMoves :=
   Equiv.cast (rightMoves_neg x).symm
-#align pgame.to_right_moves_neg Pgame.toRightMovesNeg
+#align pgame.to_right_moves_neg PGame.toRightMovesNeg
+-/
 
-theorem moveLeft_neg {x : Pgame} (i) : (-x).moveLeft (toLeftMovesNeg i) = -x.moveRight i :=
+#print PGame.moveLeft_neg /-
+theorem moveLeft_neg {x : PGame} (i) : (-x).moveLeft (toLeftMovesNeg i) = -x.moveRight i :=
   by
   cases x
   rfl
-#align pgame.move_left_neg Pgame.moveLeft_neg
+#align pgame.move_left_neg PGame.moveLeft_neg
+-/
 
+#print PGame.moveLeft_neg' /-
 @[simp]
-theorem moveLeft_neg' {x : Pgame} (i) : (-x).moveLeft i = -x.moveRight (toLeftMovesNeg.symm i) :=
+theorem moveLeft_neg' {x : PGame} (i) : (-x).moveLeft i = -x.moveRight (toLeftMovesNeg.symm i) :=
   by
   cases x
   rfl
-#align pgame.move_left_neg' Pgame.moveLeft_neg'
+#align pgame.move_left_neg' PGame.moveLeft_neg'
+-/
 
-theorem moveRight_neg {x : Pgame} (i) : (-x).moveRight (toRightMovesNeg i) = -x.moveLeft i :=
+#print PGame.moveRight_neg /-
+theorem moveRight_neg {x : PGame} (i) : (-x).moveRight (toRightMovesNeg i) = -x.moveLeft i :=
   by
   cases x
   rfl
-#align pgame.move_right_neg Pgame.moveRight_neg
+#align pgame.move_right_neg PGame.moveRight_neg
+-/
 
+#print PGame.moveRight_neg' /-
 @[simp]
-theorem moveRight_neg' {x : Pgame} (i) : (-x).moveRight i = -x.moveLeft (toRightMovesNeg.symm i) :=
+theorem moveRight_neg' {x : PGame} (i) : (-x).moveRight i = -x.moveLeft (toRightMovesNeg.symm i) :=
   by
   cases x
   rfl
-#align pgame.move_right_neg' Pgame.moveRight_neg'
+#align pgame.move_right_neg' PGame.moveRight_neg'
+-/
 
-theorem moveLeft_neg_symm {x : Pgame} (i) :
+#print PGame.moveLeft_neg_symm /-
+theorem moveLeft_neg_symm {x : PGame} (i) :
     x.moveLeft (toRightMovesNeg.symm i) = -(-x).moveRight i := by simp
-#align pgame.move_left_neg_symm Pgame.moveLeft_neg_symm
+#align pgame.move_left_neg_symm PGame.moveLeft_neg_symm
+-/
 
-theorem moveLeft_neg_symm' {x : Pgame} (i) : x.moveLeft i = -(-x).moveRight (toRightMovesNeg i) :=
+#print PGame.moveLeft_neg_symm' /-
+theorem moveLeft_neg_symm' {x : PGame} (i) : x.moveLeft i = -(-x).moveRight (toRightMovesNeg i) :=
   by simp
-#align pgame.move_left_neg_symm' Pgame.moveLeft_neg_symm'
+#align pgame.move_left_neg_symm' PGame.moveLeft_neg_symm'
+-/
 
-theorem moveRight_neg_symm {x : Pgame} (i) :
+#print PGame.moveRight_neg_symm /-
+theorem moveRight_neg_symm {x : PGame} (i) :
     x.moveRight (toLeftMovesNeg.symm i) = -(-x).moveLeft i := by simp
-#align pgame.move_right_neg_symm Pgame.moveRight_neg_symm
+#align pgame.move_right_neg_symm PGame.moveRight_neg_symm
+-/
 
-theorem moveRight_neg_symm' {x : Pgame} (i) : x.moveRight i = -(-x).moveLeft (toLeftMovesNeg i) :=
+#print PGame.moveRight_neg_symm' /-
+theorem moveRight_neg_symm' {x : PGame} (i) : x.moveRight i = -(-x).moveLeft (toLeftMovesNeg i) :=
   by simp
-#align pgame.move_right_neg_symm' Pgame.moveRight_neg_symm'
+#align pgame.move_right_neg_symm' PGame.moveRight_neg_symm'
+-/
 
+#print PGame.Relabelling.negCongr /-
 /-- If `x` has the same moves as `y`, then `-x` has the sames moves as `-y`. -/
-def Relabelling.negCongr : ∀ {x y : Pgame}, x ≡r y → -x ≡r -y
+def Relabelling.negCongr : ∀ {x y : PGame}, x ≡r y → -x ≡r -y
   | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩, ⟨L, R, hL, hR⟩ =>
     ⟨R, L, fun j => (hR j).negCongr, fun i => (hL i).negCongr⟩
-#align pgame.relabelling.neg_congr Pgame.Relabelling.negCongr
+#align pgame.relabelling.neg_congr PGame.Relabelling.negCongr
+-/
 
-private theorem neg_le_lf_neg_iff : ∀ {x y : Pgame.{u}}, (-y ≤ -x ↔ x ≤ y) ∧ (-y ⧏ -x ↔ x ⧏ y)
+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]
@@ -1301,102 +1765,168 @@ private theorem neg_le_lf_neg_iff : ∀ {x y : Pgame.{u}}, (-y ≤ -x ↔ x ≤
       apply or_congr <;> exact exists_congr fun _ => neg_le_lf_neg_iff.1decreasing_by pgame_wf_tac
 #align pgame.neg_le_lf_neg_iff pgame.neg_le_lf_neg_iff
 
+#print PGame.neg_le_neg_iff /-
 @[simp]
-theorem neg_le_neg_iff {x y : Pgame} : -y ≤ -x ↔ x ≤ y :=
+theorem neg_le_neg_iff {x y : PGame} : -y ≤ -x ↔ x ≤ y :=
   neg_le_lf_neg_iff.1
-#align pgame.neg_le_neg_iff Pgame.neg_le_neg_iff
+#align pgame.neg_le_neg_iff PGame.neg_le_neg_iff
+-/
 
+#print PGame.neg_lf_neg_iff /-
 @[simp]
-theorem neg_lf_neg_iff {x y : Pgame} : -y ⧏ -x ↔ x ⧏ y :=
+theorem neg_lf_neg_iff {x y : PGame} : -y ⧏ -x ↔ x ⧏ y :=
   neg_le_lf_neg_iff.2
-#align pgame.neg_lf_neg_iff Pgame.neg_lf_neg_iff
+#align pgame.neg_lf_neg_iff PGame.neg_lf_neg_iff
+-/
 
+/- warning: pgame.neg_lt_neg_iff -> PGame.neg_lt_neg_iff is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) (Neg.neg.{succ u1} PGame.{u1} PGame.hasNeg.{u1} y) (Neg.neg.{succ u1} PGame.{u1} PGame.hasNeg.{u1} x)) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y)
+but is expected to have type
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) (Neg.neg.{succ u1} PGame.{u1} PGame.instNegPGame.{u1} y) (Neg.neg.{succ u1} PGame.{u1} PGame.instNegPGame.{u1} x)) (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y)
+Case conversion may be inaccurate. Consider using '#align pgame.neg_lt_neg_iff PGame.neg_lt_neg_iffₓ'. -/
 @[simp]
-theorem neg_lt_neg_iff {x y : Pgame} : -y < -x ↔ x < y := by
+theorem neg_lt_neg_iff {x y : PGame} : -y < -x ↔ x < y := by
   rw [lt_iff_le_and_lf, lt_iff_le_and_lf, neg_le_neg_iff, neg_lf_neg_iff]
-#align pgame.neg_lt_neg_iff Pgame.neg_lt_neg_iff
+#align pgame.neg_lt_neg_iff PGame.neg_lt_neg_iff
 
+#print PGame.neg_equiv_neg_iff /-
 @[simp]
-theorem neg_equiv_neg_iff {x y : Pgame} : (-x ≈ -y) ↔ (x ≈ y) := by
+theorem neg_equiv_neg_iff {x y : PGame} : (-x ≈ -y) ↔ (x ≈ y) := by
   rw [Equiv, Equiv, neg_le_neg_iff, neg_le_neg_iff, and_comm]
-#align pgame.neg_equiv_neg_iff Pgame.neg_equiv_neg_iff
+#align pgame.neg_equiv_neg_iff PGame.neg_equiv_neg_iff
+-/
 
+#print PGame.neg_fuzzy_neg_iff /-
 @[simp]
-theorem neg_fuzzy_neg_iff {x y : Pgame} : -x ‖ -y ↔ x ‖ y := by
+theorem neg_fuzzy_neg_iff {x y : PGame} : -x ‖ -y ↔ x ‖ y := by
   rw [fuzzy, fuzzy, neg_lf_neg_iff, neg_lf_neg_iff, and_comm]
-#align pgame.neg_fuzzy_neg_iff Pgame.neg_fuzzy_neg_iff
-
-theorem neg_le_iff {x y : Pgame} : -y ≤ x ↔ -x ≤ y := by rw [← neg_neg x, neg_le_neg_iff, neg_neg]
-#align pgame.neg_le_iff Pgame.neg_le_iff
+#align pgame.neg_fuzzy_neg_iff PGame.neg_fuzzy_neg_iff
+-/
 
-theorem neg_lf_iff {x y : Pgame} : -y ⧏ x ↔ -x ⧏ y := by rw [← neg_neg x, neg_lf_neg_iff, neg_neg]
-#align pgame.neg_lf_iff Pgame.neg_lf_iff
+#print PGame.neg_le_iff /-
+theorem neg_le_iff {x y : PGame} : -y ≤ x ↔ -x ≤ y := by rw [← neg_neg x, neg_le_neg_iff, neg_neg]
+#align pgame.neg_le_iff PGame.neg_le_iff
+-/
 
-theorem neg_lt_iff {x y : Pgame} : -y < x ↔ -x < y := by rw [← neg_neg x, neg_lt_neg_iff, neg_neg]
-#align pgame.neg_lt_iff Pgame.neg_lt_iff
+#print PGame.neg_lf_iff /-
+theorem neg_lf_iff {x y : PGame} : -y ⧏ x ↔ -x ⧏ y := by rw [← neg_neg x, neg_lf_neg_iff, neg_neg]
+#align pgame.neg_lf_iff PGame.neg_lf_iff
+-/
 
-theorem neg_equiv_iff {x y : Pgame} : (-x ≈ y) ↔ (x ≈ -y) := by
+/- warning: pgame.neg_lt_iff -> PGame.neg_lt_iff is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) (Neg.neg.{succ u1} PGame.{u1} PGame.hasNeg.{u1} y) x) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) (Neg.neg.{succ u1} PGame.{u1} PGame.hasNeg.{u1} x) y)
+but is expected to have type
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) (Neg.neg.{succ u1} PGame.{u1} PGame.instNegPGame.{u1} y) x) (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) (Neg.neg.{succ u1} PGame.{u1} PGame.instNegPGame.{u1} x) y)
+Case conversion may be inaccurate. Consider using '#align pgame.neg_lt_iff PGame.neg_lt_iffₓ'. -/
+theorem neg_lt_iff {x y : PGame} : -y < x ↔ -x < y := by rw [← neg_neg x, neg_lt_neg_iff, neg_neg]
+#align pgame.neg_lt_iff PGame.neg_lt_iff
+
+#print PGame.neg_equiv_iff /-
+theorem neg_equiv_iff {x y : PGame} : (-x ≈ y) ↔ (x ≈ -y) := by
   rw [← neg_neg y, neg_equiv_neg_iff, neg_neg]
-#align pgame.neg_equiv_iff Pgame.neg_equiv_iff
+#align pgame.neg_equiv_iff PGame.neg_equiv_iff
+-/
 
-theorem neg_fuzzy_iff {x y : Pgame} : -x ‖ y ↔ x ‖ -y := by
+#print PGame.neg_fuzzy_iff /-
+theorem neg_fuzzy_iff {x y : PGame} : -x ‖ y ↔ x ‖ -y := by
   rw [← neg_neg y, neg_fuzzy_neg_iff, neg_neg]
-#align pgame.neg_fuzzy_iff Pgame.neg_fuzzy_iff
+#align pgame.neg_fuzzy_iff PGame.neg_fuzzy_iff
+-/
 
-theorem le_neg_iff {x y : Pgame} : y ≤ -x ↔ x ≤ -y := by rw [← neg_neg x, neg_le_neg_iff, neg_neg]
-#align pgame.le_neg_iff Pgame.le_neg_iff
+#print PGame.le_neg_iff /-
+theorem le_neg_iff {x y : PGame} : y ≤ -x ↔ x ≤ -y := by rw [← neg_neg x, neg_le_neg_iff, neg_neg]
+#align pgame.le_neg_iff PGame.le_neg_iff
+-/
 
-theorem lf_neg_iff {x y : Pgame} : y ⧏ -x ↔ x ⧏ -y := by rw [← neg_neg x, neg_lf_neg_iff, neg_neg]
-#align pgame.lf_neg_iff Pgame.lf_neg_iff
+#print PGame.lf_neg_iff /-
+theorem lf_neg_iff {x y : PGame} : y ⧏ -x ↔ x ⧏ -y := by rw [← neg_neg x, neg_lf_neg_iff, neg_neg]
+#align pgame.lf_neg_iff PGame.lf_neg_iff
+-/
 
-theorem lt_neg_iff {x y : Pgame} : y < -x ↔ x < -y := by rw [← neg_neg x, neg_lt_neg_iff, neg_neg]
-#align pgame.lt_neg_iff Pgame.lt_neg_iff
+/- warning: pgame.lt_neg_iff -> PGame.lt_neg_iff is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) y (Neg.neg.{succ u1} PGame.{u1} PGame.hasNeg.{u1} x)) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x (Neg.neg.{succ u1} PGame.{u1} PGame.hasNeg.{u1} y))
+but is expected to have type
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) y (Neg.neg.{succ u1} PGame.{u1} PGame.instNegPGame.{u1} x)) (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x (Neg.neg.{succ u1} PGame.{u1} PGame.instNegPGame.{u1} y))
+Case conversion may be inaccurate. Consider using '#align pgame.lt_neg_iff PGame.lt_neg_iffₓ'. -/
+theorem lt_neg_iff {x y : PGame} : y < -x ↔ x < -y := by rw [← neg_neg x, neg_lt_neg_iff, neg_neg]
+#align pgame.lt_neg_iff PGame.lt_neg_iff
 
+#print PGame.neg_le_zero_iff /-
 @[simp]
-theorem neg_le_zero_iff {x : Pgame} : -x ≤ 0 ↔ 0 ≤ x := by rw [neg_le_iff, neg_zero]
-#align pgame.neg_le_zero_iff Pgame.neg_le_zero_iff
+theorem neg_le_zero_iff {x : PGame} : -x ≤ 0 ↔ 0 ≤ x := by rw [neg_le_iff, neg_zero]
+#align pgame.neg_le_zero_iff PGame.neg_le_zero_iff
+-/
 
+#print PGame.zero_le_neg_iff /-
 @[simp]
-theorem zero_le_neg_iff {x : Pgame} : 0 ≤ -x ↔ x ≤ 0 := by rw [le_neg_iff, neg_zero]
-#align pgame.zero_le_neg_iff Pgame.zero_le_neg_iff
+theorem zero_le_neg_iff {x : PGame} : 0 ≤ -x ↔ x ≤ 0 := by rw [le_neg_iff, neg_zero]
+#align pgame.zero_le_neg_iff PGame.zero_le_neg_iff
+-/
 
+#print PGame.neg_lf_zero_iff /-
 @[simp]
-theorem neg_lf_zero_iff {x : Pgame} : -x ⧏ 0 ↔ 0 ⧏ x := by rw [neg_lf_iff, neg_zero]
-#align pgame.neg_lf_zero_iff Pgame.neg_lf_zero_iff
+theorem neg_lf_zero_iff {x : PGame} : -x ⧏ 0 ↔ 0 ⧏ x := by rw [neg_lf_iff, neg_zero]
+#align pgame.neg_lf_zero_iff PGame.neg_lf_zero_iff
+-/
 
+#print PGame.zero_lf_neg_iff /-
 @[simp]
-theorem zero_lf_neg_iff {x : Pgame} : 0 ⧏ -x ↔ x ⧏ 0 := by rw [lf_neg_iff, neg_zero]
-#align pgame.zero_lf_neg_iff Pgame.zero_lf_neg_iff
+theorem zero_lf_neg_iff {x : PGame} : 0 ⧏ -x ↔ x ⧏ 0 := by rw [lf_neg_iff, neg_zero]
+#align pgame.zero_lf_neg_iff PGame.zero_lf_neg_iff
+-/
 
+/- warning: pgame.neg_lt_zero_iff -> PGame.neg_lt_zero_iff is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) (Neg.neg.{succ u1} PGame.{u1} PGame.hasNeg.{u1} x) (OfNat.ofNat.{succ u1} PGame.{u1} 0 (OfNat.mk.{succ u1} PGame.{u1} 0 (Zero.zero.{succ u1} PGame.{u1} PGame.hasZero.{u1})))) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) (OfNat.ofNat.{succ u1} PGame.{u1} 0 (OfNat.mk.{succ u1} PGame.{u1} 0 (Zero.zero.{succ u1} PGame.{u1} PGame.hasZero.{u1}))) x)
+but is expected to have type
+  forall {x : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) (Neg.neg.{succ u1} PGame.{u1} PGame.instNegPGame.{u1} x) (OfNat.ofNat.{succ u1} PGame.{u1} 0 (Zero.toOfNat0.{succ u1} PGame.{u1} PGame.instZeroPGame.{u1}))) (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) (OfNat.ofNat.{succ u1} PGame.{u1} 0 (Zero.toOfNat0.{succ u1} PGame.{u1} PGame.instZeroPGame.{u1})) x)
+Case conversion may be inaccurate. Consider using '#align pgame.neg_lt_zero_iff PGame.neg_lt_zero_iffₓ'. -/
 @[simp]
-theorem neg_lt_zero_iff {x : Pgame} : -x < 0 ↔ 0 < x := by rw [neg_lt_iff, neg_zero]
-#align pgame.neg_lt_zero_iff Pgame.neg_lt_zero_iff
-
+theorem neg_lt_zero_iff {x : PGame} : -x < 0 ↔ 0 < x := by rw [neg_lt_iff, neg_zero]
+#align pgame.neg_lt_zero_iff PGame.neg_lt_zero_iff
+
+/- warning: pgame.zero_lt_neg_iff -> PGame.zero_lt_neg_iff is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) (OfNat.ofNat.{succ u1} PGame.{u1} 0 (OfNat.mk.{succ u1} PGame.{u1} 0 (Zero.zero.{succ u1} PGame.{u1} PGame.hasZero.{u1}))) (Neg.neg.{succ u1} PGame.{u1} PGame.hasNeg.{u1} x)) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x (OfNat.ofNat.{succ u1} PGame.{u1} 0 (OfNat.mk.{succ u1} PGame.{u1} 0 (Zero.zero.{succ u1} PGame.{u1} PGame.hasZero.{u1}))))
+but is expected to have type
+  forall {x : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) (OfNat.ofNat.{succ u1} PGame.{u1} 0 (Zero.toOfNat0.{succ u1} PGame.{u1} PGame.instZeroPGame.{u1})) (Neg.neg.{succ u1} PGame.{u1} PGame.instNegPGame.{u1} x)) (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x (OfNat.ofNat.{succ u1} PGame.{u1} 0 (Zero.toOfNat0.{succ u1} PGame.{u1} PGame.instZeroPGame.{u1})))
+Case conversion may be inaccurate. Consider using '#align pgame.zero_lt_neg_iff PGame.zero_lt_neg_iffₓ'. -/
 @[simp]
-theorem zero_lt_neg_iff {x : Pgame} : 0 < -x ↔ x < 0 := by rw [lt_neg_iff, neg_zero]
-#align pgame.zero_lt_neg_iff Pgame.zero_lt_neg_iff
+theorem zero_lt_neg_iff {x : PGame} : 0 < -x ↔ x < 0 := by rw [lt_neg_iff, neg_zero]
+#align pgame.zero_lt_neg_iff PGame.zero_lt_neg_iff
 
+#print PGame.neg_equiv_zero_iff /-
 @[simp]
-theorem neg_equiv_zero_iff {x : Pgame} : (-x ≈ 0) ↔ (x ≈ 0) := by rw [neg_equiv_iff, neg_zero]
-#align pgame.neg_equiv_zero_iff Pgame.neg_equiv_zero_iff
+theorem neg_equiv_zero_iff {x : PGame} : (-x ≈ 0) ↔ (x ≈ 0) := by rw [neg_equiv_iff, neg_zero]
+#align pgame.neg_equiv_zero_iff PGame.neg_equiv_zero_iff
+-/
 
+#print PGame.neg_fuzzy_zero_iff /-
 @[simp]
-theorem neg_fuzzy_zero_iff {x : Pgame} : -x ‖ 0 ↔ x ‖ 0 := by rw [neg_fuzzy_iff, neg_zero]
-#align pgame.neg_fuzzy_zero_iff Pgame.neg_fuzzy_zero_iff
+theorem neg_fuzzy_zero_iff {x : PGame} : -x ‖ 0 ↔ x ‖ 0 := by rw [neg_fuzzy_iff, neg_zero]
+#align pgame.neg_fuzzy_zero_iff PGame.neg_fuzzy_zero_iff
+-/
 
+#print PGame.zero_equiv_neg_iff /-
 @[simp]
-theorem zero_equiv_neg_iff {x : Pgame} : (0 ≈ -x) ↔ (0 ≈ x) := by rw [← neg_equiv_iff, neg_zero]
-#align pgame.zero_equiv_neg_iff Pgame.zero_equiv_neg_iff
+theorem zero_equiv_neg_iff {x : PGame} : (0 ≈ -x) ↔ (0 ≈ x) := by rw [← neg_equiv_iff, neg_zero]
+#align pgame.zero_equiv_neg_iff PGame.zero_equiv_neg_iff
+-/
 
+#print PGame.zero_fuzzy_neg_iff /-
 @[simp]
-theorem zero_fuzzy_neg_iff {x : Pgame} : 0 ‖ -x ↔ 0 ‖ x := by rw [← neg_fuzzy_iff, neg_zero]
-#align pgame.zero_fuzzy_neg_iff Pgame.zero_fuzzy_neg_iff
+theorem zero_fuzzy_neg_iff {x : PGame} : 0 ‖ -x ↔ 0 ‖ x := by rw [← neg_fuzzy_iff, neg_zero]
+#align pgame.zero_fuzzy_neg_iff PGame.zero_fuzzy_neg_iff
+-/
 
 /-! ### Addition and subtraction -/
 
 
 /-- The sum of `x = {xL | xR}` and `y = {yL | yR}` is `{xL + y, x + yL | xR + y, x + yR}`. -/
-instance : Add Pgame.{u} :=
+instance : Add PGame.{u} :=
   ⟨fun x y => by
     induction' x with xl xr xL xR IHxl IHxr generalizing y
     induction' y with yl yr yL yR IHyl IHyr
@@ -1408,171 +1938,216 @@ instance : Add Pgame.{u} :=
     · exact IHyr⟩
 
 /-- The pre-game `((0+1)+⋯)+1`. -/
-instance : NatCast Pgame :=
+instance : NatCast PGame :=
   ⟨Nat.unaryCast⟩
 
+#print PGame.nat_succ /-
 @[simp]
-protected theorem nat_succ (n : ℕ) : ((n + 1 : ℕ) : Pgame) = n + 1 :=
+protected theorem nat_succ (n : ℕ) : ((n + 1 : ℕ) : PGame) = n + 1 :=
   rfl
-#align pgame.nat_succ Pgame.nat_succ
+#align pgame.nat_succ PGame.nat_succ
+-/
 
-instance isEmpty_leftMoves_add (x y : Pgame.{u}) [IsEmpty x.LeftMoves] [IsEmpty y.LeftMoves] :
+#print PGame.isEmpty_leftMoves_add /-
+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 ⟨_, _⟩
   assumption'
-#align pgame.is_empty_left_moves_add Pgame.isEmpty_leftMoves_add
+#align pgame.is_empty_left_moves_add PGame.isEmpty_leftMoves_add
+-/
 
-instance isEmpty_rightMoves_add (x y : Pgame.{u}) [IsEmpty x.RightMoves] [IsEmpty y.RightMoves] :
+#print PGame.isEmpty_rightMoves_add /-
+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 ⟨_, _⟩
   assumption'
-#align pgame.is_empty_right_moves_add Pgame.isEmpty_rightMoves_add
+#align pgame.is_empty_right_moves_add PGame.isEmpty_rightMoves_add
+-/
 
+#print PGame.addZeroRelabelling /-
 /-- `x + 0` has exactly the same moves as `x`. -/
-def addZeroRelabelling : ∀ x : Pgame.{u}, x + 0 ≡r x
+def addZeroRelabelling : ∀ x : PGame.{u}, x + 0 ≡r x
   | ⟨xl, xr, xL, xR⟩ => by
     refine' ⟨Equiv.sumEmpty xl PEmpty, Equiv.sumEmpty xr PEmpty, _, _⟩ <;> rintro (⟨i⟩ | ⟨⟨⟩⟩) <;>
       apply add_zero_relabelling
-#align pgame.add_zero_relabelling Pgame.addZeroRelabelling
+#align pgame.add_zero_relabelling PGame.addZeroRelabelling
+-/
 
+#print PGame.add_zero_equiv /-
 /-- `x + 0` is equivalent to `x`. -/
-theorem add_zero_equiv (x : Pgame.{u}) : x + 0 ≈ x :=
+theorem add_zero_equiv (x : PGame.{u}) : x + 0 ≈ x :=
   (addZeroRelabelling x).Equiv
-#align pgame.add_zero_equiv Pgame.add_zero_equiv
+#align pgame.add_zero_equiv PGame.add_zero_equiv
+-/
 
+#print PGame.zeroAddRelabelling /-
 /-- `0 + x` has exactly the same moves as `x`. -/
-def zeroAddRelabelling : ∀ x : Pgame.{u}, 0 + x ≡r x
+def zeroAddRelabelling : ∀ x : PGame.{u}, 0 + x ≡r x
   | ⟨xl, xr, xL, xR⟩ => by
     refine' ⟨Equiv.emptySum PEmpty xl, Equiv.emptySum PEmpty xr, _, _⟩ <;> rintro (⟨⟨⟩⟩ | ⟨i⟩) <;>
       apply zero_add_relabelling
-#align pgame.zero_add_relabelling Pgame.zeroAddRelabelling
+#align pgame.zero_add_relabelling PGame.zeroAddRelabelling
+-/
 
+#print PGame.zero_add_equiv /-
 /-- `0 + x` is equivalent to `x`. -/
-theorem zero_add_equiv (x : Pgame.{u}) : 0 + x ≈ x :=
+theorem zero_add_equiv (x : PGame.{u}) : 0 + x ≈ x :=
   (zeroAddRelabelling x).Equiv
-#align pgame.zero_add_equiv Pgame.zero_add_equiv
+#align pgame.zero_add_equiv PGame.zero_add_equiv
+-/
 
-theorem leftMoves_add : ∀ x y : Pgame.{u}, (x + y).LeftMoves = Sum x.LeftMoves y.LeftMoves
+#print PGame.leftMoves_add /-
+theorem leftMoves_add : ∀ x y : PGame.{u}, (x + y).LeftMoves = Sum x.LeftMoves y.LeftMoves
   | ⟨_, _, _, _⟩, ⟨_, _, _, _⟩ => rfl
-#align pgame.left_moves_add Pgame.leftMoves_add
+#align pgame.left_moves_add PGame.leftMoves_add
+-/
 
-theorem rightMoves_add : ∀ x y : Pgame.{u}, (x + y).RightMoves = Sum x.RightMoves y.RightMoves
+#print PGame.rightMoves_add /-
+theorem rightMoves_add : ∀ x y : PGame.{u}, (x + y).RightMoves = Sum x.RightMoves y.RightMoves
   | ⟨_, _, _, _⟩, ⟨_, _, _, _⟩ => rfl
-#align pgame.right_moves_add Pgame.rightMoves_add
+#align pgame.right_moves_add PGame.rightMoves_add
+-/
 
+#print PGame.toLeftMovesAdd /-
 /-- Converts a left move for `x` or `y` into a left move for `x + y` and vice versa.
 
 Even though these types are the same (not definitionally so), this is the preferred way to convert
 between them. -/
-def toLeftMovesAdd {x y : Pgame} : Sum x.LeftMoves y.LeftMoves ≃ (x + y).LeftMoves :=
+def toLeftMovesAdd {x y : PGame} : Sum x.LeftMoves y.LeftMoves ≃ (x + y).LeftMoves :=
   Equiv.cast (leftMoves_add x y).symm
-#align pgame.to_left_moves_add Pgame.toLeftMovesAdd
+#align pgame.to_left_moves_add PGame.toLeftMovesAdd
+-/
 
+#print PGame.toRightMovesAdd /-
 /-- Converts a right move for `x` or `y` into a right move for `x + y` and vice versa.
 
 Even though these types are the same (not definitionally so), this is the preferred way to convert
 between them. -/
-def toRightMovesAdd {x y : Pgame} : Sum x.RightMoves y.RightMoves ≃ (x + y).RightMoves :=
+def toRightMovesAdd {x y : PGame} : Sum x.RightMoves y.RightMoves ≃ (x + y).RightMoves :=
   Equiv.cast (rightMoves_add x y).symm
-#align pgame.to_right_moves_add Pgame.toRightMovesAdd
+#align pgame.to_right_moves_add PGame.toRightMovesAdd
+-/
 
+#print PGame.mk_add_moveLeft_inl /-
 @[simp]
 theorem mk_add_moveLeft_inl {xl xr yl yr} {xL xR yL yR} {i} :
     (mk xl xr xL xR + mk yl yr yL yR).moveLeft (Sum.inl i) =
       (mk xl xr xL xR).moveLeft i + mk yl yr yL yR :=
   rfl
-#align pgame.mk_add_move_left_inl Pgame.mk_add_moveLeft_inl
+#align pgame.mk_add_move_left_inl PGame.mk_add_moveLeft_inl
+-/
 
+#print PGame.add_moveLeft_inl /-
 @[simp]
-theorem add_moveLeft_inl {x : Pgame} (y : Pgame) (i) :
+theorem add_moveLeft_inl {x : PGame} (y : PGame) (i) :
     (x + y).moveLeft (toLeftMovesAdd (Sum.inl i)) = x.moveLeft i + y :=
   by
   cases x
   cases y
   rfl
-#align pgame.add_move_left_inl Pgame.add_moveLeft_inl
+#align pgame.add_move_left_inl PGame.add_moveLeft_inl
+-/
 
+#print PGame.mk_add_moveRight_inl /-
 @[simp]
 theorem mk_add_moveRight_inl {xl xr yl yr} {xL xR yL yR} {i} :
     (mk xl xr xL xR + mk yl yr yL yR).moveRight (Sum.inl i) =
       (mk xl xr xL xR).moveRight i + mk yl yr yL yR :=
   rfl
-#align pgame.mk_add_move_right_inl Pgame.mk_add_moveRight_inl
+#align pgame.mk_add_move_right_inl PGame.mk_add_moveRight_inl
+-/
 
+#print PGame.add_moveRight_inl /-
 @[simp]
-theorem add_moveRight_inl {x : Pgame} (y : Pgame) (i) :
+theorem add_moveRight_inl {x : PGame} (y : PGame) (i) :
     (x + y).moveRight (toRightMovesAdd (Sum.inl i)) = x.moveRight i + y :=
   by
   cases x
   cases y
   rfl
-#align pgame.add_move_right_inl Pgame.add_moveRight_inl
+#align pgame.add_move_right_inl PGame.add_moveRight_inl
+-/
 
+#print PGame.mk_add_moveLeft_inr /-
 @[simp]
 theorem mk_add_moveLeft_inr {xl xr yl yr} {xL xR yL yR} {i} :
     (mk xl xr xL xR + mk yl yr yL yR).moveLeft (Sum.inr i) =
       mk xl xr xL xR + (mk yl yr yL yR).moveLeft i :=
   rfl
-#align pgame.mk_add_move_left_inr Pgame.mk_add_moveLeft_inr
+#align pgame.mk_add_move_left_inr PGame.mk_add_moveLeft_inr
+-/
 
+#print PGame.add_moveLeft_inr /-
 @[simp]
-theorem add_moveLeft_inr (x : Pgame) {y : Pgame} (i) :
+theorem add_moveLeft_inr (x : PGame) {y : PGame} (i) :
     (x + y).moveLeft (toLeftMovesAdd (Sum.inr i)) = x + y.moveLeft i :=
   by
   cases x
   cases y
   rfl
-#align pgame.add_move_left_inr Pgame.add_moveLeft_inr
+#align pgame.add_move_left_inr PGame.add_moveLeft_inr
+-/
 
+#print PGame.mk_add_moveRight_inr /-
 @[simp]
 theorem mk_add_moveRight_inr {xl xr yl yr} {xL xR yL yR} {i} :
     (mk xl xr xL xR + mk yl yr yL yR).moveRight (Sum.inr i) =
       mk xl xr xL xR + (mk yl yr yL yR).moveRight i :=
   rfl
-#align pgame.mk_add_move_right_inr Pgame.mk_add_moveRight_inr
+#align pgame.mk_add_move_right_inr PGame.mk_add_moveRight_inr
+-/
 
+#print PGame.add_moveRight_inr /-
 @[simp]
-theorem add_moveRight_inr (x : Pgame) {y : Pgame} (i) :
+theorem add_moveRight_inr (x : PGame) {y : PGame} (i) :
     (x + y).moveRight (toRightMovesAdd (Sum.inr i)) = x + y.moveRight i :=
   by
   cases x
   cases y
   rfl
-#align pgame.add_move_right_inr Pgame.add_moveRight_inr
+#align pgame.add_move_right_inr PGame.add_moveRight_inr
+-/
 
-theorem leftMoves_add_cases {x y : Pgame} (k) {P : (x + y).LeftMoves → Prop}
+#print PGame.leftMoves_add_cases /-
+theorem leftMoves_add_cases {x y : PGame} (k) {P : (x + y).LeftMoves → Prop}
     (hl : ∀ i, P <| toLeftMovesAdd (Sum.inl i)) (hr : ∀ i, P <| toLeftMovesAdd (Sum.inr i)) : P k :=
   by
   rw [← to_left_moves_add.apply_symm_apply k]
   cases' to_left_moves_add.symm k with i i
   · exact hl i
   · exact hr i
-#align pgame.left_moves_add_cases Pgame.leftMoves_add_cases
+#align pgame.left_moves_add_cases PGame.leftMoves_add_cases
+-/
 
-theorem rightMoves_add_cases {x y : Pgame} (k) {P : (x + y).RightMoves → Prop}
+#print PGame.rightMoves_add_cases /-
+theorem rightMoves_add_cases {x y : PGame} (k) {P : (x + y).RightMoves → Prop}
     (hl : ∀ j, P <| toRightMovesAdd (Sum.inl j)) (hr : ∀ j, P <| toRightMovesAdd (Sum.inr j)) :
     P k := by
   rw [← to_right_moves_add.apply_symm_apply k]
   cases' to_right_moves_add.symm k with i i
   · exact hl i
   · exact hr i
-#align pgame.right_moves_add_cases Pgame.rightMoves_add_cases
+#align pgame.right_moves_add_cases PGame.rightMoves_add_cases
+-/
 
+#print PGame.isEmpty_nat_rightMoves /-
 instance isEmpty_nat_rightMoves : ∀ n : ℕ, IsEmpty (RightMoves n)
   | 0 => PEmpty.isEmpty
   | n + 1 => by
     haveI := is_empty_nat_right_moves n
-    rw [Pgame.nat_succ, right_moves_add]
+    rw [PGame.nat_succ, right_moves_add]
     infer_instance
-#align pgame.is_empty_nat_right_moves Pgame.isEmpty_nat_rightMoves
+#align pgame.is_empty_nat_right_moves PGame.isEmpty_nat_rightMoves
+-/
 
+#print PGame.Relabelling.addCongr /-
 /-- If `w` has the same moves as `x` and `y` has the same moves as `z`,
 then `w + y` has the same moves as `x + z`. -/
-def Relabelling.addCongr : ∀ {w x y z : Pgame.{u}}, w ≡r x → y ≡r z → w + y ≡r x + z
+def Relabelling.addCongr : ∀ {w x y z : PGame.{u}}, w ≡r x → y ≡r z → w + y ≡r x + z
   | ⟨wl, wr, wL, wR⟩, ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩, ⟨zl, zr, zL, zR⟩, ⟨L₁, R₁, hL₁, hR₁⟩,
     ⟨L₂, R₂, hL₂, hR₂⟩ =>
     by
@@ -1583,24 +2158,30 @@ def Relabelling.addCongr : ∀ {w x y z : Pgame.{u}}, w ≡r x → y ≡r z →
     · exact Hwx.add_congr (hL₂ j)
     · exact (hR₁ i).addCongr Hyz
     · exact Hwx.add_congr (hR₂ j)decreasing_by pgame_wf_tac
-#align pgame.relabelling.add_congr Pgame.Relabelling.addCongr
+#align pgame.relabelling.add_congr PGame.Relabelling.addCongr
+-/
 
-instance : Sub Pgame :=
+instance : Sub PGame :=
   ⟨fun x y => x + -y⟩
 
+#print PGame.sub_zero /-
 @[simp]
-theorem sub_zero (x : Pgame) : x - 0 = x + 0 :=
+theorem sub_zero (x : PGame) : x - 0 = x + 0 :=
   show x + -0 = x + 0 by rw [neg_zero]
-#align pgame.sub_zero Pgame.sub_zero
+#align pgame.sub_zero PGame.sub_zero
+-/
 
+#print PGame.Relabelling.subCongr /-
 /-- If `w` has the same moves as `x` and `y` has the same moves as `z`,
 then `w - y` has the same moves as `x - z`. -/
-def Relabelling.subCongr {w x y z : Pgame} (h₁ : w ≡r x) (h₂ : y ≡r z) : w - y ≡r x - z :=
+def Relabelling.subCongr {w x y z : PGame} (h₁ : w ≡r x) (h₂ : y ≡r z) : w - y ≡r x - z :=
   h₁.addCongr h₂.negCongr
-#align pgame.relabelling.sub_congr Pgame.Relabelling.subCongr
+#align pgame.relabelling.sub_congr PGame.Relabelling.subCongr
+-/
 
+#print PGame.negAddRelabelling /-
 /-- `-(x + y)` has exactly the same moves as `-x + -y`. -/
-def negAddRelabelling : ∀ x y : Pgame, -(x + y) ≡r -x + -y
+def negAddRelabelling : ∀ x y : PGame, -(x + y) ≡r -x + -y
   | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩ =>
     by
     refine' ⟨Equiv.refl _, Equiv.refl _, _, _⟩
@@ -1609,31 +2190,41 @@ def negAddRelabelling : ∀ x y : Pgame, -(x + y) ≡r -x + -y
         Sum.casesOn j (fun j => neg_add_relabelling _ _) fun j =>
           neg_add_relabelling ⟨xl, xr, xL, xR⟩ _ decreasing_by
   pgame_wf_tac
-#align pgame.neg_add_relabelling Pgame.negAddRelabelling
+#align pgame.neg_add_relabelling PGame.negAddRelabelling
+-/
 
-theorem neg_add_le {x y : Pgame} : -(x + y) ≤ -x + -y :=
+#print PGame.neg_add_le /-
+theorem neg_add_le {x y : PGame} : -(x + y) ≤ -x + -y :=
   (negAddRelabelling x y).le
-#align pgame.neg_add_le Pgame.neg_add_le
+#align pgame.neg_add_le PGame.neg_add_le
+-/
 
+#print PGame.addCommRelabelling /-
 /-- `x + y` has exactly the same moves as `y + x`. -/
-def addCommRelabelling : ∀ x y : Pgame.{u}, x + y ≡r y + x
+def addCommRelabelling : ∀ x y : PGame.{u}, x + y ≡r y + x
   | mk xl xr xL xR, mk yl yr yL yR => by
     refine' ⟨Equiv.sumComm _ _, Equiv.sumComm _ _, _, _⟩ <;> rintro (_ | _) <;>
       · dsimp [left_moves_add, right_moves_add]
         apply add_comm_relabelling decreasing_by
   pgame_wf_tac
-#align pgame.add_comm_relabelling Pgame.addCommRelabelling
+#align pgame.add_comm_relabelling PGame.addCommRelabelling
+-/
 
-theorem add_comm_le {x y : Pgame} : x + y ≤ y + x :=
+#print PGame.add_comm_le /-
+theorem add_comm_le {x y : PGame} : x + y ≤ y + x :=
   (addCommRelabelling x y).le
-#align pgame.add_comm_le Pgame.add_comm_le
+#align pgame.add_comm_le PGame.add_comm_le
+-/
 
-theorem add_comm_equiv {x y : Pgame} : x + y ≈ y + x :=
+#print PGame.add_comm_equiv /-
+theorem add_comm_equiv {x y : PGame} : x + y ≈ y + x :=
   (addCommRelabelling x y).Equiv
-#align pgame.add_comm_equiv Pgame.add_comm_equiv
+#align pgame.add_comm_equiv PGame.add_comm_equiv
+-/
 
+#print PGame.addAssocRelabelling /-
 /-- `(x + y) + z` has exactly the same moves as `x + (y + z)`. -/
-def addAssocRelabelling : ∀ x y z : Pgame.{u}, x + y + z ≡r x + (y + z)
+def addAssocRelabelling : ∀ x y z : PGame.{u}, x + y + z ≡r x + (y + z)
   | ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩, ⟨zl, zr, zL, zR⟩ =>
     by
     refine' ⟨Equiv.sumAssoc _ _ _, Equiv.sumAssoc _ _ _, _, _⟩
@@ -1643,13 +2234,17 @@ def addAssocRelabelling : ∀ x y z : Pgame.{u}, x + y + z ≡r x + (y + z)
       · apply add_assoc_relabelling ⟨xl, xr, xL, xR⟩
       · apply add_assoc_relabelling ⟨xl, xr, xL, xR⟩ ⟨yl, yr, yL, yR⟩decreasing_by
   pgame_wf_tac
-#align pgame.add_assoc_relabelling Pgame.addAssocRelabelling
+#align pgame.add_assoc_relabelling PGame.addAssocRelabelling
+-/
 
-theorem add_assoc_equiv {x y z : Pgame} : x + y + z ≈ x + (y + z) :=
+#print PGame.add_assoc_equiv /-
+theorem add_assoc_equiv {x y z : PGame} : x + y + z ≈ x + (y + z) :=
   (addAssocRelabelling x y z).Equiv
-#align pgame.add_assoc_equiv Pgame.add_assoc_equiv
+#align pgame.add_assoc_equiv PGame.add_assoc_equiv
+-/
 
-theorem add_left_neg_le_zero : ∀ x : Pgame, -x + x ≤ 0
+#print PGame.add_left_neg_le_zero /-
+theorem add_left_neg_le_zero : ∀ x : PGame, -x + x ≤ 0
   | ⟨xl, xr, xL, xR⟩ =>
     le_zero.2 fun i => by
       cases i
@@ -1662,35 +2257,48 @@ theorem add_left_neg_le_zero : ∀ x : Pgame, -x + x ≤ 0
         refine' ⟨@to_right_moves_add ⟨_, _, _, _⟩ _ (Sum.inl i), _⟩
         convert@add_left_neg_le_zero (xL i)
         apply add_move_right_inl
-#align pgame.add_left_neg_le_zero Pgame.add_left_neg_le_zero
+#align pgame.add_left_neg_le_zero PGame.add_left_neg_le_zero
+-/
 
-theorem zero_le_add_left_neg (x : Pgame) : 0 ≤ -x + x :=
+#print PGame.zero_le_add_left_neg /-
+theorem zero_le_add_left_neg (x : PGame) : 0 ≤ -x + x :=
   by
   rw [← neg_le_neg_iff, neg_zero]
   exact neg_add_le.trans (add_left_neg_le_zero _)
-#align pgame.zero_le_add_left_neg Pgame.zero_le_add_left_neg
+#align pgame.zero_le_add_left_neg PGame.zero_le_add_left_neg
+-/
 
-theorem add_left_neg_equiv (x : Pgame) : -x + x ≈ 0 :=
+#print PGame.add_left_neg_equiv /-
+theorem add_left_neg_equiv (x : PGame) : -x + x ≈ 0 :=
   ⟨add_left_neg_le_zero x, zero_le_add_left_neg x⟩
-#align pgame.add_left_neg_equiv Pgame.add_left_neg_equiv
+#align pgame.add_left_neg_equiv PGame.add_left_neg_equiv
+-/
 
-theorem add_right_neg_le_zero (x : Pgame) : x + -x ≤ 0 :=
+#print PGame.add_right_neg_le_zero /-
+theorem add_right_neg_le_zero (x : PGame) : x + -x ≤ 0 :=
   add_comm_le.trans (add_left_neg_le_zero x)
-#align pgame.add_right_neg_le_zero Pgame.add_right_neg_le_zero
+#align pgame.add_right_neg_le_zero PGame.add_right_neg_le_zero
+-/
 
-theorem zero_le_add_right_neg (x : Pgame) : 0 ≤ x + -x :=
+#print PGame.zero_le_add_right_neg /-
+theorem zero_le_add_right_neg (x : PGame) : 0 ≤ x + -x :=
   (zero_le_add_left_neg x).trans add_comm_le
-#align pgame.zero_le_add_right_neg Pgame.zero_le_add_right_neg
+#align pgame.zero_le_add_right_neg PGame.zero_le_add_right_neg
+-/
 
-theorem add_right_neg_equiv (x : Pgame) : x + -x ≈ 0 :=
+#print PGame.add_right_neg_equiv /-
+theorem add_right_neg_equiv (x : PGame) : x + -x ≈ 0 :=
   ⟨add_right_neg_le_zero x, zero_le_add_right_neg x⟩
-#align pgame.add_right_neg_equiv Pgame.add_right_neg_equiv
+#align pgame.add_right_neg_equiv PGame.add_right_neg_equiv
+-/
 
+#print PGame.sub_self_equiv /-
 theorem sub_self_equiv : ∀ x, x - x ≈ 0 :=
   add_right_neg_equiv
-#align pgame.sub_self_equiv Pgame.sub_self_equiv
+#align pgame.sub_self_equiv PGame.sub_self_equiv
+-/
 
-private theorem add_le_add_right' : ∀ {x y z : Pgame} (h : x ≤ y), x + z ≤ y + z
+private theorem add_le_add_right' : ∀ {x y z : PGame} (h : x ≤ y), x + z ≤ y + z
   | mk xl xr xL xR, mk yl yr yL yR, mk zl zr zL zR => fun h =>
     by
     refine' le_def.2 ⟨fun i => _, fun i => _⟩ <;> cases i
@@ -1715,17 +2323,22 @@ private theorem add_le_add_right' : ∀ {x y z : Pgame} (h : x ≤ y), x + z ≤
   pgame_wf_tac
 #align pgame.add_le_add_right' pgame.add_le_add_right'
 
-instance covariantClass_swap_add_le : CovariantClass Pgame Pgame (swap (· + ·)) (· ≤ ·) :=
+#print PGame.covariantClass_swap_add_le /-
+instance covariantClass_swap_add_le : CovariantClass PGame PGame (swap (· + ·)) (· ≤ ·) :=
   ⟨fun x y z => add_le_add_right'⟩
-#align pgame.covariant_class_swap_add_le Pgame.covariantClass_swap_add_le
+#align pgame.covariant_class_swap_add_le PGame.covariantClass_swap_add_le
+-/
 
-instance covariantClass_add_le : CovariantClass Pgame Pgame (· + ·) (· ≤ ·) :=
+#print PGame.covariantClass_add_le /-
+instance covariantClass_add_le : CovariantClass PGame PGame (· + ·) (· ≤ ·) :=
   ⟨fun x y z h => (add_comm_le.trans (add_le_add_right h x)).trans add_comm_le⟩
-#align pgame.covariant_class_add_le Pgame.covariantClass_add_le
+#align pgame.covariant_class_add_le PGame.covariantClass_add_le
+-/
 
-theorem add_lf_add_right {y z : Pgame} (h : y ⧏ z) (x) : y + x ⧏ z + x :=
+#print PGame.add_lf_add_right /-
+theorem add_lf_add_right {y z : PGame} (h : y ⧏ z) (x) : y + x ⧏ z + x :=
   suffices z + x ≤ y + x → z ≤ y by
-    rw [← Pgame.not_le] at h⊢
+    rw [← PGame.not_le] at h⊢
     exact mt this h
   fun w =>
   calc
@@ -1737,56 +2350,88 @@ theorem add_lf_add_right {y z : Pgame} (h : y ⧏ z) (x) : y + x ⧏ z + x :=
     _ ≤ y + 0 := (add_le_add_left (add_right_neg_le_zero x) _)
     _ ≤ y := (addZeroRelabelling _).le
     
-#align pgame.add_lf_add_right Pgame.add_lf_add_right
+#align pgame.add_lf_add_right PGame.add_lf_add_right
+-/
 
-theorem add_lf_add_left {y z : Pgame} (h : y ⧏ z) (x) : x + y ⧏ x + z :=
+#print PGame.add_lf_add_left /-
+theorem add_lf_add_left {y z : PGame} (h : y ⧏ z) (x) : x + y ⧏ x + z :=
   by
   rw [lf_congr add_comm_equiv add_comm_equiv]
   apply add_lf_add_right h
-#align pgame.add_lf_add_left Pgame.add_lf_add_left
+#align pgame.add_lf_add_left PGame.add_lf_add_left
+-/
 
-instance covariantClass_swap_add_lt : CovariantClass Pgame Pgame (swap (· + ·)) (· < ·) :=
+/- warning: pgame.covariant_class_swap_add_lt -> PGame.covariantClass_swap_add_lt is a dubious translation:
+lean 3 declaration is
+  CovariantClass.{succ u1, succ u1} PGame.{u1} PGame.{u1} (Function.swap.{succ (succ u1), succ (succ u1), succ (succ u1)} PGame.{u1} PGame.{u1} (fun (ᾰ : PGame.{u1}) (ᾰ : PGame.{u1}) => PGame.{u1}) (HAdd.hAdd.{succ u1, succ u1, succ u1} PGame.{u1} PGame.{u1} PGame.{u1} (instHAdd.{succ u1} PGame.{u1} PGame.hasAdd.{u1}))) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}))
+but is expected to have type
+  CovariantClass.{succ u1, succ u1} PGame.{u1} PGame.{u1} (Function.swap.{succ (succ u1), succ (succ u1), succ (succ u1)} PGame.{u1} PGame.{u1} (fun (ᾰ : PGame.{u1}) (ᾰ : PGame.{u1}) => PGame.{u1}) (fun (x._@.Mathlib.SetTheory.Game.PGame._hyg.22024 : PGame.{u1}) (x._@.Mathlib.SetTheory.Game.PGame._hyg.22026 : PGame.{u1}) => HAdd.hAdd.{succ u1, succ u1, succ u1} PGame.{u1} PGame.{u1} PGame.{u1} (instHAdd.{succ u1} PGame.{u1} PGame.instAddPGame.{u1}) x._@.Mathlib.SetTheory.Game.PGame._hyg.22024 x._@.Mathlib.SetTheory.Game.PGame._hyg.22026)) (fun (x._@.Mathlib.SetTheory.Game.PGame._hyg.22039 : PGame.{u1}) (x._@.Mathlib.SetTheory.Game.PGame._hyg.22041 : PGame.{u1}) => LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x._@.Mathlib.SetTheory.Game.PGame._hyg.22039 x._@.Mathlib.SetTheory.Game.PGame._hyg.22041)
+Case conversion may be inaccurate. Consider using '#align pgame.covariant_class_swap_add_lt PGame.covariantClass_swap_add_ltₓ'. -/
+instance covariantClass_swap_add_lt : CovariantClass PGame PGame (swap (· + ·)) (· < ·) :=
   ⟨fun x y z h => ⟨add_le_add_right h.1 x, add_lf_add_right h.2 x⟩⟩
-#align pgame.covariant_class_swap_add_lt Pgame.covariantClass_swap_add_lt
-
-instance covariantClass_add_lt : CovariantClass Pgame Pgame (· + ·) (· < ·) :=
+#align pgame.covariant_class_swap_add_lt PGame.covariantClass_swap_add_lt
+
+/- warning: pgame.covariant_class_add_lt -> PGame.covariantClass_add_lt is a dubious translation:
+lean 3 declaration is
+  CovariantClass.{succ u1, succ u1} PGame.{u1} PGame.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} PGame.{u1} PGame.{u1} PGame.{u1} (instHAdd.{succ u1} PGame.{u1} PGame.hasAdd.{u1})) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}))
+but is expected to have type
+  CovariantClass.{succ u1, succ u1} PGame.{u1} PGame.{u1} (fun (x._@.Mathlib.SetTheory.Game.PGame._hyg.22077 : PGame.{u1}) (x._@.Mathlib.SetTheory.Game.PGame._hyg.22079 : PGame.{u1}) => HAdd.hAdd.{succ u1, succ u1, succ u1} PGame.{u1} PGame.{u1} PGame.{u1} (instHAdd.{succ u1} PGame.{u1} PGame.instAddPGame.{u1}) x._@.Mathlib.SetTheory.Game.PGame._hyg.22077 x._@.Mathlib.SetTheory.Game.PGame._hyg.22079) (fun (x._@.Mathlib.SetTheory.Game.PGame._hyg.22092 : PGame.{u1}) (x._@.Mathlib.SetTheory.Game.PGame._hyg.22094 : PGame.{u1}) => LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x._@.Mathlib.SetTheory.Game.PGame._hyg.22092 x._@.Mathlib.SetTheory.Game.PGame._hyg.22094)
+Case conversion may be inaccurate. Consider using '#align pgame.covariant_class_add_lt PGame.covariantClass_add_ltₓ'. -/
+instance covariantClass_add_lt : CovariantClass PGame PGame (· + ·) (· < ·) :=
   ⟨fun x y z h => ⟨add_le_add_left h.1 x, add_lf_add_left h.2 x⟩⟩
-#align pgame.covariant_class_add_lt Pgame.covariantClass_add_lt
+#align pgame.covariant_class_add_lt PGame.covariantClass_add_lt
 
-theorem add_lf_add_of_lf_of_le {w x y z : Pgame} (hwx : w ⧏ x) (hyz : y ≤ z) : w + y ⧏ x + z :=
+#print PGame.add_lf_add_of_lf_of_le /-
+theorem add_lf_add_of_lf_of_le {w x y z : PGame} (hwx : w ⧏ x) (hyz : y ≤ z) : w + y ⧏ x + z :=
   lf_of_lf_of_le (add_lf_add_right hwx y) (add_le_add_left hyz x)
-#align pgame.add_lf_add_of_lf_of_le Pgame.add_lf_add_of_lf_of_le
+#align pgame.add_lf_add_of_lf_of_le PGame.add_lf_add_of_lf_of_le
+-/
 
-theorem add_lf_add_of_le_of_lf {w x y z : Pgame} (hwx : w ≤ x) (hyz : y ⧏ z) : w + y ⧏ x + z :=
+#print PGame.add_lf_add_of_le_of_lf /-
+theorem add_lf_add_of_le_of_lf {w x y z : PGame} (hwx : w ≤ x) (hyz : y ⧏ z) : w + y ⧏ x + z :=
   lf_of_le_of_lf (add_le_add_right hwx y) (add_lf_add_left hyz x)
-#align pgame.add_lf_add_of_le_of_lf Pgame.add_lf_add_of_le_of_lf
+#align pgame.add_lf_add_of_le_of_lf PGame.add_lf_add_of_le_of_lf
+-/
 
-theorem add_congr {w x y z : Pgame} (h₁ : w ≈ x) (h₂ : y ≈ z) : w + y ≈ x + z :=
+#print PGame.add_congr /-
+theorem add_congr {w x y z : PGame} (h₁ : w ≈ x) (h₂ : y ≈ z) : w + y ≈ x + z :=
   ⟨(add_le_add_left h₂.1 w).trans (add_le_add_right h₁.1 z),
     (add_le_add_left h₂.2 x).trans (add_le_add_right h₁.2 y)⟩
-#align pgame.add_congr Pgame.add_congr
+#align pgame.add_congr PGame.add_congr
+-/
 
-theorem add_congr_left {x y z : Pgame} (h : x ≈ y) : x + z ≈ y + z :=
+#print PGame.add_congr_left /-
+theorem add_congr_left {x y z : PGame} (h : x ≈ y) : x + z ≈ y + z :=
   add_congr h equiv_rfl
-#align pgame.add_congr_left Pgame.add_congr_left
+#align pgame.add_congr_left PGame.add_congr_left
+-/
 
-theorem add_congr_right {x y z : Pgame} : (y ≈ z) → (x + y ≈ x + z) :=
+#print PGame.add_congr_right /-
+theorem add_congr_right {x y z : PGame} : (y ≈ z) → (x + y ≈ x + z) :=
   add_congr equiv_rfl
-#align pgame.add_congr_right Pgame.add_congr_right
+#align pgame.add_congr_right PGame.add_congr_right
+-/
 
-theorem sub_congr {w x y z : Pgame} (h₁ : w ≈ x) (h₂ : y ≈ z) : w - y ≈ x - z :=
+#print PGame.sub_congr /-
+theorem sub_congr {w x y z : PGame} (h₁ : w ≈ x) (h₂ : y ≈ z) : w - y ≈ x - z :=
   add_congr h₁ (neg_equiv_neg_iff.2 h₂)
-#align pgame.sub_congr Pgame.sub_congr
+#align pgame.sub_congr PGame.sub_congr
+-/
 
-theorem sub_congr_left {x y z : Pgame} (h : x ≈ y) : x - z ≈ y - z :=
+#print PGame.sub_congr_left /-
+theorem sub_congr_left {x y z : PGame} (h : x ≈ y) : x - z ≈ y - z :=
   sub_congr h equiv_rfl
-#align pgame.sub_congr_left Pgame.sub_congr_left
+#align pgame.sub_congr_left PGame.sub_congr_left
+-/
 
-theorem sub_congr_right {x y z : Pgame} : (y ≈ z) → (x - y ≈ x - z) :=
+#print PGame.sub_congr_right /-
+theorem sub_congr_right {x y z : PGame} : (y ≈ z) → (x - y ≈ x - z) :=
   sub_congr equiv_rfl
-#align pgame.sub_congr_right Pgame.sub_congr_right
+#align pgame.sub_congr_right PGame.sub_congr_right
+-/
 
-theorem le_iff_sub_nonneg {x y : Pgame} : x ≤ y ↔ 0 ≤ y - x :=
+#print PGame.le_iff_sub_nonneg /-
+theorem le_iff_sub_nonneg {x y : PGame} : x ≤ y ↔ 0 ≤ y - x :=
   ⟨fun h => (zero_le_add_right_neg x).trans (add_le_add_right h _), fun h =>
     calc
       x ≤ 0 + x := (zeroAddRelabelling x).symm.le
@@ -1795,9 +2440,11 @@ theorem le_iff_sub_nonneg {x y : Pgame} : x ≤ y ↔ 0 ≤ y - x :=
       _ ≤ y + 0 := (add_le_add_left (add_left_neg_le_zero x) _)
       _ ≤ y := (addZeroRelabelling y).le
       ⟩
-#align pgame.le_iff_sub_nonneg Pgame.le_iff_sub_nonneg
+#align pgame.le_iff_sub_nonneg PGame.le_iff_sub_nonneg
+-/
 
-theorem lf_iff_sub_zero_lf {x y : Pgame} : x ⧏ y ↔ 0 ⧏ y - x :=
+#print PGame.lf_iff_sub_zero_lf /-
+theorem lf_iff_sub_zero_lf {x y : PGame} : x ⧏ y ↔ 0 ⧏ y - x :=
   ⟨fun h => (zero_le_add_right_neg x).trans_lf (add_lf_add_right h _), fun h =>
     calc
       x ≤ 0 + x := (zeroAddRelabelling x).symm.le
@@ -1806,9 +2453,16 @@ theorem lf_iff_sub_zero_lf {x y : Pgame} : x ⧏ y ↔ 0 ⧏ y - x :=
       _ ≤ y + 0 := (add_le_add_left (add_left_neg_le_zero x) _)
       _ ≤ y := (addZeroRelabelling y).le
       ⟩
-#align pgame.lf_iff_sub_zero_lf Pgame.lf_iff_sub_zero_lf
+#align pgame.lf_iff_sub_zero_lf PGame.lf_iff_sub_zero_lf
+-/
 
-theorem lt_iff_sub_pos {x y : Pgame} : x < y ↔ 0 < y - x :=
+/- warning: pgame.lt_iff_sub_pos -> PGame.lt_iff_sub_pos is a dubious translation:
+lean 3 declaration is
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) x y) (LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) (OfNat.ofNat.{succ u1} PGame.{u1} 0 (OfNat.mk.{succ u1} PGame.{u1} 0 (Zero.zero.{succ u1} PGame.{u1} PGame.hasZero.{u1}))) (HSub.hSub.{succ u1, succ u1, succ u1} PGame.{u1} PGame.{u1} PGame.{u1} (instHSub.{succ u1} PGame.{u1} PGame.hasSub.{u1}) y x))
+but is expected to have type
+  forall {x : PGame.{u1}} {y : PGame.{u1}}, Iff (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) x y) (LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) (OfNat.ofNat.{succ u1} PGame.{u1} 0 (Zero.toOfNat0.{succ u1} PGame.{u1} PGame.instZeroPGame.{u1})) (HSub.hSub.{succ u1, succ u1, succ u1} PGame.{u1} PGame.{u1} PGame.{u1} (instHSub.{succ u1} PGame.{u1} PGame.instSubPGame.{u1}) y x))
+Case conversion may be inaccurate. Consider using '#align pgame.lt_iff_sub_pos PGame.lt_iff_sub_posₓ'. -/
+theorem lt_iff_sub_pos {x y : PGame} : x < y ↔ 0 < y - x :=
   ⟨fun h => lt_of_le_of_lt (zero_le_add_right_neg x) (add_lt_add_right h _), fun h =>
     calc
       x ≤ 0 + x := (zeroAddRelabelling x).symm.le
@@ -1817,44 +2471,59 @@ theorem lt_iff_sub_pos {x y : Pgame} : x < y ↔ 0 < y - x :=
       _ ≤ y + 0 := (add_le_add_left (add_left_neg_le_zero x) _)
       _ ≤ y := (addZeroRelabelling y).le
       ⟩
-#align pgame.lt_iff_sub_pos Pgame.lt_iff_sub_pos
+#align pgame.lt_iff_sub_pos PGame.lt_iff_sub_pos
 
 /-! ### Special pre-games -/
 
 
+#print PGame.star /-
 /-- The pre-game `star`, which is fuzzy with zero. -/
-def star : Pgame.{u} :=
+def star : PGame.{u} :=
   ⟨PUnit, PUnit, fun _ => 0, fun _ => 0⟩
-#align pgame.star Pgame.star
+#align pgame.star PGame.star
+-/
 
+#print PGame.star_leftMoves /-
 @[simp]
 theorem star_leftMoves : star.LeftMoves = PUnit :=
   rfl
-#align pgame.star_left_moves Pgame.star_leftMoves
+#align pgame.star_left_moves PGame.star_leftMoves
+-/
 
+#print PGame.star_rightMoves /-
 @[simp]
 theorem star_rightMoves : star.RightMoves = PUnit :=
   rfl
-#align pgame.star_right_moves Pgame.star_rightMoves
+#align pgame.star_right_moves PGame.star_rightMoves
+-/
 
+#print PGame.star_moveLeft /-
 @[simp]
 theorem star_moveLeft (x) : star.moveLeft x = 0 :=
   rfl
-#align pgame.star_move_left Pgame.star_moveLeft
+#align pgame.star_move_left PGame.star_moveLeft
+-/
 
+#print PGame.star_moveRight /-
 @[simp]
 theorem star_moveRight (x) : star.moveRight x = 0 :=
   rfl
-#align pgame.star_move_right Pgame.star_moveRight
+#align pgame.star_move_right PGame.star_moveRight
+-/
 
+#print PGame.uniqueStarLeftMoves /-
 instance uniqueStarLeftMoves : Unique star.LeftMoves :=
   PUnit.unique
-#align pgame.unique_star_left_moves Pgame.uniqueStarLeftMoves
+#align pgame.unique_star_left_moves PGame.uniqueStarLeftMoves
+-/
 
+#print PGame.uniqueStarRightMoves /-
 instance uniqueStarRightMoves : Unique star.RightMoves :=
   PUnit.unique
-#align pgame.unique_star_right_moves Pgame.uniqueStarRightMoves
+#align pgame.unique_star_right_moves PGame.uniqueStarRightMoves
+-/
 
+#print PGame.star_fuzzy_zero /-
 theorem star_fuzzy_zero : star ‖ 0 :=
   ⟨by
     rw [lf_zero]
@@ -1863,24 +2532,35 @@ theorem star_fuzzy_zero : star ‖ 0 :=
     rw [zero_lf]
     use default
     rintro ⟨⟩⟩
-#align pgame.star_fuzzy_zero Pgame.star_fuzzy_zero
+#align pgame.star_fuzzy_zero PGame.star_fuzzy_zero
+-/
 
+#print PGame.neg_star /-
 @[simp]
 theorem neg_star : -star = star := by simp [star]
-#align pgame.neg_star Pgame.neg_star
+#align pgame.neg_star PGame.neg_star
+-/
 
+/- warning: pgame.zero_lt_one -> PGame.zero_lt_one is a dubious translation:
+lean 3 declaration is
+  LT.lt.{succ u1} PGame.{u1} (Preorder.toHasLt.{succ u1} PGame.{u1} PGame.preorder.{u1}) (OfNat.ofNat.{succ u1} PGame.{u1} 0 (OfNat.mk.{succ u1} PGame.{u1} 0 (Zero.zero.{succ u1} PGame.{u1} PGame.hasZero.{u1}))) (OfNat.ofNat.{succ u1} PGame.{u1} 1 (OfNat.mk.{succ u1} PGame.{u1} 1 (One.one.{succ u1} PGame.{u1} PGame.hasOne.{u1})))
+but is expected to have type
+  LT.lt.{succ u1} PGame.{u1} (Preorder.toLT.{succ u1} PGame.{u1} PGame.instPreorderPGame.{u1}) (OfNat.ofNat.{succ u1} PGame.{u1} 0 (Zero.toOfNat0.{succ u1} PGame.{u1} PGame.instZeroPGame.{u1})) (OfNat.ofNat.{succ u1} PGame.{u1} 1 (One.toOfNat1.{succ u1} PGame.{u1} PGame.instOnePGame.{u1}))
+Case conversion may be inaccurate. Consider using '#align pgame.zero_lt_one PGame.zero_lt_oneₓ'. -/
 @[simp]
-protected theorem zero_lt_one : (0 : Pgame) < 1 :=
+protected theorem zero_lt_one : (0 : PGame) < 1 :=
   lt_of_le_of_lf (zero_le_of_isEmpty_rightMoves 1) (zero_lf_le.2 ⟨default, le_rfl⟩)
-#align pgame.zero_lt_one Pgame.zero_lt_one
+#align pgame.zero_lt_one PGame.zero_lt_one
 
-instance : ZeroLEOneClass Pgame :=
-  ⟨Pgame.zero_lt_one.le⟩
+instance : ZeroLEOneClass PGame :=
+  ⟨PGame.zero_lt_one.le⟩
 
+#print PGame.zero_lf_one /-
 @[simp]
-theorem zero_lf_one : (0 : Pgame) ⧏ 1 :=
-  Pgame.zero_lt_one.Lf
-#align pgame.zero_lf_one Pgame.zero_lf_one
+theorem zero_lf_one : (0 : PGame) ⧏ 1 :=
+  PGame.zero_lt_one.Lf
+#align pgame.zero_lf_one PGame.zero_lf_one
+-/
 
-end Pgame
+end PGame
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/b19481deb571022990f1baa9cbf9172e6757a479

@@ -4,13 +4,14 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Reid Barton, Mario Carneiro, Isabel Longbottom, Scott Morrison
 
 ! This file was ported from Lean 3 source module set_theory.game.pgame
-! leanprover-community/mathlib commit 2196ab363eb097c008d4497125e0dde23fb36db2
+! leanprover-community/mathlib commit dc9e5ba64653e017743ba5d2c28e42f9f486bf99
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
 import Mathbin.Data.Fin.Basic
 import Mathbin.Data.List.Basic
 import Mathbin.Logic.Relation
+import Mathbin.Order.GameAdd
 
 /-!
 # Combinatorial (pre-)games.
@@ -346,104 +347,81 @@ instance isEmpty_one_rightMoves : IsEmpty (RightMoves 1) :=
 /-! ### Pre-game order relations -/
 
 
-/-- Define simultaneously by mutual induction the `≤` relation and its swapped converse `⧏` on
-  pre-games.
-
-  The ZFC definition says that `x = {xL | xR}` is less or equal to `y = {yL | yR}` if
-  `∀ x₁ ∈ xL, x₁ ⧏ y` and `∀ y₂ ∈ yR, x ⧏ y₂`, where `x ⧏ y` means `¬ y ≤ x`. This is a tricky
-  induction because it only decreases one side at a time, and it also swaps the arguments in the
-  definition of `≤`. The solution is to define `x ≤ y` and `x ⧏ y` simultaneously. -/
-def leLf : ∀ x y : Pgame.{u}, Prop × Prop
-  | mk xl xr xL xR,
-    mk yl yr yL yR =>-- the orderings of the clauses here are carefully chosen so that
-    --   and.left/or.inl refer to moves by Left, and
-    --   and.right/or.inr refer to moves by Right.
-    ((∀ i, (le_lf (xL i) ⟨yl, yr, yL, yR⟩).2) ∧ ∀ j, (le_lf ⟨xl, xr, xL, xR⟩ (yR j)).2,
-      (∃ i, (le_lf ⟨xl, xr, xL, xR⟩ (yL i)).1) ∨
-        ∃ j, (le_lf (xR j) ⟨yl, yr, yL, yR⟩).1)decreasing_by
-  pgame_wf_tac
-#align pgame.le_lf Pgame.leLf
-
 /-- The less or equal relation on pre-games.
 
 If `0 ≤ x`, then Left can win `x` as the second player. -/
 instance : LE Pgame :=
-  ⟨fun x y => (leLf x y).1⟩
+  ⟨Sym2.GameAdd.fix wf_isOption fun x y le =>
+      (∀ i, ¬le y (x.moveLeft i) (Sym2.GameAdd.snd_fst <| IsOption.move_left i)) ∧
+        ∀ j, ¬le (y.moveRight j) x (Sym2.GameAdd.fst_snd <| IsOption.move_right j)⟩
 
 /-- The less or fuzzy relation on pre-games.
 
 If `0 ⧏ x`, then Left can win `x` as the first player. -/
 def Lf (x y : Pgame) : Prop :=
-  (leLf x y).2
+  ¬y ≤ x
 #align pgame.lf Pgame.Lf
 
 -- mathport name: pgame.lf
 scoped infixl:50 " ⧏ " => Pgame.Lf
 
-/-- Definition of `x ≤ y` on pre-games built using the constructor. -/
 @[simp]
-theorem mk_le_mk {xl xr xL xR yl yr yL yR} :
-    mk xl xr xL xR ≤ mk yl yr yL yR ↔ (∀ i, xL i ⧏ mk yl yr yL yR) ∧ ∀ j, mk xl xr xL xR ⧏ yR j :=
-  show (leLf _ _).1 ↔ _ by
-    rw [le_lf]
-    rfl
-#align pgame.mk_le_mk Pgame.mk_le_mk
+protected theorem not_le {x y : Pgame} : ¬x ≤ y ↔ y ⧏ x :=
+  Iff.rfl
+#align pgame.not_le Pgame.not_le
 
-/-- Definition of `x ≤ y` on pre-games, in terms of `⧏` -/
+@[simp]
+theorem not_lf {x y : Pgame} : ¬x ⧏ y ↔ y ≤ x :=
+  Classical.not_not
+#align pgame.not_lf Pgame.not_lf
+
+theorem LE.le.not_gf {x y : Pgame} : x ≤ y → ¬y ⧏ x :=
+  not_lf.2
+#align has_le.le.not_gf LE.le.not_gf
+
+theorem Lf.not_ge {x y : Pgame} : x ⧏ y → ¬y ≤ x :=
+  id
+#align pgame.lf.not_ge Pgame.Lf.not_ge
+
+/-- Definition of `x ≤ y` on pre-games, in terms of `⧏`.
+
+The ordering here is chosen so that `and.left` refer to moves by Left, and `and.right` refer to
+moves by Right. -/
 theorem le_iff_forall_lf {x y : Pgame} : x ≤ y ↔ (∀ i, x.moveLeft i ⧏ y) ∧ ∀ j, x ⧏ y.moveRight j :=
   by
-  cases x
-  cases y
-  exact mk_le_mk
+  unfold LE.le
+  rw [Sym2.GameAdd.fix_eq]
+  rfl
 #align pgame.le_iff_forall_lf Pgame.le_iff_forall_lf
 
+/-- Definition of `x ≤ y` on pre-games built using the constructor. -/
+@[simp]
+theorem mk_le_mk {xl xr xL xR yl yr yL yR} :
+    mk xl xr xL xR ≤ mk yl yr yL yR ↔ (∀ i, xL i ⧏ mk yl yr yL yR) ∧ ∀ j, mk xl xr xL xR ⧏ yR j :=
+  le_iff_forall_lf
+#align pgame.mk_le_mk Pgame.mk_le_mk
+
 theorem le_of_forall_lf {x y : Pgame} (h₁ : ∀ i, x.moveLeft i ⧏ y) (h₂ : ∀ j, x ⧏ y.moveRight j) :
     x ≤ y :=
   le_iff_forall_lf.2 ⟨h₁, h₂⟩
 #align pgame.le_of_forall_lf Pgame.le_of_forall_lf
 
-/-- Definition of `x ⧏ y` on pre-games built using the constructor. -/
-@[simp]
-theorem mk_lf_mk {xl xr xL xR yl yr yL yR} :
-    mk xl xr xL xR ⧏ mk yl yr yL yR ↔ (∃ i, mk xl xr xL xR ≤ yL i) ∨ ∃ j, xR j ≤ mk yl yr yL yR :=
-  show (leLf _ _).2 ↔ _ by
-    rw [le_lf]
-    rfl
-#align pgame.mk_lf_mk Pgame.mk_lf_mk
+/-- Definition of `x ⧏ y` on pre-games, in terms of `≤`.
 
-/-- Definition of `x ⧏ y` on pre-games, in terms of `≤` -/
+The ordering here is chosen so that `or.inl` refer to moves by Left, and `or.inr` refer to
+moves by Right. -/
 theorem lf_iff_exists_le {x y : Pgame} : x ⧏ y ↔ (∃ i, x ≤ y.moveLeft i) ∨ ∃ j, x.moveRight j ≤ y :=
   by
-  cases x
-  cases y
-  exact mk_lf_mk
+  rw [lf, le_iff_forall_lf, not_and_or]
+  simp
 #align pgame.lf_iff_exists_le Pgame.lf_iff_exists_le
 
-private theorem not_le_lf {x y : Pgame} : (¬x ≤ y ↔ y ⧏ x) ∧ (¬x ⧏ y ↔ y ≤ x) :=
-  by
-  induction' x with xl xr xL xR IHxl IHxr generalizing y
-  induction' y with yl yr yL yR IHyl IHyr
-  simp only [mk_le_mk, mk_lf_mk, IHxl, IHxr, IHyl, IHyr, not_and_or, not_or, not_forall, not_exists,
-    and_comm', or_comm', iff_self_iff, and_self_iff]
-#align pgame.not_le_lf pgame.not_le_lf
-
-@[simp]
-protected theorem not_le {x y : Pgame} : ¬x ≤ y ↔ y ⧏ x :=
-  not_le_lf.1
-#align pgame.not_le Pgame.not_le
-
+/-- Definition of `x ⧏ y` on pre-games built using the constructor. -/
 @[simp]
-theorem not_lf {x y : Pgame} : ¬x ⧏ y ↔ y ≤ x :=
-  not_le_lf.2
-#align pgame.not_lf Pgame.not_lf
-
-theorem LE.le.not_gf {x y : Pgame} : x ≤ y → ¬y ⧏ x :=
-  not_lf.2
-#align has_le.le.not_gf LE.le.not_gf
-
-theorem Lf.not_ge {x y : Pgame} : x ⧏ y → ¬y ≤ x :=
-  Pgame.not_le.2
-#align pgame.lf.not_ge Pgame.Lf.not_ge
+theorem mk_lf_mk {xl xr xL xR yl yr yL yR} :
+    mk xl xr xL xR ⧏ mk yl yr yL yR ↔ (∃ i, mk xl xr xL xR ≤ yL i) ∨ ∃ j, xR j ≤ mk yl yr yL yR :=
+  lf_iff_exists_le
+#align pgame.mk_lf_mk Pgame.mk_lf_mk
 
 theorem le_or_gf (x y : Pgame) : x ≤ y ∨ y ⧏ x :=
   by
@@ -499,12 +477,9 @@ private theorem le_trans_aux {x y z : Pgame}
     Pgame.not_le.1 fun h => (h₂ h hxy).not_gf <| hyz.lf_moveRight j
 #align pgame.le_trans_aux pgame.le_trans_aux
 
-instance : LT Pgame :=
-  ⟨fun x y => x ≤ y ∧ x ⧏ y⟩
-
 instance : Preorder Pgame :=
-  { Pgame.hasLe,
-    Pgame.hasLt with
+  {
+    Pgame.hasLe with
     le_refl := fun x => by
       induction' x with _ _ _ _ IHl IHr
       exact
@@ -523,9 +498,7 @@ instance : Preorder Pgame :=
         ⟨le_trans_aux (fun i => (IHxl i).2.1) fun j => (IHzr j).2.2,
           le_trans_aux (fun i => (IHyl i).2.2) fun j => (IHxr j).1,
           le_trans_aux (fun i => (IHzl i).1) fun j => (IHyr j).2.1⟩
-    lt_iff_le_not_le := fun x y => by
-      rw [Pgame.not_le]
-      rfl }
+    lt := fun x y => x ≤ y ∧ x ⧏ y }
 
 theorem lt_iff_le_and_lf {x y : Pgame} : x < y ↔ x ≤ y ∧ x ⧏ y :=
   Iff.rfl

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce7e9d53d4bbc38065db3b595cd5bd73c323bc1d

@@ -1682,12 +1682,12 @@ theorem add_left_neg_le_zero : ∀ x : Pgame, -x + x ≤ 0
       cases i
       · -- If Left played in -x, Right responds with the same move in x.
         refine' ⟨@to_right_moves_add _ ⟨_, _, _, _⟩ (Sum.inr i), _⟩
-        convert @add_left_neg_le_zero (xR i)
+        convert@add_left_neg_le_zero (xR i)
         apply add_move_right_inr
       · -- If Left in x, Right responds with the same move in -x.
         dsimp
         refine' ⟨@to_right_moves_add ⟨_, _, _, _⟩ _ (Sum.inl i), _⟩
-        convert @add_left_neg_le_zero (xL i)
+        convert@add_left_neg_le_zero (xL i)
         apply add_move_right_inl
 #align pgame.add_left_neg_le_zero Pgame.add_left_neg_le_zero
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/2196ab363eb097c008d4497125e0dde23fb36db2

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Reid Barton, Mario Carneiro, Isabel Longbottom, Scott Morrison
 
 ! This file was ported from Lean 3 source module set_theory.game.pgame
-! leanprover-community/mathlib commit 9b2660e1b25419042c8da10bf411aa3c67f14383
+! leanprover-community/mathlib commit 2196ab363eb097c008d4497125e0dde23fb36db2
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -1236,8 +1236,8 @@ theorem isOption_neg {x y : Pgame} : IsOption x (-y) ↔ IsOption (-x) y :=
   apply or_congr <;>
     · apply exists_congr
       intro
-      rw [← neg_eq_iff_neg_eq]
-      exact eq_comm
+      rw [neg_eq_iff_eq_neg]
+      rfl
 #align pgame.is_option_neg Pgame.isOption_neg
 
 @[simp]

mathlib commit https://github.com/leanprover-community/mathlib/commit/4c586d291f189eecb9d00581aeb3dd998ac34442

@@ -282,7 +282,7 @@ theorem Subsequent.mk_right {xl xr} (xL : xl → Pgame) (xR : xr → Pgame) (j :
   @Subsequent.moveRight (mk _ _ _ _) j
 #align pgame.subsequent.mk_right Pgame.Subsequent.mk_right
 
-/- ./././Mathport/Syntax/Translate/Expr.lean:334:4: warning: unsupported (TODO): `[tacs] -/
+/- ./././Mathport/Syntax/Translate/Expr.lean:330:4: warning: unsupported (TODO): `[tacs] -/
 /-- A local tactic for proving well-foundedness of recursive definitions involving pregames. -/
 unsafe def pgame_wf_tac :=
   sorry
@@ -1757,11 +1757,11 @@ theorem add_lf_add_right {y z : Pgame} (h : y ⧏ z) (x) : y + x ⧏ z + x :=
   fun w =>
   calc
     z ≤ z + 0 := (addZeroRelabelling _).symm.le
-    _ ≤ z + (x + -x) := add_le_add_left (zero_le_add_right_neg x) _
+    _ ≤ z + (x + -x) := (add_le_add_left (zero_le_add_right_neg x) _)
     _ ≤ z + x + -x := (addAssocRelabelling _ _ _).symm.le
-    _ ≤ y + x + -x := add_le_add_right w _
+    _ ≤ y + x + -x := (add_le_add_right w _)
     _ ≤ y + (x + -x) := (addAssocRelabelling _ _ _).le
-    _ ≤ y + 0 := add_le_add_left (add_right_neg_le_zero x) _
+    _ ≤ y + 0 := (add_le_add_left (add_right_neg_le_zero x) _)
     _ ≤ y := (addZeroRelabelling _).le
     
 #align pgame.add_lf_add_right Pgame.add_lf_add_right
@@ -1817,9 +1817,9 @@ theorem le_iff_sub_nonneg {x y : Pgame} : x ≤ y ↔ 0 ≤ y - x :=
   ⟨fun h => (zero_le_add_right_neg x).trans (add_le_add_right h _), fun h =>
     calc
       x ≤ 0 + x := (zeroAddRelabelling x).symm.le
-      _ ≤ y - x + x := add_le_add_right h _
+      _ ≤ y - x + x := (add_le_add_right h _)
       _ ≤ y + (-x + x) := (addAssocRelabelling _ _ _).le
-      _ ≤ y + 0 := add_le_add_left (add_left_neg_le_zero x) _
+      _ ≤ y + 0 := (add_le_add_left (add_left_neg_le_zero x) _)
       _ ≤ y := (addZeroRelabelling y).le
       ⟩
 #align pgame.le_iff_sub_nonneg Pgame.le_iff_sub_nonneg
@@ -1828,9 +1828,9 @@ theorem lf_iff_sub_zero_lf {x y : Pgame} : x ⧏ y ↔ 0 ⧏ y - x :=
   ⟨fun h => (zero_le_add_right_neg x).trans_lf (add_lf_add_right h _), fun h =>
     calc
       x ≤ 0 + x := (zeroAddRelabelling x).symm.le
-      _ ⧏ y - x + x := add_lf_add_right h _
+      _ ⧏ y - x + x := (add_lf_add_right h _)
       _ ≤ y + (-x + x) := (addAssocRelabelling _ _ _).le
-      _ ≤ y + 0 := add_le_add_left (add_left_neg_le_zero x) _
+      _ ≤ y + 0 := (add_le_add_left (add_left_neg_le_zero x) _)
       _ ≤ y := (addZeroRelabelling y).le
       ⟩
 #align pgame.lf_iff_sub_zero_lf Pgame.lf_iff_sub_zero_lf
@@ -1839,9 +1839,9 @@ theorem lt_iff_sub_pos {x y : Pgame} : x < y ↔ 0 < y - x :=
   ⟨fun h => lt_of_le_of_lt (zero_le_add_right_neg x) (add_lt_add_right h _), fun h =>
     calc
       x ≤ 0 + x := (zeroAddRelabelling x).symm.le
-      _ < y - x + x := add_lt_add_right h _
+      _ < y - x + x := (add_lt_add_right h _)
       _ ≤ y + (-x + x) := (addAssocRelabelling _ _ _).le
-      _ ≤ y + 0 := add_le_add_left (add_left_neg_le_zero x) _
+      _ ≤ y + 0 := (add_le_add_left (add_left_neg_le_zero x) _)
       _ ≤ y := (addZeroRelabelling y).le
       ⟩
 #align pgame.lt_iff_sub_pos Pgame.lt_iff_sub_pos

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

@@ -167,8 +167,7 @@ theorem moveRight_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).moveRight =
 /-- Construct a pre-game from list of pre-games describing the available moves for Left and Right.
 -/
 def ofLists (L R : List PGame.{u}) : PGame.{u} :=
-  mk (ULift (Fin L.length)) (ULift (Fin R.length)) (fun i => L.nthLe i.down i.down.is_lt) fun j ↦
-    R.nthLe j.down j.down.prop
+  mk (ULift (Fin L.length)) (ULift (Fin R.length)) (fun i => L.get i.down) fun j ↦ R.get j.down
 #align pgame.of_lists SetTheory.PGame.ofLists
 
 theorem leftMoves_ofLists (L R : List PGame) : (ofLists L R).LeftMoves = ULift (Fin L.length) :=
@@ -190,26 +189,24 @@ def toOfListsRightMoves {L R : List PGame} : Fin R.length ≃ (ofLists L R).Righ
 #align pgame.to_of_lists_right_moves SetTheory.PGame.toOfListsRightMoves
 
 theorem ofLists_moveLeft {L R : List PGame} (i : Fin L.length) :
-    (ofLists L R).moveLeft (toOfListsLeftMoves i) = L.nthLe i i.is_lt :=
+    (ofLists L R).moveLeft (toOfListsLeftMoves i) = L.get i :=
   rfl
 #align pgame.of_lists_move_left SetTheory.PGame.ofLists_moveLeft
 
 @[simp]
 theorem ofLists_moveLeft' {L R : List PGame} (i : (ofLists L R).LeftMoves) :
-    (ofLists L R).moveLeft i =
-      L.nthLe (toOfListsLeftMoves.symm i) (toOfListsLeftMoves.symm i).is_lt :=
+    (ofLists L R).moveLeft i = L.get (toOfListsLeftMoves.symm i) :=
   rfl
 #align pgame.of_lists_move_left' SetTheory.PGame.ofLists_moveLeft'
 
 theorem ofLists_moveRight {L R : List PGame} (i : Fin R.length) :
-    (ofLists L R).moveRight (toOfListsRightMoves i) = R.nthLe i i.is_lt :=
+    (ofLists L R).moveRight (toOfListsRightMoves i) = R.get i :=
   rfl
 #align pgame.of_lists_move_right SetTheory.PGame.ofLists_moveRight
 
 @[simp]
 theorem ofLists_moveRight' {L R : List PGame} (i : (ofLists L R).RightMoves) :
-    (ofLists L R).moveRight i =
-      R.nthLe (toOfListsRightMoves.symm i) (toOfListsRightMoves.symm i).is_lt :=
+    (ofLists L R).moveRight i = R.get (toOfListsRightMoves.symm i) :=
   rfl
 #align pgame.of_lists_move_right' SetTheory.PGame.ofLists_moveRight'
 
@@ -1273,14 +1270,12 @@ instance : NegZeroClass PGame :=
 @[simp]
 theorem neg_ofLists (L R : List PGame) :
     -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
-  set_option linter.deprecated false in
-  simp only [ofLists, neg_def, List.nthLe_map', mk.injEq, List.length_map, true_and]
+  simp only [ofLists, neg_def, List.get_map, mk.injEq, List.length_map, true_and]
   constructor
   all_goals
     apply hfunext
     · simp
-    · intro a a' ha
-      congr 2
+    · rintro ⟨⟨a, ha⟩⟩ ⟨⟨b, hb⟩⟩ h
       have :
         ∀ {m n} (_ : m = n) {b : ULift (Fin m)} {c : ULift (Fin n)} (_ : HEq b c),
           (b.down : ℕ) = ↑c.down := by
@@ -1288,7 +1283,8 @@ theorem neg_ofLists (L R : List PGame) :
         simp only [heq_eq_eq]
         rintro rfl
         rfl
-      exact this (List.length_map _ _).symm ha
+      congr 5
+      exact this (List.length_map _ _).symm h
 #align pgame.neg_of_lists SetTheory.PGame.neg_ofLists
 
 theorem isOption_neg {x y : PGame} : IsOption x (-y) ↔ IsOption (-x) y := by

Co-authored-by: Moritz Firsching <firsching@google.com>

@@ -1807,11 +1807,11 @@ theorem add_lf_add_right {y z : PGame} (h : y ⧏ z) (x) : y + x ⧏ z + x :=
   fun w =>
   calc
     z ≤ z + 0 := (addZeroRelabelling _).symm.le
-    _ ≤ z + (x + -x) := (add_le_add_left (zero_le_add_right_neg x) _)
+    _ ≤ z + (x + -x) := add_le_add_left (zero_le_add_right_neg x) _
     _ ≤ z + x + -x := (addAssocRelabelling _ _ _).symm.le
-    _ ≤ y + x + -x := (add_le_add_right w _)
+    _ ≤ y + x + -x := add_le_add_right w _
     _ ≤ y + (x + -x) := (addAssocRelabelling _ _ _).le
-    _ ≤ y + 0 := (add_le_add_left (add_right_neg_le_zero x) _)
+    _ ≤ y + 0 := add_le_add_left (add_right_neg_le_zero x) _
     _ ≤ y := (addZeroRelabelling _).le
 
 #align pgame.add_lf_add_right SetTheory.PGame.add_lf_add_right
@@ -1866,9 +1866,9 @@ theorem le_iff_sub_nonneg {x y : PGame} : x ≤ y ↔ 0 ≤ y - x :=
   ⟨fun h => (zero_le_add_right_neg x).trans (add_le_add_right h _), fun h =>
     calc
       x ≤ 0 + x := (zeroAddRelabelling x).symm.le
-      _ ≤ y - x + x := (add_le_add_right h _)
+      _ ≤ y - x + x := add_le_add_right h _
       _ ≤ y + (-x + x) := (addAssocRelabelling _ _ _).le
-      _ ≤ y + 0 := (add_le_add_left (add_left_neg_le_zero x) _)
+      _ ≤ y + 0 := add_le_add_left (add_left_neg_le_zero x) _
       _ ≤ y := (addZeroRelabelling y).le
       ⟩
 #align pgame.le_iff_sub_nonneg SetTheory.PGame.le_iff_sub_nonneg
@@ -1877,9 +1877,9 @@ theorem lf_iff_sub_zero_lf {x y : PGame} : x ⧏ y ↔ 0 ⧏ y - x :=
   ⟨fun h => (zero_le_add_right_neg x).trans_lf (add_lf_add_right h _), fun h =>
     calc
       x ≤ 0 + x := (zeroAddRelabelling x).symm.le
-      _ ⧏ y - x + x := (add_lf_add_right h _)
+      _ ⧏ y - x + x := add_lf_add_right h _
       _ ≤ y + (-x + x) := (addAssocRelabelling _ _ _).le
-      _ ≤ y + 0 := (add_le_add_left (add_left_neg_le_zero x) _)
+      _ ≤ y + 0 := add_le_add_left (add_left_neg_le_zero x) _
       _ ≤ y := (addZeroRelabelling y).le
       ⟩
 #align pgame.lf_iff_sub_zero_lf SetTheory.PGame.lf_iff_sub_zero_lf
@@ -1888,9 +1888,9 @@ theorem lt_iff_sub_pos {x y : PGame} : x < y ↔ 0 < y - x :=
   ⟨fun h => lt_of_le_of_lt (zero_le_add_right_neg x) (add_lt_add_right h _), fun h =>
     calc
       x ≤ 0 + x := (zeroAddRelabelling x).symm.le
-      _ < y - x + x := (add_lt_add_right h _)
+      _ < y - x + x := add_lt_add_right h _
       _ ≤ y + (-x + x) := (addAssocRelabelling _ _ _).le
-      _ ≤ y + 0 := (add_le_add_left (add_left_neg_le_zero x) _)
+      _ ≤ y + 0 := add_le_add_left (add_left_neg_le_zero x) _
       _ ≤ y := (addZeroRelabelling y).le
       ⟩
 #align pgame.lt_iff_sub_pos SetTheory.PGame.lt_iff_sub_pos

Cherry-picked from #9607 Co-authored-by: @semorrison

@@ -1274,8 +1274,7 @@ instance : NegZeroClass PGame :=
 theorem neg_ofLists (L R : List PGame) :
     -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
   set_option linter.deprecated false in
-  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
-    mk.injEq]
+  simp only [ofLists, neg_def, List.nthLe_map', mk.injEq, List.length_map, true_and]
   constructor
   all_goals
     apply hfunext

Removes the insertNth section of this long file to its own new file. This section seems to be completely independent of the rest of the file, so this is a fairly easy split to make.

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Reid Barton, Mario Carneiro, Isabel Longbottom, Scott Morrison
 -/
 import Mathlib.Data.Fin.Basic
-import Mathlib.Data.List.Basic
+import Mathlib.Data.List.InsertNth
 import Mathlib.Logic.Relation
 import Mathlib.Logic.Small.Defs
 import Mathlib.Order.GameAdd

this will break once https://github.com/leanprover/lean4/pull/3658 lands, so let's fix this now.

Also avoids binding unused variables in termination_by.

@@ -1664,7 +1664,7 @@ def Relabelling.addCongr : ∀ {w x y z : PGame.{u}}, w ≡r x → y ≡r z →
     · exact Hwx.addCongr (hL₂ j)
     · exact (hR₁ i).addCongr Hyz
     · exact Hwx.addCongr (hR₂ j)
-termination_by w x y z => (x, z)
+termination_by _ x _ z => (x, z)
 #align pgame.relabelling.add_congr SetTheory.PGame.Relabelling.addCongr
 
 instance : Sub PGame :=

ball for "bounded forall" and bex for "bounded exists" are from experience very confusing abbreviations. This PR renames them to forall_mem and exists_mem in the few Set lemma names that mention them.

Also deprecate ball_image_of_ball, mem_image_elim, mem_image_elim_on since those lemmas are duplicates of the renamed lemmas (apart from argument order and implicitness, which I am also fixing by making the binder in the RHS of forall_mem_image semi-implicit), have obscure names and are completely unused.

@@ -741,7 +741,7 @@ theorem leftResponse_spec {x : PGame} (h : 0 ≤ x) (j : x.RightMoves) :
 lemma bddAbove_range_of_small [Small.{u} ι] (f : ι → PGame.{u}) : BddAbove (Set.range f) := by
   let x : PGame.{u} := ⟨Σ i, (f $ (equivShrink.{u} ι).symm i).LeftMoves, PEmpty,
     fun x ↦ moveLeft _ x.2, PEmpty.elim⟩
-  refine ⟨x, Set.forall_range_iff.2 fun i ↦ ?_⟩
+  refine ⟨x, Set.forall_mem_range.2 fun i ↦ ?_⟩
   rw [← (equivShrink ι).symm_apply_apply i, le_iff_forall_lf]
   simpa [x] using fun j ↦ @moveLeft_lf x ⟨equivShrink ι i, j⟩
 
@@ -759,7 +759,7 @@ lemma bddAbove_of_small (s : Set PGame.{u}) [Small.{u} s] : BddAbove s := by
 lemma bddBelow_range_of_small [Small.{u} ι] (f : ι → PGame.{u}) : BddBelow (Set.range f) := by
   let x : PGame.{u} := ⟨PEmpty, Σ i, (f $ (equivShrink.{u} ι).symm i).RightMoves, PEmpty.elim,
     fun x ↦ moveRight _ x.2⟩
-  refine ⟨x, Set.forall_range_iff.2 fun i ↦ ?_⟩
+  refine ⟨x, Set.forall_mem_range.2 fun i ↦ ?_⟩
   rw [← (equivShrink ι).symm_apply_apply i, le_iff_forall_lf]
   simpa [x] using fun j ↦ @lf_moveRight x ⟨equivShrink ι i, j⟩
 

This is a very large PR, but it has been reviewed piecemeal already in PRs to the bump/v4.7.0 branch as we update to intermediate nightlies.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: damiano <adomani@gmail.com>

@@ -743,7 +743,7 @@ lemma bddAbove_range_of_small [Small.{u} ι] (f : ι → PGame.{u}) : BddAbove (
     fun x ↦ moveLeft _ x.2, PEmpty.elim⟩
   refine ⟨x, Set.forall_range_iff.2 fun i ↦ ?_⟩
   rw [← (equivShrink ι).symm_apply_apply i, le_iff_forall_lf]
-  simpa using fun j ↦ @moveLeft_lf x ⟨equivShrink ι i, j⟩
+  simpa [x] using fun j ↦ @moveLeft_lf x ⟨equivShrink ι i, j⟩
 
 /-- A small set of pre-games is bounded above. -/
 lemma bddAbove_of_small (s : Set PGame.{u}) [Small.{u} s] : BddAbove s := by
@@ -761,7 +761,7 @@ lemma bddBelow_range_of_small [Small.{u} ι] (f : ι → PGame.{u}) : BddBelow (
     fun x ↦ moveRight _ x.2⟩
   refine ⟨x, Set.forall_range_iff.2 fun i ↦ ?_⟩
   rw [← (equivShrink ι).symm_apply_apply i, le_iff_forall_lf]
-  simpa using fun j ↦ @lf_moveRight x ⟨equivShrink ι i, j⟩
+  simpa [x] using fun j ↦ @lf_moveRight x ⟨equivShrink ι i, j⟩
 
 /-- A small set of pre-games is bounded below. -/
 lemma bddBelow_of_small (s : Set PGame.{u}) [Small.{u} s] : BddBelow s := by

Partially forward-port https://github.com/leanprover-community/mathlib/pull/15260

@@ -6,9 +6,10 @@ Authors: Reid Barton, Mario Carneiro, Isabel Longbottom, Scott Morrison
 import Mathlib.Data.Fin.Basic
 import Mathlib.Data.List.Basic
 import Mathlib.Logic.Relation
+import Mathlib.Logic.Small.Defs
 import Mathlib.Order.GameAdd
 
-#align_import set_theory.game.pgame from "leanprover-community/mathlib"@"dc9e5ba64653e017743ba5d2c28e42f9f486bf99"
+#align_import set_theory.game.pgame from "leanprover-community/mathlib"@"8900d545017cd21961daa2a1734bb658ef52c618"
 
 /-!
 # Combinatorial (pre-)games.
@@ -731,6 +732,42 @@ theorem leftResponse_spec {x : PGame} (h : 0 ≤ x) (j : x.RightMoves) :
   Classical.choose_spec <| (zero_le.1 h) j
 #align pgame.left_response_spec SetTheory.PGame.leftResponse_spec
 
+#noalign pgame.upper_bound
+#noalign pgame.upper_bound_right_moves_empty
+#noalign pgame.le_upper_bound
+#noalign pgame.upper_bound_mem_upper_bounds
+
+/-- A small family of pre-games is bounded above. -/
+lemma bddAbove_range_of_small [Small.{u} ι] (f : ι → PGame.{u}) : BddAbove (Set.range f) := by
+  let x : PGame.{u} := ⟨Σ i, (f $ (equivShrink.{u} ι).symm i).LeftMoves, PEmpty,
+    fun x ↦ moveLeft _ x.2, PEmpty.elim⟩
+  refine ⟨x, Set.forall_range_iff.2 fun i ↦ ?_⟩
+  rw [← (equivShrink ι).symm_apply_apply i, le_iff_forall_lf]
+  simpa using fun j ↦ @moveLeft_lf x ⟨equivShrink ι i, j⟩
+
+/-- A small set of pre-games is bounded above. -/
+lemma bddAbove_of_small (s : Set PGame.{u}) [Small.{u} s] : BddAbove s := by
+  simpa using bddAbove_range_of_small (Subtype.val : s → PGame.{u})
+#align pgame.bdd_above_of_small SetTheory.PGame.bddAbove_of_small
+
+#noalign pgame.lower_bound
+#noalign pgame.lower_bound_left_moves_empty
+#noalign pgame.lower_bound_le
+#noalign pgame.lower_bound_mem_lower_bounds
+
+/-- A small family of pre-games is bounded below. -/
+lemma bddBelow_range_of_small [Small.{u} ι] (f : ι → PGame.{u}) : BddBelow (Set.range f) := by
+  let x : PGame.{u} := ⟨PEmpty, Σ i, (f $ (equivShrink.{u} ι).symm i).RightMoves, PEmpty.elim,
+    fun x ↦ moveRight _ x.2⟩
+  refine ⟨x, Set.forall_range_iff.2 fun i ↦ ?_⟩
+  rw [← (equivShrink ι).symm_apply_apply i, le_iff_forall_lf]
+  simpa using fun j ↦ @lf_moveRight x ⟨equivShrink ι i, j⟩
+
+/-- A small set of pre-games is bounded below. -/
+lemma bddBelow_of_small (s : Set PGame.{u}) [Small.{u} s] : BddBelow s := by
+  simpa using bddBelow_range_of_small (Subtype.val : s → PGame.{u})
+#align pgame.bdd_below_of_small SetTheory.PGame.bddBelow_of_small
+
 /-- The equivalence relation on pre-games. Two pre-games `x`, `y` are equivalent if `x ≤ y` and
 `y ≤ x`.
 

Classifies by adding issue number (#10754) to porting notes claiming added instance.

@@ -566,7 +566,7 @@ theorem lf_of_le_of_lf {x y z : PGame} (h₁ : x ≤ y) (h₂ : y ⧏ z) : x ⧏
   exact fun h₃ => h₂ (h₃.trans h₁)
 #align pgame.lf_of_le_of_lf SetTheory.PGame.lf_of_le_of_lf
 
--- Porting note: added
+-- Porting note (#10754): added instance
 instance : Trans (· ≤ ·) (· ⧏ ·) (· ⧏ ·) := ⟨lf_of_le_of_lf⟩
 
 @[trans]
@@ -575,7 +575,7 @@ theorem lf_of_lf_of_le {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y ≤ z) : x ⧏
   exact fun h₃ => h₁ (h₂.trans h₃)
 #align pgame.lf_of_lf_of_le SetTheory.PGame.lf_of_lf_of_le
 
--- Porting note: added
+-- Porting note (#10754): added instance
 instance : Trans (· ⧏ ·) (· ≤ ·) (· ⧏ ·) := ⟨lf_of_lf_of_le⟩
 
 alias _root_.LE.le.trans_lf := lf_of_le_of_lf

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Joachim Breitner <mail@joachim-breitner.de>

@@ -1124,7 +1124,7 @@ def moveRightSymm :
 @[refl]
 def refl (x : PGame) : x ≡r x :=
   ⟨Equiv.refl _, Equiv.refl _, fun i => refl _, fun j => refl _⟩
-termination_by _ => x
+termination_by x
 #align pgame.relabelling.refl SetTheory.PGame.Relabelling.refl
 
 instance (x : PGame) : Inhabited (x ≡r x) :=
@@ -1140,7 +1140,7 @@ theorem le {x y : PGame} (r : x ≡r y) : x ≤ y :=
   le_def.2
     ⟨fun i => Or.inl ⟨_, (r.moveLeft i).le⟩, fun j =>
       Or.inr ⟨_, (r.moveRightSymm j).le⟩⟩
-termination_by _ => x
+termination_by x
 #align pgame.relabelling.le SetTheory.PGame.Relabelling.le
 
 theorem ge {x y : PGame} (r : x ≡r y) : y ≤ x :=
@@ -1347,7 +1347,7 @@ private theorem neg_le_lf_neg_iff : ∀ {x y : PGame.{u}}, (-y ≤ -x ↔ x ≤
       apply and_congr <;> exact forall_congr' fun _ => neg_le_lf_neg_iff.2
     · rw [or_comm]
       apply or_congr <;> exact exists_congr fun _ => neg_le_lf_neg_iff.1
-termination_by _ x y => (x, y)
+termination_by x y => (x, y)
 
 @[simp]
 theorem neg_le_neg_iff {x y : PGame} : -y ≤ -x ↔ x ≤ y :=
@@ -1485,7 +1485,7 @@ def addZeroRelabelling : ∀ x : PGame.{u}, x + 0 ≡r x
   | ⟨xl, xr, xL, xR⟩ => by
     refine' ⟨Equiv.sumEmpty xl PEmpty, Equiv.sumEmpty xr PEmpty, _, _⟩ <;> rintro (⟨i⟩ | ⟨⟨⟩⟩) <;>
       apply addZeroRelabelling
-termination_by _ x => x
+termination_by x => x
 #align pgame.add_zero_relabelling SetTheory.PGame.addZeroRelabelling
 
 /-- `x + 0` is equivalent to `x`. -/
@@ -1627,7 +1627,7 @@ def Relabelling.addCongr : ∀ {w x y z : PGame.{u}}, w ≡r x → y ≡r z →
     · exact Hwx.addCongr (hL₂ j)
     · exact (hR₁ i).addCongr Hyz
     · exact Hwx.addCongr (hR₂ j)
-termination_by _ w x y z _ _ => (x, z)
+termination_by w x y z => (x, z)
 #align pgame.relabelling.add_congr SetTheory.PGame.Relabelling.addCongr
 
 instance : Sub PGame :=
@@ -1652,7 +1652,7 @@ def negAddRelabelling : ∀ x y : PGame, -(x + y) ≡r -x + -y
       exact fun j =>
         Sum.casesOn j (fun j => negAddRelabelling _ _) fun j =>
           negAddRelabelling ⟨xl, xr, xL, xR⟩ _
-termination_by _ x y => (x, y)
+termination_by x y => (x, y)
 #align pgame.neg_add_relabelling SetTheory.PGame.negAddRelabelling
 
 theorem neg_add_le {x y : PGame} : -(x + y) ≤ -x + -y :=
@@ -1665,7 +1665,7 @@ def addCommRelabelling : ∀ x y : PGame.{u}, x + y ≡r y + x
     refine' ⟨Equiv.sumComm _ _, Equiv.sumComm _ _, _, _⟩ <;> rintro (_ | _) <;>
       · dsimp
         apply addCommRelabelling
-termination_by _ x y => (x, y)
+termination_by x y => (x, y)
 #align pgame.add_comm_relabelling SetTheory.PGame.addCommRelabelling
 
 theorem add_comm_le {x y : PGame} : x + y ≤ y + x :=
@@ -1688,7 +1688,7 @@ def addAssocRelabelling : ∀ x y z : PGame.{u}, x + y + z ≡r x + (y + z)
       · apply addAssocRelabelling
       · apply addAssocRelabelling ⟨xl, xr, xL, xR⟩ (yR i)
       · apply addAssocRelabelling ⟨xl, xr, xL, xR⟩ ⟨yl, yr, yL, yR⟩ (zR i)
-termination_by _ x y z => (x, y, z)
+termination_by x y z => (x, y, z)
 #align pgame.add_assoc_relabelling SetTheory.PGame.addAssocRelabelling
 
 theorem add_assoc_equiv {x y z : PGame} : x + y + z ≈ x + (y + z) :=
@@ -1754,7 +1754,7 @@ private theorem add_le_add_right' : ∀ {x y z : PGame}, x ≤ y → x + z ≤ y
       · exact Or.inr ⟨toRightMovesAdd (Sum.inl j'), add_le_add_right' jh⟩
     · exact
         Or.inr ⟨@toRightMovesAdd _ ⟨_, _, _, _⟩ (Sum.inr i), add_le_add_right' h⟩
-termination_by _ x y z => (x, y, z)
+termination_by x y z => (x, y, z)
 
 instance covariantClass_swap_add_le : CovariantClass PGame PGame (swap (· + ·)) (· ≤ ·) :=
   ⟨fun _ _ _ => add_le_add_right'⟩

This is needed to work with leanprover/lean4#3087

@@ -1663,7 +1663,7 @@ theorem neg_add_le {x y : PGame} : -(x + y) ≤ -x + -y :=
 def addCommRelabelling : ∀ x y : PGame.{u}, x + y ≡r y + x
   | mk xl xr xL xR, mk yl yr yL yR => by
     refine' ⟨Equiv.sumComm _ _, Equiv.sumComm _ _, _, _⟩ <;> rintro (_ | _) <;>
-      · dsimp [leftMoves_add, rightMoves_add]
+      · dsimp
         apply addCommRelabelling
 termination_by _ x y => (x, y)
 #align pgame.add_comm_relabelling SetTheory.PGame.addCommRelabelling

@@ -1066,7 +1066,7 @@ def mk' (L : y.LeftMoves ≃ x.LeftMoves) (R : y.RightMoves ≃ x.RightMoves)
 #align pgame.relabelling.mk' SetTheory.PGame.Relabelling.mk'
 
 /-- The equivalence between left moves of `x` and `y` given by the relabelling. -/
-def leftMovesEquiv : ∀ _ : x ≡r y, x.LeftMoves ≃ y.LeftMoves
+def leftMovesEquiv : x ≡r y → x.LeftMoves ≃ y.LeftMoves
   | ⟨L,_, _,_⟩ => L
 #align pgame.relabelling.left_moves_equiv SetTheory.PGame.Relabelling.leftMovesEquiv
 
@@ -1082,7 +1082,7 @@ theorem mk'_leftMovesEquiv {x y L R hL hR} :
 #align pgame.relabelling.mk'_left_moves_equiv SetTheory.PGame.Relabelling.mk'_leftMovesEquiv
 
 /-- The equivalence between right moves of `x` and `y` given by the relabelling. -/
-def rightMovesEquiv : ∀ _ : x ≡r y, x.RightMoves ≃ y.RightMoves
+def rightMovesEquiv : x ≡r y → x.RightMoves ≃ y.RightMoves
   | ⟨_, R, _, _⟩ => R
 #align pgame.relabelling.right_moves_equiv SetTheory.PGame.Relabelling.rightMovesEquiv
 

• @[mk_iff] class MyPred now generates myPred_iff, not MyPred_iff
• add Lean.Name.decapitalize
• fix indentation and a few typos in the docs/comments.

Partially addresses issue #9129

@@ -1256,7 +1256,7 @@ theorem neg_ofLists (L R : List PGame) :
 #align pgame.neg_of_lists SetTheory.PGame.neg_ofLists
 
 theorem isOption_neg {x y : PGame} : IsOption x (-y) ↔ IsOption (-x) y := by
-  rw [IsOption_iff, IsOption_iff, or_comm]
+  rw [isOption_iff, isOption_iff, or_comm]
   cases y;
   apply or_congr <;>
     · apply exists_congr

Subset of #9319

@@ -218,7 +218,7 @@ Both this and `PGame.recOn` describe Conway induction on games. -/
 @[elab_as_elim]
 def moveRecOn {C : PGame → Sort*} (x : PGame)
     (IH : ∀ y : PGame, (∀ i, C (y.moveLeft i)) → (∀ j, C (y.moveRight j)) → C y) : C x :=
-  x.recOn <| fun yl yr yL yR => IH (mk yl yr yL yR)
+  x.recOn fun yl yr yL yR => IH (mk yl yr yL yR)
 #align pgame.move_rec_on SetTheory.PGame.moveRecOn
 
 /-- `IsOption x y` means that `x` is either a left or right option for `y`. -/

@@ -399,12 +399,12 @@ instance le : LE PGame :=
 /-- The less or fuzzy relation on pre-games.
 
 If `0 ⧏ x`, then Left can win `x` as the first player. -/
-def Lf (x y : PGame) : Prop :=
+def LF (x y : PGame) : Prop :=
   ¬y ≤ x
-#align pgame.lf SetTheory.PGame.Lf
+#align pgame.lf SetTheory.PGame.LF
 
 @[inherit_doc]
-scoped infixl:50 " ⧏ " => PGame.Lf
+scoped infixl:50 " ⧏ " => PGame.LF
 
 @[simp]
 protected theorem not_le {x y : PGame} : ¬x ≤ y ↔ y ⧏ x :=
@@ -420,9 +420,9 @@ theorem _root_.LE.le.not_gf {x y : PGame} : x ≤ y → ¬y ⧏ x :=
   not_lf.2
 #align has_le.le.not_gf LE.le.not_gf
 
-theorem Lf.not_ge {x y : PGame} : x ⧏ y → ¬y ≤ x :=
+theorem LF.not_ge {x y : PGame} : x ⧏ y → ¬y ≤ x :=
   id
-#align pgame.lf.not_ge SetTheory.PGame.Lf.not_ge
+#align pgame.lf.not_ge SetTheory.PGame.LF.not_ge
 
 /-- Definition of `x ≤ y` on pre-games, in terms of `⧏`.
 
@@ -454,7 +454,7 @@ The ordering here is chosen so that `or.inl` refer to moves by Left, and `or.inr
 moves by Right. -/
 theorem lf_iff_exists_le {x y : PGame} :
     x ⧏ y ↔ (∃ i, x ≤ y.moveLeft i) ∨ ∃ j, x.moveRight j ≤ y := by
-  rw [Lf, le_iff_forall_lf, not_and_or]
+  rw [LF, le_iff_forall_lf, not_and_or]
   simp
 #align pgame.lf_iff_exists_le SetTheory.PGame.lf_iff_exists_le
 
@@ -581,8 +581,8 @@ instance : Trans (· ⧏ ·) (· ≤ ·) (· ⧏ ·) := ⟨lf_of_lf_of_le⟩
 alias _root_.LE.le.trans_lf := lf_of_le_of_lf
 #align has_le.le.trans_lf LE.le.trans_lf
 
-alias Lf.trans_le := lf_of_lf_of_le
-#align pgame.lf.trans_le SetTheory.PGame.Lf.trans_le
+alias LF.trans_le := lf_of_lf_of_le
+#align pgame.lf.trans_le SetTheory.PGame.LF.trans_le
 
 @[trans]
 theorem lf_of_lt_of_lf {x y z : PGame} (h₁ : x < y) (h₂ : y ⧏ z) : x ⧏ z :=
@@ -597,8 +597,8 @@ theorem lf_of_lf_of_lt {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y < z) : x ⧏ z
 alias _root_.LT.lt.trans_lf := lf_of_lt_of_lf
 #align has_lt.lt.trans_lf LT.lt.trans_lf
 
-alias Lf.trans_lt := lf_of_lf_of_lt
-#align pgame.lf.trans_lt SetTheory.PGame.Lf.trans_lt
+alias LF.trans_lt := lf_of_lf_of_lt
+#align pgame.lf.trans_lt SetTheory.PGame.LF.trans_lt
 
 theorem moveLeft_lf {x : PGame} : ∀ i, x.moveLeft i ⧏ x :=
   le_rfl.moveLeft_lf
@@ -809,14 +809,14 @@ instance : Trans
     ((· ≤ ·) : PGame → PGame → Prop) where
   trans := le_of_equiv_of_le
 
-theorem Lf.not_equiv {x y : PGame} (h : x ⧏ y) : ¬(x ≈ y) := fun h' => h.not_ge h'.2
-#align pgame.lf.not_equiv SetTheory.PGame.Lf.not_equiv
+theorem LF.not_equiv {x y : PGame} (h : x ⧏ y) : ¬(x ≈ y) := fun h' => h.not_ge h'.2
+#align pgame.lf.not_equiv SetTheory.PGame.LF.not_equiv
 
-theorem Lf.not_equiv' {x y : PGame} (h : x ⧏ y) : ¬(y ≈ x) := fun h' => h.not_ge h'.1
-#align pgame.lf.not_equiv' SetTheory.PGame.Lf.not_equiv'
+theorem LF.not_equiv' {x y : PGame} (h : x ⧏ y) : ¬(y ≈ x) := fun h' => h.not_ge h'.1
+#align pgame.lf.not_equiv' SetTheory.PGame.LF.not_equiv'
 
-theorem Lf.not_gt {x y : PGame} (h : x ⧏ y) : ¬y < x := fun h' => h.not_ge h'.le
-#align pgame.lf.not_gt SetTheory.PGame.Lf.not_gt
+theorem LF.not_gt {x y : PGame} (h : x ⧏ y) : ¬y < x := fun h' => h.not_ge h'.le
+#align pgame.lf.not_gt SetTheory.PGame.LF.not_gt
 
 theorem le_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) (h : x₁ ≤ y₁) : x₂ ≤ y₂ :=
   hx.2.trans (h.trans hy.1)

Many proofs use the "stream of consciousness" style from Lean 3, rather than have ... := or suffices ... from/by.

This PR updates a fraction of these to the preferred Lean 4 style.

I think a good goal would be to delete the "deferred" versions of have, suffices, and let at the bottom of Mathlib.Tactic.Have

(Anyone who would like to contribute more cleanup is welcome to push directly to this branch.)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -524,10 +524,10 @@ instance : Preorder PGame :=
       exact
         le_of_forall_lf (fun i => lf_of_le_moveLeft (IHl i)) fun i => lf_of_moveRight_le (IHr i)
     le_trans := by
-      suffices :
+      suffices
         ∀ {x y z : PGame},
-          (x ≤ y → y ≤ z → x ≤ z) ∧ (y ≤ z → z ≤ x → y ≤ x) ∧ (z ≤ x → x ≤ y → z ≤ y)
-      exact fun x y z => this.1
+          (x ≤ y → y ≤ z → x ≤ z) ∧ (y ≤ z → z ≤ x → y ≤ x) ∧ (z ≤ x → x ≤ y → z ≤ y) from
+        fun x y z => this.1
       intro x y z
       induction' x with xl xr xL xR IHxl IHxr generalizing y z
       induction' y with yl yr yL yR IHyl IHyr generalizing z

move Game and PGame into namespace SetTheory as _root_.Game might collide with other definitions (e.g. in projects depending on mathlib)

@@ -19,23 +19,24 @@ operations descend to "games", defined via the equivalence relation `p ≈ q ↔
 
 The surreal numbers will be built as a quotient of a subtype of pregames.
 
-A pregame (`PGame` below) is axiomatised via an inductive type, whose sole constructor takes two
-types (thought of as indexing the possible moves for the players Left and Right), and a pair of
-functions out of these types to `PGame` (thought of as describing the resulting game after making a
-move).
+A pregame (`SetTheory.PGame` below) is axiomatised via an inductive type, whose sole constructor
+takes two types (thought of as indexing the possible moves for the players Left and Right), and a
+pair of functions out of these types to `SetTheory.PGame` (thought of as describing the resulting
+game after making a move).
 
 Combinatorial games themselves, as a quotient of pregames, are constructed in `Game.lean`.
 
 ## Conway induction
 
 By construction, the induction principle for pregames is exactly "Conway induction". That is, to
-prove some predicate `PGame → Prop` holds for all pregames, it suffices to prove that for every
-pregame `g`, if the predicate holds for every game resulting from making a move, then it also holds
-for `g`.
+prove some predicate `SetTheory.PGame → Prop` holds for all pregames, it suffices to prove
+that for every pregame `g`, if the predicate holds for every game resulting from making a move,
+then it also holds for `g`.
 
 While it is often convenient to work "by induction" on pregames, in some situations this becomes
-awkward, so we also define accessor functions `PGame.LeftMoves`, `PGame.RightMoves`,
-`PGame.moveLeft` and `PGame.moveRight`. There is a relation `PGame.Subsequent p q`, saying that
+awkward, so we also define accessor functions `SetTheory.PGame.LeftMoves`,
+`SetTheory.PGame.RightMoves`, `SetTheory.PGame.moveLeft` and `SetTheory.PGame.moveRight`.
+There is a relation `PGame.Subsequent p q`, saying that
 `p` can be reached by playing some non-empty sequence of moves starting from `q`, an instance
 `WellFounded Subsequent`, and a local tactic `pgame_wf_tac` which is helpful for discharging proof
 obligations in inductive proofs relying on this relation.
@@ -57,7 +58,7 @@ Statements like `zero_le_lf`, `zero_lf_le`, etc. unfold these definitions. The t
 The theorems `zero_le`, `zero_lf`, etc. also take into account that `0` has no moves.
 
 Later, games will be defined as the quotient by the `≈` relation; that is to say, the
-`Antisymmetrization` of `PGame`.
+`Antisymmetrization` of `SetTheory.PGame`.
 
 ## Algebraic structures
 
@@ -97,6 +98,8 @@ An interested reader may like to formalise some of the material from
 
 set_option autoImplicit true
 
+namespace SetTheory
+
 open Function Relation
 
 -- We'd like to be able to use multi-character auto-implicits in this file.
@@ -114,7 +117,7 @@ set_option relaxedAutoImplicit true
   reflecting that it is a proper class in ZFC. -/
 inductive PGame : Type (u + 1)
   | mk : ∀ α β : Type u, (α → PGame) → (β → PGame) → PGame
-#align pgame PGame
+#align pgame SetTheory.PGame
 compile_inductive% PGame
 
 namespace PGame
@@ -122,42 +125,42 @@ namespace PGame
 /-- The indexing type for allowable moves by Left. -/
 def LeftMoves : PGame → Type u
   | mk l _ _ _ => l
-#align pgame.left_moves PGame.LeftMoves
+#align pgame.left_moves SetTheory.PGame.LeftMoves
 
 /-- The indexing type for allowable moves by Right. -/
 def RightMoves : PGame → Type u
   | mk _ r _ _ => r
-#align pgame.right_moves PGame.RightMoves
+#align pgame.right_moves SetTheory.PGame.RightMoves
 
 /-- The new game after Left makes an allowed move. -/
 def moveLeft : ∀ g : PGame, LeftMoves g → PGame
   | mk _l _ L _ => L
-#align pgame.move_left PGame.moveLeft
+#align pgame.move_left SetTheory.PGame.moveLeft
 
 /-- The new game after Right makes an allowed move. -/
 def moveRight : ∀ g : PGame, RightMoves g → PGame
   | mk _ _r _ R => R
-#align pgame.move_right PGame.moveRight
+#align pgame.move_right SetTheory.PGame.moveRight
 
 @[simp]
 theorem leftMoves_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).LeftMoves = xl :=
   rfl
-#align pgame.left_moves_mk PGame.leftMoves_mk
+#align pgame.left_moves_mk SetTheory.PGame.leftMoves_mk
 
 @[simp]
 theorem moveLeft_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).moveLeft = xL :=
   rfl
-#align pgame.move_left_mk PGame.moveLeft_mk
+#align pgame.move_left_mk SetTheory.PGame.moveLeft_mk
 
 @[simp]
 theorem rightMoves_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).RightMoves = xr :=
   rfl
-#align pgame.right_moves_mk PGame.rightMoves_mk
+#align pgame.right_moves_mk SetTheory.PGame.rightMoves_mk
 
 @[simp]
 theorem moveRight_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).moveRight = xR :=
   rfl
-#align pgame.move_right_mk PGame.moveRight_mk
+#align pgame.move_right_mk SetTheory.PGame.moveRight_mk
 
 -- TODO define this at the level of games, as well, and perhaps also for finsets of games.
 /-- Construct a pre-game from list of pre-games describing the available moves for Left and Right.
@@ -165,49 +168,49 @@ theorem moveRight_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).moveRight =
 def ofLists (L R : List PGame.{u}) : PGame.{u} :=
   mk (ULift (Fin L.length)) (ULift (Fin R.length)) (fun i => L.nthLe i.down i.down.is_lt) fun j ↦
     R.nthLe j.down j.down.prop
-#align pgame.of_lists PGame.ofLists
+#align pgame.of_lists SetTheory.PGame.ofLists
 
 theorem leftMoves_ofLists (L R : List PGame) : (ofLists L R).LeftMoves = ULift (Fin L.length) :=
   rfl
-#align pgame.left_moves_of_lists PGame.leftMoves_ofLists
+#align pgame.left_moves_of_lists SetTheory.PGame.leftMoves_ofLists
 
 theorem rightMoves_ofLists (L R : List PGame) : (ofLists L R).RightMoves = ULift (Fin R.length) :=
   rfl
-#align pgame.right_moves_of_lists PGame.rightMoves_ofLists
+#align pgame.right_moves_of_lists SetTheory.PGame.rightMoves_ofLists
 
 /-- Converts a number into a left move for `ofLists`. -/
 def toOfListsLeftMoves {L R : List PGame} : Fin L.length ≃ (ofLists L R).LeftMoves :=
   ((Equiv.cast (leftMoves_ofLists L R).symm).trans Equiv.ulift).symm
-#align pgame.to_of_lists_left_moves PGame.toOfListsLeftMoves
+#align pgame.to_of_lists_left_moves SetTheory.PGame.toOfListsLeftMoves
 
 /-- Converts a number into a right move for `ofLists`. -/
 def toOfListsRightMoves {L R : List PGame} : Fin R.length ≃ (ofLists L R).RightMoves :=
   ((Equiv.cast (rightMoves_ofLists L R).symm).trans Equiv.ulift).symm
-#align pgame.to_of_lists_right_moves PGame.toOfListsRightMoves
+#align pgame.to_of_lists_right_moves SetTheory.PGame.toOfListsRightMoves
 
 theorem ofLists_moveLeft {L R : List PGame} (i : Fin L.length) :
     (ofLists L R).moveLeft (toOfListsLeftMoves i) = L.nthLe i i.is_lt :=
   rfl
-#align pgame.of_lists_move_left PGame.ofLists_moveLeft
+#align pgame.of_lists_move_left SetTheory.PGame.ofLists_moveLeft
 
 @[simp]
 theorem ofLists_moveLeft' {L R : List PGame} (i : (ofLists L R).LeftMoves) :
     (ofLists L R).moveLeft i =
       L.nthLe (toOfListsLeftMoves.symm i) (toOfListsLeftMoves.symm i).is_lt :=
   rfl
-#align pgame.of_lists_move_left' PGame.ofLists_moveLeft'
+#align pgame.of_lists_move_left' SetTheory.PGame.ofLists_moveLeft'
 
 theorem ofLists_moveRight {L R : List PGame} (i : Fin R.length) :
     (ofLists L R).moveRight (toOfListsRightMoves i) = R.nthLe i i.is_lt :=
   rfl
-#align pgame.of_lists_move_right PGame.ofLists_moveRight
+#align pgame.of_lists_move_right SetTheory.PGame.ofLists_moveRight
 
 @[simp]
 theorem ofLists_moveRight' {L R : List PGame} (i : (ofLists L R).RightMoves) :
     (ofLists L R).moveRight i =
       R.nthLe (toOfListsRightMoves.symm i) (toOfListsRightMoves.symm i).is_lt :=
   rfl
-#align pgame.of_lists_move_right' PGame.ofLists_moveRight'
+#align pgame.of_lists_move_right' SetTheory.PGame.ofLists_moveRight'
 
 /-- A variant of `PGame.recOn` expressed in terms of `PGame.moveLeft` and `PGame.moveRight`.
 
@@ -216,24 +219,24 @@ Both this and `PGame.recOn` describe Conway induction on games. -/
 def moveRecOn {C : PGame → Sort*} (x : PGame)
     (IH : ∀ y : PGame, (∀ i, C (y.moveLeft i)) → (∀ j, C (y.moveRight j)) → C y) : C x :=
   x.recOn <| fun yl yr yL yR => IH (mk yl yr yL yR)
-#align pgame.move_rec_on PGame.moveRecOn
+#align pgame.move_rec_on SetTheory.PGame.moveRecOn
 
 /-- `IsOption x y` means that `x` is either a left or right option for `y`. -/
 @[mk_iff]
 inductive IsOption : PGame → PGame → Prop
   | moveLeft {x : PGame} (i : x.LeftMoves) : IsOption (x.moveLeft i) x
   | moveRight {x : PGame} (i : x.RightMoves) : IsOption (x.moveRight i) x
-#align pgame.is_option PGame.IsOption
+#align pgame.is_option SetTheory.PGame.IsOption
 
 theorem IsOption.mk_left {xl xr : Type u} (xL : xl → PGame) (xR : xr → PGame) (i : xl) :
     (xL i).IsOption (mk xl xr xL xR) :=
   @IsOption.moveLeft (mk _ _ _ _) i
-#align pgame.is_option.mk_left PGame.IsOption.mk_left
+#align pgame.is_option.mk_left SetTheory.PGame.IsOption.mk_left
 
 theorem IsOption.mk_right {xl xr : Type u} (xL : xl → PGame) (xR : xr → PGame) (i : xr) :
     (xR i).IsOption (mk xl xr xL xR) :=
   @IsOption.moveRight (mk _ _ _ _) i
-#align pgame.is_option.mk_right PGame.IsOption.mk_right
+#align pgame.is_option.mk_right SetTheory.PGame.IsOption.mk_right
 
 theorem wf_isOption : WellFounded IsOption :=
   ⟨fun x =>
@@ -242,13 +245,13 @@ theorem wf_isOption : WellFounded IsOption :=
         induction' h with _ i _ j
         · exact IHl i
         · exact IHr j⟩
-#align pgame.wf_is_option PGame.wf_isOption
+#align pgame.wf_is_option SetTheory.PGame.wf_isOption
 
 /-- `Subsequent x y` says that `x` can be obtained by playing some nonempty sequence of moves from
 `y`. It is the transitive closure of `IsOption`. -/
 def Subsequent : PGame → PGame → Prop :=
   TransGen IsOption
-#align pgame.subsequent PGame.Subsequent
+#align pgame.subsequent SetTheory.PGame.Subsequent
 
 instance : IsTrans _ Subsequent :=
   inferInstanceAs <| IsTrans _ (TransGen _)
@@ -256,11 +259,11 @@ instance : IsTrans _ Subsequent :=
 @[trans]
 theorem Subsequent.trans {x y z} : Subsequent x y → Subsequent y z → Subsequent x z :=
   TransGen.trans
-#align pgame.subsequent.trans PGame.Subsequent.trans
+#align pgame.subsequent.trans SetTheory.PGame.Subsequent.trans
 
 theorem wf_subsequent : WellFounded Subsequent :=
   wf_isOption.transGen
-#align pgame.wf_subsequent PGame.wf_subsequent
+#align pgame.wf_subsequent SetTheory.PGame.wf_subsequent
 
 instance : WellFoundedRelation PGame :=
   ⟨_, wf_subsequent⟩
@@ -268,24 +271,24 @@ instance : WellFoundedRelation PGame :=
 @[simp]
 theorem Subsequent.moveLeft {x : PGame} (i : x.LeftMoves) : Subsequent (x.moveLeft i) x :=
   TransGen.single (IsOption.moveLeft i)
-#align pgame.subsequent.move_left PGame.Subsequent.moveLeft
+#align pgame.subsequent.move_left SetTheory.PGame.Subsequent.moveLeft
 
 @[simp]
 theorem Subsequent.moveRight {x : PGame} (j : x.RightMoves) : Subsequent (x.moveRight j) x :=
   TransGen.single (IsOption.moveRight j)
-#align pgame.subsequent.move_right PGame.Subsequent.moveRight
+#align pgame.subsequent.move_right SetTheory.PGame.Subsequent.moveRight
 
 @[simp]
 theorem Subsequent.mk_left {xl xr} (xL : xl → PGame) (xR : xr → PGame) (i : xl) :
     Subsequent (xL i) (mk xl xr xL xR) :=
   @Subsequent.moveLeft (mk _ _ _ _) i
-#align pgame.subsequent.mk_left PGame.Subsequent.mk_left
+#align pgame.subsequent.mk_left SetTheory.PGame.Subsequent.mk_left
 
 @[simp]
 theorem Subsequent.mk_right {xl xr} (xL : xl → PGame) (xR : xr → PGame) (j : xr) :
     Subsequent (xR j) (mk xl xr xL xR) :=
   @Subsequent.moveRight (mk _ _ _ _) j
-#align pgame.subsequent.mk_right PGame.Subsequent.mk_right
+#align pgame.subsequent.mk_right SetTheory.PGame.Subsequent.mk_right
 
 /--
 Discharges proof obligations of the form `⊢ Subsequent ..` arising in termination proofs
@@ -337,20 +340,20 @@ instance : Zero PGame :=
 @[simp]
 theorem zero_leftMoves : LeftMoves 0 = PEmpty :=
   rfl
-#align pgame.zero_left_moves PGame.zero_leftMoves
+#align pgame.zero_left_moves SetTheory.PGame.zero_leftMoves
 
 @[simp]
 theorem zero_rightMoves : RightMoves 0 = PEmpty :=
   rfl
-#align pgame.zero_right_moves PGame.zero_rightMoves
+#align pgame.zero_right_moves SetTheory.PGame.zero_rightMoves
 
 instance isEmpty_zero_leftMoves : IsEmpty (LeftMoves 0) :=
   instIsEmptyPEmpty
-#align pgame.is_empty_zero_left_moves PGame.isEmpty_zero_leftMoves
+#align pgame.is_empty_zero_left_moves SetTheory.PGame.isEmpty_zero_leftMoves
 
 instance isEmpty_zero_rightMoves : IsEmpty (RightMoves 0) :=
   instIsEmptyPEmpty
-#align pgame.is_empty_zero_right_moves PGame.isEmpty_zero_rightMoves
+#align pgame.is_empty_zero_right_moves SetTheory.PGame.isEmpty_zero_rightMoves
 
 instance : Inhabited PGame :=
   ⟨0⟩
@@ -362,25 +365,25 @@ instance instOnePGame : One PGame :=
 @[simp]
 theorem one_leftMoves : LeftMoves 1 = PUnit :=
   rfl
-#align pgame.one_left_moves PGame.one_leftMoves
+#align pgame.one_left_moves SetTheory.PGame.one_leftMoves
 
 @[simp]
 theorem one_moveLeft (x) : moveLeft 1 x = 0 :=
   rfl
-#align pgame.one_move_left PGame.one_moveLeft
+#align pgame.one_move_left SetTheory.PGame.one_moveLeft
 
 @[simp]
 theorem one_rightMoves : RightMoves 1 = PEmpty :=
   rfl
-#align pgame.one_right_moves PGame.one_rightMoves
+#align pgame.one_right_moves SetTheory.PGame.one_rightMoves
 
 instance uniqueOneLeftMoves : Unique (LeftMoves 1) :=
   PUnit.unique
-#align pgame.unique_one_left_moves PGame.uniqueOneLeftMoves
+#align pgame.unique_one_left_moves SetTheory.PGame.uniqueOneLeftMoves
 
 instance isEmpty_one_rightMoves : IsEmpty (RightMoves 1) :=
   instIsEmptyPEmpty
-#align pgame.is_empty_one_right_moves PGame.isEmpty_one_rightMoves
+#align pgame.is_empty_one_right_moves SetTheory.PGame.isEmpty_one_rightMoves
 
 /-! ### Pre-game order relations -/
 
@@ -398,7 +401,7 @@ instance le : LE PGame :=
 If `0 ⧏ x`, then Left can win `x` as the first player. -/
 def Lf (x y : PGame) : Prop :=
   ¬y ≤ x
-#align pgame.lf PGame.Lf
+#align pgame.lf SetTheory.PGame.Lf
 
 @[inherit_doc]
 scoped infixl:50 " ⧏ " => PGame.Lf
@@ -406,12 +409,12 @@ scoped infixl:50 " ⧏ " => PGame.Lf
 @[simp]
 protected theorem not_le {x y : PGame} : ¬x ≤ y ↔ y ⧏ x :=
   Iff.rfl
-#align pgame.not_le PGame.not_le
+#align pgame.not_le SetTheory.PGame.not_le
 
 @[simp]
 theorem not_lf {x y : PGame} : ¬x ⧏ y ↔ y ≤ x :=
   Classical.not_not
-#align pgame.not_lf PGame.not_lf
+#align pgame.not_lf SetTheory.PGame.not_lf
 
 theorem _root_.LE.le.not_gf {x y : PGame} : x ≤ y → ¬y ⧏ x :=
   not_lf.2
@@ -419,7 +422,7 @@ theorem _root_.LE.le.not_gf {x y : PGame} : x ≤ y → ¬y ⧏ x :=
 
 theorem Lf.not_ge {x y : PGame} : x ⧏ y → ¬y ≤ x :=
   id
-#align pgame.lf.not_ge PGame.Lf.not_ge
+#align pgame.lf.not_ge SetTheory.PGame.Lf.not_ge
 
 /-- Definition of `x ≤ y` on pre-games, in terms of `⧏`.
 
@@ -431,19 +434,19 @@ theorem le_iff_forall_lf {x y : PGame} :
   simp only
   rw [Sym2.GameAdd.fix_eq]
   rfl
-#align pgame.le_iff_forall_lf PGame.le_iff_forall_lf
+#align pgame.le_iff_forall_lf SetTheory.PGame.le_iff_forall_lf
 
 /-- Definition of `x ≤ y` on pre-games built using the constructor. -/
 @[simp]
 theorem mk_le_mk {xl xr xL xR yl yr yL yR} :
     mk xl xr xL xR ≤ mk yl yr yL yR ↔ (∀ i, xL i ⧏ mk yl yr yL yR) ∧ ∀ j, mk xl xr xL xR ⧏ yR j :=
   le_iff_forall_lf
-#align pgame.mk_le_mk PGame.mk_le_mk
+#align pgame.mk_le_mk SetTheory.PGame.mk_le_mk
 
 theorem le_of_forall_lf {x y : PGame} (h₁ : ∀ i, x.moveLeft i ⧏ y) (h₂ : ∀ j, x ⧏ y.moveRight j) :
     x ≤ y :=
   le_iff_forall_lf.2 ⟨h₁, h₂⟩
-#align pgame.le_of_forall_lf PGame.le_of_forall_lf
+#align pgame.le_of_forall_lf SetTheory.PGame.le_of_forall_lf
 
 /-- Definition of `x ⧏ y` on pre-games, in terms of `≤`.
 
@@ -453,57 +456,57 @@ theorem lf_iff_exists_le {x y : PGame} :
     x ⧏ y ↔ (∃ i, x ≤ y.moveLeft i) ∨ ∃ j, x.moveRight j ≤ y := by
   rw [Lf, le_iff_forall_lf, not_and_or]
   simp
-#align pgame.lf_iff_exists_le PGame.lf_iff_exists_le
+#align pgame.lf_iff_exists_le SetTheory.PGame.lf_iff_exists_le
 
 /-- Definition of `x ⧏ y` on pre-games built using the constructor. -/
 @[simp]
 theorem mk_lf_mk {xl xr xL xR yl yr yL yR} :
     mk xl xr xL xR ⧏ mk yl yr yL yR ↔ (∃ i, mk xl xr xL xR ≤ yL i) ∨ ∃ j, xR j ≤ mk yl yr yL yR :=
   lf_iff_exists_le
-#align pgame.mk_lf_mk PGame.mk_lf_mk
+#align pgame.mk_lf_mk SetTheory.PGame.mk_lf_mk
 
 theorem le_or_gf (x y : PGame) : x ≤ y ∨ y ⧏ x := by
   rw [← PGame.not_le]
   apply em
-#align pgame.le_or_gf PGame.le_or_gf
+#align pgame.le_or_gf SetTheory.PGame.le_or_gf
 
 theorem moveLeft_lf_of_le {x y : PGame} (h : x ≤ y) (i) : x.moveLeft i ⧏ y :=
   (le_iff_forall_lf.1 h).1 i
-#align pgame.move_left_lf_of_le PGame.moveLeft_lf_of_le
+#align pgame.move_left_lf_of_le SetTheory.PGame.moveLeft_lf_of_le
 
 alias _root_.LE.le.moveLeft_lf := moveLeft_lf_of_le
 #align has_le.le.move_left_lf LE.le.moveLeft_lf
 
 theorem lf_moveRight_of_le {x y : PGame} (h : x ≤ y) (j) : x ⧏ y.moveRight j :=
   (le_iff_forall_lf.1 h).2 j
-#align pgame.lf_move_right_of_le PGame.lf_moveRight_of_le
+#align pgame.lf_move_right_of_le SetTheory.PGame.lf_moveRight_of_le
 
 alias _root_.LE.le.lf_moveRight := lf_moveRight_of_le
 #align has_le.le.lf_move_right LE.le.lf_moveRight
 
 theorem lf_of_moveRight_le {x y : PGame} {j} (h : x.moveRight j ≤ y) : x ⧏ y :=
   lf_iff_exists_le.2 <| Or.inr ⟨j, h⟩
-#align pgame.lf_of_move_right_le PGame.lf_of_moveRight_le
+#align pgame.lf_of_move_right_le SetTheory.PGame.lf_of_moveRight_le
 
 theorem lf_of_le_moveLeft {x y : PGame} {i} (h : x ≤ y.moveLeft i) : x ⧏ y :=
   lf_iff_exists_le.2 <| Or.inl ⟨i, h⟩
-#align pgame.lf_of_le_move_left PGame.lf_of_le_moveLeft
+#align pgame.lf_of_le_move_left SetTheory.PGame.lf_of_le_moveLeft
 
 theorem lf_of_le_mk {xl xr xL xR y} : mk xl xr xL xR ≤ y → ∀ i, xL i ⧏ y :=
   moveLeft_lf_of_le
-#align pgame.lf_of_le_mk PGame.lf_of_le_mk
+#align pgame.lf_of_le_mk SetTheory.PGame.lf_of_le_mk
 
 theorem lf_of_mk_le {x yl yr yL yR} : x ≤ mk yl yr yL yR → ∀ j, x ⧏ yR j :=
   lf_moveRight_of_le
-#align pgame.lf_of_mk_le PGame.lf_of_mk_le
+#align pgame.lf_of_mk_le SetTheory.PGame.lf_of_mk_le
 
 theorem mk_lf_of_le {xl xr y j} (xL) {xR : xr → PGame} : xR j ≤ y → mk xl xr xL xR ⧏ y :=
   @lf_of_moveRight_le (mk _ _ _ _) y j
-#align pgame.mk_lf_of_le PGame.mk_lf_of_le
+#align pgame.mk_lf_of_le SetTheory.PGame.mk_lf_of_le
 
 theorem lf_mk_of_le {x yl yr} {yL : yl → PGame} (yR) {i} : x ≤ yL i → x ⧏ mk yl yr yL yR :=
   @lf_of_le_moveLeft x (mk _ _ _ _) i
-#align pgame.lf_mk_of_le PGame.lf_mk_of_le
+#align pgame.lf_mk_of_le SetTheory.PGame.lf_mk_of_le
 
 /- We prove that `x ≤ y → y ≤ z → x ≤ z` inductively, by also simultaneously proving its cyclic
 reorderings. This auxiliary lemma is used during said induction. -/
@@ -537,22 +540,22 @@ instance : Preorder PGame :=
 
 theorem lt_iff_le_and_lf {x y : PGame} : x < y ↔ x ≤ y ∧ x ⧏ y :=
   Iff.rfl
-#align pgame.lt_iff_le_and_lf PGame.lt_iff_le_and_lf
+#align pgame.lt_iff_le_and_lf SetTheory.PGame.lt_iff_le_and_lf
 
 theorem lt_of_le_of_lf {x y : PGame} (h₁ : x ≤ y) (h₂ : x ⧏ y) : x < y :=
   ⟨h₁, h₂⟩
-#align pgame.lt_of_le_of_lf PGame.lt_of_le_of_lf
+#align pgame.lt_of_le_of_lf SetTheory.PGame.lt_of_le_of_lf
 
 theorem lf_of_lt {x y : PGame} (h : x < y) : x ⧏ y :=
   h.2
-#align pgame.lf_of_lt PGame.lf_of_lt
+#align pgame.lf_of_lt SetTheory.PGame.lf_of_lt
 
 alias _root_.LT.lt.lf := lf_of_lt
 #align has_lt.lt.lf LT.lt.lf
 
 theorem lf_irrefl (x : PGame) : ¬x ⧏ x :=
   le_rfl.not_gf
-#align pgame.lf_irrefl PGame.lf_irrefl
+#align pgame.lf_irrefl SetTheory.PGame.lf_irrefl
 
 instance : IsIrrefl _ (· ⧏ ·) :=
   ⟨lf_irrefl⟩
@@ -561,7 +564,7 @@ instance : IsIrrefl _ (· ⧏ ·) :=
 theorem lf_of_le_of_lf {x y z : PGame} (h₁ : x ≤ y) (h₂ : y ⧏ z) : x ⧏ z := by
   rw [← PGame.not_le] at h₂ ⊢
   exact fun h₃ => h₂ (h₃.trans h₁)
-#align pgame.lf_of_le_of_lf PGame.lf_of_le_of_lf
+#align pgame.lf_of_le_of_lf SetTheory.PGame.lf_of_le_of_lf
 
 -- Porting note: added
 instance : Trans (· ≤ ·) (· ⧏ ·) (· ⧏ ·) := ⟨lf_of_le_of_lf⟩
@@ -570,7 +573,7 @@ instance : Trans (· ≤ ·) (· ⧏ ·) (· ⧏ ·) := ⟨lf_of_le_of_lf⟩
 theorem lf_of_lf_of_le {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y ≤ z) : x ⧏ z := by
   rw [← PGame.not_le] at h₁ ⊢
   exact fun h₃ => h₁ (h₂.trans h₃)
-#align pgame.lf_of_lf_of_le PGame.lf_of_lf_of_le
+#align pgame.lf_of_lf_of_le SetTheory.PGame.lf_of_lf_of_le
 
 -- Porting note: added
 instance : Trans (· ⧏ ·) (· ≤ ·) (· ⧏ ·) := ⟨lf_of_lf_of_le⟩
@@ -579,46 +582,46 @@ alias _root_.LE.le.trans_lf := lf_of_le_of_lf
 #align has_le.le.trans_lf LE.le.trans_lf
 
 alias Lf.trans_le := lf_of_lf_of_le
-#align pgame.lf.trans_le PGame.Lf.trans_le
+#align pgame.lf.trans_le SetTheory.PGame.Lf.trans_le
 
 @[trans]
 theorem lf_of_lt_of_lf {x y z : PGame} (h₁ : x < y) (h₂ : y ⧏ z) : x ⧏ z :=
   h₁.le.trans_lf h₂
-#align pgame.lf_of_lt_of_lf PGame.lf_of_lt_of_lf
+#align pgame.lf_of_lt_of_lf SetTheory.PGame.lf_of_lt_of_lf
 
 @[trans]
 theorem lf_of_lf_of_lt {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y < z) : x ⧏ z :=
   h₁.trans_le h₂.le
-#align pgame.lf_of_lf_of_lt PGame.lf_of_lf_of_lt
+#align pgame.lf_of_lf_of_lt SetTheory.PGame.lf_of_lf_of_lt
 
 alias _root_.LT.lt.trans_lf := lf_of_lt_of_lf
 #align has_lt.lt.trans_lf LT.lt.trans_lf
 
 alias Lf.trans_lt := lf_of_lf_of_lt
-#align pgame.lf.trans_lt PGame.Lf.trans_lt
+#align pgame.lf.trans_lt SetTheory.PGame.Lf.trans_lt
 
 theorem moveLeft_lf {x : PGame} : ∀ i, x.moveLeft i ⧏ x :=
   le_rfl.moveLeft_lf
-#align pgame.move_left_lf PGame.moveLeft_lf
+#align pgame.move_left_lf SetTheory.PGame.moveLeft_lf
 
 theorem lf_moveRight {x : PGame} : ∀ j, x ⧏ x.moveRight j :=
   le_rfl.lf_moveRight
-#align pgame.lf_move_right PGame.lf_moveRight
+#align pgame.lf_move_right SetTheory.PGame.lf_moveRight
 
 theorem lf_mk {xl xr} (xL : xl → PGame) (xR : xr → PGame) (i) : xL i ⧏ mk xl xr xL xR :=
   @moveLeft_lf (mk _ _ _ _) i
-#align pgame.lf_mk PGame.lf_mk
+#align pgame.lf_mk SetTheory.PGame.lf_mk
 
 theorem mk_lf {xl xr} (xL : xl → PGame) (xR : xr → PGame) (j) : mk xl xr xL xR ⧏ xR j :=
   @lf_moveRight (mk _ _ _ _) j
-#align pgame.mk_lf PGame.mk_lf
+#align pgame.mk_lf SetTheory.PGame.mk_lf
 
 /-- This special case of `PGame.le_of_forall_lf` is useful when dealing with surreals, where `<` is
 preferred over `⧏`. -/
 theorem le_of_forall_lt {x y : PGame} (h₁ : ∀ i, x.moveLeft i < y) (h₂ : ∀ j, x < y.moveRight j) :
     x ≤ y :=
   le_of_forall_lf (fun i => (h₁ i).lf) fun i => (h₂ i).lf
-#align pgame.le_of_forall_lt PGame.le_of_forall_lt
+#align pgame.le_of_forall_lt SetTheory.PGame.le_of_forall_lt
 
 /-- The definition of `x ≤ y` on pre-games, in terms of `≤` two moves later. -/
 theorem le_def {x y : PGame} :
@@ -629,7 +632,7 @@ theorem le_def {x y : PGame} :
   conv =>
     lhs
     simp only [lf_iff_exists_le]
-#align pgame.le_def PGame.le_def
+#align pgame.le_def SetTheory.PGame.le_def
 
 /-- The definition of `x ⧏ y` on pre-games, in terms of `⧏` two moves later. -/
 theorem lf_def {x y : PGame} :
@@ -640,93 +643,93 @@ theorem lf_def {x y : PGame} :
   conv =>
     lhs
     simp only [le_iff_forall_lf]
-#align pgame.lf_def PGame.lf_def
+#align pgame.lf_def SetTheory.PGame.lf_def
 
 /-- 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]
   simp
-#align pgame.zero_le_lf PGame.zero_le_lf
+#align pgame.zero_le_lf SetTheory.PGame.zero_le_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]
   simp
-#align pgame.le_zero_lf PGame.le_zero_lf
+#align pgame.le_zero_lf SetTheory.PGame.le_zero_lf
 
 /-- 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]
   simp
-#align pgame.zero_lf_le PGame.zero_lf_le
+#align pgame.zero_lf_le SetTheory.PGame.zero_lf_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]
   simp
-#align pgame.lf_zero_le PGame.lf_zero_le
+#align pgame.lf_zero_le SetTheory.PGame.lf_zero_le
 
 /-- 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]
   simp
-#align pgame.zero_le PGame.zero_le
+#align pgame.zero_le SetTheory.PGame.zero_le
 
 /-- 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]
   simp
-#align pgame.le_zero PGame.le_zero
+#align pgame.le_zero SetTheory.PGame.le_zero
 
 /-- 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]
   simp
-#align pgame.zero_lf PGame.zero_lf
+#align pgame.zero_lf SetTheory.PGame.zero_lf
 
 /-- 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]
   simp
-#align pgame.lf_zero PGame.lf_zero
+#align pgame.lf_zero SetTheory.PGame.lf_zero
 
 @[simp]
 theorem zero_le_of_isEmpty_rightMoves (x : PGame) [IsEmpty x.RightMoves] : 0 ≤ x :=
   zero_le.2 isEmptyElim
-#align pgame.zero_le_of_is_empty_right_moves PGame.zero_le_of_isEmpty_rightMoves
+#align pgame.zero_le_of_is_empty_right_moves SetTheory.PGame.zero_le_of_isEmpty_rightMoves
 
 @[simp]
 theorem le_zero_of_isEmpty_leftMoves (x : PGame) [IsEmpty x.LeftMoves] : x ≤ 0 :=
   le_zero.2 isEmptyElim
-#align pgame.le_zero_of_is_empty_left_moves PGame.le_zero_of_isEmpty_leftMoves
+#align pgame.le_zero_of_is_empty_left_moves SetTheory.PGame.le_zero_of_isEmpty_leftMoves
 
 /-- Given a game won by the right player when they play second, provide a response to any move by
 left. -/
 noncomputable def rightResponse {x : PGame} (h : x ≤ 0) (i : x.LeftMoves) :
     (x.moveLeft i).RightMoves :=
   Classical.choose <| (le_zero.1 h) i
-#align pgame.right_response PGame.rightResponse
+#align pgame.right_response SetTheory.PGame.rightResponse
 
 /-- Show that the response for right provided by `rightResponse` preserves the right-player-wins
 condition. -/
 theorem rightResponse_spec {x : PGame} (h : x ≤ 0) (i : x.LeftMoves) :
     (x.moveLeft i).moveRight (rightResponse h i) ≤ 0 :=
   Classical.choose_spec <| (le_zero.1 h) i
-#align pgame.right_response_spec PGame.rightResponse_spec
+#align pgame.right_response_spec SetTheory.PGame.rightResponse_spec
 
 /-- Given a game won by the left player when they play second, provide a response to any move by
 right. -/
 noncomputable def leftResponse {x : PGame} (h : 0 ≤ x) (j : x.RightMoves) :
     (x.moveRight j).LeftMoves :=
   Classical.choose <| (zero_le.1 h) j
-#align pgame.left_response PGame.leftResponse
+#align pgame.left_response SetTheory.PGame.leftResponse
 
 /-- Show that the response for left provided by `leftResponse` preserves the left-player-wins
 condition. -/
 theorem leftResponse_spec {x : PGame} (h : 0 ≤ x) (j : x.RightMoves) :
     0 ≤ (x.moveRight j).moveLeft (leftResponse h j) :=
   Classical.choose_spec <| (zero_le.1 h) j
-#align pgame.left_response_spec PGame.leftResponse_spec
+#align pgame.left_response_spec SetTheory.PGame.leftResponse_spec
 
 /-- The equivalence relation on pre-games. Two pre-games `x`, `y` are equivalent if `x ≤ y` and
 `y ≤ x`.
@@ -734,7 +737,7 @@ theorem leftResponse_spec {x : PGame} (h : 0 ≤ x) (j : x.RightMoves) :
 If `x ≈ 0`, then the second player can always win `x`. -/
 def Equiv (x y : PGame) : Prop :=
   x ≤ y ∧ y ≤ x
-#align pgame.equiv PGame.Equiv
+#align pgame.equiv SetTheory.PGame.Equiv
 
 -- Porting note: deleted the scoped notation due to notation overloading with the setoid
 -- instance and this causes the PGame.equiv docstring to not show up on hover.
@@ -748,46 +751,46 @@ instance : IsEquiv _ PGame.Equiv where
 
 instance setoid : Setoid PGame :=
   ⟨Equiv, refl, symm, Trans.trans⟩
-#align pgame.setoid PGame.setoid
+#align pgame.setoid SetTheory.PGame.setoid
 
 theorem Equiv.le {x y : PGame} (h : x ≈ y) : x ≤ y :=
   h.1
-#align pgame.equiv.le PGame.Equiv.le
+#align pgame.equiv.le SetTheory.PGame.Equiv.le
 
 theorem Equiv.ge {x y : PGame} (h : x ≈ y) : y ≤ x :=
   h.2
-#align pgame.equiv.ge PGame.Equiv.ge
+#align pgame.equiv.ge SetTheory.PGame.Equiv.ge
 
 @[refl, simp]
 theorem equiv_rfl {x : PGame} : x ≈ x :=
   refl x
-#align pgame.equiv_rfl PGame.equiv_rfl
+#align pgame.equiv_rfl SetTheory.PGame.equiv_rfl
 
 theorem equiv_refl (x : PGame) : x ≈ x :=
   refl x
-#align pgame.equiv_refl PGame.equiv_refl
+#align pgame.equiv_refl SetTheory.PGame.equiv_refl
 
 @[symm]
 protected theorem Equiv.symm {x y : PGame} : (x ≈ y) → (y ≈ x) :=
   symm
-#align pgame.equiv.symm PGame.Equiv.symm
+#align pgame.equiv.symm SetTheory.PGame.Equiv.symm
 
 @[trans]
 protected theorem Equiv.trans {x y z : PGame} : (x ≈ y) → (y ≈ z) → (x ≈ z) :=
   _root_.trans
-#align pgame.equiv.trans PGame.Equiv.trans
+#align pgame.equiv.trans SetTheory.PGame.Equiv.trans
 
 protected theorem equiv_comm {x y : PGame} : (x ≈ y) ↔ (y ≈ x) :=
   comm
-#align pgame.equiv_comm PGame.equiv_comm
+#align pgame.equiv_comm SetTheory.PGame.equiv_comm
 
 theorem equiv_of_eq {x y : PGame} (h : x = y) : x ≈ y := by subst h; rfl
-#align pgame.equiv_of_eq PGame.equiv_of_eq
+#align pgame.equiv_of_eq SetTheory.PGame.equiv_of_eq
 
 @[trans]
 theorem le_of_le_of_equiv {x y z : PGame} (h₁ : x ≤ y) (h₂ : y ≈ z) : x ≤ z :=
   h₁.trans h₂.1
-#align pgame.le_of_le_of_equiv PGame.le_of_le_of_equiv
+#align pgame.le_of_le_of_equiv SetTheory.PGame.le_of_le_of_equiv
 
 instance : Trans
     ((· ≤ ·) : PGame → PGame → Prop)
@@ -798,7 +801,7 @@ instance : Trans
 @[trans]
 theorem le_of_equiv_of_le {x y z : PGame} (h₁ : x ≈ y) : y ≤ z → x ≤ z :=
   h₁.1.trans
-#align pgame.le_of_equiv_of_le PGame.le_of_equiv_of_le
+#align pgame.le_of_equiv_of_le SetTheory.PGame.le_of_equiv_of_le
 
 instance : Trans
     ((· ≈ ·) : PGame → PGame → Prop)
@@ -807,65 +810,65 @@ instance : Trans
   trans := le_of_equiv_of_le
 
 theorem Lf.not_equiv {x y : PGame} (h : x ⧏ y) : ¬(x ≈ y) := fun h' => h.not_ge h'.2
-#align pgame.lf.not_equiv PGame.Lf.not_equiv
+#align pgame.lf.not_equiv SetTheory.PGame.Lf.not_equiv
 
 theorem Lf.not_equiv' {x y : PGame} (h : x ⧏ y) : ¬(y ≈ x) := fun h' => h.not_ge h'.1
-#align pgame.lf.not_equiv' PGame.Lf.not_equiv'
+#align pgame.lf.not_equiv' SetTheory.PGame.Lf.not_equiv'
 
 theorem Lf.not_gt {x y : PGame} (h : x ⧏ y) : ¬y < x := fun h' => h.not_ge h'.le
-#align pgame.lf.not_gt PGame.Lf.not_gt
+#align pgame.lf.not_gt SetTheory.PGame.Lf.not_gt
 
 theorem le_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) (h : x₁ ≤ y₁) : x₂ ≤ y₂ :=
   hx.2.trans (h.trans hy.1)
-#align pgame.le_congr_imp PGame.le_congr_imp
+#align pgame.le_congr_imp SetTheory.PGame.le_congr_imp
 
 theorem le_congr {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ≤ y₁ ↔ x₂ ≤ y₂ :=
   ⟨le_congr_imp hx hy, le_congr_imp (Equiv.symm hx) (Equiv.symm hy)⟩
-#align pgame.le_congr PGame.le_congr
+#align pgame.le_congr SetTheory.PGame.le_congr
 
 theorem le_congr_left {x₁ x₂ y : PGame} (hx : x₁ ≈ x₂) : x₁ ≤ y ↔ x₂ ≤ y :=
   le_congr hx equiv_rfl
-#align pgame.le_congr_left PGame.le_congr_left
+#align pgame.le_congr_left SetTheory.PGame.le_congr_left
 
 theorem le_congr_right {x y₁ y₂ : PGame} (hy : y₁ ≈ y₂) : x ≤ y₁ ↔ x ≤ y₂ :=
   le_congr equiv_rfl hy
-#align pgame.le_congr_right PGame.le_congr_right
+#align pgame.le_congr_right SetTheory.PGame.le_congr_right
 
 theorem lf_congr {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ⧏ y₁ ↔ x₂ ⧏ y₂ :=
   PGame.not_le.symm.trans <| (not_congr (le_congr hy hx)).trans PGame.not_le
-#align pgame.lf_congr PGame.lf_congr
+#align pgame.lf_congr SetTheory.PGame.lf_congr
 
 theorem lf_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ⧏ y₁ → x₂ ⧏ y₂ :=
   (lf_congr hx hy).1
-#align pgame.lf_congr_imp PGame.lf_congr_imp
+#align pgame.lf_congr_imp SetTheory.PGame.lf_congr_imp
 
 theorem lf_congr_left {x₁ x₂ y : PGame} (hx : x₁ ≈ x₂) : x₁ ⧏ y ↔ x₂ ⧏ y :=
   lf_congr hx equiv_rfl
-#align pgame.lf_congr_left PGame.lf_congr_left
+#align pgame.lf_congr_left SetTheory.PGame.lf_congr_left
 
 theorem lf_congr_right {x y₁ y₂ : PGame} (hy : y₁ ≈ y₂) : x ⧏ y₁ ↔ x ⧏ y₂ :=
   lf_congr equiv_rfl hy
-#align pgame.lf_congr_right PGame.lf_congr_right
+#align pgame.lf_congr_right SetTheory.PGame.lf_congr_right
 
 @[trans]
 theorem lf_of_lf_of_equiv {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y ≈ z) : x ⧏ z :=
   lf_congr_imp equiv_rfl h₂ h₁
-#align pgame.lf_of_lf_of_equiv PGame.lf_of_lf_of_equiv
+#align pgame.lf_of_lf_of_equiv SetTheory.PGame.lf_of_lf_of_equiv
 
 @[trans]
 theorem lf_of_equiv_of_lf {x y z : PGame} (h₁ : x ≈ y) : y ⧏ z → x ⧏ z :=
   lf_congr_imp (Equiv.symm h₁) equiv_rfl
-#align pgame.lf_of_equiv_of_lf PGame.lf_of_equiv_of_lf
+#align pgame.lf_of_equiv_of_lf SetTheory.PGame.lf_of_equiv_of_lf
 
 @[trans]
 theorem lt_of_lt_of_equiv {x y z : PGame} (h₁ : x < y) (h₂ : y ≈ z) : x < z :=
   h₁.trans_le h₂.1
-#align pgame.lt_of_lt_of_equiv PGame.lt_of_lt_of_equiv
+#align pgame.lt_of_lt_of_equiv SetTheory.PGame.lt_of_lt_of_equiv
 
 @[trans]
 theorem lt_of_equiv_of_lt {x y z : PGame} (h₁ : x ≈ y) : y < z → x < z :=
   h₁.1.trans_lt
-#align pgame.lt_of_equiv_of_lt PGame.lt_of_equiv_of_lt
+#align pgame.lt_of_equiv_of_lt SetTheory.PGame.lt_of_equiv_of_lt
 
 instance : Trans
     ((· ≈ ·) : PGame → PGame → Prop)
@@ -875,23 +878,23 @@ instance : Trans
 
 theorem lt_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) (h : x₁ < y₁) : x₂ < y₂ :=
   hx.2.trans_lt (h.trans_le hy.1)
-#align pgame.lt_congr_imp PGame.lt_congr_imp
+#align pgame.lt_congr_imp SetTheory.PGame.lt_congr_imp
 
 theorem lt_congr {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ < y₁ ↔ x₂ < y₂ :=
   ⟨lt_congr_imp hx hy, lt_congr_imp (Equiv.symm hx) (Equiv.symm hy)⟩
-#align pgame.lt_congr PGame.lt_congr
+#align pgame.lt_congr SetTheory.PGame.lt_congr
 
 theorem lt_congr_left {x₁ x₂ y : PGame} (hx : x₁ ≈ x₂) : x₁ < y ↔ x₂ < y :=
   lt_congr hx equiv_rfl
-#align pgame.lt_congr_left PGame.lt_congr_left
+#align pgame.lt_congr_left SetTheory.PGame.lt_congr_left
 
 theorem lt_congr_right {x y₁ y₂ : PGame} (hy : y₁ ≈ y₂) : x < y₁ ↔ x < y₂ :=
   lt_congr equiv_rfl hy
-#align pgame.lt_congr_right PGame.lt_congr_right
+#align pgame.lt_congr_right SetTheory.PGame.lt_congr_right
 
 theorem lt_or_equiv_of_le {x y : PGame} (h : x ≤ y) : x < y ∨ (x ≈ y) :=
   and_or_left.mp ⟨h, (em <| y ≤ x).symm.imp_left PGame.not_le.1⟩
-#align pgame.lt_or_equiv_of_le PGame.lt_or_equiv_of_le
+#align pgame.lt_or_equiv_of_le SetTheory.PGame.lt_or_equiv_of_le
 
 theorem lf_or_equiv_or_gf (x y : PGame) : x ⧏ y ∨ (x ≈ y) ∨ y ⧏ x := by
   by_cases h : x ⧏ y
@@ -900,17 +903,17 @@ theorem lf_or_equiv_or_gf (x y : PGame) : x ⧏ y ∨ (x ≈ y) ∨ y ⧏ x := b
     cases' lt_or_equiv_of_le (PGame.not_lf.1 h) with h' h'
     · exact Or.inr h'.lf
     · exact Or.inl (Equiv.symm h')
-#align pgame.lf_or_equiv_or_gf PGame.lf_or_equiv_or_gf
+#align pgame.lf_or_equiv_or_gf SetTheory.PGame.lf_or_equiv_or_gf
 
 theorem equiv_congr_left {y₁ y₂ : PGame} : (y₁ ≈ y₂) ↔ ∀ x₁, (x₁ ≈ y₁) ↔ (x₁ ≈ y₂) :=
   ⟨fun h _ => ⟨fun h' => Equiv.trans h' h, fun h' => Equiv.trans h' (Equiv.symm h)⟩,
    fun h => (h y₁).1 <| equiv_rfl⟩
-#align pgame.equiv_congr_left PGame.equiv_congr_left
+#align pgame.equiv_congr_left SetTheory.PGame.equiv_congr_left
 
 theorem equiv_congr_right {x₁ x₂ : PGame} : (x₁ ≈ x₂) ↔ ∀ y₁, (x₁ ≈ y₁) ↔ (x₂ ≈ y₁) :=
   ⟨fun h _ => ⟨fun h' => Equiv.trans (Equiv.symm h) h', fun h' => Equiv.trans h h'⟩,
    fun h => (h x₂).2 <| equiv_rfl⟩
-#align pgame.equiv_congr_right PGame.equiv_congr_right
+#align pgame.equiv_congr_right SetTheory.PGame.equiv_congr_right
 
 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))
@@ -918,14 +921,14 @@ theorem equiv_of_mk_equiv {x y : PGame} (L : x.LeftMoves ≃ y.LeftMoves)
   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 simpa using (hl (L.symm i)).2⟩, fun j => Or.inr ⟨_, (hr j).2⟩⟩
-#align pgame.equiv_of_mk_equiv PGame.equiv_of_mk_equiv
+#align pgame.equiv_of_mk_equiv SetTheory.PGame.equiv_of_mk_equiv
 
 /-- The fuzzy, confused, or incomparable relation on pre-games.
 
 If `x ‖ 0`, then the first player can always win `x`. -/
 def Fuzzy (x y : PGame) : Prop :=
   x ⧏ y ∧ y ⧏ x
-#align pgame.fuzzy PGame.Fuzzy
+#align pgame.fuzzy SetTheory.PGame.Fuzzy
 
 @[inherit_doc]
 scoped infixl:50 " ‖ " => PGame.Fuzzy
@@ -933,17 +936,17 @@ scoped infixl:50 " ‖ " => PGame.Fuzzy
 @[symm]
 theorem Fuzzy.swap {x y : PGame} : x ‖ y → y ‖ x :=
   And.symm
-#align pgame.fuzzy.swap PGame.Fuzzy.swap
+#align pgame.fuzzy.swap SetTheory.PGame.Fuzzy.swap
 
 instance : IsSymm _ (· ‖ ·) :=
   ⟨fun _ _ => Fuzzy.swap⟩
 
 theorem Fuzzy.swap_iff {x y : PGame} : x ‖ y ↔ y ‖ x :=
   ⟨Fuzzy.swap, Fuzzy.swap⟩
-#align pgame.fuzzy.swap_iff PGame.Fuzzy.swap_iff
+#align pgame.fuzzy.swap_iff SetTheory.PGame.Fuzzy.swap_iff
 
 theorem fuzzy_irrefl (x : PGame) : ¬x ‖ x := fun h => lf_irrefl x h.1
-#align pgame.fuzzy_irrefl PGame.fuzzy_irrefl
+#align pgame.fuzzy_irrefl SetTheory.PGame.fuzzy_irrefl
 
 instance : IsIrrefl _ (· ‖ ·) :=
   ⟨fuzzy_irrefl⟩
@@ -951,64 +954,64 @@ instance : IsIrrefl _ (· ‖ ·) :=
 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]
   tauto
-#align pgame.lf_iff_lt_or_fuzzy PGame.lf_iff_lt_or_fuzzy
+#align pgame.lf_iff_lt_or_fuzzy SetTheory.PGame.lf_iff_lt_or_fuzzy
 
 theorem lf_of_fuzzy {x y : PGame} (h : x ‖ y) : x ⧏ y :=
   lf_iff_lt_or_fuzzy.2 (Or.inr h)
-#align pgame.lf_of_fuzzy PGame.lf_of_fuzzy
+#align pgame.lf_of_fuzzy SetTheory.PGame.lf_of_fuzzy
 
 alias Fuzzy.lf := lf_of_fuzzy
-#align pgame.fuzzy.lf PGame.Fuzzy.lf
+#align pgame.fuzzy.lf SetTheory.PGame.Fuzzy.lf
 
 theorem lt_or_fuzzy_of_lf {x y : PGame} : x ⧏ y → x < y ∨ x ‖ y :=
   lf_iff_lt_or_fuzzy.1
-#align pgame.lt_or_fuzzy_of_lf PGame.lt_or_fuzzy_of_lf
+#align pgame.lt_or_fuzzy_of_lf SetTheory.PGame.lt_or_fuzzy_of_lf
 
 theorem Fuzzy.not_equiv {x y : PGame} (h : x ‖ y) : ¬(x ≈ y) := fun h' => h'.1.not_gf h.2
-#align pgame.fuzzy.not_equiv PGame.Fuzzy.not_equiv
+#align pgame.fuzzy.not_equiv SetTheory.PGame.Fuzzy.not_equiv
 
 theorem Fuzzy.not_equiv' {x y : PGame} (h : x ‖ y) : ¬(y ≈ x) := fun h' => h'.2.not_gf h.2
-#align pgame.fuzzy.not_equiv' PGame.Fuzzy.not_equiv'
+#align pgame.fuzzy.not_equiv' SetTheory.PGame.Fuzzy.not_equiv'
 
 theorem not_fuzzy_of_le {x y : PGame} (h : x ≤ y) : ¬x ‖ y := fun h' => h'.2.not_ge h
-#align pgame.not_fuzzy_of_le PGame.not_fuzzy_of_le
+#align pgame.not_fuzzy_of_le SetTheory.PGame.not_fuzzy_of_le
 
 theorem not_fuzzy_of_ge {x y : PGame} (h : y ≤ x) : ¬x ‖ y := fun h' => h'.1.not_ge h
-#align pgame.not_fuzzy_of_ge PGame.not_fuzzy_of_ge
+#align pgame.not_fuzzy_of_ge SetTheory.PGame.not_fuzzy_of_ge
 
 theorem Equiv.not_fuzzy {x y : PGame} (h : x ≈ y) : ¬x ‖ y :=
   not_fuzzy_of_le h.1
-#align pgame.equiv.not_fuzzy PGame.Equiv.not_fuzzy
+#align pgame.equiv.not_fuzzy SetTheory.PGame.Equiv.not_fuzzy
 
 theorem Equiv.not_fuzzy' {x y : PGame} (h : x ≈ y) : ¬y ‖ x :=
   not_fuzzy_of_le h.2
-#align pgame.equiv.not_fuzzy' PGame.Equiv.not_fuzzy'
+#align pgame.equiv.not_fuzzy' SetTheory.PGame.Equiv.not_fuzzy'
 
 theorem fuzzy_congr {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ‖ y₁ ↔ x₂ ‖ y₂ :=
   show _ ∧ _ ↔ _ ∧ _ by rw [lf_congr hx hy, lf_congr hy hx]
-#align pgame.fuzzy_congr PGame.fuzzy_congr
+#align pgame.fuzzy_congr SetTheory.PGame.fuzzy_congr
 
 theorem fuzzy_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ‖ y₁ → x₂ ‖ y₂ :=
   (fuzzy_congr hx hy).1
-#align pgame.fuzzy_congr_imp PGame.fuzzy_congr_imp
+#align pgame.fuzzy_congr_imp SetTheory.PGame.fuzzy_congr_imp
 
 theorem fuzzy_congr_left {x₁ x₂ y : PGame} (hx : x₁ ≈ x₂) : x₁ ‖ y ↔ x₂ ‖ y :=
   fuzzy_congr hx equiv_rfl
-#align pgame.fuzzy_congr_left PGame.fuzzy_congr_left
+#align pgame.fuzzy_congr_left SetTheory.PGame.fuzzy_congr_left
 
 theorem fuzzy_congr_right {x y₁ y₂ : PGame} (hy : y₁ ≈ y₂) : x ‖ y₁ ↔ x ‖ y₂ :=
   fuzzy_congr equiv_rfl hy
-#align pgame.fuzzy_congr_right PGame.fuzzy_congr_right
+#align pgame.fuzzy_congr_right SetTheory.PGame.fuzzy_congr_right
 
 @[trans]
 theorem fuzzy_of_fuzzy_of_equiv {x y z : PGame} (h₁ : x ‖ y) (h₂ : y ≈ z) : x ‖ z :=
   (fuzzy_congr_right h₂).1 h₁
-#align pgame.fuzzy_of_fuzzy_of_equiv PGame.fuzzy_of_fuzzy_of_equiv
+#align pgame.fuzzy_of_fuzzy_of_equiv SetTheory.PGame.fuzzy_of_fuzzy_of_equiv
 
 @[trans]
 theorem fuzzy_of_equiv_of_fuzzy {x y z : PGame} (h₁ : x ≈ y) (h₂ : y ‖ z) : x ‖ z :=
   (fuzzy_congr_left h₁).2 h₂
-#align pgame.fuzzy_of_equiv_of_fuzzy PGame.fuzzy_of_equiv_of_fuzzy
+#align pgame.fuzzy_of_equiv_of_fuzzy SetTheory.PGame.fuzzy_of_equiv_of_fuzzy
 
 /-- 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
@@ -1026,12 +1029,12 @@ theorem lt_or_equiv_or_gt_or_fuzzy (x y : PGame) : x < y ∨ (x ≈ y) ∨ y < x
     right
     right
     exact ⟨h₂, h₁⟩
-#align pgame.lt_or_equiv_or_gt_or_fuzzy PGame.lt_or_equiv_or_gt_or_fuzzy
+#align pgame.lt_or_equiv_or_gt_or_fuzzy SetTheory.PGame.lt_or_equiv_or_gt_or_fuzzy
 
 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]
   exact lt_or_equiv_or_gt_or_fuzzy x y
-#align pgame.lt_or_equiv_or_gf PGame.lt_or_equiv_or_gf
+#align pgame.lt_or_equiv_or_gf SetTheory.PGame.lt_or_equiv_or_gf
 
 /-! ### Relabellings -/
 
@@ -1046,7 +1049,7 @@ inductive Relabelling : PGame.{u} → PGame.{u} → Type (u + 1)
     ∀ {x y : PGame} (L : x.LeftMoves ≃ y.LeftMoves) (R : x.RightMoves ≃ y.RightMoves),
       (∀ i, Relabelling (x.moveLeft i) (y.moveLeft (L i))) →
         (∀ j, Relabelling (x.moveRight j) (y.moveRight (R j))) → Relabelling x y
-#align pgame.relabelling PGame.Relabelling
+#align pgame.relabelling SetTheory.PGame.Relabelling
 
 @[inherit_doc]
 scoped infixl:50 " ≡r " => PGame.Relabelling
@@ -1060,69 +1063,69 @@ 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 simpa using hR (R.symm j)⟩
-#align pgame.relabelling.mk' PGame.Relabelling.mk'
+#align pgame.relabelling.mk' SetTheory.PGame.Relabelling.mk'
 
 /-- The equivalence between left moves of `x` and `y` given by the relabelling. -/
 def leftMovesEquiv : ∀ _ : x ≡r y, x.LeftMoves ≃ y.LeftMoves
   | ⟨L,_, _,_⟩ => L
-#align pgame.relabelling.left_moves_equiv PGame.Relabelling.leftMovesEquiv
+#align pgame.relabelling.left_moves_equiv SetTheory.PGame.Relabelling.leftMovesEquiv
 
 @[simp]
 theorem mk_leftMovesEquiv {x y L R hL hR} : (@Relabelling.mk x y L R hL hR).leftMovesEquiv = L :=
   rfl
-#align pgame.relabelling.mk_left_moves_equiv PGame.Relabelling.mk_leftMovesEquiv
+#align pgame.relabelling.mk_left_moves_equiv SetTheory.PGame.Relabelling.mk_leftMovesEquiv
 
 @[simp]
 theorem mk'_leftMovesEquiv {x y L R hL hR} :
     (@Relabelling.mk' x y L R hL hR).leftMovesEquiv = L.symm :=
   rfl
-#align pgame.relabelling.mk'_left_moves_equiv PGame.Relabelling.mk'_leftMovesEquiv
+#align pgame.relabelling.mk'_left_moves_equiv SetTheory.PGame.Relabelling.mk'_leftMovesEquiv
 
 /-- The equivalence between right moves of `x` and `y` given by the relabelling. -/
 def rightMovesEquiv : ∀ _ : x ≡r y, x.RightMoves ≃ y.RightMoves
   | ⟨_, R, _, _⟩ => R
-#align pgame.relabelling.right_moves_equiv PGame.Relabelling.rightMovesEquiv
+#align pgame.relabelling.right_moves_equiv SetTheory.PGame.Relabelling.rightMovesEquiv
 
 @[simp]
 theorem mk_rightMovesEquiv {x y L R hL hR} : (@Relabelling.mk x y L R hL hR).rightMovesEquiv = R :=
   rfl
-#align pgame.relabelling.mk_right_moves_equiv PGame.Relabelling.mk_rightMovesEquiv
+#align pgame.relabelling.mk_right_moves_equiv SetTheory.PGame.Relabelling.mk_rightMovesEquiv
 
 @[simp]
 theorem mk'_rightMovesEquiv {x y L R hL hR} :
     (@Relabelling.mk' x y L R hL hR).rightMovesEquiv = R.symm :=
   rfl
-#align pgame.relabelling.mk'_right_moves_equiv PGame.Relabelling.mk'_rightMovesEquiv
+#align pgame.relabelling.mk'_right_moves_equiv SetTheory.PGame.Relabelling.mk'_rightMovesEquiv
 
 /-- A left move of `x` is a relabelling of a left move of `y`. -/
 def moveLeft : ∀ (r : x ≡r y) (i : x.LeftMoves), x.moveLeft i ≡r y.moveLeft (r.leftMovesEquiv i)
   | ⟨_, _, hL, _⟩ => hL
-#align pgame.relabelling.move_left PGame.Relabelling.moveLeft
+#align pgame.relabelling.move_left SetTheory.PGame.Relabelling.moveLeft
 
 /-- 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 simpa using hL (L.symm i)
-#align pgame.relabelling.move_left_symm PGame.Relabelling.moveLeftSymm
+#align pgame.relabelling.move_left_symm SetTheory.PGame.Relabelling.moveLeftSymm
 
 /-- A right move of `x` is a relabelling of a right move of `y`. -/
 def moveRight :
     ∀ (r : x ≡r y) (i : x.RightMoves), x.moveRight i ≡r y.moveRight (r.rightMovesEquiv i)
   | ⟨_, _, _, hR⟩ => hR
-#align pgame.relabelling.move_right PGame.Relabelling.moveRight
+#align pgame.relabelling.move_right SetTheory.PGame.Relabelling.moveRight
 
 /-- 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 simpa using hR (R.symm i)
-#align pgame.relabelling.move_right_symm PGame.Relabelling.moveRightSymm
+#align pgame.relabelling.move_right_symm SetTheory.PGame.Relabelling.moveRightSymm
 
 /-- The identity relabelling. -/
 @[refl]
 def refl (x : PGame) : x ≡r x :=
   ⟨Equiv.refl _, Equiv.refl _, fun i => refl _, fun j => refl _⟩
 termination_by _ => x
-#align pgame.relabelling.refl PGame.Relabelling.refl
+#align pgame.relabelling.refl SetTheory.PGame.Relabelling.refl
 
 instance (x : PGame) : Inhabited (x ≡r x) :=
   ⟨refl _⟩
@@ -1131,41 +1134,41 @@ instance (x : PGame) : Inhabited (x ≡r x) :=
 @[symm]
 def symm : ∀ {x y : PGame}, x ≡r y → y ≡r x
   | _, _, ⟨L, R, hL, hR⟩ => mk' L R (fun i => (hL i).symm) fun j => (hR j).symm
-#align pgame.relabelling.symm PGame.Relabelling.symm
+#align pgame.relabelling.symm SetTheory.PGame.Relabelling.symm
 
 theorem le {x y : PGame} (r : x ≡r y) : x ≤ y :=
   le_def.2
     ⟨fun i => Or.inl ⟨_, (r.moveLeft i).le⟩, fun j =>
       Or.inr ⟨_, (r.moveRightSymm j).le⟩⟩
 termination_by _ => x
-#align pgame.relabelling.le PGame.Relabelling.le
+#align pgame.relabelling.le SetTheory.PGame.Relabelling.le
 
 theorem ge {x y : PGame} (r : x ≡r y) : y ≤ x :=
   r.symm.le
-#align pgame.relabelling.ge PGame.Relabelling.ge
+#align pgame.relabelling.ge SetTheory.PGame.Relabelling.ge
 
 /-- A relabelling lets us prove equivalence of games. -/
 theorem equiv (r : x ≡r y) : x ≈ y :=
   ⟨r.le, r.ge⟩
-#align pgame.relabelling.equiv PGame.Relabelling.equiv
+#align pgame.relabelling.equiv SetTheory.PGame.Relabelling.equiv
 
 /-- Transitivity of relabelling. -/
 @[trans]
 def trans : ∀ {x y z : PGame}, x ≡r y → y ≡r z → x ≡r z
   | _, _, _, ⟨L₁, R₁, hL₁, hR₁⟩, ⟨L₂, R₂, hL₂, hR₂⟩ =>
     ⟨L₁.trans L₂, R₁.trans R₂, fun i => (hL₁ i).trans (hL₂ _), fun j => (hR₁ j).trans (hR₂ _)⟩
-#align pgame.relabelling.trans PGame.Relabelling.trans
+#align pgame.relabelling.trans SetTheory.PGame.Relabelling.trans
 
 /-- Any game without left or right moves is a relabelling of 0. -/
 def isEmpty (x : PGame) [IsEmpty x.LeftMoves] [IsEmpty x.RightMoves] : x ≡r 0 :=
   ⟨Equiv.equivPEmpty _, Equiv.equivOfIsEmpty _ _, isEmptyElim, isEmptyElim⟩
-#align pgame.relabelling.is_empty PGame.Relabelling.isEmpty
+#align pgame.relabelling.is_empty SetTheory.PGame.Relabelling.isEmpty
 
 end Relabelling
 
 theorem Equiv.isEmpty (x : PGame) [IsEmpty x.LeftMoves] [IsEmpty x.RightMoves] : x ≈ 0 :=
   (Relabelling.isEmpty x).equiv
-#align pgame.equiv.is_empty PGame.Equiv.isEmpty
+#align pgame.equiv.is_empty SetTheory.PGame.Equiv.isEmpty
 
 instance {x y : PGame} : Coe (x ≡r y) (x ≈ y) :=
   ⟨Relabelling.equiv⟩
@@ -1173,34 +1176,34 @@ instance {x y : PGame} : Coe (x ≡r y) (x ≈ y) :=
 /-- Replace the types indexing the next moves for Left and Right by equivalent types. -/
 def relabel {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves) : PGame :=
   ⟨xl', xr', x.moveLeft ∘ el, x.moveRight ∘ er⟩
-#align pgame.relabel PGame.relabel
+#align pgame.relabel SetTheory.PGame.relabel
 
 @[simp]
 theorem relabel_moveLeft' {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
     (i : xl') : moveLeft (relabel el er) i = x.moveLeft (el i) :=
   rfl
-#align pgame.relabel_move_left' PGame.relabel_moveLeft'
+#align pgame.relabel_move_left' SetTheory.PGame.relabel_moveLeft'
 
 theorem relabel_moveLeft {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
     (i : x.LeftMoves) : moveLeft (relabel el er) (el.symm i) = x.moveLeft i := by simp
-#align pgame.relabel_move_left PGame.relabel_moveLeft
+#align pgame.relabel_move_left SetTheory.PGame.relabel_moveLeft
 
 @[simp]
 theorem relabel_moveRight' {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
     (j : xr') : moveRight (relabel el er) j = x.moveRight (er j) :=
   rfl
-#align pgame.relabel_move_right' PGame.relabel_moveRight'
+#align pgame.relabel_move_right' SetTheory.PGame.relabel_moveRight'
 
 theorem relabel_moveRight {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
     (j : x.RightMoves) : moveRight (relabel el er) (er.symm j) = x.moveRight j := by simp
-#align pgame.relabel_move_right PGame.relabel_moveRight
+#align pgame.relabel_move_right SetTheory.PGame.relabel_moveRight
 
 /-- The game obtained by relabelling the next moves is a relabelling of the original game. -/
 def relabelRelabelling {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves) :
     x ≡r relabel el er :=
   -- Porting note: needed to add `rfl`
   Relabelling.mk' el er (fun i => by simp; rfl) (fun j => by simp; rfl)
-#align pgame.relabel_relabelling PGame.relabelRelabelling
+#align pgame.relabel_relabelling SetTheory.PGame.relabelRelabelling
 
 /-! ### Negation -/
 
@@ -1208,7 +1211,7 @@ def relabelRelabelling {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr
 /-- The negation of `{L | R}` is `{-R | -L}`. -/
 def neg : PGame → PGame
   | ⟨l, r, L, R⟩ => ⟨r, l, fun i => neg (R i), fun i => neg (L i)⟩
-#align pgame.neg PGame.neg
+#align pgame.neg SetTheory.PGame.neg
 
 instance : Neg PGame :=
   ⟨neg⟩
@@ -1216,7 +1219,7 @@ instance : Neg PGame :=
 @[simp]
 theorem neg_def {xl xr xL xR} : -mk xl xr xL xR = mk xr xl (fun j => -xR j) fun i => -xL i :=
   rfl
-#align pgame.neg_def PGame.neg_def
+#align pgame.neg_def SetTheory.PGame.neg_def
 
 instance : InvolutiveNeg PGame :=
   { inferInstanceAs (Neg PGame) with
@@ -1250,7 +1253,7 @@ theorem neg_ofLists (L R : List PGame) :
         rintro rfl
         rfl
       exact this (List.length_map _ _).symm ha
-#align pgame.neg_of_lists PGame.neg_ofLists
+#align pgame.neg_of_lists SetTheory.PGame.neg_ofLists
 
 theorem isOption_neg {x y : PGame} : IsOption x (-y) ↔ IsOption (-x) y := by
   rw [IsOption_iff, IsOption_iff, or_comm]
@@ -1260,20 +1263,20 @@ theorem isOption_neg {x y : PGame} : IsOption x (-y) ↔ IsOption (-x) y := by
       intro
       rw [neg_eq_iff_eq_neg]
       rfl
-#align pgame.is_option_neg PGame.isOption_neg
+#align pgame.is_option_neg SetTheory.PGame.isOption_neg
 
 @[simp]
 theorem isOption_neg_neg {x y : PGame} : IsOption (-x) (-y) ↔ IsOption x y := by
   rw [isOption_neg, neg_neg]
-#align pgame.is_option_neg_neg PGame.isOption_neg_neg
+#align pgame.is_option_neg_neg SetTheory.PGame.isOption_neg_neg
 
 theorem leftMoves_neg : ∀ x : PGame, (-x).LeftMoves = x.RightMoves
   | ⟨_, _, _, _⟩ => rfl
-#align pgame.left_moves_neg PGame.leftMoves_neg
+#align pgame.left_moves_neg SetTheory.PGame.leftMoves_neg
 
 theorem rightMoves_neg : ∀ x : PGame, (-x).RightMoves = x.LeftMoves
   | ⟨_, _, _, _⟩ => rfl
-#align pgame.right_moves_neg PGame.rightMoves_neg
+#align pgame.right_moves_neg SetTheory.PGame.rightMoves_neg
 
 /-- Turns a right move for `x` into a left move for `-x` and vice versa.
 
@@ -1281,7 +1284,7 @@ Even though these types are the same (not definitionally so), this is the prefer
 between them. -/
 def toLeftMovesNeg {x : PGame} : x.RightMoves ≃ (-x).LeftMoves :=
   Equiv.cast (leftMoves_neg x).symm
-#align pgame.to_left_moves_neg PGame.toLeftMovesNeg
+#align pgame.to_left_moves_neg SetTheory.PGame.toLeftMovesNeg
 
 /-- Turns a left move for `x` into a right move for `-x` and vice versa.
 
@@ -1289,52 +1292,52 @@ Even though these types are the same (not definitionally so), this is the prefer
 between them. -/
 def toRightMovesNeg {x : PGame} : x.LeftMoves ≃ (-x).RightMoves :=
   Equiv.cast (rightMoves_neg x).symm
-#align pgame.to_right_moves_neg PGame.toRightMovesNeg
+#align pgame.to_right_moves_neg SetTheory.PGame.toRightMovesNeg
 
 theorem moveLeft_neg {x : PGame} (i) : (-x).moveLeft (toLeftMovesNeg i) = -x.moveRight i := by
   cases x
   rfl
-#align pgame.move_left_neg PGame.moveLeft_neg
+#align pgame.move_left_neg SetTheory.PGame.moveLeft_neg
 
 @[simp]
 theorem moveLeft_neg' {x : PGame} (i) : (-x).moveLeft i = -x.moveRight (toLeftMovesNeg.symm i) := by
   cases x
   rfl
-#align pgame.move_left_neg' PGame.moveLeft_neg'
+#align pgame.move_left_neg' SetTheory.PGame.moveLeft_neg'
 
 theorem moveRight_neg {x : PGame} (i) : (-x).moveRight (toRightMovesNeg i) = -x.moveLeft i := by
   cases x
   rfl
-#align pgame.move_right_neg PGame.moveRight_neg
+#align pgame.move_right_neg SetTheory.PGame.moveRight_neg
 
 @[simp]
 theorem moveRight_neg' {x : PGame} (i) :
     (-x).moveRight i = -x.moveLeft (toRightMovesNeg.symm i) := by
   cases x
   rfl
-#align pgame.move_right_neg' PGame.moveRight_neg'
+#align pgame.move_right_neg' SetTheory.PGame.moveRight_neg'
 
 theorem moveLeft_neg_symm {x : PGame} (i) :
     x.moveLeft (toRightMovesNeg.symm i) = -(-x).moveRight i := by simp
-#align pgame.move_left_neg_symm PGame.moveLeft_neg_symm
+#align pgame.move_left_neg_symm SetTheory.PGame.moveLeft_neg_symm
 
 theorem moveLeft_neg_symm' {x : PGame} (i) : x.moveLeft i = -(-x).moveRight (toRightMovesNeg i) :=
   by simp
-#align pgame.move_left_neg_symm' PGame.moveLeft_neg_symm'
+#align pgame.move_left_neg_symm' SetTheory.PGame.moveLeft_neg_symm'
 
 theorem moveRight_neg_symm {x : PGame} (i) :
     x.moveRight (toLeftMovesNeg.symm i) = -(-x).moveLeft i := by simp
-#align pgame.move_right_neg_symm PGame.moveRight_neg_symm
+#align pgame.move_right_neg_symm SetTheory.PGame.moveRight_neg_symm
 
 theorem moveRight_neg_symm' {x : PGame} (i) : x.moveRight i = -(-x).moveLeft (toLeftMovesNeg i) :=
   by simp
-#align pgame.move_right_neg_symm' PGame.moveRight_neg_symm'
+#align pgame.move_right_neg_symm' SetTheory.PGame.moveRight_neg_symm'
 
 /-- If `x` has the same moves as `y`, then `-x` has the same moves as `-y`. -/
 def Relabelling.negCongr : ∀ {x y : PGame}, x ≡r y → -x ≡r -y
   | ⟨_, _, _, _⟩, ⟨_, _, _, _⟩, ⟨L, R, hL, hR⟩ =>
     ⟨R, L, fun j => (hR j).negCongr, fun i => (hL i).negCongr⟩
-#align pgame.relabelling.neg_congr PGame.Relabelling.negCongr
+#align pgame.relabelling.neg_congr SetTheory.PGame.Relabelling.negCongr
 
 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
@@ -1349,94 +1352,94 @@ termination_by _ x y => (x, y)
 @[simp]
 theorem neg_le_neg_iff {x y : PGame} : -y ≤ -x ↔ x ≤ y :=
   neg_le_lf_neg_iff.1
-#align pgame.neg_le_neg_iff PGame.neg_le_neg_iff
+#align pgame.neg_le_neg_iff SetTheory.PGame.neg_le_neg_iff
 
 @[simp]
 theorem neg_lf_neg_iff {x y : PGame} : -y ⧏ -x ↔ x ⧏ y :=
   neg_le_lf_neg_iff.2
-#align pgame.neg_lf_neg_iff PGame.neg_lf_neg_iff
+#align pgame.neg_lf_neg_iff SetTheory.PGame.neg_lf_neg_iff
 
 @[simp]
 theorem neg_lt_neg_iff {x y : PGame} : -y < -x ↔ x < y := by
   rw [lt_iff_le_and_lf, lt_iff_le_and_lf, neg_le_neg_iff, neg_lf_neg_iff]
-#align pgame.neg_lt_neg_iff PGame.neg_lt_neg_iff
+#align pgame.neg_lt_neg_iff SetTheory.PGame.neg_lt_neg_iff
 
 @[simp]
 theorem neg_equiv_neg_iff {x y : PGame} : (-x ≈ -y) ↔ (x ≈ y) := by
   show Equiv (-x) (-y) ↔ Equiv x y
   rw [Equiv, Equiv, neg_le_neg_iff, neg_le_neg_iff, and_comm]
-#align pgame.neg_equiv_neg_iff PGame.neg_equiv_neg_iff
+#align pgame.neg_equiv_neg_iff SetTheory.PGame.neg_equiv_neg_iff
 
 @[simp]
 theorem neg_fuzzy_neg_iff {x y : PGame} : -x ‖ -y ↔ x ‖ y := by
   rw [Fuzzy, Fuzzy, neg_lf_neg_iff, neg_lf_neg_iff, and_comm]
-#align pgame.neg_fuzzy_neg_iff PGame.neg_fuzzy_neg_iff
+#align pgame.neg_fuzzy_neg_iff SetTheory.PGame.neg_fuzzy_neg_iff
 
 theorem neg_le_iff {x y : PGame} : -y ≤ x ↔ -x ≤ y := by rw [← neg_neg x, neg_le_neg_iff, neg_neg]
-#align pgame.neg_le_iff PGame.neg_le_iff
+#align pgame.neg_le_iff SetTheory.PGame.neg_le_iff
 
 theorem neg_lf_iff {x y : PGame} : -y ⧏ x ↔ -x ⧏ y := by rw [← neg_neg x, neg_lf_neg_iff, neg_neg]
-#align pgame.neg_lf_iff PGame.neg_lf_iff
+#align pgame.neg_lf_iff SetTheory.PGame.neg_lf_iff
 
 theorem neg_lt_iff {x y : PGame} : -y < x ↔ -x < y := by rw [← neg_neg x, neg_lt_neg_iff, neg_neg]
-#align pgame.neg_lt_iff PGame.neg_lt_iff
+#align pgame.neg_lt_iff SetTheory.PGame.neg_lt_iff
 
 theorem neg_equiv_iff {x y : PGame} : (-x ≈ y) ↔ (x ≈ -y) := by
   rw [← neg_neg y, neg_equiv_neg_iff, neg_neg]
-#align pgame.neg_equiv_iff PGame.neg_equiv_iff
+#align pgame.neg_equiv_iff SetTheory.PGame.neg_equiv_iff
 
 theorem neg_fuzzy_iff {x y : PGame} : -x ‖ y ↔ x ‖ -y := by
   rw [← neg_neg y, neg_fuzzy_neg_iff, neg_neg]
-#align pgame.neg_fuzzy_iff PGame.neg_fuzzy_iff
+#align pgame.neg_fuzzy_iff SetTheory.PGame.neg_fuzzy_iff
 
 theorem le_neg_iff {x y : PGame} : y ≤ -x ↔ x ≤ -y := by rw [← neg_neg x, neg_le_neg_iff, neg_neg]
-#align pgame.le_neg_iff PGame.le_neg_iff
+#align pgame.le_neg_iff SetTheory.PGame.le_neg_iff
 
 theorem lf_neg_iff {x y : PGame} : y ⧏ -x ↔ x ⧏ -y := by rw [← neg_neg x, neg_lf_neg_iff, neg_neg]
-#align pgame.lf_neg_iff PGame.lf_neg_iff
+#align pgame.lf_neg_iff SetTheory.PGame.lf_neg_iff
 
 theorem lt_neg_iff {x y : PGame} : y < -x ↔ x < -y := by rw [← neg_neg x, neg_lt_neg_iff, neg_neg]
-#align pgame.lt_neg_iff PGame.lt_neg_iff
+#align pgame.lt_neg_iff SetTheory.PGame.lt_neg_iff
 
 @[simp]
 theorem neg_le_zero_iff {x : PGame} : -x ≤ 0 ↔ 0 ≤ x := by rw [neg_le_iff, neg_zero]
-#align pgame.neg_le_zero_iff PGame.neg_le_zero_iff
+#align pgame.neg_le_zero_iff SetTheory.PGame.neg_le_zero_iff
 
 @[simp]
 theorem zero_le_neg_iff {x : PGame} : 0 ≤ -x ↔ x ≤ 0 := by rw [le_neg_iff, neg_zero]
-#align pgame.zero_le_neg_iff PGame.zero_le_neg_iff
+#align pgame.zero_le_neg_iff SetTheory.PGame.zero_le_neg_iff
 
 @[simp]
 theorem neg_lf_zero_iff {x : PGame} : -x ⧏ 0 ↔ 0 ⧏ x := by rw [neg_lf_iff, neg_zero]
-#align pgame.neg_lf_zero_iff PGame.neg_lf_zero_iff
+#align pgame.neg_lf_zero_iff SetTheory.PGame.neg_lf_zero_iff
 
 @[simp]
 theorem zero_lf_neg_iff {x : PGame} : 0 ⧏ -x ↔ x ⧏ 0 := by rw [lf_neg_iff, neg_zero]
-#align pgame.zero_lf_neg_iff PGame.zero_lf_neg_iff
+#align pgame.zero_lf_neg_iff SetTheory.PGame.zero_lf_neg_iff
 
 @[simp]
 theorem neg_lt_zero_iff {x : PGame} : -x < 0 ↔ 0 < x := by rw [neg_lt_iff, neg_zero]
-#align pgame.neg_lt_zero_iff PGame.neg_lt_zero_iff
+#align pgame.neg_lt_zero_iff SetTheory.PGame.neg_lt_zero_iff
 
 @[simp]
 theorem zero_lt_neg_iff {x : PGame} : 0 < -x ↔ x < 0 := by rw [lt_neg_iff, neg_zero]
-#align pgame.zero_lt_neg_iff PGame.zero_lt_neg_iff
+#align pgame.zero_lt_neg_iff SetTheory.PGame.zero_lt_neg_iff
 
 @[simp]
 theorem neg_equiv_zero_iff {x : PGame} : (-x ≈ 0) ↔ (x ≈ 0) := by rw [neg_equiv_iff, neg_zero]
-#align pgame.neg_equiv_zero_iff PGame.neg_equiv_zero_iff
+#align pgame.neg_equiv_zero_iff SetTheory.PGame.neg_equiv_zero_iff
 
 @[simp]
 theorem neg_fuzzy_zero_iff {x : PGame} : -x ‖ 0 ↔ x ‖ 0 := by rw [neg_fuzzy_iff, neg_zero]
-#align pgame.neg_fuzzy_zero_iff PGame.neg_fuzzy_zero_iff
+#align pgame.neg_fuzzy_zero_iff SetTheory.PGame.neg_fuzzy_zero_iff
 
 @[simp]
 theorem zero_equiv_neg_iff {x : PGame} : (0 ≈ -x) ↔ (0 ≈ x) := by rw [← neg_equiv_iff, neg_zero]
-#align pgame.zero_equiv_neg_iff PGame.zero_equiv_neg_iff
+#align pgame.zero_equiv_neg_iff SetTheory.PGame.zero_equiv_neg_iff
 
 @[simp]
 theorem zero_fuzzy_neg_iff {x : PGame} : 0 ‖ -x ↔ 0 ‖ x := by rw [← neg_fuzzy_iff, neg_zero]
-#align pgame.zero_fuzzy_neg_iff PGame.zero_fuzzy_neg_iff
+#align pgame.zero_fuzzy_neg_iff SetTheory.PGame.zero_fuzzy_neg_iff
 
 /-! ### Addition and subtraction -/
 
@@ -1459,7 +1462,7 @@ instance : NatCast PGame :=
 @[simp]
 protected theorem nat_succ (n : ℕ) : ((n + 1 : ℕ) : PGame) = n + 1 :=
   rfl
-#align pgame.nat_succ PGame.nat_succ
+#align pgame.nat_succ SetTheory.PGame.nat_succ
 
 instance isEmpty_leftMoves_add (x y : PGame.{u}) [IsEmpty x.LeftMoves] [IsEmpty y.LeftMoves] :
     IsEmpty (x + y).LeftMoves := by
@@ -1467,7 +1470,7 @@ instance isEmpty_leftMoves_add (x y : PGame.{u}) [IsEmpty x.LeftMoves] [IsEmpty
   cases y
   apply isEmpty_sum.2 ⟨_, _⟩
   assumption'
-#align pgame.is_empty_left_moves_add PGame.isEmpty_leftMoves_add
+#align pgame.is_empty_left_moves_add SetTheory.PGame.isEmpty_leftMoves_add
 
 instance isEmpty_rightMoves_add (x y : PGame.{u}) [IsEmpty x.RightMoves] [IsEmpty y.RightMoves] :
     IsEmpty (x + y).RightMoves := by
@@ -1475,7 +1478,7 @@ instance isEmpty_rightMoves_add (x y : PGame.{u}) [IsEmpty x.RightMoves] [IsEmpt
   cases y
   apply isEmpty_sum.2 ⟨_, _⟩
   assumption'
-#align pgame.is_empty_right_moves_add PGame.isEmpty_rightMoves_add
+#align pgame.is_empty_right_moves_add SetTheory.PGame.isEmpty_rightMoves_add
 
 /-- `x + 0` has exactly the same moves as `x`. -/
 def addZeroRelabelling : ∀ x : PGame.{u}, x + 0 ≡r x
@@ -1483,32 +1486,32 @@ def addZeroRelabelling : ∀ x : PGame.{u}, x + 0 ≡r x
     refine' ⟨Equiv.sumEmpty xl PEmpty, Equiv.sumEmpty xr PEmpty, _, _⟩ <;> rintro (⟨i⟩ | ⟨⟨⟩⟩) <;>
       apply addZeroRelabelling
 termination_by _ x => x
-#align pgame.add_zero_relabelling PGame.addZeroRelabelling
+#align pgame.add_zero_relabelling SetTheory.PGame.addZeroRelabelling
 
 /-- `x + 0` is equivalent to `x`. -/
 theorem add_zero_equiv (x : PGame.{u}) : x + 0 ≈ x :=
   (addZeroRelabelling x).equiv
-#align pgame.add_zero_equiv PGame.add_zero_equiv
+#align pgame.add_zero_equiv SetTheory.PGame.add_zero_equiv
 
 /-- `0 + x` has exactly the same moves as `x`. -/
 def zeroAddRelabelling : ∀ x : PGame.{u}, 0 + x ≡r x
   | ⟨xl, xr, xL, xR⟩ => by
     refine' ⟨Equiv.emptySum PEmpty xl, Equiv.emptySum PEmpty xr, _, _⟩ <;> rintro (⟨⟨⟩⟩ | ⟨i⟩) <;>
       apply zeroAddRelabelling
-#align pgame.zero_add_relabelling PGame.zeroAddRelabelling
+#align pgame.zero_add_relabelling SetTheory.PGame.zeroAddRelabelling
 
 /-- `0 + x` is equivalent to `x`. -/
 theorem zero_add_equiv (x : PGame.{u}) : 0 + x ≈ x :=
   (zeroAddRelabelling x).equiv
-#align pgame.zero_add_equiv PGame.zero_add_equiv
+#align pgame.zero_add_equiv SetTheory.PGame.zero_add_equiv
 
 theorem leftMoves_add : ∀ x y : PGame.{u}, (x + y).LeftMoves = Sum x.LeftMoves y.LeftMoves
   | ⟨_, _, _, _⟩, ⟨_, _, _, _⟩ => rfl
-#align pgame.left_moves_add PGame.leftMoves_add
+#align pgame.left_moves_add SetTheory.PGame.leftMoves_add
 
 theorem rightMoves_add : ∀ x y : PGame.{u}, (x + y).RightMoves = Sum x.RightMoves y.RightMoves
   | ⟨_, _, _, _⟩, ⟨_, _, _, _⟩ => rfl
-#align pgame.right_moves_add PGame.rightMoves_add
+#align pgame.right_moves_add SetTheory.PGame.rightMoves_add
 
 /-- Converts a left move for `x` or `y` into a left move for `x + y` and vice versa.
 
@@ -1516,7 +1519,7 @@ Even though these types are the same (not definitionally so), this is the prefer
 between them. -/
 def toLeftMovesAdd {x y : PGame} : Sum x.LeftMoves y.LeftMoves ≃ (x + y).LeftMoves :=
   Equiv.cast (leftMoves_add x y).symm
-#align pgame.to_left_moves_add PGame.toLeftMovesAdd
+#align pgame.to_left_moves_add SetTheory.PGame.toLeftMovesAdd
 
 /-- Converts a right move for `x` or `y` into a right move for `x + y` and vice versa.
 
@@ -1524,14 +1527,14 @@ Even though these types are the same (not definitionally so), this is the prefer
 between them. -/
 def toRightMovesAdd {x y : PGame} : Sum x.RightMoves y.RightMoves ≃ (x + y).RightMoves :=
   Equiv.cast (rightMoves_add x y).symm
-#align pgame.to_right_moves_add PGame.toRightMovesAdd
+#align pgame.to_right_moves_add SetTheory.PGame.toRightMovesAdd
 
 @[simp]
 theorem mk_add_moveLeft_inl {xl xr yl yr} {xL xR yL yR} {i} :
     (mk xl xr xL xR + mk yl yr yL yR).moveLeft (Sum.inl i) =
       (mk xl xr xL xR).moveLeft i + mk yl yr yL yR :=
   rfl
-#align pgame.mk_add_move_left_inl PGame.mk_add_moveLeft_inl
+#align pgame.mk_add_move_left_inl SetTheory.PGame.mk_add_moveLeft_inl
 
 @[simp]
 theorem add_moveLeft_inl {x : PGame} (y : PGame) (i) :
@@ -1539,14 +1542,14 @@ theorem add_moveLeft_inl {x : PGame} (y : PGame) (i) :
   cases x
   cases y
   rfl
-#align pgame.add_move_left_inl PGame.add_moveLeft_inl
+#align pgame.add_move_left_inl SetTheory.PGame.add_moveLeft_inl
 
 @[simp]
 theorem mk_add_moveRight_inl {xl xr yl yr} {xL xR yL yR} {i} :
     (mk xl xr xL xR + mk yl yr yL yR).moveRight (Sum.inl i) =
       (mk xl xr xL xR).moveRight i + mk yl yr yL yR :=
   rfl
-#align pgame.mk_add_move_right_inl PGame.mk_add_moveRight_inl
+#align pgame.mk_add_move_right_inl SetTheory.PGame.mk_add_moveRight_inl
 
 @[simp]
 theorem add_moveRight_inl {x : PGame} (y : PGame) (i) :
@@ -1554,14 +1557,14 @@ theorem add_moveRight_inl {x : PGame} (y : PGame) (i) :
   cases x
   cases y
   rfl
-#align pgame.add_move_right_inl PGame.add_moveRight_inl
+#align pgame.add_move_right_inl SetTheory.PGame.add_moveRight_inl
 
 @[simp]
 theorem mk_add_moveLeft_inr {xl xr yl yr} {xL xR yL yR} {i} :
     (mk xl xr xL xR + mk yl yr yL yR).moveLeft (Sum.inr i) =
       mk xl xr xL xR + (mk yl yr yL yR).moveLeft i :=
   rfl
-#align pgame.mk_add_move_left_inr PGame.mk_add_moveLeft_inr
+#align pgame.mk_add_move_left_inr SetTheory.PGame.mk_add_moveLeft_inr
 
 @[simp]
 theorem add_moveLeft_inr (x : PGame) {y : PGame} (i) :
@@ -1569,14 +1572,14 @@ theorem add_moveLeft_inr (x : PGame) {y : PGame} (i) :
   cases x
   cases y
   rfl
-#align pgame.add_move_left_inr PGame.add_moveLeft_inr
+#align pgame.add_move_left_inr SetTheory.PGame.add_moveLeft_inr
 
 @[simp]
 theorem mk_add_moveRight_inr {xl xr yl yr} {xL xR yL yR} {i} :
     (mk xl xr xL xR + mk yl yr yL yR).moveRight (Sum.inr i) =
       mk xl xr xL xR + (mk yl yr yL yR).moveRight i :=
   rfl
-#align pgame.mk_add_move_right_inr PGame.mk_add_moveRight_inr
+#align pgame.mk_add_move_right_inr SetTheory.PGame.mk_add_moveRight_inr
 
 @[simp]
 theorem add_moveRight_inr (x : PGame) {y : PGame} (i) :
@@ -1584,7 +1587,7 @@ theorem add_moveRight_inr (x : PGame) {y : PGame} (i) :
   cases x
   cases y
   rfl
-#align pgame.add_move_right_inr PGame.add_moveRight_inr
+#align pgame.add_move_right_inr SetTheory.PGame.add_moveRight_inr
 
 theorem leftMoves_add_cases {x y : PGame} (k) {P : (x + y).LeftMoves → Prop}
     (hl : ∀ i, P <| toLeftMovesAdd (Sum.inl i)) (hr : ∀ i, P <| toLeftMovesAdd (Sum.inr i)) :
@@ -1593,7 +1596,7 @@ theorem leftMoves_add_cases {x y : PGame} (k) {P : (x + y).LeftMoves → Prop}
   cases' toLeftMovesAdd.symm k with i i
   · exact hl i
   · exact hr i
-#align pgame.left_moves_add_cases PGame.leftMoves_add_cases
+#align pgame.left_moves_add_cases SetTheory.PGame.leftMoves_add_cases
 
 theorem rightMoves_add_cases {x y : PGame} (k) {P : (x + y).RightMoves → Prop}
     (hl : ∀ j, P <| toRightMovesAdd (Sum.inl j)) (hr : ∀ j, P <| toRightMovesAdd (Sum.inr j)) :
@@ -1602,7 +1605,7 @@ theorem rightMoves_add_cases {x y : PGame} (k) {P : (x + y).RightMoves → Prop}
   cases' toRightMovesAdd.symm k with i i
   · exact hl i
   · exact hr i
-#align pgame.right_moves_add_cases PGame.rightMoves_add_cases
+#align pgame.right_moves_add_cases SetTheory.PGame.rightMoves_add_cases
 
 instance isEmpty_nat_rightMoves : ∀ n : ℕ, IsEmpty (RightMoves n)
   | 0 => inferInstanceAs (IsEmpty PEmpty)
@@ -1610,7 +1613,7 @@ instance isEmpty_nat_rightMoves : ∀ n : ℕ, IsEmpty (RightMoves n)
     haveI := isEmpty_nat_rightMoves n
     rw [PGame.nat_succ, rightMoves_add]
     infer_instance
-#align pgame.is_empty_nat_right_moves PGame.isEmpty_nat_rightMoves
+#align pgame.is_empty_nat_right_moves SetTheory.PGame.isEmpty_nat_rightMoves
 
 /-- If `w` has the same moves as `x` and `y` has the same moves as `z`,
 then `w + y` has the same moves as `x + z`. -/
@@ -1625,7 +1628,7 @@ def Relabelling.addCongr : ∀ {w x y z : PGame.{u}}, w ≡r x → y ≡r z →
     · exact (hR₁ i).addCongr Hyz
     · exact Hwx.addCongr (hR₂ j)
 termination_by _ w x y z _ _ => (x, z)
-#align pgame.relabelling.add_congr PGame.Relabelling.addCongr
+#align pgame.relabelling.add_congr SetTheory.PGame.Relabelling.addCongr
 
 instance : Sub PGame :=
   ⟨fun x y => x + -y⟩
@@ -1633,13 +1636,13 @@ instance : Sub PGame :=
 @[simp]
 theorem sub_zero (x : PGame) : x - 0 = x + 0 :=
   show x + -0 = x + 0 by rw [neg_zero]
-#align pgame.sub_zero PGame.sub_zero
+#align pgame.sub_zero SetTheory.PGame.sub_zero
 
 /-- If `w` has the same moves as `x` and `y` has the same moves as `z`,
 then `w - y` has the same moves as `x - z`. -/
 def Relabelling.subCongr {w x y z : PGame} (h₁ : w ≡r x) (h₂ : y ≡r z) : w - y ≡r x - z :=
   h₁.addCongr h₂.negCongr
-#align pgame.relabelling.sub_congr PGame.Relabelling.subCongr
+#align pgame.relabelling.sub_congr SetTheory.PGame.Relabelling.subCongr
 
 /-- `-(x + y)` has exactly the same moves as `-x + -y`. -/
 def negAddRelabelling : ∀ x y : PGame, -(x + y) ≡r -x + -y
@@ -1650,11 +1653,11 @@ def negAddRelabelling : ∀ x y : PGame, -(x + y) ≡r -x + -y
         Sum.casesOn j (fun j => negAddRelabelling _ _) fun j =>
           negAddRelabelling ⟨xl, xr, xL, xR⟩ _
 termination_by _ x y => (x, y)
-#align pgame.neg_add_relabelling PGame.negAddRelabelling
+#align pgame.neg_add_relabelling SetTheory.PGame.negAddRelabelling
 
 theorem neg_add_le {x y : PGame} : -(x + y) ≤ -x + -y :=
   (negAddRelabelling x y).le
-#align pgame.neg_add_le PGame.neg_add_le
+#align pgame.neg_add_le SetTheory.PGame.neg_add_le
 
 /-- `x + y` has exactly the same moves as `y + x`. -/
 def addCommRelabelling : ∀ x y : PGame.{u}, x + y ≡r y + x
@@ -1663,15 +1666,15 @@ def addCommRelabelling : ∀ x y : PGame.{u}, x + y ≡r y + x
       · dsimp [leftMoves_add, rightMoves_add]
         apply addCommRelabelling
 termination_by _ x y => (x, y)
-#align pgame.add_comm_relabelling PGame.addCommRelabelling
+#align pgame.add_comm_relabelling SetTheory.PGame.addCommRelabelling
 
 theorem add_comm_le {x y : PGame} : x + y ≤ y + x :=
   (addCommRelabelling x y).le
-#align pgame.add_comm_le PGame.add_comm_le
+#align pgame.add_comm_le SetTheory.PGame.add_comm_le
 
 theorem add_comm_equiv {x y : PGame} : x + y ≈ y + x :=
   (addCommRelabelling x y).equiv
-#align pgame.add_comm_equiv PGame.add_comm_equiv
+#align pgame.add_comm_equiv SetTheory.PGame.add_comm_equiv
 
 /-- `(x + y) + z` has exactly the same moves as `x + (y + z)`. -/
 def addAssocRelabelling : ∀ x y z : PGame.{u}, x + y + z ≡r x + (y + z)
@@ -1686,11 +1689,11 @@ def addAssocRelabelling : ∀ x y z : PGame.{u}, x + y + z ≡r x + (y + z)
       · apply addAssocRelabelling ⟨xl, xr, xL, xR⟩ (yR i)
       · apply addAssocRelabelling ⟨xl, xr, xL, xR⟩ ⟨yl, yr, yL, yR⟩ (zR i)
 termination_by _ x y z => (x, y, z)
-#align pgame.add_assoc_relabelling PGame.addAssocRelabelling
+#align pgame.add_assoc_relabelling SetTheory.PGame.addAssocRelabelling
 
 theorem add_assoc_equiv {x y z : PGame} : x + y + z ≈ x + (y + z) :=
   (addAssocRelabelling x y z).equiv
-#align pgame.add_assoc_equiv PGame.add_assoc_equiv
+#align pgame.add_assoc_equiv SetTheory.PGame.add_assoc_equiv
 
 theorem add_left_neg_le_zero : ∀ x : PGame, -x + x ≤ 0
   | ⟨xl, xr, xL, xR⟩ =>
@@ -1705,32 +1708,32 @@ theorem add_left_neg_le_zero : ∀ x : PGame, -x + x ≤ 0
         refine' ⟨@toRightMovesAdd ⟨_, _, _, _⟩ _ (Sum.inl i), _⟩
         convert @add_left_neg_le_zero (xL i)
         apply add_moveRight_inl
-#align pgame.add_left_neg_le_zero PGame.add_left_neg_le_zero
+#align pgame.add_left_neg_le_zero SetTheory.PGame.add_left_neg_le_zero
 
 theorem zero_le_add_left_neg (x : PGame) : 0 ≤ -x + x := by
   rw [← neg_le_neg_iff, neg_zero]
   exact neg_add_le.trans (add_left_neg_le_zero _)
-#align pgame.zero_le_add_left_neg PGame.zero_le_add_left_neg
+#align pgame.zero_le_add_left_neg SetTheory.PGame.zero_le_add_left_neg
 
 theorem add_left_neg_equiv (x : PGame) : -x + x ≈ 0 :=
   ⟨add_left_neg_le_zero x, zero_le_add_left_neg x⟩
-#align pgame.add_left_neg_equiv PGame.add_left_neg_equiv
+#align pgame.add_left_neg_equiv SetTheory.PGame.add_left_neg_equiv
 
 theorem add_right_neg_le_zero (x : PGame) : x + -x ≤ 0 :=
   add_comm_le.trans (add_left_neg_le_zero x)
-#align pgame.add_right_neg_le_zero PGame.add_right_neg_le_zero
+#align pgame.add_right_neg_le_zero SetTheory.PGame.add_right_neg_le_zero
 
 theorem zero_le_add_right_neg (x : PGame) : 0 ≤ x + -x :=
   (zero_le_add_left_neg x).trans add_comm_le
-#align pgame.zero_le_add_right_neg PGame.zero_le_add_right_neg
+#align pgame.zero_le_add_right_neg SetTheory.PGame.zero_le_add_right_neg
 
 theorem add_right_neg_equiv (x : PGame) : x + -x ≈ 0 :=
   ⟨add_right_neg_le_zero x, zero_le_add_right_neg x⟩
-#align pgame.add_right_neg_equiv PGame.add_right_neg_equiv
+#align pgame.add_right_neg_equiv SetTheory.PGame.add_right_neg_equiv
 
 theorem sub_self_equiv : ∀ (x : PGame), x - x ≈ 0 :=
   add_right_neg_equiv
-#align pgame.sub_self_equiv PGame.sub_self_equiv
+#align pgame.sub_self_equiv SetTheory.PGame.sub_self_equiv
 
 private theorem add_le_add_right' : ∀ {x y z : PGame}, x ≤ y → x + z ≤ y + z
   | mk xl xr xL xR, mk yl yr yL yR, mk zl zr zL zR => fun h => by
@@ -1755,11 +1758,11 @@ termination_by _ x y z => (x, y, z)
 
 instance covariantClass_swap_add_le : CovariantClass PGame PGame (swap (· + ·)) (· ≤ ·) :=
   ⟨fun _ _ _ => add_le_add_right'⟩
-#align pgame.covariant_class_swap_add_le PGame.covariantClass_swap_add_le
+#align pgame.covariant_class_swap_add_le SetTheory.PGame.covariantClass_swap_add_le
 
 instance covariantClass_add_le : CovariantClass PGame PGame (· + ·) (· ≤ ·) :=
   ⟨fun x _ _ h => (add_comm_le.trans (add_le_add_right h x)).trans add_comm_le⟩
-#align pgame.covariant_class_add_le PGame.covariantClass_add_le
+#align pgame.covariant_class_add_le SetTheory.PGame.covariantClass_add_le
 
 theorem add_lf_add_right {y z : PGame} (h : y ⧏ z) (x) : y + x ⧏ z + x :=
   suffices z + x ≤ y + x → z ≤ y by
@@ -1775,53 +1778,53 @@ theorem add_lf_add_right {y z : PGame} (h : y ⧏ z) (x) : y + x ⧏ z + x :=
     _ ≤ y + 0 := (add_le_add_left (add_right_neg_le_zero x) _)
     _ ≤ y := (addZeroRelabelling _).le
 
-#align pgame.add_lf_add_right PGame.add_lf_add_right
+#align pgame.add_lf_add_right SetTheory.PGame.add_lf_add_right
 
 theorem add_lf_add_left {y z : PGame} (h : y ⧏ z) (x) : x + y ⧏ x + z := by
   rw [lf_congr add_comm_equiv add_comm_equiv]
   apply add_lf_add_right h
-#align pgame.add_lf_add_left PGame.add_lf_add_left
+#align pgame.add_lf_add_left SetTheory.PGame.add_lf_add_left
 
 instance covariantClass_swap_add_lt : CovariantClass PGame PGame (swap (· + ·)) (· < ·) :=
   ⟨fun x _ _ h => ⟨add_le_add_right h.1 x, add_lf_add_right h.2 x⟩⟩
-#align pgame.covariant_class_swap_add_lt PGame.covariantClass_swap_add_lt
+#align pgame.covariant_class_swap_add_lt SetTheory.PGame.covariantClass_swap_add_lt
 
 instance covariantClass_add_lt : CovariantClass PGame PGame (· + ·) (· < ·) :=
   ⟨fun x _ _ h => ⟨add_le_add_left h.1 x, add_lf_add_left h.2 x⟩⟩
-#align pgame.covariant_class_add_lt PGame.covariantClass_add_lt
+#align pgame.covariant_class_add_lt SetTheory.PGame.covariantClass_add_lt
 
 theorem add_lf_add_of_lf_of_le {w x y z : PGame} (hwx : w ⧏ x) (hyz : y ≤ z) : w + y ⧏ x + z :=
   lf_of_lf_of_le (add_lf_add_right hwx y) (add_le_add_left hyz x)
-#align pgame.add_lf_add_of_lf_of_le PGame.add_lf_add_of_lf_of_le
+#align pgame.add_lf_add_of_lf_of_le SetTheory.PGame.add_lf_add_of_lf_of_le
 
 theorem add_lf_add_of_le_of_lf {w x y z : PGame} (hwx : w ≤ x) (hyz : y ⧏ z) : w + y ⧏ x + z :=
   lf_of_le_of_lf (add_le_add_right hwx y) (add_lf_add_left hyz x)
-#align pgame.add_lf_add_of_le_of_lf PGame.add_lf_add_of_le_of_lf
+#align pgame.add_lf_add_of_le_of_lf SetTheory.PGame.add_lf_add_of_le_of_lf
 
 theorem add_congr {w x y z : PGame} (h₁ : w ≈ x) (h₂ : y ≈ z) : w + y ≈ x + z :=
   ⟨(add_le_add_left h₂.1 w).trans (add_le_add_right h₁.1 z),
     (add_le_add_left h₂.2 x).trans (add_le_add_right h₁.2 y)⟩
-#align pgame.add_congr PGame.add_congr
+#align pgame.add_congr SetTheory.PGame.add_congr
 
 theorem add_congr_left {x y z : PGame} (h : x ≈ y) : x + z ≈ y + z :=
   add_congr h equiv_rfl
-#align pgame.add_congr_left PGame.add_congr_left
+#align pgame.add_congr_left SetTheory.PGame.add_congr_left
 
 theorem add_congr_right {x y z : PGame} : (y ≈ z) → (x + y ≈ x + z) :=
   add_congr equiv_rfl
-#align pgame.add_congr_right PGame.add_congr_right
+#align pgame.add_congr_right SetTheory.PGame.add_congr_right
 
 theorem sub_congr {w x y z : PGame} (h₁ : w ≈ x) (h₂ : y ≈ z) : w - y ≈ x - z :=
   add_congr h₁ (neg_equiv_neg_iff.2 h₂)
-#align pgame.sub_congr PGame.sub_congr
+#align pgame.sub_congr SetTheory.PGame.sub_congr
 
 theorem sub_congr_left {x y z : PGame} (h : x ≈ y) : x - z ≈ y - z :=
   sub_congr h equiv_rfl
-#align pgame.sub_congr_left PGame.sub_congr_left
+#align pgame.sub_congr_left SetTheory.PGame.sub_congr_left
 
 theorem sub_congr_right {x y z : PGame} : (y ≈ z) → (x - y ≈ x - z) :=
   sub_congr equiv_rfl
-#align pgame.sub_congr_right PGame.sub_congr_right
+#align pgame.sub_congr_right SetTheory.PGame.sub_congr_right
 
 theorem le_iff_sub_nonneg {x y : PGame} : x ≤ y ↔ 0 ≤ y - x :=
   ⟨fun h => (zero_le_add_right_neg x).trans (add_le_add_right h _), fun h =>
@@ -1832,7 +1835,7 @@ theorem le_iff_sub_nonneg {x y : PGame} : x ≤ y ↔ 0 ≤ y - x :=
       _ ≤ y + 0 := (add_le_add_left (add_left_neg_le_zero x) _)
       _ ≤ y := (addZeroRelabelling y).le
       ⟩
-#align pgame.le_iff_sub_nonneg PGame.le_iff_sub_nonneg
+#align pgame.le_iff_sub_nonneg SetTheory.PGame.le_iff_sub_nonneg
 
 theorem lf_iff_sub_zero_lf {x y : PGame} : x ⧏ y ↔ 0 ⧏ y - x :=
   ⟨fun h => (zero_le_add_right_neg x).trans_lf (add_lf_add_right h _), fun h =>
@@ -1843,7 +1846,7 @@ theorem lf_iff_sub_zero_lf {x y : PGame} : x ⧏ y ↔ 0 ⧏ y - x :=
       _ ≤ y + 0 := (add_le_add_left (add_left_neg_le_zero x) _)
       _ ≤ y := (addZeroRelabelling y).le
       ⟩
-#align pgame.lf_iff_sub_zero_lf PGame.lf_iff_sub_zero_lf
+#align pgame.lf_iff_sub_zero_lf SetTheory.PGame.lf_iff_sub_zero_lf
 
 theorem lt_iff_sub_pos {x y : PGame} : x < y ↔ 0 < y - x :=
   ⟨fun h => lt_of_le_of_lt (zero_le_add_right_neg x) (add_lt_add_right h _), fun h =>
@@ -1854,7 +1857,7 @@ theorem lt_iff_sub_pos {x y : PGame} : x < y ↔ 0 < y - x :=
       _ ≤ y + 0 := (add_le_add_left (add_left_neg_le_zero x) _)
       _ ≤ y := (addZeroRelabelling y).le
       ⟩
-#align pgame.lt_iff_sub_pos PGame.lt_iff_sub_pos
+#align pgame.lt_iff_sub_pos SetTheory.PGame.lt_iff_sub_pos
 
 /-! ### Special pre-games -/
 
@@ -1862,35 +1865,35 @@ theorem lt_iff_sub_pos {x y : PGame} : x < y ↔ 0 < y - x :=
 /-- The pre-game `star`, which is fuzzy with zero. -/
 def star : PGame.{u} :=
   ⟨PUnit, PUnit, fun _ => 0, fun _ => 0⟩
-#align pgame.star PGame.star
+#align pgame.star SetTheory.PGame.star
 
 @[simp]
 theorem star_leftMoves : star.LeftMoves = PUnit :=
   rfl
-#align pgame.star_left_moves PGame.star_leftMoves
+#align pgame.star_left_moves SetTheory.PGame.star_leftMoves
 
 @[simp]
 theorem star_rightMoves : star.RightMoves = PUnit :=
   rfl
-#align pgame.star_right_moves PGame.star_rightMoves
+#align pgame.star_right_moves SetTheory.PGame.star_rightMoves
 
 @[simp]
 theorem star_moveLeft (x) : star.moveLeft x = 0 :=
   rfl
-#align pgame.star_move_left PGame.star_moveLeft
+#align pgame.star_move_left SetTheory.PGame.star_moveLeft
 
 @[simp]
 theorem star_moveRight (x) : star.moveRight x = 0 :=
   rfl
-#align pgame.star_move_right PGame.star_moveRight
+#align pgame.star_move_right SetTheory.PGame.star_moveRight
 
 instance uniqueStarLeftMoves : Unique star.LeftMoves :=
   PUnit.unique
-#align pgame.unique_star_left_moves PGame.uniqueStarLeftMoves
+#align pgame.unique_star_left_moves SetTheory.PGame.uniqueStarLeftMoves
 
 instance uniqueStarRightMoves : Unique star.RightMoves :=
   PUnit.unique
-#align pgame.unique_star_right_moves PGame.uniqueStarRightMoves
+#align pgame.unique_star_right_moves SetTheory.PGame.uniqueStarRightMoves
 
 theorem star_fuzzy_zero : star ‖ 0 :=
   ⟨by
@@ -1901,16 +1904,16 @@ theorem star_fuzzy_zero : star ‖ 0 :=
     rw [zero_lf]
     use default
     rintro ⟨⟩⟩
-#align pgame.star_fuzzy_zero PGame.star_fuzzy_zero
+#align pgame.star_fuzzy_zero SetTheory.PGame.star_fuzzy_zero
 
 @[simp]
 theorem neg_star : -star = star := by simp [star]
-#align pgame.neg_star PGame.neg_star
+#align pgame.neg_star SetTheory.PGame.neg_star
 
 @[simp]
 protected theorem zero_lt_one : (0 : PGame) < 1 :=
   lt_of_le_of_lf (zero_le_of_isEmpty_rightMoves 1) (zero_lf_le.2 ⟨default, le_rfl⟩)
-#align pgame.zero_lt_one PGame.zero_lt_one
+#align pgame.zero_lt_one SetTheory.PGame.zero_lt_one
 
 instance : ZeroLEOneClass PGame :=
   ⟨PGame.zero_lt_one.le⟩
@@ -1918,6 +1921,6 @@ instance : ZeroLEOneClass PGame :=
 @[simp]
 theorem zero_lf_one : (0 : PGame) ⧏ 1 :=
   PGame.zero_lt_one.lf
-#align pgame.zero_lf_one PGame.zero_lf_one
+#align pgame.zero_lf_one SetTheory.PGame.zero_lf_one
 
 end PGame

@@ -471,14 +471,14 @@ theorem moveLeft_lf_of_le {x y : PGame} (h : x ≤ y) (i) : x.moveLeft i ⧏ y :
   (le_iff_forall_lf.1 h).1 i
 #align pgame.move_left_lf_of_le PGame.moveLeft_lf_of_le
 
-alias moveLeft_lf_of_le ← _root_.LE.le.moveLeft_lf
+alias _root_.LE.le.moveLeft_lf := moveLeft_lf_of_le
 #align has_le.le.move_left_lf LE.le.moveLeft_lf
 
 theorem lf_moveRight_of_le {x y : PGame} (h : x ≤ y) (j) : x ⧏ y.moveRight j :=
   (le_iff_forall_lf.1 h).2 j
 #align pgame.lf_move_right_of_le PGame.lf_moveRight_of_le
 
-alias lf_moveRight_of_le ← _root_.LE.le.lf_moveRight
+alias _root_.LE.le.lf_moveRight := lf_moveRight_of_le
 #align has_le.le.lf_move_right LE.le.lf_moveRight
 
 theorem lf_of_moveRight_le {x y : PGame} {j} (h : x.moveRight j ≤ y) : x ⧏ y :=
@@ -547,7 +547,7 @@ theorem lf_of_lt {x y : PGame} (h : x < y) : x ⧏ y :=
   h.2
 #align pgame.lf_of_lt PGame.lf_of_lt
 
-alias lf_of_lt ← _root_.LT.lt.lf
+alias _root_.LT.lt.lf := lf_of_lt
 #align has_lt.lt.lf LT.lt.lf
 
 theorem lf_irrefl (x : PGame) : ¬x ⧏ x :=
@@ -575,10 +575,10 @@ theorem lf_of_lf_of_le {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y ≤ z) : x ⧏
 -- Porting note: added
 instance : Trans (· ⧏ ·) (· ≤ ·) (· ⧏ ·) := ⟨lf_of_lf_of_le⟩
 
-alias lf_of_le_of_lf ← _root_.LE.le.trans_lf
+alias _root_.LE.le.trans_lf := lf_of_le_of_lf
 #align has_le.le.trans_lf LE.le.trans_lf
 
-alias lf_of_lf_of_le ← Lf.trans_le
+alias Lf.trans_le := lf_of_lf_of_le
 #align pgame.lf.trans_le PGame.Lf.trans_le
 
 @[trans]
@@ -591,10 +591,10 @@ theorem lf_of_lf_of_lt {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y < z) : x ⧏ z
   h₁.trans_le h₂.le
 #align pgame.lf_of_lf_of_lt PGame.lf_of_lf_of_lt
 
-alias lf_of_lt_of_lf ← _root_.LT.lt.trans_lf
+alias _root_.LT.lt.trans_lf := lf_of_lt_of_lf
 #align has_lt.lt.trans_lf LT.lt.trans_lf
 
-alias lf_of_lf_of_lt ← Lf.trans_lt
+alias Lf.trans_lt := lf_of_lf_of_lt
 #align pgame.lf.trans_lt PGame.Lf.trans_lt
 
 theorem moveLeft_lf {x : PGame} : ∀ i, x.moveLeft i ⧏ x :=
@@ -957,7 +957,7 @@ theorem lf_of_fuzzy {x y : PGame} (h : x ‖ y) : x ⧏ y :=
   lf_iff_lt_or_fuzzy.2 (Or.inr h)
 #align pgame.lf_of_fuzzy PGame.lf_of_fuzzy
 
-alias lf_of_fuzzy ← Fuzzy.lf
+alias Fuzzy.lf := lf_of_fuzzy
 #align pgame.fuzzy.lf PGame.Fuzzy.lf
 
 theorem lt_or_fuzzy_of_lf {x y : PGame} : x ⧏ y → x < y ∨ x ‖ y :=

Autoimplicits are highly controversial and also defeat the performance-improving work in #6474.

The intent of this PR is to make autoImplicit opt-in on a per-file basis, by disabling it in the lakefile and enabling it again with set_option autoImplicit true in the few files that rely on it.

That also keeps this PR small, as opposed to attempting to "fix" files to not need it any more.

I claim that many of the uses of autoImplicit in these files are accidental; situations such as:

• Assuming variables are in scope, but pasting the lemma in the wrong section
• Pasting in a lemma from a scratch file without checking to see if the variable names are consistent with the rest of the file
• Making a copy-paste error between lemmas and forgetting to add an explicit arguments.

Having set_option autoImplicit false as the default prevents these types of mistake being made in the 90% of files where autoImplicits are not used at all, and causes them to be caught by CI during review.

I think there were various points during the port where we encouraged porters to delete the universes u v lines; I think having autoparams for universe variables only would cover a lot of the cases we actually use them, while avoiding any real shortcomings.

A Zulip poll (after combining overlapping votes accordingly) was in favor of this change with 5:5:18 as the no:dontcare:yes vote ratio.

While this PR was being reviewed, a handful of files gained some more likely-accidental autoImplicits. In these places, set_option autoImplicit true has been placed locally within a section, rather than at the top of the file.

@@ -95,6 +95,8 @@ An interested reader may like to formalise some of the material from
 * [André Joyal, *Remarques sur la théorie des jeux à deux personnes*][joyal1997]
 -/
 
+set_option autoImplicit true
+
 open Function Relation
 
 -- We'd like to be able to use multi-character auto-implicits in this file.

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

@@ -211,7 +211,7 @@ theorem ofLists_moveRight' {L R : List PGame} (i : (ofLists L R).RightMoves) :
 
 Both this and `PGame.recOn` describe Conway induction on games. -/
 @[elab_as_elim]
-def moveRecOn {C : PGame → Sort _} (x : PGame)
+def moveRecOn {C : PGame → Sort*} (x : PGame)
     (IH : ∀ y : PGame, (∀ i, C (y.moveLeft i)) → (∀ j, C (y.moveRight j)) → C y) : C x :=
   x.recOn <| fun yl yr yL yR => IH (mk yl yr yL yR)
 #align pgame.move_rec_on PGame.moveRecOn

Per https://github.com/leanprover/lean4/issues/2343, we are going to need to change the automatic generation of instance names, as they become too long.

This PR ensures that everywhere in Mathlib that refers to an instance by name, that name is given explicitly, rather than being automatically generated.

There are four exceptions, which are now commented, with links to https://github.com/leanprover/lean4/issues/2343.

This was implemented by running Mathlib against a modified Lean that appended _ᾰ to all automatically generated names, and fixing everything.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -249,7 +249,7 @@ def Subsequent : PGame → PGame → Prop :=
 #align pgame.subsequent PGame.Subsequent
 
 instance : IsTrans _ Subsequent :=
-  Relation.instIsTransTransGen
+  inferInstanceAs <| IsTrans _ (TransGen _)
 
 @[trans]
 theorem Subsequent.trans {x y z} : Subsequent x y → Subsequent y z → Subsequent x z :=
@@ -354,7 +354,7 @@ instance : Inhabited PGame :=
   ⟨0⟩
 
 /-- The pre-game `One` is defined by `1 = { 0 | }`. -/
-instance : One PGame :=
+instance instOnePGame : One PGame :=
   ⟨⟨PUnit, PEmpty, fun _ => 0, PEmpty.elim⟩⟩
 
 @[simp]

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -97,7 +97,7 @@ An interested reader may like to formalise some of the material from
 
 open Function Relation
 
--- This is fine, we'd like to be able to use multi-character auto-implicits.
+-- We'd like to be able to use multi-character auto-implicits in this file.
 set_option relaxedAutoImplicit true
 
 /-! ### Pre-game moves -/

@@ -97,7 +97,7 @@ An interested reader may like to formalise some of the material from
 
 open Function Relation
 
--- This is file, we'd like to be able to use multi-character auto-implicits.
+-- This is fine, we'd like to be able to use multi-character auto-implicits.
 set_option relaxedAutoImplicit true
 
 /-! ### Pre-game moves -/
@@ -735,7 +735,7 @@ def Equiv (x y : PGame) : Prop :=
 #align pgame.equiv PGame.Equiv
 
 -- Porting note: deleted the scoped notation due to notation overloading with the setoid
--- instance and this causes the the PGame.equiv docstring to not show up on hover.
+-- instance and this causes the PGame.equiv docstring to not show up on hover.
 
 instance : IsEquiv _ PGame.Equiv where
   refl _ := ⟨le_rfl, le_rfl⟩

• depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -2,17 +2,14 @@
 Copyright (c) 2019 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Reid Barton, Mario Carneiro, Isabel Longbottom, Scott Morrison
-
-! This file was ported from Lean 3 source module set_theory.game.pgame
-! leanprover-community/mathlib commit dc9e5ba64653e017743ba5d2c28e42f9f486bf99
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Fin.Basic
 import Mathlib.Data.List.Basic
 import Mathlib.Logic.Relation
 import Mathlib.Order.GameAdd
 
+#align_import set_theory.game.pgame from "leanprover-community/mathlib"@"dc9e5ba64653e017743ba5d2c28e42f9f486bf99"
+
 /-!
 # Combinatorial (pre-)games.
 

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -790,11 +790,23 @@ theorem le_of_le_of_equiv {x y z : PGame} (h₁ : x ≤ y) (h₂ : y ≈ z) : x
   h₁.trans h₂.1
 #align pgame.le_of_le_of_equiv PGame.le_of_le_of_equiv
 
+instance : Trans
+    ((· ≤ ·) : PGame → PGame → Prop)
+    ((· ≈ ·) : PGame → PGame → Prop)
+    ((· ≤ ·) : PGame → PGame → Prop) where
+  trans := le_of_le_of_equiv
+
 @[trans]
 theorem le_of_equiv_of_le {x y z : PGame} (h₁ : x ≈ y) : y ≤ z → x ≤ z :=
   h₁.1.trans
 #align pgame.le_of_equiv_of_le PGame.le_of_equiv_of_le
 
+instance : Trans
+    ((· ≈ ·) : PGame → PGame → Prop)
+    ((· ≤ ·) : PGame → PGame → Prop)
+    ((· ≤ ·) : PGame → PGame → Prop) where
+  trans := le_of_equiv_of_le
+
 theorem Lf.not_equiv {x y : PGame} (h : x ⧏ y) : ¬(x ≈ y) := fun h' => h.not_ge h'.2
 #align pgame.lf.not_equiv PGame.Lf.not_equiv
 
@@ -856,6 +868,12 @@ theorem lt_of_equiv_of_lt {x y z : PGame} (h₁ : x ≈ y) : y < z → x < z :=
   h₁.1.trans_lt
 #align pgame.lt_of_equiv_of_lt PGame.lt_of_equiv_of_lt
 
+instance : Trans
+    ((· ≈ ·) : PGame → PGame → Prop)
+    ((· < ·) : PGame → PGame → Prop)
+    ((· < ·) : PGame → PGame → Prop) where
+  trans := lt_of_equiv_of_lt
+
 theorem lt_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) (h : x₁ < y₁) : x₂ < y₂ :=
   hx.2.trans_lt (h.trans_le hy.1)
 #align pgame.lt_congr_imp PGame.lt_congr_imp

@@ -506,7 +506,7 @@ theorem lf_mk_of_le {x yl yr} {yL : yl → PGame} (yR) {i} : x ≤ yL i → x 
   @lf_of_le_moveLeft x (mk _ _ _ _) i
 #align pgame.lf_mk_of_le PGame.lf_mk_of_le
 
-/- We prove that `x ≤ y → y ≤ z ← x ≤ z` inductively, by also simultaneously proving its cyclic
+/- We prove that `x ≤ y → y ≤ z → x ≤ z` inductively, by also simultaneously proving its cyclic
 reorderings. This auxiliary lemma is used during said induction. -/
 private theorem le_trans_aux {x y z : PGame}
     (h₁ : ∀ {i}, y ≤ z → z ≤ x.moveLeft i → y ≤ x.moveLeft i)

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: David Renshaw <dwrenshaw@gmail.com> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com> Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com>

@@ -293,9 +293,10 @@ Discharges proof obligations of the form `⊢ Subsequent ..` arising in terminat
 of definitions using well-founded recursion on `PGame`.
 -/
 macro "pgame_wf_tac" : tactic =>
-  `(tactic| solve_by_elim (config := {maxDepth := 6 }) [PSigma.Lex.left, PSigma.Lex.right,
-  Subsequent.moveLeft, Subsequent.moveRight, Subsequent.mk_left, Subsequent.mk_right,
-  Subsequent.trans] )
+  `(tactic| solve_by_elim (config := { maxDepth := 8 })
+    [Prod.Lex.left, Prod.Lex.right, PSigma.Lex.left, PSigma.Lex.right,
+    Subsequent.moveLeft, Subsequent.moveRight, Subsequent.mk_left, Subsequent.mk_right,
+    Subsequent.trans] )
 
 -- Register some consequences of pgame_wf_tac as simp-lemmas for convenience
 -- (which are applied by default for WF goals)
@@ -736,14 +737,20 @@ def Equiv (x y : PGame) : Prop :=
   x ≤ y ∧ y ≤ x
 #align pgame.equiv PGame.Equiv
 
-@[inherit_doc]
-scoped infixl:0 " ≈ " => PGame.Equiv
+-- Porting note: deleted the scoped notation due to notation overloading with the setoid
+-- instance and this causes the the PGame.equiv docstring to not show up on hover.
 
 instance : IsEquiv _ PGame.Equiv where
   refl _ := ⟨le_rfl, le_rfl⟩
   trans := fun _ _ _ ⟨xy, yx⟩ ⟨yz, zy⟩ => ⟨xy.trans yz, zy.trans yx⟩
   symm _ _ := And.symm
 
+-- Porting note: moved the setoid instance from Basic.lean to here
+
+instance setoid : Setoid PGame :=
+  ⟨Equiv, refl, symm, Trans.trans⟩
+#align pgame.setoid PGame.setoid
+
 theorem Equiv.le {x y : PGame} (h : x ≈ y) : x ≤ y :=
   h.1
 #align pgame.equiv.le PGame.Equiv.le
@@ -802,7 +809,7 @@ theorem le_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y
 #align pgame.le_congr_imp PGame.le_congr_imp
 
 theorem le_congr {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ≤ y₁ ↔ x₂ ≤ y₂ :=
-  ⟨le_congr_imp hx hy, le_congr_imp hx.symm hy.symm⟩
+  ⟨le_congr_imp hx hy, le_congr_imp (Equiv.symm hx) (Equiv.symm hy)⟩
 #align pgame.le_congr PGame.le_congr
 
 theorem le_congr_left {x₁ x₂ y : PGame} (hx : x₁ ≈ x₂) : x₁ ≤ y ↔ x₂ ≤ y :=
@@ -836,7 +843,7 @@ theorem lf_of_lf_of_equiv {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y ≈ z) : x
 
 @[trans]
 theorem lf_of_equiv_of_lf {x y z : PGame} (h₁ : x ≈ y) : y ⧏ z → x ⧏ z :=
-  lf_congr_imp h₁.symm equiv_rfl
+  lf_congr_imp (Equiv.symm h₁) equiv_rfl
 #align pgame.lf_of_equiv_of_lf PGame.lf_of_equiv_of_lf
 
 @[trans]
@@ -854,7 +861,7 @@ theorem lt_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y
 #align pgame.lt_congr_imp PGame.lt_congr_imp
 
 theorem lt_congr {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ < y₁ ↔ x₂ < y₂ :=
-  ⟨lt_congr_imp hx hy, lt_congr_imp hx.symm hy.symm⟩
+  ⟨lt_congr_imp hx hy, lt_congr_imp (Equiv.symm hx) (Equiv.symm hy)⟩
 #align pgame.lt_congr PGame.lt_congr
 
 theorem lt_congr_left {x₁ x₂ y : PGame} (hx : x₁ ≈ x₂) : x₁ < y ↔ x₂ < y :=
@@ -875,15 +882,17 @@ theorem lf_or_equiv_or_gf (x y : PGame) : x ⧏ y ∨ (x ≈ y) ∨ y ⧏ x := b
   · right
     cases' lt_or_equiv_of_le (PGame.not_lf.1 h) with h' h'
     · exact Or.inr h'.lf
-    · exact Or.inl h'.symm
+    · exact Or.inl (Equiv.symm h')
 #align pgame.lf_or_equiv_or_gf PGame.lf_or_equiv_or_gf
 
 theorem equiv_congr_left {y₁ y₂ : PGame} : (y₁ ≈ y₂) ↔ ∀ x₁, (x₁ ≈ y₁) ↔ (x₁ ≈ y₂) :=
-  ⟨fun h _ => ⟨fun h' => h'.trans h, fun h' => h'.trans h.symm⟩, fun h => (h y₁).1 <| equiv_rfl⟩
+  ⟨fun h _ => ⟨fun h' => Equiv.trans h' h, fun h' => Equiv.trans h' (Equiv.symm h)⟩,
+   fun h => (h y₁).1 <| equiv_rfl⟩
 #align pgame.equiv_congr_left PGame.equiv_congr_left
 
 theorem equiv_congr_right {x₁ x₂ : PGame} : (x₁ ≈ x₂) ↔ ∀ y₁, (x₁ ≈ y₁) ↔ (x₂ ≈ y₁) :=
-  ⟨fun h _ => ⟨fun h' => h.symm.trans h', fun h' => h.trans h'⟩, fun h => (h x₂).2 <| equiv_rfl⟩
+  ⟨fun h _ => ⟨fun h' => Equiv.trans (Equiv.symm h) h', fun h' => Equiv.trans h h'⟩,
+   fun h => (h x₂).2 <| equiv_rfl⟩
 #align pgame.equiv_congr_right PGame.equiv_congr_right
 
 theorem equiv_of_mk_equiv {x y : PGame} (L : x.LeftMoves ≃ y.LeftMoves)
@@ -1337,6 +1346,7 @@ theorem neg_lt_neg_iff {x y : PGame} : -y < -x ↔ x < y := by
 
 @[simp]
 theorem neg_equiv_neg_iff {x y : PGame} : (-x ≈ -y) ↔ (x ≈ y) := by
+  show Equiv (-x) (-y) ↔ Equiv x y
   rw [Equiv, Equiv, neg_le_neg_iff, neg_le_neg_iff, and_comm]
 #align pgame.neg_equiv_neg_iff PGame.neg_equiv_neg_iff
 

We disable the "relaxed" auto-implicit feature, so only single character identifiers become eligible as auto-implicits. See discussion on zulip and 2.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au>

@@ -100,6 +100,9 @@ An interested reader may like to formalise some of the material from
 
 open Function Relation
 
+-- This is file, we'd like to be able to use multi-character auto-implicits.
+set_option relaxedAutoImplicit true
+
 /-! ### Pre-game moves -/
 
 

Changes are of the form

• some_tactic at h⊢ -> some_tactic at h ⊢
• some_tactic at h -> some_tactic at h

@@ -556,7 +556,7 @@ instance : IsIrrefl _ (· ⧏ ·) :=
 
 @[trans]
 theorem lf_of_le_of_lf {x y z : PGame} (h₁ : x ≤ y) (h₂ : y ⧏ z) : x ⧏ z := by
-  rw [← PGame.not_le] at h₂⊢
+  rw [← PGame.not_le] at h₂ ⊢
   exact fun h₃ => h₂ (h₃.trans h₁)
 #align pgame.lf_of_le_of_lf PGame.lf_of_le_of_lf
 
@@ -565,7 +565,7 @@ instance : Trans (· ≤ ·) (· ⧏ ·) (· ⧏ ·) := ⟨lf_of_le_of_lf⟩
 
 @[trans]
 theorem lf_of_lf_of_le {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y ≤ z) : x ⧏ z := by
-  rw [← PGame.not_le] at h₁⊢
+  rw [← PGame.not_le] at h₁ ⊢
   exact fun h₃ => h₁ (h₂.trans h₃)
 #align pgame.lf_of_lf_of_le PGame.lf_of_lf_of_le
 
@@ -1733,7 +1733,7 @@ instance covariantClass_add_le : CovariantClass PGame PGame (· + ·) (· ≤ ·
 
 theorem add_lf_add_right {y z : PGame} (h : y ⧏ z) (x) : y + x ⧏ z + x :=
   suffices z + x ≤ y + x → z ≤ y by
-    rw [← PGame.not_le] at h⊢
+    rw [← PGame.not_le] at h ⊢
     exact mt this h
   fun w =>
   calc

These are all doc fixes

@@ -1301,7 +1301,7 @@ theorem moveRight_neg_symm' {x : PGame} (i) : x.moveRight i = -(-x).moveLeft (to
   by simp
 #align pgame.move_right_neg_symm' PGame.moveRight_neg_symm'
 
-/-- If `x` has the same moves as `y`, then `-x` has the sames moves as `-y`. -/
+/-- If `x` has the same moves as `y`, then `-x` has the same moves as `-y`. -/
 def Relabelling.negCongr : ∀ {x y : PGame}, x ≡r y → -x ≡r -y
   | ⟨_, _, _, _⟩, ⟨_, _, _, _⟩, ⟨L, R, hL, hR⟩ =>
     ⟨R, L, fun j => (hR j).negCongr, fun i => (hL i).negCongr⟩

Add a #compile inductive command to compile the recursors of an inductive type, which works by creating a recursive definition and using @[csimp].

Co-authored-by: Parth Shastri <31370288+cppio@users.noreply.github.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com>

@@ -113,9 +113,7 @@ open Function Relation
 inductive PGame : Type (u + 1)
   | mk : ∀ α β : Type u, (α → PGame) → (β → PGame) → PGame
 #align pgame PGame
-
--- Porting note: many definitions here are noncomputable as the compiler does not support PGame.rec
-noncomputable section
+compile_inductive% PGame
 
 namespace PGame
 

• Run a non-interactive version of fix-comments.py on all files.
• Go through the diff and manually add/discard/edit chunks.

@@ -45,7 +45,7 @@ obligations in inductive proofs relying on this relation.
 
 ## Order properties
 
-Pregames have both a `≤` and a `<` relation, satisfying the usual properties of a `preorder`. The
+Pregames have both a `≤` and a `<` relation, satisfying the usual properties of a `Preorder`. The
 relation `0 < x` means that `x` can always be won by Left, while `0 ≤ x` means that `x` can be won
 by Left as the second player.
 
@@ -60,7 +60,7 @@ Statements like `zero_le_lf`, `zero_lf_le`, etc. unfold these definitions. The t
 The theorems `zero_le`, `zero_lf`, etc. also take into account that `0` has no moves.
 
 Later, games will be defined as the quotient by the `≈` relation; that is to say, the
-`antisymmetrization` of `PGame`.
+`Antisymmetrization` of `PGame`.
 
 ## Algebraic structures
 
@@ -422,7 +422,7 @@ theorem Lf.not_ge {x y : PGame} : x ⧏ y → ¬y ≤ x :=
 
 /-- Definition of `x ≤ y` on pre-games, in terms of `⧏`.
 
-The ordering here is chosen so that `and.left` refer to moves by Left, and `and.right` refer to
+The ordering here is chosen so that `And.left` refer to moves by Left, and `And.right` refer to
 moves by Right. -/
 theorem le_iff_forall_lf {x y : PGame} :
     x ≤ y ↔ (∀ i, x.moveLeft i ⧏ y) ∧ ∀ j, x ⧏ y.moveRight j := by
@@ -612,7 +612,7 @@ theorem mk_lf {xl xr} (xL : xl → PGame) (xR : xr → PGame) (j) : mk xl xr xL
   @lf_moveRight (mk _ _ _ _) j
 #align pgame.mk_lf PGame.mk_lf
 
-/-- This special case of `pgame.le_of_forall_lf` is useful when dealing with surreals, where `<` is
+/-- This special case of `PGame.le_of_forall_lf` is useful when dealing with surreals, where `<` is
 preferred over `⧏`. -/
 theorem le_of_forall_lt {x y : PGame} (h₁ : ∀ i, x.moveLeft i < y) (h₂ : ∀ j, x < y.moveRight j) :
     x ≤ y :=

Co-authored-by: Maxwell Thum <maxwell.thum2718@gmail.com> Co-authored-by: Lukas Miaskiwskyi <lukas.mias@gmail.com> Co-authored-by: Gabriel Ebner <gebner@gebner.org> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>