ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- SetTheory.PGame.Subsequent.mk_right
@[simp]
theorem Subsequent.mk_right {xl xr} (xL : xl → PGame) (xR : xr → PGame) (j : xr) :
    Subsequent (xR j) (mk xl xr xL xR) 
Arguments: {xl xr : Type u_1} (xL : xl → SetTheory.PGame) (xR : xr → SetTheory.PGame) (j : xr)
Goal: (xR j).Subsequent (SetTheory.PGame.mk xl xr xL xR)
-- SetTheory.PGame.Subsequent.mk_right'
@[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) 
Arguments: {xl xr : Type u} (xL : xl → SetTheory.PGame) (xR : xr → SetTheory.PGame) (j : (SetTheory.PGame.mk xl xr xL xR).RightMoves)
Goal: (xR j).Subsequent (SetTheory.PGame.mk xl xr xL xR)
-- SetTheory.PGame.Subsequent.moveRight_mk_left
@[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) 
Arguments: {xl xr : Type u} {xR : xr → SetTheory.PGame} {i : xl} (xL : xl → SetTheory.PGame) (j : (xL i).RightMoves)
Goal: ((xL i).moveRight j).Subsequent (SetTheory.PGame.mk xl xr xL xR)
-- SetTheory.PGame.Subsequent.moveRight_mk_right
@[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) 
Arguments: {xl xr : Type u} {xL : xl → SetTheory.PGame} {i : xr} (xR : xr → SetTheory.PGame) (j : (xR i).RightMoves)
Goal: ((xR i).moveRight j).Subsequent (SetTheory.PGame.mk xl xr xL xR)
-- SetTheory.PGame.Subsequent.moveLeft_mk_left
@[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) 
Arguments: {xl xr : Type u} {xR : xr → SetTheory.PGame} {i : xl} (xL : xl → SetTheory.PGame) (j : (xL i).LeftMoves)
Goal: ((xL i).moveLeft j).Subsequent (SetTheory.PGame.mk xl xr xL xR)
-- SetTheory.PGame.Subsequent.moveLeft_mk_right
@[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) 
Arguments: {xl xr : Type u} {xL : xl → SetTheory.PGame} {i : xr} (xR : xr → SetTheory.PGame) (j : (xR i).LeftMoves)
Goal: ((xR i).moveLeft j).Subsequent (SetTheory.PGame.mk xl xr xL xR)
-- SetTheory.PGame.zero_leftMoves
@[simp]
theorem zero_leftMoves : LeftMoves 0 = PEmpty 
Goal: SetTheory.PGame.LeftMoves 0 = PEmpty.{u_1 + 1}
-- SetTheory.PGame.zero_rightMoves
@[simp]
theorem zero_rightMoves : RightMoves 0 = PEmpty 
Goal: SetTheory.PGame.RightMoves 0 = PEmpty.{u_1 + 1}
-- SetTheory.PGame.one_leftMoves
@[simp]
theorem one_leftMoves : LeftMoves 1 = PUnit 
Goal: SetTheory.PGame.LeftMoves 1 = PUnit.{u_1 + 1}
-- SetTheory.PGame.one_moveLeft
@[simp]
theorem one_moveLeft (x) : moveLeft 1 x = 0 
Arguments: (x : SetTheory.PGame.LeftMoves 1)
Goal: SetTheory.PGame.moveLeft 1 x = 0
-- SetTheory.PGame.one_rightMoves
@[simp]
theorem one_rightMoves : RightMoves 1 = PEmpty 
Goal: SetTheory.PGame.RightMoves 1 = PEmpty.{u_1 + 1}
-- SetTheory.PGame.not_le
@[simp]
protected theorem not_le {x y : PGame} : ¬x ≤ y ↔ y ⧏ x 
Arguments: {x y : SetTheory.PGame}
Goal: ¬x ≤ y ↔ y.LF x
-- SetTheory.PGame.not_lf
@[simp]
theorem not_lf {x y : PGame} : ¬x ⧏ y ↔ y ≤ x 
Arguments: {x y : SetTheory.PGame}
Goal: ¬x.LF y ↔ y ≤ x
-- LE.le.not_gf
theorem _root_.LE.le.not_gf {x y : PGame} : x ≤ y → ¬y ⧏ x 
Arguments: {x y : SetTheory.PGame}
Goal: x ≤ y → ¬y.LF x
-- SetTheory.PGame.LF.not_ge
theorem LF.not_ge {x y : PGame} : x ⧏ y → ¬y ≤ x 
Arguments: {x y : SetTheory.PGame}
Goal: x.LF y → ¬y ≤ x
-- SetTheory.PGame.le_iff_forall_lf
theorem le_iff_forall_lf {x y : PGame} :
    x ≤ y ↔ (∀ i, x.moveLeft i ⧏ y) ∧ ∀ j, x ⧏ y.moveRight j 
