ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- SetTheory.PGame.fuzzy_congr_right
theorem fuzzy_congr_right {x y₁ y₂ : PGame} (hy : y₁ ≈ y₂) : x ‖ y₁ ↔ x ‖ y₂ 
Arguments: {x y₁ y₂ : SetTheory.PGame} (hy : y₁ ≈ y₂)
Goal: x.Fuzzy y₁ ↔ x.Fuzzy y₂
-- SetTheory.PGame.fuzzy_of_fuzzy_of_equiv
@[trans]
theorem fuzzy_of_fuzzy_of_equiv {x y z : PGame} (h₁ : x ‖ y) (h₂ : y ≈ z) : x ‖ z 
Arguments: {x y z : SetTheory.PGame} (h₁ : x.Fuzzy y) (h₂ : y ≈ z)
Goal: x.Fuzzy z
-- SetTheory.PGame.fuzzy_of_equiv_of_fuzzy
@[trans]
theorem fuzzy_of_equiv_of_fuzzy {x y z : PGame} (h₁ : x ≈ y) (h₂ : y ‖ z) : x ‖ z 
Arguments: {x y z : SetTheory.PGame} (h₁ : x ≈ y) (h₂ : y.Fuzzy z)
Goal: x.Fuzzy z
-- SetTheory.PGame.lt_or_equiv_or_gt_or_fuzzy
theorem lt_or_equiv_or_gt_or_fuzzy (x y : PGame) : x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y 
Arguments: (x y : SetTheory.PGame)
Goal: x < y ∨ x ≈ y ∨ y < x ∨ x.Fuzzy y
-- SetTheory.PGame.lt_or_equiv_or_gf
theorem lt_or_equiv_or_gf (x y : PGame) : x < y ∨ (x ≈ y) ∨ y ⧏ x 
Arguments: (x y : SetTheory.PGame)
Goal: x < y ∨ x ≈ y ∨ y.LF x
-- SetTheory.PGame.Relabelling.mk_leftMovesEquiv
@[simp]
theorem mk_leftMovesEquiv {x y L R hL hR} : (@Relabelling.mk x y L R hL hR).leftMovesEquiv = L 
Arguments: {x y : SetTheory.PGame} {L : x.LeftMoves ≃ y.LeftMoves} {R : x.RightMoves ≃ y.RightMoves} {hL : (i : x.LeftMoves) → (x.moveLeft i).Relabelling (y.moveLeft (L i))} {hR : (j : x.RightMoves) → (x.moveRight j).Relabelling (y.moveRight (R j))}
Goal: (SetTheory.PGame.Relabelling.mk L R hL hR).leftMovesEquiv = L
-- SetTheory.PGame.Relabelling.mk'_leftMovesEquiv
@[simp]
theorem mk'_leftMovesEquiv {x y L R hL hR} :
    (@Relabelling.mk' x y L R hL hR).leftMovesEquiv = L.symm 
Arguments: {x y : SetTheory.PGame} {L : y.LeftMoves ≃ x.LeftMoves} {R : y.RightMoves ≃ x.RightMoves} {hL : (i : y.LeftMoves) → (x.moveLeft (L i)).Relabelling (y.moveLeft i)} {hR : (j : y.RightMoves) → (x.moveRight (R j)).Relabelling (y.moveRight j)}
Goal: (SetTheory.PGame.Relabelling.mk' L R hL hR).leftMovesEquiv = L.symm
-- SetTheory.PGame.Relabelling.mk_rightMovesEquiv
@[simp]
theorem mk_rightMovesEquiv {x y L R hL hR} : (@Relabelling.mk x y L R hL hR).rightMovesEquiv = R 
Arguments: {x y : SetTheory.PGame} {L : x.LeftMoves ≃ y.LeftMoves} {R : x.RightMoves ≃ y.RightMoves} {hL : (i : x.LeftMoves) → (x.moveLeft i).Relabelling (y.moveLeft (L i))} {hR : (j : x.RightMoves) → (x.moveRight j).Relabelling (y.moveRight (R j))}
Goal: (SetTheory.PGame.Relabelling.mk L R hL hR).rightMovesEquiv = R
-- SetTheory.PGame.Relabelling.mk'_rightMovesEquiv
@[simp]
theorem mk'_rightMovesEquiv {x y L R hL hR} :
    (@Relabelling.mk' x y L R hL hR).rightMovesEquiv = R.symm 
Arguments: {x y : SetTheory.PGame} {L : y.LeftMoves ≃ x.LeftMoves} {R : y.RightMoves ≃ x.RightMoves} {hL : (i : y.LeftMoves) → (x.moveLeft (L i)).Relabelling (y.moveLeft i)} {hR : (j : y.RightMoves) → (x.moveRight (R j)).Relabelling (y.moveRight j)}
Goal: (SetTheory.PGame.Relabelling.mk' L R hL hR).rightMovesEquiv = R.symm
-- SetTheory.PGame.Relabelling.le
theorem le {x y : PGame} (r : x ≡r y) : x ≤ y 
Arguments: {x y : SetTheory.PGame} (r : x.Relabelling y)
Goal: x ≤ y
-- SetTheory.PGame.Relabelling.ge
theorem ge {x y : PGame} (r : x ≡r y) : y ≤ x 
Arguments: {x y : SetTheory.PGame} (r : x.Relabelling y)
Goal: y ≤ x
-- SetTheory.PGame.Relabelling.equiv
theorem equiv (r : x ≡r y) : x ≈ y 
Arguments: {x y : SetTheory.PGame} (r : x.Relabelling y)
Goal: x ≈ y
-- SetTheory.PGame.Equiv.isEmpty
theorem Equiv.isEmpty (x : PGame) [IsEmpty x.LeftMoves] [IsEmpty x.RightMoves] : x ≈ 0 
Arguments: (x : SetTheory.PGame) [IsEmpty x.LeftMoves] [IsEmpty x.RightMoves]
Goal: x ≈ 0
-- SetTheory.PGame.relabel_moveLeft'
@[simp]
theorem relabel_moveLeft' {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
    (i : xl') : moveLeft (relabel el er) i = x.moveLeft (el i) 
Arguments: {x : SetTheory.PGame} {xl' xr' : Type u_1} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves) (i : xl')
Goal: (SetTheory.PGame.relabel el er).moveLeft i = x.moveLeft (el i)
-- SetTheory.PGame.relabel_moveLeft
theorem relabel_moveLeft {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
    (i : x.LeftMoves) : moveLeft (relabel el er) (el.symm i) = x.moveLeft i 
Arguments: {x : SetTheory.PGame} {xl' xr' : Type u_1} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves) (i : x.LeftMoves)
Goal: (SetTheory.PGame.relabel el er).moveLeft (el.symm i) = x.moveLeft i
-- SetTheory.PGame.relabel_moveRight'
@[simp]
theorem relabel_moveRight' {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
    (j : xr') : moveRight (relabel el er) j = x.moveRight (er j) 
Arguments: {x : SetTheory.PGame} {xl' xr' : Type u_1} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves) (j : xr')
Goal: (SetTheory.PGame.relabel el er).moveRight j = x.moveRight (er j)
-- SetTheory.PGame.relabel_moveRight
theorem relabel_moveRight {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
    (j : x.RightMoves) : moveRight (relabel el er) (er.symm j) = x.moveRight j 
Arguments: {x : SetTheory.PGame} {xl' xr' : Type u_1} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves) (j : x.RightMoves)
Goal: (SetTheory.PGame.relabel el er).moveRight (er.symm j) = x.moveRight j
-- SetTheory.PGame.neg_def
@[simp]
theorem neg_def {xl xr xL xR} : -mk xl xr xL xR = mk xr xl (fun j => -xR j) fun i => -xL i 
Arguments: {xl xr : Type u_1} {xL : xl → SetTheory.PGame} {xR : xr → SetTheory.PGame}
Goal: -SetTheory.PGame.mk xl xr xL xR = SetTheory.PGame.mk xr xl (fun j => -xR j) fun i => -xL i
-- SetTheory.PGame.neg_ofLists
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) 
Arguments: (L R : List SetTheory.PGame)
Goal: -SetTheory.PGame.ofLists L R = SetTheory.PGame.ofLists (List.map (fun x => -x) R) (List.map (fun x => -x) L)
-- SetTheory.PGame.isOption_neg
theorem isOption_neg {x y : PGame} : IsOption x (-y) ↔ IsOption (-x) y 
Arguments: {x y : SetTheory.PGame}
Goal: x.IsOption (-y) ↔ (-x).IsOption y
-- SetTheory.PGame.isOption_neg_neg
@[simp]
theorem isOption_neg_neg {x y : PGame} : IsOption (-x) (-y) ↔ IsOption x y 
Arguments: {x y : SetTheory.PGame}
Goal: (-x).IsOption (-y) ↔ x.IsOption y
-- SetTheory.PGame.leftMoves_neg
theorem leftMoves_neg : ∀ x : PGame, (-x).LeftMoves = x.RightMoves
  
Arguments: (x : SetTheory.PGame)
Goal: (-x).LeftMoves = x.RightMoves
-- SetTheory.PGame.rightMoves_neg
theorem rightMoves_neg : ∀ x : PGame, (-x).RightMoves = x.LeftMoves
  
Arguments: (x : SetTheory.PGame)
Goal: (-x).RightMoves = x.LeftMoves
-- SetTheory.PGame.moveLeft_neg
theorem moveLeft_neg {x : PGame} (i) : (-x).moveLeft (toLeftMovesNeg i) = -x.moveRight i 
Arguments: {x : SetTheory.PGame} (i : x.RightMoves)
Goal: (-x).moveLeft (SetTheory.PGame.toLeftMovesNeg i) = -x.moveRight i
-- SetTheory.PGame.moveLeft_neg'
@[simp]
theorem moveLeft_neg' {x : PGame} (i) : (-x).moveLeft i = -x.moveRight (toLeftMovesNeg.symm i) 
Arguments: {x : SetTheory.PGame} (i : (-x).LeftMoves)
Goal: (-x).moveLeft i = -x.moveRight (SetTheory.PGame.toLeftMovesNeg.symm i)
-- SetTheory.PGame.moveRight_neg
theorem moveRight_neg {x : PGame} (i) : (-x).moveRight (toRightMovesNeg i) = -x.moveLeft i 
Arguments: {x : SetTheory.PGame} (i : x.LeftMoves)
Goal: (-x).moveRight (SetTheory.PGame.toRightMovesNeg i) = -x.moveLeft i
-- SetTheory.PGame.moveRight_neg'
@[simp]
theorem moveRight_neg' {x : PGame} (i) :
    (-x).moveRight i = -x.moveLeft (toRightMovesNeg.symm i) 
Arguments: {x : SetTheory.PGame} (i : (-x).RightMoves)
Goal: (-x).moveRight i = -x.moveLeft (SetTheory.PGame.toRightMovesNeg.symm i)
-- SetTheory.PGame.moveLeft_neg_symm
theorem moveLeft_neg_symm {x : PGame} (i) :
    x.moveLeft (toRightMovesNeg.symm i) = -(-x).moveRight i 
Arguments: {x : SetTheory.PGame} (i : (-x).RightMoves)
Goal: x.moveLeft (SetTheory.PGame.toRightMovesNeg.symm i) = -(-x).moveRight i
-- SetTheory.PGame.moveLeft_neg_symm'
theorem moveLeft_neg_symm' {x : PGame} (i) :
    x.moveLeft i = -(-x).moveRight (toRightMovesNeg i) 
Arguments: {x : SetTheory.PGame} (i : x.LeftMoves)
Goal: x.moveLeft i = -(-x).moveRight (SetTheory.PGame.toRightMovesNeg i)
-- SetTheory.PGame.moveRight_neg_symm
theorem moveRight_neg_symm {x : PGame} (i) :
    x.moveRight (toLeftMovesNeg.symm i) = -(-x).moveLeft i 
Arguments: {x : SetTheory.PGame} (i : (-x).LeftMoves)
Goal: x.moveRight (SetTheory.PGame.toLeftMovesNeg.symm i) = -(-x).moveLeft i
-- SetTheory.PGame.moveRight_neg_symm'
theorem moveRight_neg_symm' {x : PGame} (i) :
    x.moveRight i = -(-x).moveLeft (toLeftMovesNeg i) 
Arguments: {x : SetTheory.PGame} (i : x.RightMoves)
Goal: x.moveRight i = -(-x).moveLeft (SetTheory.PGame.toLeftMovesNeg i)
-- _private.Mathlib.SetTheory.Game.PGame.0.SetTheory.PGame.neg_le_lf_neg_iff
private theorem neg_le_lf_neg_iff : ∀ {x y : PGame.{u}}, (-y ≤ -x ↔ x ≤ y) ∧ (-y ⧏ -x ↔ x ⧏ y)
  
Arguments: {x y : SetTheory.PGame}
Goal: (-y ≤ -x ↔ x ≤ y) ∧ ((-y).LF (-x) ↔ x.LF y)
-- SetTheory.PGame.neg_le_neg_iff
@[simp]
theorem neg_le_neg_iff {x y : PGame} : -y ≤ -x ↔ x ≤ y 
Arguments: {x y : SetTheory.PGame}
Goal: -y ≤ -x ↔ x ≤ y
-- SetTheory.PGame.neg_lf_neg_iff
@[simp]
theorem neg_lf_neg_iff {x y : PGame} : -y ⧏ -x ↔ x ⧏ y 
Arguments: {x y : SetTheory.PGame}
Goal: (-y).LF (-x) ↔ x.LF y
-- SetTheory.PGame.neg_lt_neg_iff
@[simp]
theorem neg_lt_neg_iff {x y : PGame} : -y < -x ↔ x < y 
Arguments: {x y : SetTheory.PGame}
Goal: -y < -x ↔ x < y
-- SetTheory.PGame.neg_equiv_neg_iff
@[simp]
theorem neg_equiv_neg_iff {x y : PGame} : (-x ≈ -y) ↔ (x ≈ y) 
Arguments: {x y : SetTheory.PGame}
Goal: -x ≈ -y ↔ x ≈ y
-- SetTheory.PGame.neg_fuzzy_neg_iff
@[simp]
theorem neg_fuzzy_neg_iff {x y : PGame} : -x ‖ -y ↔ x ‖ y 
Arguments: {x y : SetTheory.PGame}
Goal: (-x).Fuzzy (-y) ↔ x.Fuzzy y
-- SetTheory.PGame.neg_le_iff
theorem neg_le_iff {x y : PGame} : -y ≤ x ↔ -x ≤ y 
Arguments: {x y : SetTheory.PGame}
Goal: -y ≤ x ↔ -x ≤ y
-- SetTheory.PGame.neg_lf_iff
theorem neg_lf_iff {x y : PGame} : -y ⧏ x ↔ -x ⧏ y 
Arguments: {x y : SetTheory.PGame}
Goal: (-y).LF x ↔ (-x).LF y
-- SetTheory.PGame.neg_lt_iff
theorem neg_lt_iff {x y : PGame} : -y < x ↔ -x < y 
Arguments: {x y : SetTheory.PGame}
Goal: -y < x ↔ -x < y
-- SetTheory.PGame.neg_equiv_iff
theorem neg_equiv_iff {x y : PGame} : (-x ≈ y) ↔ (x ≈ -y) 
Arguments: {x y : SetTheory.PGame}
Goal: -x ≈ y ↔ x ≈ -y
-- SetTheory.PGame.neg_fuzzy_iff
theorem neg_fuzzy_iff {x y : PGame} : -x ‖ y ↔ x ‖ -y 
Arguments: {x y : SetTheory.PGame}
Goal: (-x).Fuzzy y ↔ x.Fuzzy (-y)
-- SetTheory.PGame.le_neg_iff
theorem le_neg_iff {x y : PGame} : y ≤ -x ↔ x ≤ -y 
Arguments: {x y : SetTheory.PGame}
Goal: y ≤ -x ↔ x ≤ -y
-- SetTheory.PGame.lf_neg_iff
theorem lf_neg_iff {x y : PGame} : y ⧏ -x ↔ x ⧏ -y 
Arguments: {x y : SetTheory.PGame}
Goal: y.LF (-x) ↔ x.LF (-y)
-- SetTheory.PGame.lt_neg_iff
theorem lt_neg_iff {x y : PGame} : y < -x ↔ x < -y 
Arguments: {x y : SetTheory.PGame}
Goal: y < -x ↔ x < -y
-- SetTheory.PGame.neg_le_zero_iff
@[simp]
theorem neg_le_zero_iff {x : PGame} : -x ≤ 0 ↔ 0 ≤ x 
Arguments: {x : SetTheory.PGame}
Goal: -x ≤ 0 ↔ 0 ≤ x
-- SetTheory.PGame.zero_le_neg_iff
@[simp]
theorem zero_le_neg_iff {x : PGame} : 0 ≤ -x ↔ x ≤ 0 
Arguments: {x : SetTheory.PGame}
Goal: 0 ≤ -x ↔ x ≤ 0
-- SetTheory.PGame.neg_lf_zero_iff
@[simp]
theorem neg_lf_zero_iff {x : PGame} : -x ⧏ 0 ↔ 0 ⧏ x 
Arguments: {x : SetTheory.PGame}
Goal: (-x).LF 0 ↔ SetTheory.PGame.LF 0 x
-- SetTheory.PGame.zero_lf_neg_iff
@[simp]
theorem zero_lf_neg_iff {x : PGame} : 0 ⧏ -x ↔ x ⧏ 0 
Arguments: {x : SetTheory.PGame}
Goal: SetTheory.PGame.LF 0 (-x) ↔ x.LF 0
-- SetTheory.PGame.neg_lt_zero_iff
@[simp]
theorem neg_lt_zero_iff {x : PGame} : -x < 0 ↔ 0 < x 
Arguments: {x : SetTheory.PGame}
Goal: -x < 0 ↔ 0 < x
-- SetTheory.PGame.zero_lt_neg_iff
@[simp]
theorem zero_lt_neg_iff {x : PGame} : 0 < -x ↔ x < 0 
Arguments: {x : SetTheory.PGame}
Goal: 0 < -x ↔ x < 0
-- SetTheory.PGame.neg_equiv_zero_iff
@[simp]
theorem neg_equiv_zero_iff {x : PGame} : (-x ≈ 0) ↔ (x ≈ 0) 
Arguments: {x : SetTheory.PGame}
Goal: -x ≈ 0 ↔ x ≈ 0
-- SetTheory.PGame.neg_fuzzy_zero_iff
@[simp]
theorem neg_fuzzy_zero_iff {x : PGame} : -x ‖ 0 ↔ x ‖ 0 
Arguments: {x : SetTheory.PGame}
Goal: (-x).Fuzzy 0 ↔ x.Fuzzy 0
-- SetTheory.PGame.zero_equiv_neg_iff
@[simp]
theorem zero_equiv_neg_iff {x : PGame} : (0 ≈ -x) ↔ (0 ≈ x) 
Arguments: {x : SetTheory.PGame}
Goal: 0 ≈ -x ↔ 0 ≈ x
-- SetTheory.PGame.zero_fuzzy_neg_iff
@[simp]
theorem zero_fuzzy_neg_iff {x : PGame} : 0 ‖ -x ↔ 0 ‖ x 
Arguments: {x : SetTheory.PGame}
Goal: SetTheory.PGame.Fuzzy 0 (-x) ↔ SetTheory.PGame.Fuzzy 0 x
-- SetTheory.PGame.nat_succ
@[simp]
protected theorem nat_succ (n : ℕ) : ((n + 1 : ℕ) : PGame) = n + 1 
Arguments: (n : ℕ)
Goal: ↑(n + 1) = ↑n + 1
-- SetTheory.PGame.add_zero_equiv
theorem add_zero_equiv (x : PGame.{u}) : x + 0 ≈ x 
Arguments: (x : SetTheory.PGame)
Goal: x + 0 ≈ x
-- SetTheory.PGame.zero_add_equiv
theorem zero_add_equiv (x : PGame.{u}) : 0 + x ≈ x 
Arguments: (x : SetTheory.PGame)
Goal: 0 + x ≈ x
-- SetTheory.PGame.leftMoves_add
theorem leftMoves_add : ∀ x y : PGame.{u}, (x + y).LeftMoves = (x.LeftMoves ⊕ y.LeftMoves)
  
Arguments: (x y : SetTheory.PGame)
Goal: (x + y).LeftMoves = (x.LeftMoves ⊕ y.LeftMoves)
-- SetTheory.PGame.rightMoves_add
theorem rightMoves_add : ∀ x y : PGame.{u}, (x + y).RightMoves = (x.RightMoves ⊕ y.RightMoves)
  
Arguments: (x y : SetTheory.PGame)
Goal: (x + y).RightMoves = (x.RightMoves ⊕ y.RightMoves)
-- SetTheory.PGame.mk_add_moveLeft_inl
@[simp]
theorem mk_add_moveLeft_inl {xl xr yl yr} {xL xR yL yR} {i} :
    (mk xl xr xL xR + mk yl yr yL yR).moveLeft (Sum.inl i) =
      (mk xl xr xL xR).moveLeft i + mk yl yr yL yR 
Arguments: {xl xr yl yr : Type u_1} {xL : xl → SetTheory.PGame} {xR : xr → SetTheory.PGame} {yL : yl → SetTheory.PGame} {yR : yr → SetTheory.PGame} {i : xl}
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
-- SetTheory.PGame.add_moveLeft_inl
@[simp]
theorem add_moveLeft_inl {x : PGame} (y : PGame) (i) :
    (x + y).moveLeft (toLeftMovesAdd (Sum.inl i)) = x.moveLeft i + y 
Arguments: {x : SetTheory.PGame} (y : SetTheory.PGame) (i : x.LeftMoves)
Goal: (x + y).moveLeft (SetTheory.PGame.toLeftMovesAdd (Sum.inl i)) = x.moveLeft i + y
-- SetTheory.PGame.mk_add_moveRight_inl
@[simp]
theorem mk_add_moveRight_inl {xl xr yl yr} {xL xR yL yR} {i} :
    (mk xl xr xL xR + mk yl yr yL yR).moveRight (Sum.inl i) =
      (mk xl xr xL xR).moveRight i + mk yl yr yL yR 
Arguments: {xl xr yl yr : Type u_1} {xL : xl → SetTheory.PGame} {xR : xr → SetTheory.PGame} {yL : yl → SetTheory.PGame} {yR : yr → SetTheory.PGame} {i : xr}
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
-- SetTheory.PGame.add_moveRight_inl
@[simp]
theorem add_moveRight_inl {x : PGame} (y : PGame) (i) :
    (x + y).moveRight (toRightMovesAdd (Sum.inl i)) = x.moveRight i + y 
Arguments: {x : SetTheory.PGame} (y : SetTheory.PGame) (i : x.RightMoves)
Goal: (x + y).moveRight (SetTheory.PGame.toRightMovesAdd (Sum.inl i)) = x.moveRight i + y
-- SetTheory.PGame.mk_add_moveLeft_inr
@[simp]
theorem mk_add_moveLeft_inr {xl xr yl yr} {xL xR yL yR} {i} :
    (mk xl xr xL xR + mk yl yr yL yR).moveLeft (Sum.inr i) =
      mk xl xr xL xR + (mk yl yr yL yR).moveLeft i 
Arguments: {xl xr yl yr : Type u_1} {xL : xl → SetTheory.PGame} {xR : xr → SetTheory.PGame} {yL : yl → SetTheory.PGame} {yR : yr → SetTheory.PGame} {i : yl}
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
-- SetTheory.PGame.add_moveLeft_inr
@[simp]
theorem add_moveLeft_inr (x : PGame) {y : PGame} (i) :
    (x + y).moveLeft (toLeftMovesAdd (Sum.inr i)) = x + y.moveLeft i 
Arguments: (x : SetTheory.PGame) {y : SetTheory.PGame} (i : y.LeftMoves)
Goal: (x + y).moveLeft (SetTheory.PGame.toLeftMovesAdd (Sum.inr i)) = x + y.moveLeft i
-- SetTheory.PGame.mk_add_moveRight_inr
@[simp]
theorem mk_add_moveRight_inr {xl xr yl yr} {xL xR yL yR} {i} :
    (mk xl xr xL xR + mk yl yr yL yR).moveRight (Sum.inr i) =
      mk xl xr xL xR + (mk yl yr yL yR).moveRight i 
Arguments: {xl xr yl yr : Type u_1} {xL : xl → SetTheory.PGame} {xR : xr → SetTheory.PGame} {yL : yl → SetTheory.PGame} {yR : yr → SetTheory.PGame} {i : yr}
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
-- SetTheory.PGame.add_moveRight_inr
@[simp]
theorem add_moveRight_inr (x : PGame) {y : PGame} (i) :
    (x + y).moveRight (toRightMovesAdd (Sum.inr i)) = x + y.moveRight i 
Arguments: (x : SetTheory.PGame) {y : SetTheory.PGame} (i : y.RightMoves)
Goal: (x + y).moveRight (SetTheory.PGame.toRightMovesAdd (Sum.inr i)) = x + y.moveRight i
-- SetTheory.PGame.leftMoves_add_cases
theorem leftMoves_add_cases {x y : PGame} (k) {P : (x + y).LeftMoves → Prop}
    (hl : ∀ i, P <| toLeftMovesAdd (Sum.inl i)) (hr : ∀ i, P <| toLeftMovesAdd (Sum.inr i)) :
    P k 
Arguments: {x y : SetTheory.PGame} (k : (x + y).LeftMoves) {P : (x + y).LeftMoves → Prop} (hl : ∀ (i : x.LeftMoves), P (SetTheory.PGame.toLeftMovesAdd (Sum.inl i))) (hr : ∀ (i : y.LeftMoves), P (SetTheory.PGame.toLeftMovesAdd (Sum.inr i)))
Goal: P k
-- SetTheory.PGame.rightMoves_add_cases
theorem rightMoves_add_cases {x y : PGame} (k) {P : (x + y).RightMoves → Prop}
    (hl : ∀ j, P <| toRightMovesAdd (Sum.inl j)) (hr : ∀ j, P <| toRightMovesAdd (Sum.inr j)) :
    P k 
Arguments: {x y : SetTheory.PGame} (k : (x + y).RightMoves) {P : (x + y).RightMoves → Prop} (hl : ∀ (j : x.RightMoves), P (SetTheory.PGame.toRightMovesAdd (Sum.inl j))) (hr : ∀ (j : y.RightMoves), P (SetTheory.PGame.toRightMovesAdd (Sum.inr j)))
Goal: P k
-- SetTheory.PGame.sub_zero
@[simp]
theorem sub_zero (x : PGame) : x - 0 = x + 0 
Arguments: (x : SetTheory.PGame)
Goal: x - 0 = x + 0
-- SetTheory.PGame.neg_add_le
theorem neg_add_le {x y : PGame} : -(x + y) ≤ -x + -y 
Arguments: {x y : SetTheory.PGame}
Goal: -(x + y) ≤ -x + -y
-- SetTheory.PGame.add_comm_le
theorem add_comm_le {x y : PGame} : x + y ≤ y + x 
Arguments: {x y : SetTheory.PGame}
Goal: x + y ≤ y + x
-- SetTheory.PGame.add_comm_equiv
theorem add_comm_equiv {x y : PGame} : x + y ≈ y + x 
Arguments: {x y : SetTheory.PGame}
Goal: x + y ≈ y + x
-- SetTheory.PGame.add_assoc_equiv
theorem add_assoc_equiv {x y z : PGame} : x + y + z ≈ x + (y + z) 
Arguments: {x y z : SetTheory.PGame}
Goal: x + y + z ≈ x + (y + z)
-- SetTheory.PGame.add_left_neg_le_zero
theorem add_left_neg_le_zero : ∀ x : PGame, -x + x ≤ 0
  
Arguments: (x : SetTheory.PGame)
Goal: -x + x ≤ 0
-- SetTheory.PGame.zero_le_add_left_neg
theorem zero_le_add_left_neg (x : PGame) : 0 ≤ -x + x 
Arguments: (x : SetTheory.PGame)
Goal: 0 ≤ -x + x
-- SetTheory.PGame.add_left_neg_equiv
theorem add_left_neg_equiv (x : PGame) : -x + x ≈ 0 
Arguments: (x : SetTheory.PGame)
Goal: -x + x ≈ 0
-- SetTheory.PGame.add_right_neg_le_zero
theorem add_right_neg_le_zero (x : PGame) : x + -x ≤ 0 
Arguments: (x : SetTheory.PGame)
Goal: x + -x ≤ 0
-- SetTheory.PGame.zero_le_add_right_neg
theorem zero_le_add_right_neg (x : PGame) : 0 ≤ x + -x 
Arguments: (x : SetTheory.PGame)
Goal: 0 ≤ x + -x
-- SetTheory.PGame.add_right_neg_equiv
theorem add_right_neg_equiv (x : PGame) : x + -x ≈ 0 
Arguments: (x : SetTheory.PGame)
Goal: x + -x ≈ 0
-- SetTheory.PGame.sub_self_equiv
theorem sub_self_equiv : ∀ (x : PGame), x - x ≈ 0 
Arguments: (x : SetTheory.PGame)
Goal: x - x ≈ 0
-- _private.Mathlib.SetTheory.Game.PGame.0.SetTheory.PGame.add_le_add_right'
private theorem add_le_add_right' : ∀ {x y z : PGame}, x ≤ y → x + z ≤ y + z
  
Arguments: {x y z : SetTheory.PGame}
Goal: x ≤ y → x + z ≤ y + z
-- SetTheory.PGame.add_lf_add_right
theorem add_lf_add_right {y z : PGame} (h : y ⧏ z) (x) : y + x ⧏ z + x 
Arguments: {y z : SetTheory.PGame} (h : y.LF z) (x : SetTheory.PGame)
Goal: (y + x).LF (z + x)
-- SetTheory.PGame.add_lf_add_left
theorem add_lf_add_left {y z : PGame} (h : y ⧏ z) (x) : x + y ⧏ x + z 
Arguments: {y z : SetTheory.PGame} (h : y.LF z) (x : SetTheory.PGame)
Goal: (x + y).LF (x + z)
-- SetTheory.PGame.add_lf_add_of_lf_of_le
theorem add_lf_add_of_lf_of_le {w x y z : PGame} (hwx : w ⧏ x) (hyz : y ≤ z) : w + y ⧏ x + z 
Arguments: {w x y z : SetTheory.PGame} (hwx : w.LF x) (hyz : y ≤ z)
Goal: (w + y).LF (x + z)
-- SetTheory.PGame.add_lf_add_of_le_of_lf
theorem add_lf_add_of_le_of_lf {w x y z : PGame} (hwx : w ≤ x) (hyz : y ⧏ z) : w + y ⧏ x + z 
Arguments: {w x y z : SetTheory.PGame} (hwx : w ≤ x) (hyz : y.LF z)
Goal: (w + y).LF (x + z)
-- SetTheory.PGame.add_congr
theorem add_congr {w x y z : PGame} (h₁ : w ≈ x) (h₂ : y ≈ z) : w + y ≈ x + z 
Arguments: {w x y z : SetTheory.PGame} (h₁ : w ≈ x) (h₂ : y ≈ z)
Goal: w + y ≈ x + z
-- SetTheory.PGame.add_congr_left
theorem add_congr_left {x y z : PGame} (h : x ≈ y) : x + z ≈ y + z 
Arguments: {x y z : SetTheory.PGame} (h : x ≈ y)
Goal: x + z ≈ y + z
-- SetTheory.PGame.add_congr_right
theorem add_congr_right {x y z : PGame} : (y ≈ z) → (x + y ≈ x + z) 
Arguments: {x y z : SetTheory.PGame}
Goal: y ≈ z → x + y ≈ x + z
-- SetTheory.PGame.sub_congr
theorem sub_congr {w x y z : PGame} (h₁ : w ≈ x) (h₂ : y ≈ z) : w - y ≈ x - z 
Arguments: {w x y z : SetTheory.PGame} (h₁ : w ≈ x) (h₂ : y ≈ z)
Goal: w - y ≈ x - z
-- SetTheory.PGame.sub_congr_left
theorem sub_congr_left {x y z : PGame} (h : x ≈ y) : x - z ≈ y - z 
Arguments: {x y z : SetTheory.PGame} (h : x ≈ y)
Goal: x - z ≈ y - z
-- SetTheory.PGame.sub_congr_right
theorem sub_congr_right {x y z : PGame} : (y ≈ z) → (x - y ≈ x - z) 
Arguments: {x y z : SetTheory.PGame}
Goal: y ≈ z → x - y ≈ x - z
-- SetTheory.PGame.le_iff_sub_nonneg
theorem le_iff_sub_nonneg {x y : PGame} : x ≤ y ↔ 0 ≤ y - x 
Arguments: {x y : SetTheory.PGame}
Goal: x ≤ y ↔ 0 ≤ y - x
-- SetTheory.PGame.lf_iff_sub_zero_lf
theorem lf_iff_sub_zero_lf {x y : PGame} : x ⧏ y ↔ 0 ⧏ y - x 
Arguments: {x y : SetTheory.PGame}
Goal: x.LF y ↔ SetTheory.PGame.LF 0 (y - x)
-- SetTheory.PGame.lt_iff_sub_pos
theorem lt_iff_sub_pos {x y : PGame} : x < y ↔ 0 < y - x 
Arguments: {x y : SetTheory.PGame}
Goal: x < y ↔ 0 < y - x
-- SetTheory.PGame.le_insertLeft
lemma le_insertLeft (x x' : PGame) : x ≤ insertLeft x x' 
Arguments: (x x' : SetTheory.PGame)
Goal: x ≤ x.insertLeft x'
-- SetTheory.PGame.insertLeft_equiv_of_lf
lemma insertLeft_equiv_of_lf {x x' : PGame} (h : x' ⧏ x) : insertLeft x x' ≈ x 
Arguments: {x x' : SetTheory.PGame} (h : x'.LF x)
Goal: x.insertLeft x' ≈ x
-- SetTheory.PGame.neg_insertRight_neg
theorem neg_insertRight_neg (x x' : PGame.{u}) : (-x).insertRight (-x') = -x.insertLeft x' 
Arguments: (x x' : SetTheory.PGame)
Goal: (-x).insertRight (-x') = -x.insertLeft x'
-- SetTheory.PGame.neg_insertLeft_neg
theorem neg_insertLeft_neg (x x' : PGame.{u}) : (-x).insertLeft (-x') = -x.insertRight x' 
Arguments: (x x' : SetTheory.PGame)
Goal: (-x).insertLeft (-x') = -x.insertRight x'
-- SetTheory.PGame.insertRight_le
lemma insertRight_le (x x' : PGame) : insertRight x x' ≤ x 
Arguments: (x x' : SetTheory.PGame)
Goal: x.insertRight x' ≤ x
-- SetTheory.PGame.insertRight_equiv_of_lf
lemma insertRight_equiv_of_lf {x x' : PGame} (h : x ⧏ x') : insertRight x x' ≈ x 
Arguments: {x x' : SetTheory.PGame} (h : x.LF x')
Goal: x.insertRight x' ≈ x
-- SetTheory.PGame.insertRight_insertLeft
theorem insertRight_insertLeft {x x' x'' : PGame} :
    insertRight (insertLeft x x') x'' = insertLeft (insertRight x x'') x' 
Arguments: {x x' x'' : SetTheory.PGame}
Goal: (x.insertLeft x').insertRight x'' = (x.insertRight x'').insertLeft x'
-- SetTheory.PGame.star_leftMoves
@[simp]
theorem star_leftMoves : star.LeftMoves = PUnit 
Goal: SetTheory.PGame.star.LeftMoves = PUnit.{u_1 + 1}
-- SetTheory.PGame.star_rightMoves
@[simp]
theorem star_rightMoves : star.RightMoves = PUnit 
Goal: SetTheory.PGame.star.RightMoves = PUnit.{u_1 + 1}
-- SetTheory.PGame.star_moveLeft
@[simp]
theorem star_moveLeft (x) : star.moveLeft x = 0 
Arguments: (x : SetTheory.PGame.star.LeftMoves)
Goal: SetTheory.PGame.star.moveLeft x = 0
-- SetTheory.PGame.star_moveRight
@[simp]
theorem star_moveRight (x) : star.moveRight x = 0 
Arguments: (x : SetTheory.PGame.star.RightMoves)
Goal: SetTheory.PGame.star.moveRight x = 0
-- SetTheory.PGame.star_fuzzy_zero
theorem star_fuzzy_zero : star ‖ 0 
Goal: SetTheory.PGame.star.Fuzzy 0