File: Mathlib/SetTheory/Game/PGame.lean

full_name: SetTheory.PGame.mk
code: /-- 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
  stage. To do this in type theory, we say that a pre-game is built
  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
goal: (α → SetTheory.PGame) → (β → SetTheory.PGame) → SetTheory.PGame

full_name: SetTheory.PGame
code: /-- 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
  stage. To do this in type theory, we say that a pre-game is built
  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
goal: Type (u + 1)

full_name: SetTheory.PGame.LeftMoves
code: /-- The indexing type for allowable moves by Left. -/
def LeftMoves : PGame → Type u
  
goal: SetTheory.PGame → Type u

full_name: SetTheory.PGame.RightMoves
code: /-- The indexing type for allowable moves by Right. -/
def RightMoves : PGame → Type u
  
goal: SetTheory.PGame → Type u

full_name: SetTheory.PGame.moveLeft
code: /-- The new game after Left makes an allowed move. -/
def moveLeft : ∀ g : PGame, LeftMoves g → PGame
  
goal: g.LeftMoves → SetTheory.PGame

full_name: SetTheory.PGame.moveRight
code: /-- The new game after Right makes an allowed move. -/
def moveRight : ∀ g : PGame, RightMoves g → PGame
  
goal: g.RightMoves → SetTheory.PGame

full_name: SetTheory.PGame.leftMoves_mk
code: @[simp]
theorem leftMoves_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).LeftMoves = xl 
goal: (SetTheory.PGame.mk xl xr xL xR).LeftMoves = xl

full_name: SetTheory.PGame.moveLeft_mk
code: @[simp]
theorem moveLeft_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).moveLeft = xL 
goal: (SetTheory.PGame.mk xl xr xL xR).moveLeft = xL

full_name: SetTheory.PGame.rightMoves_mk
code: @[simp]
theorem rightMoves_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).RightMoves = xr 
goal: (SetTheory.PGame.mk xl xr xL xR).RightMoves = xr

full_name: SetTheory.PGame.moveRight_mk
code: @[simp]
theorem moveRight_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).moveRight = xR 
goal: (SetTheory.PGame.mk xl xr xL xR).moveRight = xR

full_name: SetTheory.PGame.ofLists
code: /-- 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} 
goal: SetTheory.PGame

full_name: SetTheory.PGame.leftMoves_ofLists
code: theorem leftMoves_ofLists (L R : List PGame) : (ofLists L R).LeftMoves = ULift (Fin L.length) 
goal: (SetTheory.PGame.ofLists L R).LeftMoves = ULift.{u_1, 0} (Fin L.length)

full_name: SetTheory.PGame.rightMoves_ofLists
code: theorem rightMoves_ofLists (L R : List PGame) : (ofLists L R).RightMoves = ULift (Fin R.length) 
goal: (SetTheory.PGame.ofLists L R).RightMoves = ULift.{u_1, 0} (Fin R.length)

full_name: SetTheory.PGame.toOfListsLeftMoves
code: /-- Converts a number into a left move for `ofLists`. -/
def toOfListsLeftMoves {L R : List PGame} : Fin L.length ≃ (ofLists L R).LeftMoves 
goal: Fin L.length ≃ (SetTheory.PGame.ofLists L R).LeftMoves

full_name: SetTheory.PGame.toOfListsRightMoves
code: /-- Converts a number into a right move for `ofLists`. -/
def toOfListsRightMoves {L R : List PGame} : Fin R.length ≃ (ofLists L R).RightMoves 
goal: Fin R.length ≃ (SetTheory.PGame.ofLists L R).RightMoves

full_name: SetTheory.PGame.ofLists_moveLeft
code: theorem ofLists_moveLeft {L R : List PGame} (i : Fin L.length) :
    (ofLists L R).moveLeft (toOfListsLeftMoves i) = L.get i 
goal: (SetTheory.PGame.ofLists L R).moveLeft (SetTheory.PGame.toOfListsLeftMoves i) = L.get i

full_name: SetTheory.PGame.ofLists_moveLeft'
code: @[simp]
theorem ofLists_moveLeft' {L R : List PGame} (i : (ofLists L R).LeftMoves) :
    (ofLists L R).moveLeft i = L.get (toOfListsLeftMoves.symm i) 
goal: (SetTheory.PGame.ofLists L R).moveLeft i = L.get (SetTheory.PGame.toOfListsLeftMoves.symm i)

full_name: SetTheory.PGame.ofLists_moveRight
code: theorem ofLists_moveRight {L R : List PGame} (i : Fin R.length) :
    (ofLists L R).moveRight (toOfListsRightMoves i) = R.get i 
goal: (SetTheory.PGame.ofLists L R).moveRight (SetTheory.PGame.toOfListsRightMoves i) = R.get i

full_name: SetTheory.PGame.ofLists_moveRight'
code: @[simp]
theorem ofLists_moveRight' {L R : List PGame} (i : (ofLists L R).RightMoves) :
    (ofLists L R).moveRight i = R.get (toOfListsRightMoves.symm i) 
goal: (SetTheory.PGame.ofLists L R).moveRight i = R.get (SetTheory.PGame.toOfListsRightMoves.symm i)

full_name: SetTheory.PGame.moveRecOn
code: /-- A variant of `PGame.recOn` expressed in terms of `PGame.moveLeft` and `PGame.moveRight`.

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 
goal: C x

full_name: SetTheory.PGame.IsOption.moveLeft
code: /-- `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
goal: (x.moveLeft i).IsOption x

full_name: SetTheory.PGame.IsOption.moveRight
code: /-- `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
goal: (x.moveRight i).IsOption x

full_name: SetTheory.PGame.IsOption
code: /-- `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
goal: SetTheory.PGame → SetTheory.PGame → Prop

full_name: SetTheory.PGame.isOption_iff
code: /-- `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
goal: ∀ (a a_1 : SetTheory.PGame), a.IsOption a_1 ↔ (∃ i, a = a_1.moveLeft i) ∨ ∃ i, a = a_1.moveRight i

full_name: SetTheory.PGame.IsOption.mk_left
code: theorem IsOption.mk_left {xl xr : Type u} (xL : xl → PGame) (xR : xr → PGame) (i : xl) :
    (xL i).IsOption (mk xl xr xL xR) 
goal: (xL i).IsOption (SetTheory.PGame.mk xl xr xL xR)

full_name: SetTheory.PGame.IsOption.mk_right
code: theorem IsOption.mk_right {xl xr : Type u} (xL : xl → PGame) (xR : xr → PGame) (i : xr) :
    (xR i).IsOption (mk xl xr xL xR) 
goal: (xR i).IsOption (SetTheory.PGame.mk xl xr xL xR)

full_name: SetTheory.PGame.wf_isOption
code: theorem wf_isOption : WellFounded IsOption 
goal: WellFounded SetTheory.PGame.IsOption

full_name: SetTheory.PGame.Subsequent
code: /-- `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 
goal: SetTheory.PGame → SetTheory.PGame → Prop

full_name: SetTheory.PGame.instIsTransSubsequent
code: instance : IsTrans _ Subsequent 
goal: IsTrans SetTheory.PGame SetTheory.PGame.Subsequent

full_name: SetTheory.PGame.Subsequent.trans
code: @[trans]
theorem Subsequent.trans {x y z} : Subsequent x y → Subsequent y z → Subsequent x z 
goal: x.Subsequent y → y.Subsequent z → x.Subsequent z

full_name: SetTheory.PGame.wf_subsequent
code: theorem wf_subsequent : WellFounded Subsequent 
goal: WellFounded SetTheory.PGame.Subsequent

full_name: SetTheory.PGame.instWellFoundedRelation
code: instance : WellFoundedRelation PGame 
goal: WellFoundedRelation SetTheory.PGame

full_name: SetTheory.PGame.Subsequent.moveLeft
code: @[simp]
theorem Subsequent.moveLeft {x : PGame} (i : x.LeftMoves) : Subsequent (x.moveLeft i) x 
goal: (x.moveLeft i).Subsequent x

full_name: SetTheory.PGame.Subsequent.moveRight
code: @[simp]
theorem Subsequent.moveRight {x : PGame} (j : x.RightMoves) : Subsequent (x.moveRight j) x 
goal: (x.moveRight j).Subsequent x

full_name: SetTheory.PGame.Subsequent.mk_left
code: @[simp]
theorem Subsequent.mk_left {xl xr} (xL : xl → PGame) (xR : xr → PGame) (i : xl) :
    Subsequent (xL i) (mk xl xr xL xR) 
goal: (xL i).Subsequent (SetTheory.PGame.mk xl xr xL xR)

full_name: SetTheory.PGame.Subsequent.mk_right
code: @[simp]
theorem Subsequent.mk_right {xl xr} (xL : xl → PGame) (xR : xr → PGame) (j : xr) :
    Subsequent (xR j) (mk xl xr xL xR) 
goal: (xR j).Subsequent (SetTheory.PGame.mk xl xr xL xR)

full_name: SetTheory.PGame._aux_Mathlib_SetTheory_Game_PGame___macroRules_SetTheory_PGame_tacticPgame_wf_tac_1
code: macro "pgame_wf_tac" : tactic =>
  `(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] )
goal: Lean.Macro