Arguments: {x y : SetTheory.PGame}
Goal: x ≤ y ↔ (∀ (i : x.LeftMoves), (x.moveLeft i).LF y) ∧ ∀ (j : y.RightMoves), x.LF (y.moveRight j)
-- SetTheory.PGame.mk_le_mk
@[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 
Arguments: {xl xr : Type u_1} {xL : xl → SetTheory.PGame} {xR : xr → SetTheory.PGame} {yl yr : Type u_1} {yL : yl → SetTheory.PGame} {yR : yr → SetTheory.PGame}
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)
-- SetTheory.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 
Arguments: {x y : SetTheory.PGame} (h₁ : ∀ (i : x.LeftMoves), (x.moveLeft i).LF y) (h₂ : ∀ (j : y.RightMoves), x.LF (y.moveRight j))
Goal: x ≤ y
-- SetTheory.PGame.lf_iff_exists_le
theorem lf_iff_exists_le {x y : PGame} :
    x ⧏ y ↔ (∃ i, x ≤ y.moveLeft i) ∨ ∃ j, x.moveRight j ≤ y 
Arguments: {x y : SetTheory.PGame}
Goal: x.LF y ↔ (∃ i, x ≤ y.moveLeft i) ∨ ∃ j, x.moveRight j ≤ y
-- SetTheory.PGame.mk_lf_mk
@[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 
Arguments: {xl xr : Type u_1} {xL : xl → SetTheory.PGame} {xR : xr → SetTheory.PGame} {yl yr : Type u_1} {yL : yl → SetTheory.PGame} {yR : yr → SetTheory.PGame}
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
-- SetTheory.PGame.le_or_gf
theorem le_or_gf (x y : PGame) : x ≤ y ∨ y ⧏ x 
Arguments: (x y : SetTheory.PGame)
Goal: x ≤ y ∨ y.LF x
-- SetTheory.PGame.moveLeft_lf_of_le
theorem moveLeft_lf_of_le {x y : PGame} (h : x ≤ y) (i) : x.moveLeft i ⧏ y 
Arguments: {x y : SetTheory.PGame} (h : x ≤ y) (i : x.LeftMoves)
Goal: (x.moveLeft i).LF y
-- SetTheory.PGame.lf_moveRight_of_le
theorem lf_moveRight_of_le {x y : PGame} (h : x ≤ y) (j) : x ⧏ y.moveRight j 
Arguments: {x y : SetTheory.PGame} (h : x ≤ y) (j : y.RightMoves)
Goal: x.LF (y.moveRight j)
-- SetTheory.PGame.lf_of_moveRight_le
theorem lf_of_moveRight_le {x y : PGame} {j} (h : x.moveRight j ≤ y) : x ⧏ y 
Arguments: {x y : SetTheory.PGame} {j : x.RightMoves} (h : x.moveRight j ≤ y)
Goal: x.LF y
-- SetTheory.PGame.lf_of_le_moveLeft
theorem lf_of_le_moveLeft {x y : PGame} {i} (h : x ≤ y.moveLeft i) : x ⧏ y 
Arguments: {x y : SetTheory.PGame} {i : y.LeftMoves} (h : x ≤ y.moveLeft i)
Goal: x.LF y
-- SetTheory.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 
Arguments: {xl xr : Type u_1} {xL : xl → SetTheory.PGame} {xR : xr → SetTheory.PGame} {y : SetTheory.PGame}
Goal: SetTheory.PGame.mk xl xr xL xR ≤ y → ∀ (i : xl), (xL i).LF y
-- SetTheory.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 
Arguments: {x : SetTheory.PGame} {yl yr : Type u_1} {yL : yl → SetTheory.PGame} {yR : yr → SetTheory.PGame}
Goal: x ≤ SetTheory.PGame.mk yl yr yL yR → ∀ (j : yr), x.LF (yR j)
-- SetTheory.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 
Arguments: {xl xr : Type u_1} {y : SetTheory.PGame} {j : xr} (xL : xl → SetTheory.PGame) {xR : xr → SetTheory.PGame}
Goal: xR j ≤ y → (SetTheory.PGame.mk xl xr xL xR).LF y
-- SetTheory.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 
Arguments: {x : SetTheory.PGame} {yl yr : Type u_1} {yL : yl → SetTheory.PGame} (yR : yr → SetTheory.PGame) {i : yl}
Goal: x ≤ yL i → x.LF (SetTheory.PGame.mk yl yr yL yR)
-- _private.Mathlib.SetTheory.Game.PGame.0.SetTheory.PGame.le_trans_aux
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 
Arguments: {x y z : SetTheory.PGame} (h₁ : ∀ {i : x.LeftMoves}, y ≤ z → z ≤ x.moveLeft i → y ≤ x.moveLeft i) (h₂ : ∀ {j : z.RightMoves}, z.moveRight j ≤ x → x ≤ y → z.moveRight j ≤ y) (hxy : x ≤ y) (hyz : y ≤ z)
Goal: x ≤ z
-- SetTheory.PGame.lt_iff_le_and_lf
theorem lt_iff_le_and_lf {x y : PGame} : x < y ↔ x ≤ y ∧ x ⧏ y 
Arguments: {x y : SetTheory.PGame}
Goal: x < y ↔ x ≤ y ∧ x.LF y
-- SetTheory.PGame.lt_of_le_of_lf
theorem lt_of_le_of_lf {x y : PGame} (h₁ : x ≤ y) (h₂ : x ⧏ y) : x < y 
Arguments: {x y : SetTheory.PGame} (h₁ : x ≤ y) (h₂ : x.LF y)
Goal: x < y
-- SetTheory.PGame.lf_of_lt
theorem lf_of_lt {x y : PGame} (h : x < y) : x ⧏ y 
Arguments: {x y : SetTheory.PGame} (h : x < y)
Goal: x.LF y
-- SetTheory.PGame.lf_irrefl
theorem lf_irrefl (x : PGame) : ¬x ⧏ x 
Arguments: (x : SetTheory.PGame)
Goal: ¬x.LF x
-- 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 
Arguments: {x y z : SetTheory.PGame} (h₁ : x ≤ y) (h₂ : y.LF z)
Goal: x.LF z
-- 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 
Arguments: {x y z : SetTheory.PGame} (h₁ : x.LF y) (h₂ : y ≤ z)
Goal: x.LF z
-- 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 
Arguments: {x y z : SetTheory.PGame} (h₁ : x < y) (h₂ : y.LF z)
Goal: x.LF z
-- 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 
Arguments: {x y z : SetTheory.PGame} (h₁ : x.LF y) (h₂ : y < z)
Goal: x.LF z
-- SetTheory.PGame.moveLeft_lf
theorem moveLeft_lf {x : PGame} : ∀ i, x.moveLeft i ⧏ x 
Arguments: {x : SetTheory.PGame} (i : x.LeftMoves)
Goal: (x.moveLeft i).LF x
-- SetTheory.PGame.lf_moveRight
theorem lf_moveRight {x : PGame} : ∀ j, x ⧏ x.moveRight j 
Arguments: {x : SetTheory.PGame} (j : x.RightMoves)
Goal: x.LF (x.moveRight j)
-- SetTheory.PGame.lf_mk
theorem lf_mk {xl xr} (xL : xl → PGame) (xR : xr → PGame) (i) : xL i ⧏ mk xl xr xL xR 
Arguments: {xl xr : Type u_1} (xL : xl → SetTheory.PGame) (xR : xr → SetTheory.PGame) (i : xl)
Goal: (xL i).LF (SetTheory.PGame.mk xl xr xL xR)
-- SetTheory.PGame.mk_lf
theorem mk_lf {xl xr} (xL : xl → PGame) (xR : xr → PGame) (j) : mk xl xr xL xR ⧏ xR j 
Arguments: {xl xr : Type u_1} (xL : xl → SetTheory.PGame) (xR : xr → SetTheory.PGame) (j : xr)
Goal: (SetTheory.PGame.mk xl xr xL xR).LF (xR j)
-- SetTheory.PGame.le_of_forall_lt
theorem le_of_forall_lt {x y : PGame} (h₁ : ∀ i, x.moveLeft i < y) (h₂ : ∀ j, x < y.moveRight j) :
    x ≤ y 
Arguments: {x y : SetTheory.PGame} (h₁ : ∀ (i : x.LeftMoves), x.moveLeft i < y) (h₂ : ∀ (j : y.RightMoves), x < y.moveRight j)
Goal: x ≤ y
-- SetTheory.PGame.le_def
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 
Arguments: {x y : SetTheory.PGame}
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
-- SetTheory.PGame.lf_def
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' 
Arguments: {x y : SetTheory.PGame}
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')
-- SetTheory.PGame.zero_le_lf
theorem zero_le_lf {x : PGame} : 0 ≤ x ↔ ∀ j, 0 ⧏ x.moveRight j 
Arguments: {x : SetTheory.PGame}
Goal: 0 ≤ x ↔ ∀ (j : x.RightMoves), SetTheory.PGame.LF 0 (x.moveRight j)
-- SetTheory.PGame.le_zero_lf
theorem le_zero_lf {x : PGame} : x ≤ 0 ↔ ∀ i, x.moveLeft i ⧏ 0 
Arguments: {x : SetTheory.PGame}
Goal: x ≤ 0 ↔ ∀ (i : x.LeftMoves), (x.moveLeft i).LF 0
-- SetTheory.PGame.zero_lf_le
theorem zero_lf_le {x : PGame} : 0 ⧏ x ↔ ∃ i, 0 ≤ x.moveLeft i 
Arguments: {x : SetTheory.PGame}
Goal: SetTheory.PGame.LF 0 x ↔ ∃ i, 0 ≤ x.moveLeft i
-- SetTheory.PGame.lf_zero_le
theorem lf_zero_le {x : PGame} : x ⧏ 0 ↔ ∃ j, x.moveRight j ≤ 0 
Arguments: {x : SetTheory.PGame}
Goal: x.LF 0 ↔ ∃ j, x.moveRight j ≤ 0
-- SetTheory.PGame.zero_le
theorem zero_le {x : PGame} : 0 ≤ x ↔ ∀ j, ∃ i, 0 ≤ (x.moveRight j).moveLeft i 
Arguments: {x : SetTheory.PGame}
Goal: 0 ≤ x ↔ ∀ (j : x.RightMoves), ∃ i, 0 ≤ (x.moveRight j).moveLeft i
-- SetTheory.PGame.le_zero
theorem le_zero {x : PGame} : x ≤ 0 ↔ ∀ i, ∃ j, (x.moveLeft i).moveRight j ≤ 0 
Arguments: {x : SetTheory.PGame}
Goal: x ≤ 0 ↔ ∀ (i : x.LeftMoves), ∃ j, (x.moveLeft i).moveRight j ≤ 0
-- SetTheory.PGame.zero_lf
theorem zero_lf {x : PGame} : 0 ⧏ x ↔ ∃ i, ∀ j, 0 ⧏ (x.moveLeft i).moveRight j 
Arguments: {x : SetTheory.PGame}
Goal: SetTheory.PGame.LF 0 x ↔ ∃ i, ∀ (j : (x.moveLeft i).RightMoves), SetTheory.PGame.LF 0 ((x.moveLeft i).moveRight j)
-- SetTheory.PGame.lf_zero
theorem lf_zero {x : PGame} : x ⧏ 0 ↔ ∃ j, ∀ i, (x.moveRight j).moveLeft i ⧏ 0 
Arguments: {x : SetTheory.PGame}
Goal: x.LF 0 ↔ ∃ j, ∀ (i : (x.moveRight j).LeftMoves), ((x.moveRight j).moveLeft i).LF 0
-- SetTheory.PGame.zero_le_of_isEmpty_rightMoves
@[simp]
theorem zero_le_of_isEmpty_rightMoves (x : PGame) [IsEmpty x.RightMoves] : 0 ≤ x 
Arguments: (x : SetTheory.PGame) [IsEmpty x.RightMoves]
Goal: 0 ≤ x
-- SetTheory.PGame.le_zero_of_isEmpty_leftMoves
@[simp]
theorem le_zero_of_isEmpty_leftMoves (x : PGame) [IsEmpty x.LeftMoves] : x ≤ 0 
Arguments: (x : SetTheory.PGame) [IsEmpty x.LeftMoves]
Goal: x ≤ 0
-- SetTheory.PGame.rightResponse_spec
theorem rightResponse_spec {x : PGame} (h : x ≤ 0) (i : x.LeftMoves) :
    (x.moveLeft i).moveRight (rightResponse h i) ≤ 0 
Arguments: {x : SetTheory.PGame} (h : x ≤ 0) (i : x.LeftMoves)
Goal: (x.moveLeft i).moveRight (SetTheory.PGame.rightResponse h i) ≤ 0
-- SetTheory.PGame.leftResponse_spec
theorem leftResponse_spec {x : PGame} (h : 0 ≤ x) (j : x.RightMoves) :
    0 ≤ (x.moveRight j).moveLeft (leftResponse h j) 
Arguments: {x : SetTheory.PGame} (h : 0 ≤ x) (j : x.RightMoves)
Goal: 0 ≤ (x.moveRight j).moveLeft (SetTheory.PGame.leftResponse h j)
-- SetTheory.PGame.bddAbove_range_of_small
lemma bddAbove_range_of_small {ι : Type*} [Small.{u} ι] (f : ι → PGame.{u}) :
    BddAbove (Set.range f) 
Arguments: {ι : Type u_1} [Small.{u, u_1} ι] (f : ι → SetTheory.PGame)
Goal: BddAbove (Set.range f)
-- SetTheory.PGame.bddAbove_of_small
lemma bddAbove_of_small (s : Set PGame.{u}) [Small.{u} s] : BddAbove s 
Arguments: (s : Set SetTheory.PGame) [Small.{u, u + 1} ↑s]
Goal: BddAbove s
-- SetTheory.PGame.bddBelow_range_of_small
lemma bddBelow_range_of_small {ι : Type*} [Small.{u} ι] (f : ι → PGame.{u}) :
    BddBelow (Set.range f) 
Arguments: {ι : Type u_1} [Small.{u, u_1} ι] (f : ι → SetTheory.PGame)
Goal: BddBelow (Set.range f)
-- SetTheory.PGame.bddBelow_of_small
lemma bddBelow_of_small (s : Set PGame.{u}) [Small.{u} s] : BddBelow s 
Arguments: (s : Set SetTheory.PGame) [Small.{u, u + 1} ↑s]
Goal: BddBelow s
-- SetTheory.PGame.equiv_def
theorem equiv_def {x y : PGame} : x ≈ y ↔ x ≤ y ∧ y ≤ x 
Arguments: {x y : SetTheory.PGame}
Goal: x ≈ y ↔ x ≤ y ∧ y ≤ x
-- SetTheory.PGame.Equiv.le
theorem Equiv.le {x y : PGame} (h : x ≈ y) : x ≤ y 
Arguments: {x y : SetTheory.PGame} (h : x ≈ y)
Goal: x ≤ y
-- SetTheory.PGame.Equiv.ge
theorem Equiv.ge {x y : PGame} (h : x ≈ y) : y ≤ x 
Arguments: {x y : SetTheory.PGame} (h : x ≈ y)
Goal: y ≤ x
-- SetTheory.PGame.equiv_rfl
@[refl, simp]
theorem equiv_rfl {x : PGame} : x ≈ x 
Arguments: {x : SetTheory.PGame}
Goal: x ≈ x
-- SetTheory.PGame.equiv_refl
theorem equiv_refl (x : PGame) : x ≈ x 
Arguments: (x : SetTheory.PGame)
Goal: x ≈ x
-- SetTheory.PGame.Equiv.symm
@[symm]
protected theorem Equiv.symm {x y : PGame} : (x ≈ y) → (y ≈ x) 
Arguments: {x y : SetTheory.PGame}
Goal: x ≈ y → y ≈ x
-- SetTheory.PGame.Equiv.trans
@[trans]
protected theorem Equiv.trans {x y z : PGame} : (x ≈ y) → (y ≈ z) → (x ≈ z) 
Arguments: {x y z : SetTheory.PGame}
Goal: x ≈ y → y ≈ z → x ≈ z
-- SetTheory.PGame.equiv_comm
protected theorem equiv_comm {x y : PGame} : (x ≈ y) ↔ (y ≈ x) 
Arguments: {x y : SetTheory.PGame}
Goal: x ≈ y ↔ y ≈ x
-- SetTheory.PGame.equiv_of_eq
theorem equiv_of_eq {x y : PGame} (h : x = y) : x ≈ y 
Arguments: {x y : SetTheory.PGame} (h : x = y)
Goal: x ≈ y
-- SetTheory.PGame.le_of_le_of_equiv
@[trans]
theorem le_of_le_of_equiv {x y z : PGame} (h₁ : x ≤ y) (h₂ : y ≈ z) : x ≤ z 
Arguments: {x y z : SetTheory.PGame} (h₁ : x ≤ y) (h₂ : y ≈ z)
Goal: x ≤ z
-- SetTheory.PGame.le_of_equiv_of_le
@[trans]
theorem le_of_equiv_of_le {x y z : PGame} (h₁ : x ≈ y) : y ≤ z → x ≤ z 
Arguments: {x y z : SetTheory.PGame} (h₁ : x ≈ y)
Goal: y ≤ z → x ≤ z
-- SetTheory.PGame.LF.not_equiv
theorem LF.not_equiv {x y : PGame} (h : x ⧏ y) : ¬(x ≈ y) 
Arguments: {x y : SetTheory.PGame} (h : x.LF y)
Goal: ¬x ≈ y
-- SetTheory.PGame.LF.not_equiv'
theorem LF.not_equiv' {x y : PGame} (h : x ⧏ y) : ¬(y ≈ x) 
Arguments: {x y : SetTheory.PGame} (h : x.LF y)
Goal: ¬y ≈ x
-- SetTheory.PGame.LF.not_gt
theorem LF.not_gt {x y : PGame} (h : x ⧏ y) : ¬y < x 
Arguments: {x y : SetTheory.PGame} (h : x.LF y)
Goal: ¬y < x
-- SetTheory.PGame.le_congr_imp
theorem le_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) (h : x₁ ≤ y₁) : x₂ ≤ y₂ 
Arguments: {x₁ y₁ x₂ y₂ : SetTheory.PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) (h : x₁ ≤ y₁)
Goal: x₂ ≤ y₂
-- SetTheory.PGame.le_congr
theorem le_congr {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ≤ y₁ ↔ x₂ ≤ y₂ 
Arguments: {x₁ y₁ x₂ y₂ : SetTheory.PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂)
Goal: x₁ ≤ y₁ ↔ x₂ ≤ y₂
-- SetTheory.PGame.le_congr_left
theorem le_congr_left {x₁ x₂ y : PGame} (hx : x₁ ≈ x₂) : x₁ ≤ y ↔ x₂ ≤ y 
Arguments: {x₁ x₂ y : SetTheory.PGame} (hx : x₁ ≈ x₂)
Goal: x₁ ≤ y ↔ x₂ ≤ y
-- SetTheory.PGame.le_congr_right
theorem le_congr_right {x y₁ y₂ : PGame} (hy : y₁ ≈ y₂) : x ≤ y₁ ↔ x ≤ y₂ 
Arguments: {x y₁ y₂ : SetTheory.PGame} (hy : y₁ ≈ y₂)
Goal: x ≤ y₁ ↔ x ≤ y₂
-- SetTheory.PGame.lf_congr
theorem lf_congr {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ⧏ y₁ ↔ x₂ ⧏ y₂ 
Arguments: {x₁ y₁ x₂ y₂ : SetTheory.PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂)
Goal: x₁.LF y₁ ↔ x₂.LF y₂
-- SetTheory.PGame.lf_congr_imp
theorem lf_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ⧏ y₁ → x₂ ⧏ y₂ 
Arguments: {x₁ y₁ x₂ y₂ : SetTheory.PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂)
Goal: x₁.LF y₁ → x₂.LF y₂
-- SetTheory.PGame.lf_congr_left
theorem lf_congr_left {x₁ x₂ y : PGame} (hx : x₁ ≈ x₂) : x₁ ⧏ y ↔ x₂ ⧏ y 
Arguments: {x₁ x₂ y : SetTheory.PGame} (hx : x₁ ≈ x₂)
Goal: x₁.LF y ↔ x₂.LF y
-- SetTheory.PGame.lf_congr_right
theorem lf_congr_right {x y₁ y₂ : PGame} (hy : y₁ ≈ y₂) : x ⧏ y₁ ↔ x ⧏ y₂ 
Arguments: {x y₁ y₂ : SetTheory.PGame} (hy : y₁ ≈ y₂)
Goal: x.LF y₁ ↔ x.LF y₂
-- SetTheory.PGame.lf_of_lf_of_equiv
@[trans]
theorem lf_of_lf_of_equiv {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y ≈ z) : x ⧏ z 
Arguments: {x y z : SetTheory.PGame} (h₁ : x.LF y) (h₂ : y ≈ z)
Goal: x.LF z
-- SetTheory.PGame.lf_of_equiv_of_lf
@[trans]
theorem lf_of_equiv_of_lf {x y z : PGame} (h₁ : x ≈ y) : y ⧏ z → x ⧏ z 
Arguments: {x y z : SetTheory.PGame} (h₁ : x ≈ y)
Goal: y.LF z → x.LF z
-- SetTheory.PGame.lt_of_lt_of_equiv
@[trans]
theorem lt_of_lt_of_equiv {x y z : PGame} (h₁ : x < y) (h₂ : y ≈ z) : x < z 
Arguments: {x y z : SetTheory.PGame} (h₁ : x < y) (h₂ : y ≈ z)
Goal: x < z
-- SetTheory.PGame.lt_of_equiv_of_lt
@[trans]
theorem lt_of_equiv_of_lt {x y z : PGame} (h₁ : x ≈ y) : y < z → x < z 
Arguments: {x y z : SetTheory.PGame} (h₁ : x ≈ y)
Goal: y < z → x < z
-- SetTheory.PGame.lt_congr_imp
theorem lt_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) (h : x₁ < y₁) : x₂ < y₂ 
Arguments: {x₁ y₁ x₂ y₂ : SetTheory.PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) (h : x₁ < y₁)
Goal: x₂ < y₂
-- SetTheory.PGame.lt_congr
theorem lt_congr {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ < y₁ ↔ x₂ < y₂ 
Arguments: {x₁ y₁ x₂ y₂ : SetTheory.PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂)
Goal: x₁ < y₁ ↔ x₂ < y₂
-- SetTheory.PGame.lt_congr_left
theorem lt_congr_left {x₁ x₂ y : PGame} (hx : x₁ ≈ x₂) : x₁ < y ↔ x₂ < y 
Arguments: {x₁ x₂ y : SetTheory.PGame} (hx : x₁ ≈ x₂)
Goal: x₁ < y ↔ x₂ < y
-- SetTheory.PGame.lt_congr_right
theorem lt_congr_right {x y₁ y₂ : PGame} (hy : y₁ ≈ y₂) : x < y₁ ↔ x < y₂ 
Arguments: {x y₁ y₂ : SetTheory.PGame} (hy : y₁ ≈ y₂)
Goal: x < y₁ ↔ x < y₂
-- SetTheory.PGame.lt_or_equiv_of_le
theorem lt_or_equiv_of_le {x y : PGame} (h : x ≤ y) : x < y ∨ (x ≈ y) 
Arguments: {x y : SetTheory.PGame} (h : x ≤ y)
Goal: x < y ∨ x ≈ y
-- SetTheory.PGame.lf_or_equiv_or_gf
theorem lf_or_equiv_or_gf (x y : PGame) : x ⧏ y ∨ (x ≈ y) ∨ y ⧏ x 
Arguments: (x y : SetTheory.PGame)
Goal: x.LF y ∨ x ≈ y ∨ y.LF x
-- SetTheory.PGame.equiv_congr_left
theorem equiv_congr_left {y₁ y₂ : PGame} : (y₁ ≈ y₂) ↔ ∀ x₁, (x₁ ≈ y₁) ↔ (x₁ ≈ y₂) 
Arguments: {y₁ y₂ : SetTheory.PGame}
Goal: y₁ ≈ y₂ ↔ ∀ (x₁ : SetTheory.PGame), x₁ ≈ y₁ ↔ x₁ ≈ y₂
-- SetTheory.PGame.equiv_congr_right
theorem equiv_congr_right {x₁ x₂ : PGame} : (x₁ ≈ x₂) ↔ ∀ y₁, (x₁ ≈ y₁) ↔ (x₂ ≈ y₁) 
Arguments: {x₁ x₂ : SetTheory.PGame}
Goal: x₁ ≈ x₂ ↔ ∀ (y₁ : SetTheory.PGame), x₁ ≈ y₁ ↔ x₂ ≈ y₁
-- SetTheory.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 
Arguments: {x y : SetTheory.PGame} (L : x.LeftMoves ≃ y.LeftMoves) (R : x.RightMoves ≃ y.RightMoves) (hl : ∀ (i : x.LeftMoves), x.moveLeft i ≈ y.moveLeft (L i)) (hr : ∀ (j : x.RightMoves), x.moveRight j ≈ y.moveRight (R j))
Goal: x ≈ y
-- SetTheory.PGame.Fuzzy.swap
@[symm]
theorem Fuzzy.swap {x y : PGame} : x ‖ y → y ‖ x 
Arguments: {x y : SetTheory.PGame}
Goal: x.Fuzzy y → y.Fuzzy x
-- SetTheory.PGame.Fuzzy.swap_iff
theorem Fuzzy.swap_iff {x y : PGame} : x ‖ y ↔ y ‖ x 
Arguments: {x y : SetTheory.PGame}
Goal: x.Fuzzy y ↔ y.Fuzzy x
-- SetTheory.PGame.fuzzy_irrefl
theorem fuzzy_irrefl (x : PGame) : ¬x ‖ x 
Arguments: (x : SetTheory.PGame)
Goal: ¬x.Fuzzy x
-- SetTheory.PGame.lf_iff_lt_or_fuzzy
theorem lf_iff_lt_or_fuzzy {x y : PGame} : x ⧏ y ↔ x < y ∨ x ‖ y 
Arguments: {x y : SetTheory.PGame}
Goal: x.LF y ↔ x < y ∨ x.Fuzzy y
-- SetTheory.PGame.lf_of_fuzzy
theorem lf_of_fuzzy {x y : PGame} (h : x ‖ y) : x ⧏ y 
Arguments: {x y : SetTheory.PGame} (h : x.Fuzzy y)
Goal: x.LF y
-- SetTheory.PGame.lt_or_fuzzy_of_lf
theorem lt_or_fuzzy_of_lf {x y : PGame} : x ⧏ y → x < y ∨ x ‖ y 
Arguments: {x y : SetTheory.PGame}
Goal: x.LF y → x < y ∨ x.Fuzzy y
-- SetTheory.PGame.Fuzzy.not_equiv
theorem Fuzzy.not_equiv {x y : PGame} (h : x ‖ y) : ¬(x ≈ y) 
Arguments: {x y : SetTheory.PGame} (h : x.Fuzzy y)
Goal: ¬x ≈ y
-- SetTheory.PGame.Fuzzy.not_equiv'
theorem Fuzzy.not_equiv' {x y : PGame} (h : x ‖ y) : ¬(y ≈ x) 
Arguments: {x y : SetTheory.PGame} (h : x.Fuzzy y)
Goal: ¬y ≈ x
-- SetTheory.PGame.not_fuzzy_of_le
theorem not_fuzzy_of_le {x y : PGame} (h : x ≤ y) : ¬x ‖ y 
Arguments: {x y : SetTheory.PGame} (h : x ≤ y)
Goal: ¬x.Fuzzy y
-- SetTheory.PGame.not_fuzzy_of_ge
theorem not_fuzzy_of_ge {x y : PGame} (h : y ≤ x) : ¬x ‖ y 
Arguments: {x y : SetTheory.PGame} (h : y ≤ x)
Goal: ¬x.Fuzzy y
-- SetTheory.PGame.Equiv.not_fuzzy
theorem Equiv.not_fuzzy {x y : PGame} (h : x ≈ y) : ¬x ‖ y 
Arguments: {x y : SetTheory.PGame} (h : x ≈ y)
Goal: ¬x.Fuzzy y
-- SetTheory.PGame.Equiv.not_fuzzy'
theorem Equiv.not_fuzzy' {x y : PGame} (h : x ≈ y) : ¬y ‖ x 
Arguments: {x y : SetTheory.PGame} (h : x ≈ y)
Goal: ¬y.Fuzzy x
-- SetTheory.PGame.fuzzy_congr
theorem fuzzy_congr {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ‖ y₁ ↔ x₂ ‖ y₂ 
Arguments: {x₁ y₁ x₂ y₂ : SetTheory.PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂)
Goal: x₁.Fuzzy y₁ ↔ x₂.Fuzzy y₂
-- SetTheory.PGame.fuzzy_congr_imp
theorem fuzzy_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ‖ y₁ → x₂ ‖ y₂ 
Arguments: {x₁ y₁ x₂ y₂ : SetTheory.PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂)
Goal: x₁.Fuzzy y₁ → x₂.Fuzzy y₂
-- SetTheory.PGame.fuzzy_congr_left
theorem fuzzy_congr_left {x₁ x₂ y : PGame} (hx : x₁ ≈ x₂) : x₁ ‖ y ↔ x₂ ‖ y 
Arguments: {x₁ x₂ y : SetTheory.PGame} (hx : x₁ ≈ x₂)
Goal: x₁.Fuzzy y ↔ x₂.Fuzzy y