full_name: SetTheory.PGame.tacticPgame_wf_tac
code: macro "pgame_wf_tac" : tactic =>
  `(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] )
goal: Lean.ParserDescr

full_name: SetTheory.PGame.Subsequent.mk_right'
code: @[simp]
theorem Subsequent.mk_right' (xL : xl → PGame) (xR : xr → PGame) (j : RightMoves (mk xl xr xL xR)) :
    Subsequent (xR j) (mk xl xr xL xR) 
goal: (xR j).Subsequent (SetTheory.PGame.mk xl xr xL xR)

full_name: SetTheory.PGame.Subsequent.moveRight_mk_left
code: @[simp] theorem Subsequent.moveRight_mk_left {xR : xr → PGame} {i : xl} (xL : xl → PGame) (j) :
    Subsequent ((xL i).moveRight j) (mk xl xr xL xR) 
goal: ((xL i).moveRight j).Subsequent (SetTheory.PGame.mk xl xr xL xR)

full_name: SetTheory.PGame.Subsequent.moveRight_mk_right
code: @[simp] theorem Subsequent.moveRight_mk_right {xL : xl → PGame} {i : xr} (xR : xr → PGame) (j) :
    Subsequent ((xR i).moveRight j) (mk xl xr xL xR) 
goal: ((xR i).moveRight j).Subsequent (SetTheory.PGame.mk xl xr xL xR)

full_name: SetTheory.PGame.Subsequent.moveLeft_mk_left
code: @[simp] theorem Subsequent.moveLeft_mk_left {xR : xr → PGame} {i : xl} (xL : xl → PGame) (j) :
    Subsequent ((xL i).moveLeft j) (mk xl xr xL xR) 
goal: ((xL i).moveLeft j).Subsequent (SetTheory.PGame.mk xl xr xL xR)

full_name: SetTheory.PGame.Subsequent.moveLeft_mk_right
code: @[simp] theorem Subsequent.moveLeft_mk_right {xL : xl → PGame} {i : xr} (xR : xr → PGame) (j) :
    Subsequent ((xR i).moveLeft j) (mk xl xr xL xR) 
goal: ((xR i).moveLeft j).Subsequent (SetTheory.PGame.mk xl xr xL xR)

full_name: SetTheory.PGame.instZero
code: /-- The pre-game `Zero` is defined by `0 = { | }`. -/
instance : Zero PGame 
goal: Zero SetTheory.PGame

full_name: SetTheory.PGame.zero_leftMoves
code: @[simp]
theorem zero_leftMoves : LeftMoves 0 = PEmpty 
goal: SetTheory.PGame.LeftMoves 0 = PEmpty.{u_1 + 1}

full_name: SetTheory.PGame.zero_rightMoves
code: @[simp]
theorem zero_rightMoves : RightMoves 0 = PEmpty 
goal: SetTheory.PGame.RightMoves 0 = PEmpty.{u_1 + 1}

full_name: SetTheory.PGame.isEmpty_zero_leftMoves
code: instance isEmpty_zero_leftMoves : IsEmpty (LeftMoves 0) 
goal: IsEmpty (SetTheory.PGame.LeftMoves 0)

full_name: SetTheory.PGame.isEmpty_zero_rightMoves
code: instance isEmpty_zero_rightMoves : IsEmpty (RightMoves 0) 
goal: IsEmpty (SetTheory.PGame.RightMoves 0)

full_name: SetTheory.PGame.instInhabited
code: instance : Inhabited PGame 
goal: Inhabited SetTheory.PGame

full_name: SetTheory.PGame.instOnePGame
code: /-- The pre-game `One` is defined by `1 = { 0 | }`. -/
instance instOnePGame : One PGame 
goal: One SetTheory.PGame

full_name: SetTheory.PGame.one_leftMoves
code: @[simp]
theorem one_leftMoves : LeftMoves 1 = PUnit 
goal: SetTheory.PGame.LeftMoves 1 = PUnit.{u_1 + 1}

full_name: SetTheory.PGame.one_moveLeft
code: @[simp]
theorem one_moveLeft (x) : moveLeft 1 x = 0 
goal: SetTheory.PGame.moveLeft 1 x = 0

full_name: SetTheory.PGame.one_rightMoves
code: @[simp]
theorem one_rightMoves : RightMoves 1 = PEmpty 
goal: SetTheory.PGame.RightMoves 1 = PEmpty.{u_1 + 1}

full_name: SetTheory.PGame.uniqueOneLeftMoves
code: instance uniqueOneLeftMoves : Unique (LeftMoves 1) 
goal: Unique (SetTheory.PGame.LeftMoves 1)

full_name: SetTheory.PGame.isEmpty_one_rightMoves
code: instance isEmpty_one_rightMoves : IsEmpty (RightMoves 1) 
goal: IsEmpty (SetTheory.PGame.RightMoves 1)

full_name: SetTheory.PGame.le
code: /-- The less or equal relation on pre-games.

If `0 ≤ x`, then Left can win `x` as the second player. -/
instance le : LE PGame 
goal: LE SetTheory.PGame

full_name: SetTheory.PGame.LF
code: /-- 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 
goal: Prop

full_name: SetTheory.PGame.«_aux_Mathlib_SetTheory_Game_PGame___macroRules_SetTheory_PGame_term_⧏__1»
code: @[inherit_doc]
scoped infixl:50 " ⧏ " => PGame.LF
goal: Lean.Macro

full_name: SetTheory.PGame._aux_Mathlib_SetTheory_Game_PGame___unexpand_SetTheory_PGame_LF_1
code: @[inherit_doc]
scoped infixl:50 " ⧏ " => PGame.LF
goal: Lean.PrettyPrinter.Unexpander

full_name: SetTheory.PGame.not_le
code: @[simp]
protected theorem not_le {x y : PGame} : ¬x ≤ y ↔ y ⧏ x 
goal: ¬x ≤ y ↔ y.LF x

full_name: SetTheory.PGame.not_lf
code: @[simp]
theorem not_lf {x y : PGame} : ¬x ⧏ y ↔ y ≤ x 
goal: ¬x.LF y ↔ y ≤ x

full_name: LE.le.not_gf
code: theorem _root_.LE.le.not_gf {x y : PGame} : x ≤ y → ¬y ⧏ x 
goal: x ≤ y → ¬y.LF x

full_name: SetTheory.PGame.LF.not_ge
code: theorem LF.not_ge {x y : PGame} : x ⧏ y → ¬y ≤ x 
goal: x.LF y → ¬y ≤ x

full_name: SetTheory.PGame.le_iff_forall_lf
code: /-- 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 
goal: x ≤ y ↔ (∀ (i : x.LeftMoves), (x.moveLeft i).LF y) ∧ ∀ (j : y.RightMoves), x.LF (y.moveRight j)

full_name: SetTheory.PGame.mk_le_mk
code: /-- 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 
goal: SetTheory.PGame.mk xl xr xL xR ≤ SetTheory.PGame.mk yl yr yL yR ↔
  (∀ (i : xl), (xL i).LF (SetTheory.PGame.mk yl yr yL yR)) ∧ ∀ (j : yr), (SetTheory.PGame.mk xl xr xL xR).LF (yR j)

full_name: SetTheory.PGame.le_of_forall_lf
code: theorem le_of_forall_lf {x y : PGame} (h₁ : ∀ i, x.moveLeft i ⧏ y) (h₂ : ∀ j, x ⧏ y.moveRight j) :
    x ≤ y 
goal: x ≤ y

full_name: SetTheory.PGame.lf_iff_exists_le
code: /-- 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 
goal: x.LF y ↔ (∃ i, x ≤ y.moveLeft i) ∨ ∃ j, x.moveRight j ≤ y

full_name: SetTheory.PGame.mk_lf_mk
code: /-- 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 
goal: (SetTheory.PGame.mk xl xr xL xR).LF (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

full_name: SetTheory.PGame.le_or_gf
code: theorem le_or_gf (x y : PGame) : x ≤ y ∨ y ⧏ x 
goal: x ≤ y ∨ y.LF x

full_name: SetTheory.PGame.moveLeft_lf_of_le
code: theorem moveLeft_lf_of_le {x y : PGame} (h : x ≤ y) (i) : x.moveLeft i ⧏ y 
goal: (x.moveLeft i).LF y

full_name: SetTheory.PGame.lf_moveRight_of_le
code: theorem lf_moveRight_of_le {x y : PGame} (h : x ≤ y) (j) : x ⧏ y.moveRight j 
goal: x.LF (y.moveRight j)

full_name: SetTheory.PGame.lf_of_moveRight_le
code: theorem lf_of_moveRight_le {x y : PGame} {j} (h : x.moveRight j ≤ y) : x ⧏ y 
goal: x.LF y

full_name: SetTheory.PGame.lf_of_le_moveLeft
code: theorem lf_of_le_moveLeft {x y : PGame} {i} (h : x ≤ y.moveLeft i) : x ⧏ y 
goal: x.LF y

full_name: SetTheory.PGame.lf_of_le_mk
code: theorem lf_of_le_mk {xl xr xL xR y} : mk xl xr xL xR ≤ y → ∀ i, xL i ⧏ y 
goal: SetTheory.PGame.mk xl xr xL xR ≤ y → ∀ (i : xl), (xL i).LF y

full_name: SetTheory.PGame.lf_of_mk_le
code: theorem lf_of_mk_le {x yl yr yL yR} : x ≤ mk yl yr yL yR → ∀ j, x ⧏ yR j 
goal: x ≤ SetTheory.PGame.mk yl yr yL yR → ∀ (j : yr), x.LF (yR j)

full_name: SetTheory.PGame.mk_lf_of_le
code: theorem mk_lf_of_le {xl xr y j} (xL) {xR : xr → PGame} : xR j ≤ y → mk xl xr xL xR ⧏ y 
goal: xR j ≤ y → (SetTheory.PGame.mk xl xr xL xR).LF y

full_name: SetTheory.PGame.lf_mk_of_le
code: theorem lf_mk_of_le {x yl yr} {yL : yl → PGame} (yR) {i} : x ≤ yL i → x ⧏ mk yl yr yL yR 
goal: x ≤ yL i → x.LF (SetTheory.PGame.mk yl yr yL yR)

full_name: _private.Mathlib.SetTheory.Game.PGame.0.SetTheory.PGame.le_trans_aux
code: 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 
goal: x ≤ z

full_name: SetTheory.PGame.instPreorder
code: instance : Preorder PGame 
goal: Preorder SetTheory.PGame

full_name: SetTheory.PGame.lt_iff_le_and_lf
code: theorem lt_iff_le_and_lf {x y : PGame} : x < y ↔ x ≤ y ∧ x ⧏ y 
goal: x < y ↔ x ≤ y ∧ x.LF y

full_name: SetTheory.PGame.lt_of_le_of_lf
code: theorem lt_of_le_of_lf {x y : PGame} (h₁ : x ≤ y) (h₂ : x ⧏ y) : x < y 
goal: x < y

full_name: SetTheory.PGame.lf_of_lt
code: theorem lf_of_lt {x y : PGame} (h : x < y) : x ⧏ y 
goal: x.LF y

full_name: SetTheory.PGame.lf_irrefl
code: theorem lf_irrefl (x : PGame) : ¬x ⧏ x 
goal: ¬x.LF x

full_name: SetTheory.PGame.instIsIrreflLF
code: instance : IsIrrefl _ (· ⧏ ·) 
goal: IsIrrefl SetTheory.PGame fun x x_1 => x.LF x_1

full_name: SetTheory.PGame.lf_of_le_of_lf
code: @[trans]
theorem lf_of_le_of_lf {x y z : PGame} (h₁ : x ≤ y) (h₂ : y ⧏ z) : x ⧏ z 
goal: x.LF z

full_name: SetTheory.PGame.instTransLeLF
code: instance : Trans (· ≤ ·) (· ⧏ ·) (· ⧏ ·) 
goal: Trans (fun x x_1 => x ≤ x_1) (fun x x_1 => x.LF x_1) fun x x_1 => x.LF x_1

full_name: SetTheory.PGame.lf_of_lf_of_le
code: @[trans]
theorem lf_of_lf_of_le {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y ≤ z) : x ⧏ z 
goal: x.LF z

full_name: SetTheory.PGame.instTransLFLe
code: instance : Trans (· ⧏ ·) (· ≤ ·) (· ⧏ ·) 
goal: Trans (fun x x_1 => x.LF x_1) (fun x x_1 => x ≤ x_1) fun x x_1 => x.LF x_1

full_name: SetTheory.PGame.lf_of_lt_of_lf
code: @[trans]
theorem lf_of_lt_of_lf {x y z : PGame} (h₁ : x < y) (h₂ : y ⧏ z) : x ⧏ z 
goal: x.LF z

full_name: SetTheory.PGame.lf_of_lf_of_lt
code: @[trans]
theorem lf_of_lf_of_lt {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y < z) : x ⧏ z 
goal: x.LF z

full_name: SetTheory.PGame.moveLeft_lf
code: theorem moveLeft_lf {x : PGame} : ∀ i, x.moveLeft i ⧏ x 
goal: (x.moveLeft i).LF x

full_name: SetTheory.PGame.lf_moveRight
code: theorem lf_moveRight {x : PGame} : ∀ j, x ⧏ x.moveRight j 
goal: x.LF (x.moveRight j)

full_name: SetTheory.PGame.lf_mk
code: theorem lf_mk {xl xr} (xL : xl → PGame) (xR : xr → PGame) (i) : xL i ⧏ mk xl xr xL xR 
goal: (xL i).LF (SetTheory.PGame.mk xl xr xL xR)

full_name: SetTheory.PGame.mk_lf
code: theorem mk_lf {xl xr} (xL : xl → PGame) (xR : xr → PGame) (j) : mk xl xr xL xR ⧏ xR j 
goal: (SetTheory.PGame.mk xl xr xL xR).LF (xR j)

full_name: SetTheory.PGame.le_of_forall_lt
code: /-- 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 
goal: x ≤ y

full_name: SetTheory.PGame.le_def
code: /-- The definition of `x ≤ y` on pre-games, in terms of `≤` two moves later. -/
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 
goal: x ≤ y ↔
  (∀ (i : x.LeftMoves), (∃ i', x.moveLeft i ≤ y.moveLeft i') ∨ ∃ j, (x.moveLeft i).moveRight j ≤ y) ∧
    ∀ (j : y.RightMoves), (∃ i, x ≤ (y.moveRight j).moveLeft i) ∨ ∃ j', x.moveRight j' ≤ y.moveRight j

full_name: SetTheory.PGame.lf_def
code: /-- The definition of `x ⧏ y` on pre-games, in terms of `⧏` two moves later. -/
theorem lf_def {x y : PGame} :
    x ⧏ y ↔
      (∃ i, (∀ i', x.moveLeft i' ⧏ y.moveLeft i) ∧ ∀ j, x ⧏ (y.moveLeft i).moveRight j) ∨
        ∃ j, (∀ i, (x.moveRight j).moveLeft i ⧏ y) ∧ ∀ j', x.moveRight j ⧏ y.moveRight j' 
goal: x.LF y ↔
  (∃ i,
      (∀ (i' : x.LeftMoves), (x.moveLeft i').LF (y.moveLeft i)) ∧
        ∀ (j : (y.moveLeft i).RightMoves), x.LF ((y.moveLeft i).moveRight j)) ∨
    ∃ j,
      (∀ (i : (x.moveRight j).LeftMoves), ((x.moveRight j).moveLeft i).LF y) ∧
        ∀ (j' : y.RightMoves), (x.moveRight j).LF (y.moveRight j')

full_name: SetTheory.PGame.zero_le_lf
code: /-- 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 
goal: 0 ≤ x ↔ ∀ (j : x.RightMoves), SetTheory.PGame.LF 0 (x.moveRight j)

full_name: SetTheory.PGame.le_zero_lf
code: /-- 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 
goal: x ≤ 0 ↔ ∀ (i : x.LeftMoves), (x.moveLeft i).LF 0

full_name: SetTheory.PGame.zero_lf_le
code: /-- 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 
goal: SetTheory.PGame.LF 0 x ↔ ∃ i, 0 ≤ x.moveLeft i

full_name: SetTheory.PGame.lf_zero_le
code: /-- 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 
goal: x.LF 0 ↔ ∃ j, x.moveRight j ≤ 0

full_name: SetTheory.PGame.zero_le
code: /-- 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 
goal: 0 ≤ x ↔ ∀ (j : x.RightMoves), ∃ i, 0 ≤ (x.moveRight j).moveLeft i

full_name: SetTheory.PGame.le_zero
code: /-- 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 
goal: x ≤ 0 ↔ ∀ (i : x.LeftMoves), ∃ j, (x.moveLeft i).moveRight j ≤ 0

full_name: SetTheory.PGame.zero_lf
code: /-- 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 
goal: SetTheory.PGame.LF 0 x ↔ ∃ i, ∀ (j : (x.moveLeft i).RightMoves), SetTheory.PGame.LF 0 ((x.moveLeft i).moveRight j)

full_name: SetTheory.PGame.lf_zero
code: /-- 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 
goal: x.LF 0 ↔ ∃ j, ∀ (i : (x.moveRight j).LeftMoves), ((x.moveRight j).moveLeft i).LF 0

full_name: SetTheory.PGame.zero_le_of_isEmpty_rightMoves
code: @[simp]
theorem zero_le_of_isEmpty_rightMoves (x : PGame) [IsEmpty x.RightMoves] : 0 ≤ x 
goal: 0 ≤ x

full_name: SetTheory.PGame.le_zero_of_isEmpty_leftMoves
code: @[simp]
theorem le_zero_of_isEmpty_leftMoves (x : PGame) [IsEmpty x.LeftMoves] : x ≤ 0 
goal: x ≤ 0

full_name: SetTheory.PGame.rightResponse
code: /-- 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 
goal: (x.moveLeft i).RightMoves

full_name: SetTheory.PGame.rightResponse_spec
code: /-- 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 
goal: (x.moveLeft i).moveRight (SetTheory.PGame.rightResponse h i) ≤ 0

full_name: SetTheory.PGame.leftResponse
code: /-- 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 
goal: (x.moveRight j).LeftMoves

full_name: SetTheory.PGame.leftResponse_spec
code: /-- 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) 
goal: 0 ≤ (x.moveRight j).moveLeft (SetTheory.PGame.leftResponse h j)

full_name: SetTheory.PGame.bddAbove_range_of_small
code: /-- A small family of pre-games is bounded above. -/
lemma bddAbove_range_of_small {ι : Type*} [Small.{u} ι] (f : ι → PGame.{u}) :
    BddAbove (Set.range f) 
goal: BddAbove (Set.range f)

full_name: SetTheory.PGame.bddAbove_of_small
code: /-- A small set of pre-games is bounded above. -/
lemma bddAbove_of_small (s : Set PGame.{u}) [Small.{u} s] : BddAbove s 
goal: BddAbove s

full_name: SetTheory.PGame.bddBelow_range_of_small
code: /-- A small family of pre-games is bounded below. -/
lemma bddBelow_range_of_small {ι : Type*} [Small.{u} ι] (f : ι → PGame.{u}) :
    BddBelow (Set.range f) 
goal: BddBelow (Set.range f)

full_name: SetTheory.PGame.bddBelow_of_small
code: /-- A small set of pre-games is bounded below. -/
lemma bddBelow_of_small (s : Set PGame.{u}) [Small.{u} s] : BddBelow s 
goal: BddBelow s

full_name: SetTheory.PGame.Equiv
code: /-- 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 
goal: Prop

full_name: SetTheory.PGame.instIsEquivEquiv
code: instance : IsEquiv _ PGame.Equiv 
goal: IsEquiv SetTheory.PGame SetTheory.PGame.Equiv

full_name: SetTheory.PGame.setoid
code: instance setoid : Setoid PGame 
goal: Setoid SetTheory.PGame

full_name: SetTheory.PGame.equiv_def
code: theorem equiv_def {x y : PGame} : x ≈ y ↔ x ≤ y ∧ y ≤ x 
goal: x ≈ y ↔ x ≤ y ∧ y ≤ x

full_name: SetTheory.PGame.Equiv.le
code: theorem Equiv.le {x y : PGame} (h : x ≈ y) : x ≤ y 
goal: x ≤ y

full_name: SetTheory.PGame.Equiv.ge
code: theorem Equiv.ge {x y : PGame} (h : x ≈ y) : y ≤ x 
goal: y ≤ x

full_name: SetTheory.PGame.equiv_rfl
code: @[refl, simp]
theorem equiv_rfl {x : PGame} : x ≈ x 
goal: x ≈ x

full_name: SetTheory.PGame.equiv_refl
code: theorem equiv_refl (x : PGame) : x ≈ x 
goal: x ≈ x

full_name: SetTheory.PGame.Equiv.symm
code: @[symm]
protected theorem Equiv.symm {x y : PGame} : (x ≈ y) → (y ≈ x) 
goal: x ≈ y → y ≈ x

full_name: SetTheory.PGame.Equiv.trans
code: @[trans]
protected theorem Equiv.trans {x y z : PGame} : (x ≈ y) → (y ≈ z) → (x ≈ z) 
goal: x ≈ y → y ≈ z → x ≈ z

full_name: SetTheory.PGame.equiv_comm
code: protected theorem equiv_comm {x y : PGame} : (x ≈ y) ↔ (y ≈ x) 
goal: x ≈ y ↔ y ≈ x

full_name: SetTheory.PGame.equiv_of_eq
code: theorem equiv_of_eq {x y : PGame} (h : x = y) : x ≈ y 
goal: x ≈ y

full_name: SetTheory.PGame.le_of_le_of_equiv
code: @[trans]
theorem le_of_le_of_equiv {x y z : PGame} (h₁ : x ≤ y) (h₂ : y ≈ z) : x ≤ z 
goal: x ≤ z

full_name: SetTheory.PGame.instTransLeEquiv
code: instance : Trans
    ((· ≤ ·) : PGame → PGame → Prop)
    ((· ≈ ·) : PGame → PGame → Prop)
    ((· ≤ ·) : PGame → PGame → Prop) 
goal: Trans (fun x x_1 => x ≤ x_1) (fun x x_1 => x ≈ x_1) fun x x_1 => x ≤ x_1

full_name: SetTheory.PGame.le_of_equiv_of_le
code: @[trans]
theorem le_of_equiv_of_le {x y z : PGame} (h₁ : x ≈ y) : y ≤ z → x ≤ z 
goal: y ≤ z → x ≤ z

full_name: SetTheory.PGame.instTransEquivLe
code: instance : Trans
    ((· ≈ ·) : PGame → PGame → Prop)
    ((· ≤ ·) : PGame → PGame → Prop)
    ((· ≤ ·) : PGame → PGame → Prop) 
goal: Trans (fun x x_1 => x ≈ x_1) (fun x x_1 => x ≤ x_1) fun x x_1 => x ≤ x_1

full_name: SetTheory.PGame.LF.not_equiv
code: theorem LF.not_equiv {x y : PGame} (h : x ⧏ y) : ¬(x ≈ y) 
goal: ¬x ≈ y

full_name: SetTheory.PGame.LF.not_equiv'
code: theorem LF.not_equiv' {x y : PGame} (h : x ⧏ y) : ¬(y ≈ x) 
goal: ¬y ≈ x

full_name: SetTheory.PGame.LF.not_gt
code: theorem LF.not_gt {x y : PGame} (h : x ⧏ y) : ¬y < x 
goal: ¬y < x

full_name: SetTheory.PGame.le_congr_imp
code: theorem le_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) (h : x₁ ≤ y₁) : x₂ ≤ y₂ 
goal: x₂ ≤ y₂

full_name: SetTheory.PGame.le_congr
code: theorem le_congr {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ≤ y₁ ↔ x₂ ≤ y₂ 
goal: x₁ ≤ y₁ ↔ x₂ ≤ y₂

full_name: SetTheory.PGame.le_congr_left
code: theorem le_congr_left {x₁ x₂ y : PGame} (hx : x₁ ≈ x₂) : x₁ ≤ y ↔ x₂ ≤ y 
goal: x₁ ≤ y ↔ x₂ ≤ y

full_name: SetTheory.PGame.le_congr_right
code: theorem le_congr_right {x y₁ y₂ : PGame} (hy : y₁ ≈ y₂) : x ≤ y₁ ↔ x ≤ y₂ 
goal: x ≤ y₁ ↔ x ≤ y₂

full_name: SetTheory.PGame.lf_congr
code: theorem lf_congr {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ⧏ y₁ ↔ x₂ ⧏ y₂ 
goal: x₁.LF y₁ ↔ x₂.LF y₂

full_name: SetTheory.PGame.lf_congr_imp
code: theorem lf_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ⧏ y₁ → x₂ ⧏ y₂ 
goal: x₁.LF y₁ → x₂.LF y₂

full_name: SetTheory.PGame.lf_congr_left
code: theorem lf_congr_left {x₁ x₂ y : PGame} (hx : x₁ ≈ x₂) : x₁ ⧏ y ↔ x₂ ⧏ y 
goal: x₁.LF y ↔ x₂.LF y

full_name: SetTheory.PGame.lf_congr_right
code: theorem lf_congr_right {x y₁ y₂ : PGame} (hy : y₁ ≈ y₂) : x ⧏ y₁ ↔ x ⧏ y₂ 
goal: x.LF y₁ ↔ x.LF y₂

full_name: SetTheory.PGame.lf_of_lf_of_equiv
code: @[trans]
theorem lf_of_lf_of_equiv {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y ≈ z) : x ⧏ z 
goal: x.LF z

full_name: SetTheory.PGame.instTransLFEquiv
code: instance : Trans (· ⧏ ·) (· ≈ ·) (· ⧏ ·) 
goal: Trans (fun x x_1 => x.LF x_1) (fun x x_1 => x ≈ x_1) fun x x_1 => x.LF x_1

full_name: SetTheory.PGame.lf_of_equiv_of_lf
code: @[trans]
theorem lf_of_equiv_of_lf {x y z : PGame} (h₁ : x ≈ y) : y ⧏ z → x ⧏ z 
goal: y.LF z → x.LF z

full_name: SetTheory.PGame.instTransEquivLF
code: instance : Trans (· ≈ ·) (· ⧏ ·) (· ⧏ ·) 
goal: Trans (fun x x_1 => x ≈ x_1) (fun x x_1 => x.LF x_1) fun x x_1 => x.LF x_1

full_name: SetTheory.PGame.lt_of_lt_of_equiv
code: @[trans]
theorem lt_of_lt_of_equiv {x y z : PGame} (h₁ : x < y) (h₂ : y ≈ z) : x < z 
goal: x < z

full_name: SetTheory.PGame.instTransLtEquiv
code: instance : Trans
    ((· < ·) : PGame → PGame → Prop)
    ((· ≈ ·) : PGame → PGame → Prop)
    ((· < ·) : PGame → PGame → Prop) 
goal: Trans (fun x x_1 => x < x_1) (fun x x_1 => x ≈ x_1) fun x x_1 => x < x_1

full_name: SetTheory.PGame.lt_of_equiv_of_lt
code: @[trans]
theorem lt_of_equiv_of_lt {x y z : PGame} (h₁ : x ≈ y) : y < z → x < z 
goal: y < z → x < z

full_name: SetTheory.PGame.instTransEquivLt
code: instance : Trans
    ((· ≈ ·) : PGame → PGame → Prop)
    ((· < ·) : PGame → PGame → Prop)
    ((· < ·) : PGame → PGame → Prop) 
goal: Trans (fun x x_1 => x ≈ x_1) (fun x x_1 => x < x_1) fun x x_1 => x < x_1

full_name: SetTheory.PGame.lt_congr_imp
code: theorem lt_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) (h : x₁ < y₁) : x₂ < y₂ 
goal: x₂ < y₂

full_name: SetTheory.PGame.lt_congr
code: theorem lt_congr {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ < y₁ ↔ x₂ < y₂ 
goal: x₁ < y₁ ↔ x₂ < y₂

full_name: SetTheory.PGame.lt_congr_left
code: theorem lt_congr_left {x₁ x₂ y : PGame} (hx : x₁ ≈ x₂) : x₁ < y ↔ x₂ < y 
goal: x₁ < y ↔ x₂ < y

full_name: SetTheory.PGame.lt_congr_right
code: theorem lt_congr_right {x y₁ y₂ : PGame} (hy : y₁ ≈ y₂) : x < y₁ ↔ x < y₂ 
goal: x < y₁ ↔ x < y₂

full_name: SetTheory.PGame.lt_or_equiv_of_le
code: theorem lt_or_equiv_of_le {x y : PGame} (h : x ≤ y) : x < y ∨ (x ≈ y) 
goal: x < y ∨ x ≈ y

full_name: SetTheory.PGame.lf_or_equiv_or_gf
code: theorem lf_or_equiv_or_gf (x y : PGame) : x ⧏ y ∨ (x ≈ y) ∨ y ⧏ x 
goal: x.LF y ∨ x ≈ y ∨ y.LF x

full_name: SetTheory.PGame.equiv_congr_left
code: theorem equiv_congr_left {y₁ y₂ : PGame} : (y₁ ≈ y₂) ↔ ∀ x₁, (x₁ ≈ y₁) ↔ (x₁ ≈ y₂) 
goal: y₁ ≈ y₂ ↔ ∀ (x₁ : SetTheory.PGame), x₁ ≈ y₁ ↔ x₁ ≈ y₂

full_name: SetTheory.PGame.equiv_congr_right
code: theorem equiv_congr_right {x₁ x₂ : PGame} : (x₁ ≈ x₂) ↔ ∀ y₁, (x₁ ≈ y₁) ↔ (x₂ ≈ y₁) 
goal: x₁ ≈ x₂ ↔ ∀ (y₁ : SetTheory.PGame), x₁ ≈ y₁ ↔ x₂ ≈ y₁

full_name: SetTheory.PGame.equiv_of_mk_equiv
code: 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 
goal: x ≈ y

full_name: SetTheory.PGame.Fuzzy
code: /-- 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 
goal: Prop

full_name: SetTheory.PGame._aux_Mathlib_SetTheory_Game_PGame___unexpand_SetTheory_PGame_Fuzzy_1
code: @[inherit_doc]
scoped infixl:50 " ‖ " => PGame.Fuzzy
goal: Lean.PrettyPrinter.Unexpander

full_name: SetTheory.PGame.«_aux_Mathlib_SetTheory_Game_PGame___macroRules_SetTheory_PGame_term_‖__1»
code: @[inherit_doc]
scoped infixl:50 " ‖ " => PGame.Fuzzy
goal: Lean.Macro

full_name: SetTheory.PGame.Fuzzy.swap
code: @[symm]
theorem Fuzzy.swap {x y : PGame} : x ‖ y → y ‖ x 
goal: x.Fuzzy y → y.Fuzzy x

full_name: SetTheory.PGame.instIsSymmFuzzy
code: instance : IsSymm _ (· ‖ ·) 
goal: IsSymm SetTheory.PGame fun x x_1 => x.Fuzzy x_1

full_name: SetTheory.PGame.Fuzzy.swap_iff
code: theorem Fuzzy.swap_iff {x y : PGame} : x ‖ y ↔ y ‖ x 
goal: x.Fuzzy y ↔ y.Fuzzy x

full_name: SetTheory.PGame.fuzzy_irrefl
code: theorem fuzzy_irrefl (x : PGame) : ¬x ‖ x 
goal: ¬x.Fuzzy x

full_name: SetTheory.PGame.instIsIrreflFuzzy
code: instance : IsIrrefl _ (· ‖ ·) 
goal: IsIrrefl SetTheory.PGame fun x x_1 => x.Fuzzy x_1

full_name: SetTheory.PGame.lf_iff_lt_or_fuzzy
code: theorem lf_iff_lt_or_fuzzy {x y : PGame} : x ⧏ y ↔ x < y ∨ x ‖ y 
goal: x.LF y ↔ x < y ∨ x.Fuzzy y

full_name: SetTheory.PGame.lf_of_fuzzy
code: theorem lf_of_fuzzy {x y : PGame} (h : x ‖ y) : x ⧏ y 
goal: x.LF y

full_name: SetTheory.PGame.lt_or_fuzzy_of_lf
code: theorem lt_or_fuzzy_of_lf {x y : PGame} : x ⧏ y → x < y ∨ x ‖ y 
goal: x.LF y → x < y ∨ x.Fuzzy y

full_name: SetTheory.PGame.Fuzzy.not_equiv
code: theorem Fuzzy.not_equiv {x y : PGame} (h : x ‖ y) : ¬(x ≈ y) 
goal: ¬x ≈ y

full_name: SetTheory.PGame.Fuzzy.not_equiv'
code: theorem Fuzzy.not_equiv' {x y : PGame} (h : x ‖ y) : ¬(y ≈ x) 
goal: ¬y ≈ x

full_name: SetTheory.PGame.not_fuzzy_of_le
code: theorem not_fuzzy_of_le {x y : PGame} (h : x ≤ y) : ¬x ‖ y 
goal: ¬x.Fuzzy y

full_name: SetTheory.PGame.not_fuzzy_of_ge
code: theorem not_fuzzy_of_ge {x y : PGame} (h : y ≤ x) : ¬x ‖ y 
goal: ¬x.Fuzzy y

full_name: SetTheory.PGame.Equiv.not_fuzzy
code: theorem Equiv.not_fuzzy {x y : PGame} (h : x ≈ y) : ¬x ‖ y 
goal: ¬x.Fuzzy y

full_name: SetTheory.PGame.Equiv.not_fuzzy'
code: theorem Equiv.not_fuzzy' {x y : PGame} (h : x ≈ y) : ¬y ‖ x 
goal: ¬y.Fuzzy x

full_name: SetTheory.PGame.fuzzy_congr
code: theorem fuzzy_congr {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ‖ y₁ ↔ x₂ ‖ y₂ 
goal: x₁.Fuzzy y₁ ↔ x₂.Fuzzy y₂

full_name: SetTheory.PGame.fuzzy_congr_imp
code: theorem fuzzy_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ‖ y₁ → x₂ ‖ y₂ 
goal: x₁.Fuzzy y₁ → x₂.Fuzzy y₂

full_name: SetTheory.PGame.fuzzy_congr_left
code: theorem fuzzy_congr_left {x₁ x₂ y : PGame} (hx : x₁ ≈ x₂) : x₁ ‖ y ↔ x₂ ‖ y 
goal: x₁.Fuzzy y ↔ x₂.Fuzzy y

full_name: SetTheory.PGame.fuzzy_congr_right
code: theorem fuzzy_congr_right {x y₁ y₂ : PGame} (hy : y₁ ≈ y₂) : x ‖ y₁ ↔ x ‖ y₂ 
goal: x.Fuzzy y₁ ↔ x.Fuzzy y₂

full_name: SetTheory.PGame.fuzzy_of_fuzzy_of_equiv
code: @[trans]
theorem fuzzy_of_fuzzy_of_equiv {x y z : PGame} (h₁ : x ‖ y) (h₂ : y ≈ z) : x ‖ z 
goal: x.Fuzzy z

full_name: SetTheory.PGame.fuzzy_of_equiv_of_fuzzy
code: @[trans]
theorem fuzzy_of_equiv_of_fuzzy {x y z : PGame} (h₁ : x ≈ y) (h₂ : y ‖ z) : x ‖ z 
goal: x.Fuzzy z

full_name: SetTheory.PGame.lt_or_equiv_or_gt_or_fuzzy
code: /-- 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 
goal: x < y ∨ x ≈ y ∨ y < x ∨ x.Fuzzy y

full_name: SetTheory.PGame.lt_or_equiv_or_gf
code: theorem lt_or_equiv_or_gf (x y : PGame) : x < y ∨ (x ≈ y) ∨ y ⧏ x 
goal: x < y ∨ x ≈ y ∨ y.LF x

full_name: SetTheory.PGame.Relabelling
code: /-- `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)
  |
  mk :
    ∀ {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
goal: SetTheory.PGame → SetTheory.PGame → Type (u + 1)

full_name: SetTheory.PGame.Relabelling.mk
code: /-- `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)
  |
  mk :
    ∀ {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
goal: ((i : x.LeftMoves) → (x.moveLeft i).Relabelling (y.moveLeft (L i))) →
  ((j : x.RightMoves) → (x.moveRight j).Relabelling (y.moveRight (R j))) → x.Relabelling y

full_name: SetTheory.PGame.«_aux_Mathlib_SetTheory_Game_PGame___macroRules_SetTheory_PGame_term_≡r__1»
code: @[inherit_doc]
scoped infixl:50 " ≡r " => PGame.Relabelling
goal: Lean.Macro

full_name: SetTheory.PGame._aux_Mathlib_SetTheory_Game_PGame___unexpand_SetTheory_PGame_Relabelling_1
code: @[inherit_doc]
scoped infixl:50 " ≡r " => PGame.Relabelling
goal: Lean.PrettyPrinter.Unexpander

full_name: SetTheory.PGame.Relabelling.mk'
code: /-- 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 
goal: x.Relabelling y

full_name: SetTheory.PGame.Relabelling.leftMovesEquiv
code: /-- The equivalence between left moves of `x` and `y` given by the relabelling. -/
def leftMovesEquiv : x ≡r y → x.LeftMoves ≃ y.LeftMoves
  
goal: x.Relabelling y → x.LeftMoves ≃ y.LeftMoves

full_name: SetTheory.PGame.Relabelling.mk_leftMovesEquiv
code: @[simp]
theorem mk_leftMovesEquiv {x y L R hL hR} : (@Relabelling.mk x y L R hL hR).leftMovesEquiv = L 
goal: (SetTheory.PGame.Relabelling.mk L R hL hR).leftMovesEquiv = L

full_name: SetTheory.PGame.Relabelling.mk'_leftMovesEquiv
code: @[simp]
theorem mk'_leftMovesEquiv {x y L R hL hR} :
    (@Relabelling.mk' x y L R hL hR).leftMovesEquiv = L.symm 
goal: (SetTheory.PGame.Relabelling.mk' L R hL hR).leftMovesEquiv = L.symm

full_name: SetTheory.PGame.Relabelling.rightMovesEquiv
code: /-- The equivalence between right moves of `x` and `y` given by the relabelling. -/
def rightMovesEquiv : x ≡r y → x.RightMoves ≃ y.RightMoves
  
goal: x.Relabelling y → x.RightMoves ≃ y.RightMoves

full_name: SetTheory.PGame.Relabelling.mk_rightMovesEquiv
code: @[simp]
theorem mk_rightMovesEquiv {x y L R hL hR} : (@Relabelling.mk x y L R hL hR).rightMovesEquiv = R 
goal: (SetTheory.PGame.Relabelling.mk L R hL hR).rightMovesEquiv = R

full_name: SetTheory.PGame.Relabelling.mk'_rightMovesEquiv
code: @[simp]
theorem mk'_rightMovesEquiv {x y L R hL hR} :
    (@Relabelling.mk' x y L R hL hR).rightMovesEquiv = R.symm 
goal: (SetTheory.PGame.Relabelling.mk' L R hL hR).rightMovesEquiv = R.symm

full_name: SetTheory.PGame.Relabelling.moveLeft
code: /-- 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)
  
goal: (x.moveLeft i).Relabelling (y.moveLeft (r.leftMovesEquiv i))

full_name: SetTheory.PGame.Relabelling.moveLeftSymm
code: /-- 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
  
goal: (x.moveLeft (r.leftMovesEquiv.symm i)).Relabelling (y.moveLeft i)

full_name: SetTheory.PGame.Relabelling.moveRight
code: /-- 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)
  
goal: (x.moveRight i).Relabelling (y.moveRight (r.rightMovesEquiv i))

full_name: SetTheory.PGame.Relabelling.moveRightSymm
code: /-- 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
  
goal: (x.moveRight (r.rightMovesEquiv.symm i)).Relabelling (y.moveRight i)

full_name: SetTheory.PGame.Relabelling.refl
code: /-- The identity relabelling. -/
@[refl]
def refl (x : PGame) : x ≡r x 
goal: x.Relabelling x

full_name: SetTheory.PGame.Relabelling.instInhabited
code: instance (x : PGame) : Inhabited (x ≡r x) 
goal: Inhabited (x.Relabelling x)

full_name: SetTheory.PGame.Relabelling.symm
code: /-- Flip a relabelling. -/
@[symm]
def symm : ∀ {x y : PGame}, x ≡r y → y ≡r x
  
goal: x.Relabelling y → y.Relabelling x

full_name: SetTheory.PGame.Relabelling.le
code: theorem le {x y : PGame} (r : x ≡r y) : x ≤ y 
goal: x ≤ y

full_name: SetTheory.PGame.Relabelling.ge
code: theorem ge {x y : PGame} (r : x ≡r y) : y ≤ x 
goal: y ≤ x

full_name: SetTheory.PGame.Relabelling.equiv
code: /-- A relabelling lets us prove equivalence of games. -/
theorem equiv (r : x ≡r y) : x ≈ y 
goal: x ≈ y

full_name: SetTheory.PGame.Relabelling.trans
code: /-- Transitivity of relabelling. -/
@[trans]
def trans : ∀ {x y z : PGame}, x ≡r y → y ≡r z → x ≡r z
  
goal: x.Relabelling y → y.Relabelling z → x.Relabelling z

full_name: SetTheory.PGame.Relabelling.isEmpty
code: /-- 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 
goal: x.Relabelling 0

full_name: SetTheory.PGame.Equiv.isEmpty
code: theorem Equiv.isEmpty (x : PGame) [IsEmpty x.LeftMoves] [IsEmpty x.RightMoves] : x ≈ 0 
goal: x ≈ 0

full_name: SetTheory.PGame.instCoeRelabellingEquiv
code: instance {x y : PGame} : Coe (x ≡r y) (x ≈ y) 
goal: Coe (x.Relabelling y) (x ≈ y)

full_name: SetTheory.PGame.relabel
code: /-- 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 
goal: SetTheory.PGame

full_name: SetTheory.PGame.relabel_moveLeft'
code: @[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) 
goal: (SetTheory.PGame.relabel el er).moveLeft i = x.moveLeft (el i)

full_name: SetTheory.PGame.relabel_moveLeft
code: 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 
goal: (SetTheory.PGame.relabel el er).moveLeft (el.symm i) = x.moveLeft i

full_name: SetTheory.PGame.relabel_moveRight'
code: @[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) 
goal: (SetTheory.PGame.relabel el er).moveRight j = x.moveRight (er j)

full_name: SetTheory.PGame.relabel_moveRight
code: 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 
goal: (SetTheory.PGame.relabel el er).moveRight (er.symm j) = x.moveRight j

full_name: SetTheory.PGame.relabelRelabelling
code: /-- 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 
goal: x.Relabelling (SetTheory.PGame.relabel el er)

full_name: SetTheory.PGame.neg
code: /-- The negation of `{L | R}` is `{-R | -L}`. -/
def neg : PGame → PGame
  
goal: SetTheory.PGame → SetTheory.PGame

full_name: SetTheory.PGame.instNeg
code: instance : Neg PGame 
goal: Neg SetTheory.PGame

full_name: SetTheory.PGame.neg_def
code: @[simp]
theorem neg_def {xl xr xL xR} : -mk xl xr xL xR = mk xr xl (fun j => -xR j) fun i => -xL i 
goal: -SetTheory.PGame.mk xl xr xL xR = SetTheory.PGame.mk xr xl (fun j => -xR j) fun i => -xL i

full_name: SetTheory.PGame.instInvolutiveNeg
code: instance : InvolutiveNeg PGame 
goal: InvolutiveNeg SetTheory.PGame

full_name: SetTheory.PGame.instNegZeroClass
code: instance : NegZeroClass PGame 
goal: NegZeroClass SetTheory.PGame

full_name: SetTheory.PGame.neg_ofLists
code: @[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) 
goal: -SetTheory.PGame.ofLists L R = SetTheory.PGame.ofLists (List.map (fun x => -x) R) (List.map (fun x => -x) L)

full_name: SetTheory.PGame.isOption_neg
code: theorem isOption_neg {x y : PGame} : IsOption x (-y) ↔ IsOption (-x) y 
goal: x.IsOption (-y) ↔ (-x).IsOption y

full_name: SetTheory.PGame.isOption_neg_neg
code: @[simp]
theorem isOption_neg_neg {x y : PGame} : IsOption (-x) (-y) ↔ IsOption x y 
goal: (-x).IsOption (-y) ↔ x.IsOption y

full_name: SetTheory.PGame.leftMoves_neg
code: theorem leftMoves_neg : ∀ x : PGame, (-x).LeftMoves = x.RightMoves
  
goal: (-x).LeftMoves = x.RightMoves

full_name: SetTheory.PGame.rightMoves_neg
code: theorem rightMoves_neg : ∀ x : PGame, (-x).RightMoves = x.LeftMoves
  
goal: (-x).RightMoves = x.LeftMoves

full_name: SetTheory.PGame.toLeftMovesNeg
code: /-- 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 
goal: x.RightMoves ≃ (-x).LeftMoves

full_name: SetTheory.PGame.toRightMovesNeg
code: /-- 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 
goal: x.LeftMoves ≃ (-x).RightMoves

full_name: SetTheory.PGame.moveLeft_neg
code: theorem moveLeft_neg {x : PGame} (i) : (-x).moveLeft (toLeftMovesNeg i) = -x.moveRight i 
goal: (-x).moveLeft (SetTheory.PGame.toLeftMovesNeg i) = -x.moveRight i

full_name: SetTheory.PGame.moveLeft_neg'
code: @[simp]
theorem moveLeft_neg' {x : PGame} (i) : (-x).moveLeft i = -x.moveRight (toLeftMovesNeg.symm i) 
goal: (-x).moveLeft i = -x.moveRight (SetTheory.PGame.toLeftMovesNeg.symm i)

full_name: SetTheory.PGame.moveRight_neg
code: theorem moveRight_neg {x : PGame} (i) : (-x).moveRight (toRightMovesNeg i) = -x.moveLeft i 
goal: (-x).moveRight (SetTheory.PGame.toRightMovesNeg i) = -x.moveLeft i

full_name: SetTheory.PGame.moveRight_neg'
code: @[simp]
theorem moveRight_neg' {x : PGame} (i) :
    (-x).moveRight i = -x.moveLeft (toRightMovesNeg.symm i) 
goal: (-x).moveRight i = -x.moveLeft (SetTheory.PGame.toRightMovesNeg.symm i)

full_name: SetTheory.PGame.moveLeft_neg_symm
code: theorem moveLeft_neg_symm {x : PGame} (i) :
    x.moveLeft (toRightMovesNeg.symm i) = -(-x).moveRight i 
goal: x.moveLeft (SetTheory.PGame.toRightMovesNeg.symm i) = -(-x).moveRight i

full_name: SetTheory.PGame.moveLeft_neg_symm'
code: theorem moveLeft_neg_symm' {x : PGame} (i) :
    x.moveLeft i = -(-x).moveRight (toRightMovesNeg i) 
goal: x.moveLeft i = -(-x).moveRight (SetTheory.PGame.toRightMovesNeg i)

full_name: SetTheory.PGame.moveRight_neg_symm
code: theorem moveRight_neg_symm {x : PGame} (i) :
    x.moveRight (toLeftMovesNeg.symm i) = -(-x).moveLeft i 
goal: x.moveRight (SetTheory.PGame.toLeftMovesNeg.symm i) = -(-x).moveLeft i

full_name: SetTheory.PGame.moveRight_neg_symm'
code: theorem moveRight_neg_symm' {x : PGame} (i) :
    x.moveRight i = -(-x).moveLeft (toLeftMovesNeg i) 
goal: x.moveRight i = -(-x).moveLeft (SetTheory.PGame.toLeftMovesNeg i)

full_name: SetTheory.PGame.Relabelling.negCongr
code: /-- 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
  
goal: x.Relabelling y → (-x).Relabelling (-y)

full_name: _private.Mathlib.SetTheory.Game.PGame.0.SetTheory.PGame.neg_le_lf_neg_iff
code: private theorem neg_le_lf_neg_iff : ∀ {x y : PGame.{u}}, (-y ≤ -x ↔ x ≤ y) ∧ (-y ⧏ -x ↔ x ⧏ y)
  
goal: (-y ≤ -x ↔ x ≤ y) ∧ ((-y).LF (-x) ↔ x.LF y)

full_name: SetTheory.PGame.neg_le_neg_iff
code: @[simp]
theorem neg_le_neg_iff {x y : PGame} : -y ≤ -x ↔ x ≤ y 
goal: -y ≤ -x ↔ x ≤ y

full_name: SetTheory.PGame.neg_lf_neg_iff
code: @[simp]
theorem neg_lf_neg_iff {x y : PGame} : -y ⧏ -x ↔ x ⧏ y 
goal: (-y).LF (-x) ↔ x.LF y

full_name: SetTheory.PGame.neg_lt_neg_iff
code: @[simp]
theorem neg_lt_neg_iff {x y : PGame} : -y < -x ↔ x < y 
goal: -y < -x ↔ x < y

full_name: SetTheory.PGame.neg_equiv_neg_iff
code: @[simp]
theorem neg_equiv_neg_iff {x y : PGame} : (-x ≈ -y) ↔ (x ≈ y) 
goal: -x ≈ -y ↔ x ≈ y

full_name: SetTheory.PGame.neg_fuzzy_neg_iff
code: @[simp]
theorem neg_fuzzy_neg_iff {x y : PGame} : -x ‖ -y ↔ x ‖ y 
goal: (-x).Fuzzy (-y) ↔ x.Fuzzy y

full_name: SetTheory.PGame.neg_le_iff
code: theorem neg_le_iff {x y : PGame} : -y ≤ x ↔ -x ≤ y 
goal: -y ≤ x ↔ -x ≤ y

full_name: SetTheory.PGame.neg_lf_iff
code: theorem neg_lf_iff {x y : PGame} : -y ⧏ x ↔ -x ⧏ y 
goal: (-y).LF x ↔ (-x).LF y

full_name: SetTheory.PGame.neg_lt_iff
code: theorem neg_lt_iff {x y : PGame} : -y < x ↔ -x < y 
goal: -y < x ↔ -x < y

full_name: SetTheory.PGame.neg_equiv_iff
code: theorem neg_equiv_iff {x y : PGame} : (-x ≈ y) ↔ (x ≈ -y) 
goal: -x ≈ y ↔ x ≈ -y

full_name: SetTheory.PGame.neg_fuzzy_iff
code: theorem neg_fuzzy_iff {x y : PGame} : -x ‖ y ↔ x ‖ -y 
goal: (-x).Fuzzy y ↔ x.Fuzzy (-y)

full_name: SetTheory.PGame.le_neg_iff
code: theorem le_neg_iff {x y : PGame} : y ≤ -x ↔ x ≤ -y 
goal: y ≤ -x ↔ x ≤ -y

full_name: SetTheory.PGame.lf_neg_iff
code: theorem lf_neg_iff {x y : PGame} : y ⧏ -x ↔ x ⧏ -y 
goal: y.LF (-x) ↔ x.LF (-y)

full_name: SetTheory.PGame.lt_neg_iff
code: theorem lt_neg_iff {x y : PGame} : y < -x ↔ x < -y 
goal: y < -x ↔ x < -y

full_name: SetTheory.PGame.neg_le_zero_iff
code: @[simp]
theorem neg_le_zero_iff {x : PGame} : -x ≤ 0 ↔ 0 ≤ x 
goal: -x ≤ 0 ↔ 0 ≤ x

full_name: SetTheory.PGame.zero_le_neg_iff
code: @[simp]
theorem zero_le_neg_iff {x : PGame} : 0 ≤ -x ↔ x ≤ 0 
goal: 0 ≤ -x ↔ x ≤ 0

full_name: SetTheory.PGame.neg_lf_zero_iff
code: @[simp]
theorem neg_lf_zero_iff {x : PGame} : -x ⧏ 0 ↔ 0 ⧏ x 
goal: (-x).LF 0 ↔ SetTheory.PGame.LF 0 x

full_name: SetTheory.PGame.zero_lf_neg_iff
code: @[simp]
theorem zero_lf_neg_iff {x : PGame} : 0 ⧏ -x ↔ x ⧏ 0 
goal: SetTheory.PGame.LF 0 (-x) ↔ x.LF 0

full_name: SetTheory.PGame.neg_lt_zero_iff
code: @[simp]
theorem neg_lt_zero_iff {x : PGame} : -x < 0 ↔ 0 < x 
goal: -x < 0 ↔ 0 < x

full_name: SetTheory.PGame.zero_lt_neg_iff
code: @[simp]
theorem zero_lt_neg_iff {x : PGame} : 0 < -x ↔ x < 0 
goal: 0 < -x ↔ x < 0

full_name: SetTheory.PGame.neg_equiv_zero_iff
code: @[simp]
theorem neg_equiv_zero_iff {x : PGame} : (-x ≈ 0) ↔ (x ≈ 0) 
goal: -x ≈ 0 ↔ x ≈ 0

full_name: SetTheory.PGame.neg_fuzzy_zero_iff
code: @[simp]
theorem neg_fuzzy_zero_iff {x : PGame} : -x ‖ 0 ↔ x ‖ 0 
goal: (-x).Fuzzy 0 ↔ x.Fuzzy 0

full_name: SetTheory.PGame.zero_equiv_neg_iff
code: @[simp]
theorem zero_equiv_neg_iff {x : PGame} : (0 ≈ -x) ↔ (0 ≈ x) 
goal: 0 ≈ -x ↔ 0 ≈ x

full_name: SetTheory.PGame.zero_fuzzy_neg_iff
code: @[simp]
theorem zero_fuzzy_neg_iff {x : PGame} : 0 ‖ -x ↔ 0 ‖ x 
goal: SetTheory.PGame.Fuzzy 0 (-x) ↔ SetTheory.PGame.Fuzzy 0 x

full_name: SetTheory.PGame.instAdd
code: /-- The sum of `x = {xL | xR}` and `y = {yL | yR}` is `{xL + y, x + yL | xR + y, x + yR}`. -/
instance : Add PGame.{u} 
goal: Add SetTheory.PGame

full_name: SetTheory.PGame.instNatCast
code: /-- The pre-game `((0+1)+⋯)+1`. -/
instance : NatCast PGame 
goal: NatCast SetTheory.PGame

full_name: SetTheory.PGame.nat_succ
code: @[simp]
protected theorem nat_succ (n : ℕ) : ((n + 1 : ℕ) : PGame) = n + 1 
goal: ↑(n + 1) = ↑n + 1

full_name: SetTheory.PGame.isEmpty_leftMoves_add
code: instance isEmpty_leftMoves_add (x y : PGame.{u}) [IsEmpty x.LeftMoves] [IsEmpty y.LeftMoves] :
    IsEmpty (x + y).LeftMoves 
goal: IsEmpty (x + y).LeftMoves

full_name: SetTheory.PGame.isEmpty_rightMoves_add
code: instance isEmpty_rightMoves_add (x y : PGame.{u}) [IsEmpty x.RightMoves] [IsEmpty y.RightMoves] :
    IsEmpty (x + y).RightMoves 
goal: IsEmpty (x + y).RightMoves

full_name: SetTheory.PGame.addZeroRelabelling
code: /-- `x + 0` has exactly the same moves as `x`. -/
def addZeroRelabelling : ∀ x : PGame.{u}, x + 0 ≡r x
  
goal: (x + 0).Relabelling x

full_name: SetTheory.PGame.add_zero_equiv
code: /-- `x + 0` is equivalent to `x`. -/
theorem add_zero_equiv (x : PGame.{u}) : x + 0 ≈ x 
goal: x + 0 ≈ x

full_name: SetTheory.PGame.zeroAddRelabelling
code: /-- `0 + x` has exactly the same moves as `x`. -/
def zeroAddRelabelling : ∀ x : PGame.{u}, 0 + x ≡r x
  
goal: (0 + x).Relabelling x

full_name: SetTheory.PGame.zero_add_equiv
code: /-- `0 + x` is equivalent to `x`. -/
theorem zero_add_equiv (x : PGame.{u}) : 0 + x ≈ x 
goal: 0 + x ≈ x

full_name: SetTheory.PGame.leftMoves_add
code: theorem leftMoves_add : ∀ x y : PGame.{u}, (x + y).LeftMoves = (x.LeftMoves ⊕ y.LeftMoves)
  
goal: (x + y).LeftMoves = (x.LeftMoves ⊕ y.LeftMoves)

full_name: SetTheory.PGame.rightMoves_add
code: theorem rightMoves_add : ∀ x y : PGame.{u}, (x + y).RightMoves = (x.RightMoves ⊕ y.RightMoves)
  
goal: (x + y).RightMoves = (x.RightMoves ⊕ y.RightMoves)

full_name: SetTheory.PGame.toLeftMovesAdd
code: /-- 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} : x.LeftMoves ⊕ y.LeftMoves ≃ (x + y).LeftMoves 
goal: x.LeftMoves ⊕ y.LeftMoves ≃ (x + y).LeftMoves

full_name: SetTheory.PGame.toRightMovesAdd
code: /-- 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} : x.RightMoves ⊕ y.RightMoves ≃ (x + y).RightMoves 
goal: x.RightMoves ⊕ y.RightMoves ≃ (x + y).RightMoves

full_name: SetTheory.PGame.mk_add_moveLeft_inl
code: @[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 
goal: (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

full_name: SetTheory.PGame.add_moveLeft_inl
code: @[simp]
theorem add_moveLeft_inl {x : PGame} (y : PGame) (i) :
    (x + y).moveLeft (toLeftMovesAdd (Sum.inl i)) = x.moveLeft i + y 
goal: (x + y).moveLeft (SetTheory.PGame.toLeftMovesAdd (Sum.inl i)) = x.moveLeft i + y

full_name: SetTheory.PGame.mk_add_moveRight_inl
code: @[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 
goal: (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

full_name: SetTheory.PGame.add_moveRight_inl
code: @[simp]
theorem add_moveRight_inl {x : PGame} (y : PGame) (i) :
    (x + y).moveRight (toRightMovesAdd (Sum.inl i)) = x.moveRight i + y 
goal: (x + y).moveRight (SetTheory.PGame.toRightMovesAdd (Sum.inl i)) = x.moveRight i + y

full_name: SetTheory.PGame.mk_add_moveLeft_inr
code: @[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 
goal: (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

full_name: SetTheory.PGame.add_moveLeft_inr
code: @[simp]
theorem add_moveLeft_inr (x : PGame) {y : PGame} (i) :
    (x + y).moveLeft (toLeftMovesAdd (Sum.inr i)) = x + y.moveLeft i 
goal: (x + y).moveLeft (SetTheory.PGame.toLeftMovesAdd (Sum.inr i)) = x + y.moveLeft i

full_name: SetTheory.PGame.mk_add_moveRight_inr
code: @[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 
goal: (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

full_name: SetTheory.PGame.add_moveRight_inr
code: @[simp]
theorem add_moveRight_inr (x : PGame) {y : PGame} (i) :
    (x + y).moveRight (toRightMovesAdd (Sum.inr i)) = x + y.moveRight i 
goal: (x + y).moveRight (SetTheory.PGame.toRightMovesAdd (Sum.inr i)) = x + y.moveRight i

full_name: SetTheory.PGame.leftMoves_add_cases
code: 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 
goal: P k

full_name: SetTheory.PGame.rightMoves_add_cases
code: 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 
goal: P k

full_name: SetTheory.PGame.isEmpty_nat_rightMoves
code: instance isEmpty_nat_rightMoves : ∀ n : ℕ, IsEmpty (RightMoves n)
  
goal: IsEmpty (↑n).RightMoves

full_name: SetTheory.PGame.Relabelling.addCongr
code: /-- 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
  
goal: w.Relabelling x → y.Relabelling z → (w + y).Relabelling (x + z)

full_name: SetTheory.PGame.instSub
code: instance : Sub PGame 
goal: Sub SetTheory.PGame

full_name: SetTheory.PGame.sub_zero
code: @[simp]
theorem sub_zero (x : PGame) : x - 0 = x + 0 
goal: x - 0 = x + 0

full_name: SetTheory.PGame.Relabelling.subCongr
code: /-- 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 
goal: (w - y).Relabelling (x - z)

full_name: SetTheory.PGame.negAddRelabelling
code: /-- `-(x + y)` has exactly the same moves as `-x + -y`. -/
def negAddRelabelling : ∀ x y : PGame, -(x + y) ≡r -x + -y
  
goal: (-(x + y)).Relabelling (-x + -y)

full_name: SetTheory.PGame.neg_add_le
code: theorem neg_add_le {x y : PGame} : -(x + y) ≤ -x + -y 
goal: -(x + y) ≤ -x + -y

full_name: SetTheory.PGame.addCommRelabelling
code: /-- `x + y` has exactly the same moves as `y + x`. -/
def addCommRelabelling : ∀ x y : PGame.{u}, x + y ≡r y + x
  
goal: (x + y).Relabelling (y + x)

full_name: SetTheory.PGame.add_comm_le
code: theorem add_comm_le {x y : PGame} : x + y ≤ y + x 
goal: x + y ≤ y + x

full_name: SetTheory.PGame.add_comm_equiv
code: theorem add_comm_equiv {x y : PGame} : x + y ≈ y + x 
goal: x + y ≈ y + x

full_name: SetTheory.PGame.addAssocRelabelling
code: /-- `(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)
  
goal: (x + y + z).Relabelling (x + (y + z))

full_name: SetTheory.PGame.add_assoc_equiv
code: theorem add_assoc_equiv {x y z : PGame} : x + y + z ≈ x + (y + z) 
goal: x + y + z ≈ x + (y + z)

full_name: SetTheory.PGame.add_left_neg_le_zero
code: theorem add_left_neg_le_zero : ∀ x : PGame, -x + x ≤ 0
  
goal: -x + x ≤ 0

full_name: SetTheory.PGame.zero_le_add_left_neg
code: theorem zero_le_add_left_neg (x : PGame) : 0 ≤ -x + x 
goal: 0 ≤ -x + x

full_name: SetTheory.PGame.add_left_neg_equiv
code: theorem add_left_neg_equiv (x : PGame) : -x + x ≈ 0 
goal: -x + x ≈ 0

full_name: SetTheory.PGame.add_right_neg_le_zero
code: theorem add_right_neg_le_zero (x : PGame) : x + -x ≤ 0 
goal: x + -x ≤ 0

full_name: SetTheory.PGame.zero_le_add_right_neg
code: theorem zero_le_add_right_neg (x : PGame) : 0 ≤ x + -x 
goal: 0 ≤ x + -x

full_name: SetTheory.PGame.add_right_neg_equiv
code: theorem add_right_neg_equiv (x : PGame) : x + -x ≈ 0 
goal: x + -x ≈ 0

full_name: SetTheory.PGame.sub_self_equiv
code: theorem sub_self_equiv : ∀ (x : PGame), x - x ≈ 0 
goal: x - x ≈ 0

full_name: _private.Mathlib.SetTheory.Game.PGame.0.SetTheory.PGame.add_le_add_right'
code: private theorem add_le_add_right' : ∀ {x y z : PGame}, x ≤ y → x + z ≤ y + z
  
goal: x ≤ y → x + z ≤ y + z

full_name: SetTheory.PGame.covariantClass_swap_add_le
code: instance covariantClass_swap_add_le : CovariantClass PGame PGame (swap (· + ·)) (· ≤ ·) 
goal: CovariantClass SetTheory.PGame SetTheory.PGame (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: SetTheory.PGame.covariantClass_add_le
code: instance covariantClass_add_le : CovariantClass PGame PGame (· + ·) (· ≤ ·) 
goal: CovariantClass SetTheory.PGame SetTheory.PGame (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: SetTheory.PGame.add_lf_add_right
code: theorem add_lf_add_right {y z : PGame} (h : y ⧏ z) (x) : y + x ⧏ z + x 
goal: (y + x).LF (z + x)

full_name: SetTheory.PGame.add_lf_add_left
code: theorem add_lf_add_left {y z : PGame} (h : y ⧏ z) (x) : x + y ⧏ x + z 
goal: (x + y).LF (x + z)

full_name: SetTheory.PGame.covariantClass_swap_add_lt
code: instance covariantClass_swap_add_lt : CovariantClass PGame PGame (swap (· + ·)) (· < ·) 
goal: CovariantClass SetTheory.PGame SetTheory.PGame (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1

full_name: SetTheory.PGame.covariantClass_add_lt
code: instance covariantClass_add_lt : CovariantClass PGame PGame (· + ·) (· < ·) 
goal: CovariantClass SetTheory.PGame SetTheory.PGame (fun x x_1 => x + x_1) fun x x_1 => x < x_1

full_name: SetTheory.PGame.add_lf_add_of_lf_of_le
code: theorem add_lf_add_of_lf_of_le {w x y z : PGame} (hwx : w ⧏ x) (hyz : y ≤ z) : w + y ⧏ x + z 
goal: (w + y).LF (x + z)

full_name: SetTheory.PGame.add_lf_add_of_le_of_lf
code: theorem add_lf_add_of_le_of_lf {w x y z : PGame} (hwx : w ≤ x) (hyz : y ⧏ z) : w + y ⧏ x + z 
goal: (w + y).LF (x + z)

full_name: SetTheory.PGame.add_congr
code: theorem add_congr {w x y z : PGame} (h₁ : w ≈ x) (h₂ : y ≈ z) : w + y ≈ x + z 
goal: w + y ≈ x + z

full_name: SetTheory.PGame.add_congr_left
code: theorem add_congr_left {x y z : PGame} (h : x ≈ y) : x + z ≈ y + z 
goal: x + z ≈ y + z

full_name: SetTheory.PGame.add_congr_right
code: theorem add_congr_right {x y z : PGame} : (y ≈ z) → (x + y ≈ x + z) 
goal: y ≈ z → x + y ≈ x + z

full_name: SetTheory.PGame.sub_congr
code: theorem sub_congr {w x y z : PGame} (h₁ : w ≈ x) (h₂ : y ≈ z) : w - y ≈ x - z 
goal: w - y ≈ x - z

full_name: SetTheory.PGame.sub_congr_left
code: theorem sub_congr_left {x y z : PGame} (h : x ≈ y) : x - z ≈ y - z 
goal: x - z ≈ y - z

full_name: SetTheory.PGame.sub_congr_right
code: theorem sub_congr_right {x y z : PGame} : (y ≈ z) → (x - y ≈ x - z) 
goal: y ≈ z → x - y ≈ x - z

full_name: SetTheory.PGame.le_iff_sub_nonneg
code: theorem le_iff_sub_nonneg {x y : PGame} : x ≤ y ↔ 0 ≤ y - x 
goal: x ≤ y ↔ 0 ≤ y - x

full_name: SetTheory.PGame.lf_iff_sub_zero_lf
code: theorem lf_iff_sub_zero_lf {x y : PGame} : x ⧏ y ↔ 0 ⧏ y - x 
goal: x.LF y ↔ SetTheory.PGame.LF 0 (y - x)

full_name: SetTheory.PGame.lt_iff_sub_pos
code: theorem lt_iff_sub_pos {x y : PGame} : x < y ↔ 0 < y - x 
goal: x < y ↔ 0 < y - x

full_name: SetTheory.PGame.insertLeft
code: /-- The pregame constructed by inserting `x'` as a new left option into x. -/
def insertLeft (x x' : PGame.{u}) : PGame 
goal: SetTheory.PGame

full_name: SetTheory.PGame.le_insertLeft
code: /-- A new left option cannot hurt Left. -/
lemma le_insertLeft (x x' : PGame) : x ≤ insertLeft x x' 
goal: x ≤ x.insertLeft x'

full_name: SetTheory.PGame.insertLeft_equiv_of_lf
code: /-- Adding a gift horse left option does not change the value of `x`. A gift horse left option is
 a game `x'` with `x' ⧏ x`. It is called "gift horse" because it seems like Left has gotten the
 "gift" of a new option, but actually the value of the game did not change. -/
lemma insertLeft_equiv_of_lf {x x' : PGame} (h : x' ⧏ x) : insertLeft x x' ≈ x 
goal: x.insertLeft x' ≈ x

full_name: SetTheory.PGame.insertRight
code: /-- The pregame constructed by inserting `x'` as a new right option into x. -/
def insertRight (x x' : PGame.{u}) : PGame 
goal: SetTheory.PGame

full_name: SetTheory.PGame.neg_insertRight_neg
code: theorem neg_insertRight_neg (x x' : PGame.{u}) : (-x).insertRight (-x') = -x.insertLeft x' 
goal: (-x).insertRight (-x') = -x.insertLeft x'

full_name: SetTheory.PGame.neg_insertLeft_neg
code: theorem neg_insertLeft_neg (x x' : PGame.{u}) : (-x).insertLeft (-x') = -x.insertRight x' 
goal: (-x).insertLeft (-x') = -x.insertRight x'

full_name: SetTheory.PGame.insertRight_le
code: /-- A new right option cannot hurt Right. -/
lemma insertRight_le (x x' : PGame) : insertRight x x' ≤ x 
goal: x.insertRight x' ≤ x

full_name: SetTheory.PGame.insertRight_equiv_of_lf
code: /-- Adding a gift horse right option does not change the value of `x`. A gift horse right option is
 a game `x'` with `x ⧏ x'`. It is called "gift horse" because it seems like Right has gotten the
 "gift" of a new option, but actually the value of the game did not change. -/
lemma insertRight_equiv_of_lf {x x' : PGame} (h : x ⧏ x') : insertRight x x' ≈ x 
goal: x.insertRight x' ≈ x

full_name: SetTheory.PGame.insertRight_insertLeft
code: /-- Inserting on the left and right commutes. -/
theorem insertRight_insertLeft {x x' x'' : PGame} :
    insertRight (insertLeft x x') x'' = insertLeft (insertRight x x'') x' 
goal: (x.insertLeft x').insertRight x'' = (x.insertRight x'').insertLeft x'

full_name: SetTheory.PGame.star
code: /-- The pre-game `star`, which is fuzzy with zero. -/
def star : PGame.{u} 
goal: SetTheory.PGame

full_name: SetTheory.PGame.star_leftMoves
code: @[simp]
theorem star_leftMoves : star.LeftMoves = PUnit 
goal: SetTheory.PGame.star.LeftMoves = PUnit.{u_1 + 1}

full_name: SetTheory.PGame.star_rightMoves
code: @[simp]
theorem star_rightMoves : star.RightMoves = PUnit 
goal: SetTheory.PGame.star.RightMoves = PUnit.{u_1 + 1}

full_name: SetTheory.PGame.star_moveLeft
code: @[simp]
theorem star_moveLeft (x) : star.moveLeft x = 0 
goal: SetTheory.PGame.star.moveLeft x = 0

full_name: SetTheory.PGame.star_moveRight
code: @[simp]
theorem star_moveRight (x) : star.moveRight x = 0 
goal: SetTheory.PGame.star.moveRight x = 0

full_name: SetTheory.PGame.uniqueStarLeftMoves
code: instance uniqueStarLeftMoves : Unique star.LeftMoves 
goal: Unique SetTheory.PGame.star.LeftMoves

full_name: SetTheory.PGame.uniqueStarRightMoves
code: instance uniqueStarRightMoves : Unique star.RightMoves 
goal: Unique SetTheory.PGame.star.RightMoves

full_name: SetTheory.PGame.star_fuzzy_zero
code: theorem star_fuzzy_zero : star ‖ 0 
goal: SetTheory.PGame.star.Fuzzy 0

full_name: SetTheory.PGame.neg_star
code: @[simp]
theorem neg_star : -star = star 
goal: -SetTheory.PGame.star = SetTheory.PGame.star

full_name: SetTheory.PGame.zero_lt_one
code: @[simp]
protected theorem zero_lt_one : (0 : PGame) < 1 
goal: 0 < 1

full_name: SetTheory.PGame.instZeroLEOneClass
code: instance : ZeroLEOneClass PGame 
goal: ZeroLEOneClass SetTheory.PGame

full_name: SetTheory.PGame.zero_lf_one
code: @[simp]
theorem zero_lf_one : (0 : PGame) ⧏ 1 
goal: SetTheory.PGame.LF 0 1