ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.MonoidalCoherence.right'_hom
@[simps]
instance right' (X Y : C) [MonoidalCoherence X Y] :
    MonoidalCoherence X (Y ⊗ 𝟙_ C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] (X Y : C) [CategoryTheory.MonoidalCoherence X Y]
Goal:  ⊗𝟙 = ⊗𝟙 ≫ (ρ_ Y).inv
-- CategoryTheory.MonoidalCoherence.assoc_hom
@[simps]
instance assoc (X Y Z W : C) [MonoidalCoherence (X ⊗ (Y ⊗ Z)) W] :
    MonoidalCoherence ((X ⊗ Y) ⊗ Z) W 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] (X Y Z W : C) [CategoryTheory.MonoidalCoherence (X ⊗ Y ⊗ Z) W]
Goal:  ⊗𝟙 = (α_ X Y Z).hom ≫ ⊗𝟙
-- CategoryTheory.MonoidalCoherence.assoc'_hom
@[simps]
instance assoc' (W X Y Z : C) [MonoidalCoherence W (X ⊗ (Y ⊗ Z))] :
    MonoidalCoherence W ((X ⊗ Y) ⊗ Z) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] (W X Y Z : C) [CategoryTheory.MonoidalCoherence W (X ⊗ Y ⊗ Z)]
Goal:  ⊗𝟙 = ⊗𝟙 ≫ (α_ X Y Z).inv
-- CategoryTheory.monoidalComp_refl
@[simp] lemma monoidalComp_refl {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) :
    f ⊗≫ g = f ≫ g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: f ⊗≫ g = f ≫ g
-- Mathlib.Tactic.Coherence.assoc_liftHom
-- We have unused typeclass arguments here.
-- They are intentional, to ensure that `simp only [assoc_LiftHom]` only left associates
-- monoidal structural morphisms.
@[nolint unusedArguments]
lemma assoc_liftHom {W X Y Z : C} [LiftObj W] [LiftObj X] [LiftObj Y]
    (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z) [LiftHom f] [LiftHom g] :
    f ≫ (g ≫ h) = (f ≫ g) ≫ h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} [Mathlib.Tactic.Coherence.LiftObj W] [Mathlib.Tactic.Coherence.LiftObj X] [Mathlib.Tactic.Coherence.LiftObj Y] (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z) [Mathlib.Tactic.Coherence.LiftHom f] [Mathlib.Tactic.Coherence.LiftHom g]
Goal: f ≫ g ≫ h = (f ≫ g) ≫ h
-- Mathlib.Tactic.Coherence.insert_id_lhs
lemma insert_id_lhs {C : Type*} [Category C] {X Y : C} (f g : X ⟶ Y) (w : f ≫ 𝟙 _ = g) :
    f = g 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} (f g : X ⟶ Y) (w : f ≫ 𝟙 Y = g)
Goal: f = g
-- Mathlib.Tactic.Coherence.insert_id_rhs
lemma insert_id_rhs {C : Type*} [Category C] {X Y : C} (f g : X ⟶ Y) (w : f = g ≫ 𝟙 _) :
    f = g 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} (f g : X ⟶ Y) (w : f = g ≫ 𝟙 Y)
Goal: f = g
-- SetTheory.Game.not_le
@[simp]
theorem not_le : ∀ {x y : Game}, ¬x ≤ y ↔ y ⧏ x 
Arguments: {x y : SetTheory.Game}
Goal: ¬x ≤ y ↔ y.LF x
-- SetTheory.Game.not_lf
@[simp]
theorem not_lf : ∀ {x y : Game}, ¬x ⧏ y ↔ y ≤ x 
Arguments: {x y : SetTheory.Game}
Goal: ¬x.LF y ↔ y ≤ x
-- SetTheory.Game.PGame.le_iff_game_le
theorem PGame.le_iff_game_le {x y : PGame} : x ≤ y ↔ (⟦x⟧ : Game) ≤ ⟦y⟧ 
Arguments: {x y : SetTheory.PGame}
Goal: x ≤ y ↔ ⟦x⟧ ≤ ⟦y⟧
-- SetTheory.Game.PGame.lf_iff_game_lf
theorem PGame.lf_iff_game_lf {x y : PGame} : PGame.LF x y ↔ ⟦x⟧ ⧏ ⟦y⟧ 
Arguments: {x y : SetTheory.PGame}
Goal: x.LF y ↔ SetTheory.Game.LF ⟦x⟧ ⟦y⟧
-- SetTheory.Game.PGame.lt_iff_game_lt
theorem PGame.lt_iff_game_lt {x y : PGame} : x < y ↔ (⟦x⟧ : Game) < ⟦y⟧ 
Arguments: {x y : SetTheory.PGame}
Goal: x < y ↔ ⟦x⟧ < ⟦y⟧
-- SetTheory.Game.PGame.equiv_iff_game_eq
theorem PGame.equiv_iff_game_eq {x y : PGame} : x ≈ y ↔ (⟦x⟧ : Game) = ⟦y⟧ 
Arguments: {x y : SetTheory.PGame}
Goal: x ≈ y ↔ ⟦x⟧ = ⟦y⟧
-- SetTheory.Game.PGame.fuzzy_iff_game_fuzzy
theorem PGame.fuzzy_iff_game_fuzzy {x y : PGame} : PGame.Fuzzy x y ↔ ⟦x⟧ ‖ ⟦y⟧ 
Arguments: {x y : SetTheory.PGame}
Goal: x.Fuzzy y ↔ SetTheory.Game.Fuzzy ⟦x⟧ ⟦y⟧
-- SetTheory.Game.add_lf_add_right
theorem add_lf_add_right : ∀ {b c : Game} (_ : b ⧏ c) (a), (b + a : Game) ⧏ c + a 
Arguments: {b c : SetTheory.Game}
Goal: b.LF c → ∀ (a : SetTheory.Game), (b + a).LF (c + a)
-- SetTheory.Game.add_lf_add_left
theorem add_lf_add_left : ∀ {b c : Game} (_ : b ⧏ c) (a), (a + b : Game) ⧏ a + c 
Arguments: {b c : SetTheory.Game}
Goal: b.LF c → ∀ (a : SetTheory.Game), (a + b).LF (a + c)
-- SetTheory.Game.bddAbove_range_of_small
lemma bddAbove_range_of_small {ι : Type*} [Small.{u} ι] (f : ι → Game.{u}) :
    BddAbove (Set.range f) 
Arguments: {ι : Type u_1} [Small.{u, u_1} ι] (f : ι → SetTheory.Game)
Goal: BddAbove (Set.range f)
-- SetTheory.Game.bddAbove_of_small
lemma bddAbove_of_small (s : Set Game.{u}) [Small.{u} s] : BddAbove s 
Arguments: (s : Set SetTheory.Game) [Small.{u, u + 1} ↑s]
Goal: BddAbove s
-- SetTheory.Game.bddBelow_range_of_small
lemma bddBelow_range_of_small {ι : Type*} [Small.{u} ι] (f : ι → Game.{u}) :
    BddBelow (Set.range f) 
Arguments: {ι : Type u_1} [Small.{u, u_1} ι] (f : ι → SetTheory.Game)
Goal: BddBelow (Set.range f)
-- SetTheory.Game.bddBelow_of_small
lemma bddBelow_of_small (s : Set Game.{u}) [Small.{u} s] : BddBelow s 
Arguments: (s : Set SetTheory.Game) [Small.{u, u + 1} ↑s]
Goal: BddBelow s
-- SetTheory.PGame.quot_neg
@[simp]
theorem quot_neg (a : PGame) : (⟦-a⟧ : Game) = -⟦a⟧ 
Arguments: (a : SetTheory.PGame)
Goal: ⟦-a⟧ = -⟦a⟧
-- SetTheory.PGame.quot_add
@[simp]
theorem quot_add (a b : PGame) : ⟦a + b⟧ = (⟦a⟧ : Game) + ⟦b⟧ 
Arguments: (a b : SetTheory.PGame)
Goal: ⟦a + b⟧ = ⟦a⟧ + ⟦b⟧
-- SetTheory.PGame.quot_sub
@[simp]
theorem quot_sub (a b : PGame) : ⟦a - b⟧ = (⟦a⟧ : Game) - ⟦b⟧ 
Arguments: (a b : SetTheory.PGame)
Goal: ⟦a - b⟧ = ⟦a⟧ - ⟦b⟧
-- SetTheory.PGame.quot_eq_of_mk'_quot_eq
theorem quot_eq_of_mk'_quot_eq {x y : PGame} (L : x.LeftMoves ≃ y.LeftMoves)
    (R : x.RightMoves ≃ y.RightMoves) (hl : ∀ i, (⟦x.moveLeft i⟧ : Game) = ⟦y.moveLeft (L i)⟧)
    (hr : ∀ j, (⟦x.moveRight j⟧ : Game) = ⟦y.moveRight (R j)⟧) : (⟦x⟧ : Game) = ⟦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.leftMoves_mul
theorem leftMoves_mul :
    ∀ x y : PGame.{u},
      (x * y).LeftMoves = (x.LeftMoves × y.LeftMoves ⊕ x.RightMoves × y.RightMoves)
  
Arguments: (x y : SetTheory.PGame)
Goal: (x * y).LeftMoves = (x.LeftMoves × y.LeftMoves ⊕ x.RightMoves × y.RightMoves)
-- SetTheory.PGame.rightMoves_mul
theorem rightMoves_mul :
    ∀ x y : PGame.{u},
      (x * y).RightMoves = (x.LeftMoves × y.RightMoves ⊕ x.RightMoves × y.LeftMoves)
  
Arguments: (x y : SetTheory.PGame)
Goal: (x * y).RightMoves = (x.LeftMoves × y.RightMoves ⊕ x.RightMoves × y.LeftMoves)
-- SetTheory.PGame.mk_mul_moveLeft_inl
@[simp]
theorem mk_mul_moveLeft_inl {xl xr yl yr} {xL xR yL yR} {i j} :
    (mk xl xr xL xR * mk yl yr yL yR).moveLeft (Sum.inl (i, j)) =
      xL i * mk yl yr yL yR + mk xl xr xL xR * yL j - xL i * yL j 
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} {j : yl}
Goal: (SetTheory.PGame.mk xl xr xL xR * SetTheory.PGame.mk yl yr yL yR).moveLeft (Sum.inl (i, j)) =
  xL i * SetTheory.PGame.mk yl yr yL yR + SetTheory.PGame.mk xl xr xL xR * yL j - xL i * yL j
-- SetTheory.PGame.mul_moveLeft_inl
@[simp]
theorem mul_moveLeft_inl {x y : PGame} {i j} :
    (x * y).moveLeft (toLeftMovesMul (Sum.inl (i, j))) =
      x.moveLeft i * y + x * y.moveLeft j - x.moveLeft i * y.moveLeft j 
Arguments: {x y : SetTheory.PGame} {i : x.LeftMoves} {j : y.LeftMoves}
Goal: (x * y).moveLeft (SetTheory.PGame.toLeftMovesMul (Sum.inl (i, j))) =
  x.moveLeft i * y + x * y.moveLeft j - x.moveLeft i * y.moveLeft j
-- SetTheory.PGame.mk_mul_moveLeft_inr
@[simp]
theorem mk_mul_moveLeft_inr {xl xr yl yr} {xL xR yL yR} {i j} :
    (mk xl xr xL xR * mk yl yr yL yR).moveLeft (Sum.inr (i, j)) =
      xR i * mk yl yr yL yR + mk xl xr xL xR * yR j - xR i * yR j 
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} {j : yr}
Goal: (SetTheory.PGame.mk xl xr xL xR * SetTheory.PGame.mk yl yr yL yR).moveLeft (Sum.inr (i, j)) =
  xR i * SetTheory.PGame.mk yl yr yL yR + SetTheory.PGame.mk xl xr xL xR * yR j - xR i * yR j
-- SetTheory.PGame.mul_moveLeft_inr
@[simp]
theorem mul_moveLeft_inr {x y : PGame} {i j} :
    (x * y).moveLeft (toLeftMovesMul (Sum.inr (i, j))) =
      x.moveRight i * y + x * y.moveRight j - x.moveRight i * y.moveRight j 
Arguments: {x y : SetTheory.PGame} {i : x.RightMoves} {j : y.RightMoves}
Goal: (x * y).moveLeft (SetTheory.PGame.toLeftMovesMul (Sum.inr (i, j))) =
  x.moveRight i * y + x * y.moveRight j - x.moveRight i * y.moveRight j
-- SetTheory.PGame.mk_mul_moveRight_inl
@[simp]
theorem mk_mul_moveRight_inl {xl xr yl yr} {xL xR yL yR} {i j} :
    (mk xl xr xL xR * mk yl yr yL yR).moveRight (Sum.inl (i, j)) =
      xL i * mk yl yr yL yR + mk xl xr xL xR * yR j - xL i * yR j 
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} {j : yr}
Goal: (SetTheory.PGame.mk xl xr xL xR * SetTheory.PGame.mk yl yr yL yR).moveRight (Sum.inl (i, j)) =
  xL i * SetTheory.PGame.mk yl yr yL yR + SetTheory.PGame.mk xl xr xL xR * yR j - xL i * yR j
-- SetTheory.PGame.mul_moveRight_inl
@[simp]
theorem mul_moveRight_inl {x y : PGame} {i j} :
    (x * y).moveRight (toRightMovesMul (Sum.inl (i, j))) =
      x.moveLeft i * y + x * y.moveRight j - x.moveLeft i * y.moveRight j 
Arguments: {x y : SetTheory.PGame} {i : x.LeftMoves} {j : y.RightMoves}
Goal: (x * y).moveRight (SetTheory.PGame.toRightMovesMul (Sum.inl (i, j))) =
  x.moveLeft i * y + x * y.moveRight j - x.moveLeft i * y.moveRight j
-- SetTheory.PGame.mk_mul_moveRight_inr
@[simp]
theorem mk_mul_moveRight_inr {xl xr yl yr} {xL xR yL yR} {i j} :
    (mk xl xr xL xR * mk yl yr yL yR).moveRight (Sum.inr (i, j)) =
      xR i * mk yl yr yL yR + mk xl xr xL xR * yL j - xR i * yL j 
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} {j : yl}
Goal: (SetTheory.PGame.mk xl xr xL xR * SetTheory.PGame.mk yl yr yL yR).moveRight (Sum.inr (i, j)) =
  xR i * SetTheory.PGame.mk yl yr yL yR + SetTheory.PGame.mk xl xr xL xR * yL j - xR i * yL j
-- SetTheory.PGame.mul_moveRight_inr
@[simp]
theorem mul_moveRight_inr {x y : PGame} {i j} :
    (x * y).moveRight (toRightMovesMul (Sum.inr (i, j))) =
      x.moveRight i * y + x * y.moveLeft j - x.moveRight i * y.moveLeft j 
Arguments: {x y : SetTheory.PGame} {i : x.RightMoves} {j : y.LeftMoves}
Goal: (x * y).moveRight (SetTheory.PGame.toRightMovesMul (Sum.inr (i, j))) =
  x.moveRight i * y + x * y.moveLeft j - x.moveRight i * y.moveLeft j
-- SetTheory.PGame.neg_mk_mul_moveLeft_inl
theorem neg_mk_mul_moveLeft_inl {xl xr yl yr} {xL xR yL yR} {i j} :
    (-(mk xl xr xL xR * mk yl yr yL yR)).moveLeft (Sum.inl (i, j)) =
      -(xL i * mk yl yr yL yR + mk xl xr xL xR * yR j - xL i * yR j) 
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} {j : yr}
Goal: (-(SetTheory.PGame.mk xl xr xL xR * SetTheory.PGame.mk yl yr yL yR)).moveLeft (Sum.inl (i, j)) =
  -(xL i * SetTheory.PGame.mk yl yr yL yR + SetTheory.PGame.mk xl xr xL xR * yR j - xL i * yR j)
-- SetTheory.PGame.neg_mk_mul_moveLeft_inr
theorem neg_mk_mul_moveLeft_inr {xl xr yl yr} {xL xR yL yR} {i j} :
    (-(mk xl xr xL xR * mk yl yr yL yR)).moveLeft (Sum.inr (i, j)) =
      -(xR i * mk yl yr yL yR + mk xl xr xL xR * yL j - xR i * yL j) 
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} {j : yl}
Goal: (-(SetTheory.PGame.mk xl xr xL xR * SetTheory.PGame.mk yl yr yL yR)).moveLeft (Sum.inr (i, j)) =
  -(xR i * SetTheory.PGame.mk yl yr yL yR + SetTheory.PGame.mk xl xr xL xR * yL j - xR i * yL j)
-- SetTheory.PGame.neg_mk_mul_moveRight_inl
theorem neg_mk_mul_moveRight_inl {xl xr yl yr} {xL xR yL yR} {i j} :
    (-(mk xl xr xL xR * mk yl yr yL yR)).moveRight (Sum.inl (i, j)) =
      -(xL i * mk yl yr yL yR + mk xl xr xL xR * yL j - xL i * yL j) 
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} {j : yl}
Goal: (-(SetTheory.PGame.mk xl xr xL xR * SetTheory.PGame.mk yl yr yL yR)).moveRight (Sum.inl (i, j)) =
  -(xL i * SetTheory.PGame.mk yl yr yL yR + SetTheory.PGame.mk xl xr xL xR * yL j - xL i * yL j)
-- SetTheory.PGame.neg_mk_mul_moveRight_inr
theorem neg_mk_mul_moveRight_inr {xl xr yl yr} {xL xR yL yR} {i j} :
    (-(mk xl xr xL xR * mk yl yr yL yR)).moveRight (Sum.inr (i, j)) =
      -(xR i * mk yl yr yL yR + mk xl xr xL xR * yR j - xR i * yR j) 
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} {j : yr}
Goal: (-(SetTheory.PGame.mk xl xr xL xR * SetTheory.PGame.mk yl yr yL yR)).moveRight (Sum.inr (i, j)) =
  -(xR i * SetTheory.PGame.mk yl yr yL yR + SetTheory.PGame.mk xl xr xL xR * yR j - xR i * yR j)
-- SetTheory.PGame.leftMoves_mul_cases
theorem leftMoves_mul_cases {x y : PGame} (k) {P : (x * y).LeftMoves → Prop}
    (hl : ∀ ix iy, P <| toLeftMovesMul (Sum.inl ⟨ix, iy⟩))
    (hr : ∀ jx jy, P <| toLeftMovesMul (Sum.inr ⟨jx, jy⟩)) : P k 
Arguments: {x y : SetTheory.PGame} (k : (x * y).LeftMoves) {P : (x * y).LeftMoves → Prop} (hl : ∀ (ix : x.LeftMoves) (iy : y.LeftMoves), P (SetTheory.PGame.toLeftMovesMul (Sum.inl (ix, iy)))) (hr : ∀ (jx : x.RightMoves) (jy : y.RightMoves), P (SetTheory.PGame.toLeftMovesMul (Sum.inr (jx, jy))))
Goal: P k
-- SetTheory.PGame.rightMoves_mul_cases
theorem rightMoves_mul_cases {x y : PGame} (k) {P : (x * y).RightMoves → Prop}
    (hl : ∀ ix jy, P <| toRightMovesMul (Sum.inl ⟨ix, jy⟩))
    (hr : ∀ jx iy, P <| toRightMovesMul (Sum.inr ⟨jx, iy⟩)) : P k 
Arguments: {x y : SetTheory.PGame} (k : (x * y).RightMoves) {P : (x * y).RightMoves → Prop} (hl : ∀ (ix : x.LeftMoves) (jy : y.RightMoves), P (SetTheory.PGame.toRightMovesMul (Sum.inl (ix, jy)))) (hr : ∀ (jx : x.RightMoves) (iy : y.LeftMoves), P (SetTheory.PGame.toRightMovesMul (Sum.inr (jx, iy))))
Goal: P k
-- SetTheory.PGame.quot_mul_comm
theorem quot_mul_comm (x y : PGame.{u}) : (⟦x * y⟧ : Game) = ⟦y * x⟧ 
Arguments: (x y : SetTheory.PGame)
Goal: ⟦x * y⟧ = ⟦y * x⟧
-- SetTheory.PGame.mul_comm_equiv
theorem mul_comm_equiv (x y : PGame) : x * y ≈ y * x 
Arguments: (x y : SetTheory.PGame)
Goal: x * y ≈ y * x
-- SetTheory.PGame.mul_zero_equiv
theorem mul_zero_equiv (x : PGame) : x * 0 ≈ 0 
Arguments: (x : SetTheory.PGame)
Goal: x * 0 ≈ 0
-- SetTheory.PGame.quot_mul_zero
@[simp]
theorem quot_mul_zero (x : PGame) : (⟦x * 0⟧ : Game) = ⟦0⟧ 
Arguments: (x : SetTheory.PGame)
Goal: ⟦x * 0⟧ = ⟦0⟧
-- SetTheory.PGame.zero_mul_equiv
theorem zero_mul_equiv (x : PGame) : 0 * x ≈ 0 
Arguments: (x : SetTheory.PGame)
Goal: 0 * x ≈ 0
-- SetTheory.PGame.quot_zero_mul
@[simp]
theorem quot_zero_mul (x : PGame) : (⟦0 * x⟧ : Game) = ⟦0⟧ 
Arguments: (x : SetTheory.PGame)
Goal: ⟦0 * x⟧ = ⟦0⟧
-- SetTheory.PGame.quot_neg_mul
@[simp]
theorem quot_neg_mul (x y : PGame) : (⟦-x * y⟧ : Game) = -⟦x * y⟧ 
Arguments: (x y : SetTheory.PGame)
Goal: ⟦-x * y⟧ = -⟦x * y⟧
-- SetTheory.PGame.quot_mul_neg
@[simp]
theorem quot_mul_neg (x y : PGame) : ⟦x * -y⟧ = (-⟦x * y⟧ : Game) 
Arguments: (x y : SetTheory.PGame)
Goal: ⟦x * -y⟧ = -⟦x * y⟧
-- SetTheory.PGame.quot_neg_mul_neg
theorem quot_neg_mul_neg (x y : PGame) : ⟦-x * -y⟧ = (⟦x * y⟧ : Game) 
Arguments: (x y : SetTheory.PGame)
Goal: ⟦-x * -y⟧ = ⟦x * y⟧
-- SetTheory.PGame.quot_left_distrib
@[simp]
theorem quot_left_distrib (x y z : PGame) : (⟦x * (y + z)⟧ : Game) = ⟦x * y⟧ + ⟦x * z⟧ 
Arguments: (x y z : SetTheory.PGame)
Goal: ⟦x * (y + z)⟧ = ⟦x * y⟧ + ⟦x * z⟧
-- SetTheory.PGame.left_distrib_equiv
theorem left_distrib_equiv (x y z : PGame) : x * (y + z) ≈ x * y + x * z 
Arguments: (x y z : SetTheory.PGame)
Goal: x * (y + z) ≈ x * y + x * z
-- SetTheory.PGame.quot_left_distrib_sub
@[simp]
theorem quot_left_distrib_sub (x y z : PGame) : (⟦x * (y - z)⟧ : Game) = ⟦x * y⟧ - ⟦x * z⟧ 
Arguments: (x y z : SetTheory.PGame)
Goal: ⟦x * (y - z)⟧ = ⟦x * y⟧ - ⟦x * z⟧
-- SetTheory.PGame.quot_right_distrib
@[simp]
theorem quot_right_distrib (x y z : PGame) : (⟦(x + y) * z⟧ : Game) = ⟦x * z⟧ + ⟦y * z⟧ 
Arguments: (x y z : SetTheory.PGame)
Goal: ⟦(x + y) * z⟧ = ⟦x * z⟧ + ⟦y * z⟧
-- SetTheory.PGame.right_distrib_equiv
theorem right_distrib_equiv (x y z : PGame) : (x + y) * z ≈ x * z + y * z 
Arguments: (x y z : SetTheory.PGame)
Goal: (x + y) * z ≈ x * z + y * z
-- SetTheory.PGame.quot_right_distrib_sub
@[simp]
theorem quot_right_distrib_sub (x y z : PGame) : (⟦(y - z) * x⟧ : Game) = ⟦y * x⟧ - ⟦z * x⟧ 
Arguments: (x y z : SetTheory.PGame)
Goal: ⟦(y - z) * x⟧ = ⟦y * x⟧ - ⟦z * x⟧
-- SetTheory.PGame.quot_mul_one
@[simp]
theorem quot_mul_one (x : PGame) : (⟦x * 1⟧ : Game) = ⟦x⟧ 
Arguments: (x : SetTheory.PGame)
Goal: ⟦x * 1⟧ = ⟦x⟧
-- SetTheory.PGame.mul_one_equiv
theorem mul_one_equiv (x : PGame) : x * 1 ≈ x 
Arguments: (x : SetTheory.PGame)
Goal: x * 1 ≈ x
-- SetTheory.PGame.quot_one_mul
@[simp]
theorem quot_one_mul (x : PGame) : (⟦1 * x⟧ : Game) = ⟦x⟧ 
Arguments: (x : SetTheory.PGame)
Goal: ⟦1 * x⟧ = ⟦x⟧
-- SetTheory.PGame.one_mul_equiv
theorem one_mul_equiv (x : PGame) : 1 * x ≈ x 
Arguments: (x : SetTheory.PGame)
Goal: 1 * x ≈ x
-- SetTheory.PGame.quot_mul_assoc
theorem quot_mul_assoc (x y z : PGame) : (⟦x * y * z⟧ : Game) = ⟦x * (y * z)⟧ 
Arguments: (x y z : SetTheory.PGame)
Goal: ⟦x * y * z⟧ = ⟦x * (y * z)⟧
-- SetTheory.PGame.mul_assoc_equiv
theorem mul_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.mulOption_neg_neg
lemma mulOption_neg_neg {x} (y) {i j} :
    mulOption x y i j = mulOption x (-(-y)) i (toLeftMovesNeg <| toRightMovesNeg j) 
Arguments: {x : SetTheory.PGame} (y : SetTheory.PGame) {i : x.LeftMoves} {j : y.LeftMoves}
Goal: x.mulOption y i j = x.mulOption (- -y) i (SetTheory.PGame.toLeftMovesNeg (SetTheory.PGame.toRightMovesNeg j))
-- SetTheory.PGame.mulOption_symm
lemma mulOption_symm (x y) {i j} : ⟦mulOption x y i j⟧ = (⟦mulOption y x j i⟧ : Game) 
Arguments: (x y : SetTheory.PGame) {i : x.LeftMoves} {j : y.LeftMoves}
Goal: ⟦x.mulOption y i j⟧ = ⟦y.mulOption x j i⟧
-- SetTheory.PGame.leftMoves_mul_iff
lemma leftMoves_mul_iff {x y : PGame} (P : Game → Prop) :
    (∀ k, P ⟦(x * y).moveLeft k⟧) ↔
    (∀ i j, P ⟦mulOption x y i j⟧) ∧ (∀ i j, P ⟦mulOption (-x) (-y) i j⟧) 
Arguments: {x y : SetTheory.PGame} (P : SetTheory.Game → Prop)
Goal: (∀ (k : (x * y).LeftMoves), P ⟦(x * y).moveLeft k⟧) ↔
  (∀ (i : x.LeftMoves) (j : y.LeftMoves), P ⟦x.mulOption y i j⟧) ∧
    ∀ (i : (-x).LeftMoves) (j : (-y).LeftMoves), P ⟦(-x).mulOption (-y) i j⟧
-- SetTheory.PGame.rightMoves_mul_iff
lemma rightMoves_mul_iff {x y : PGame} (P : Game → Prop) :
    (∀ k, P ⟦(x * y).moveRight k⟧) ↔
    (∀ i j, P (-⟦mulOption x (-y) i j⟧)) ∧ (∀ i j, P (-⟦mulOption (-x) y i j⟧)) 
Arguments: {x y : SetTheory.PGame} (P : SetTheory.Game → Prop)
Goal: (∀ (k : (x * y).RightMoves), P ⟦(x * y).moveRight k⟧) ↔
  (∀ (i : x.LeftMoves) (j : (-y).LeftMoves), P (-⟦x.mulOption (-y) i j⟧)) ∧
    ∀ (i : (-x).LeftMoves) (j : y.LeftMoves), P (-⟦(-x).mulOption y i j⟧)
-- SetTheory.PGame.invVal_isEmpty
@[simp]
theorem invVal_isEmpty {l r : Type u} {b} (L R IHl IHr) (i : InvTy l r b) (x) [IsEmpty l]
    [IsEmpty r] : invVal L R IHl IHr x i = 0 
Arguments: {l r : Type u} {b : Bool} (L : l → SetTheory.PGame) (R : r → SetTheory.PGame) (IHl : l → SetTheory.PGame) (IHr : r → SetTheory.PGame) (i : SetTheory.PGame.InvTy l r b) (x : SetTheory.PGame) [IsEmpty l] [IsEmpty r]
Goal: SetTheory.PGame.invVal L R IHl IHr x i = 0
-- SetTheory.PGame.zero_lf_inv'
theorem zero_lf_inv' : ∀ x : PGame, 0 ⧏ inv' x
  
Arguments: (x : SetTheory.PGame)
Goal: SetTheory.PGame.LF 0 x.inv'
-- SetTheory.PGame.inv'_zero_equiv
theorem inv'_zero_equiv : inv' 0 ≈ 1 
Goal: SetTheory.PGame.inv' 0 ≈ 1
-- SetTheory.PGame.inv'_one_equiv
theorem inv'_one_equiv : inv' 1 ≈ 1 
Goal: SetTheory.PGame.inv' 1 ≈ 1
-- SetTheory.PGame.inv_eq_of_equiv_zero
theorem inv_eq_of_equiv_zero {x : PGame} (h : x ≈ 0) : x⁻¹ = 0 
Arguments: {x : SetTheory.PGame} (h : x ≈ 0)
Goal: x⁻¹ = 0
-- SetTheory.PGame.inv_zero
@[simp]
theorem inv_zero : (0 : PGame)⁻¹ = 0 
Goal: 0⁻¹ = 0
-- SetTheory.PGame.inv_eq_of_pos
theorem inv_eq_of_pos {x : PGame} (h : 0 < x) : x⁻¹ = inv' x 
Arguments: {x : SetTheory.PGame} (h : 0 < x)
Goal: x⁻¹ = x.inv'
-- SetTheory.PGame.inv_eq_of_lf_zero
theorem inv_eq_of_lf_zero {x : PGame} (h : x ⧏ 0) : x⁻¹ = -inv' (-x) 
Arguments: {x : SetTheory.PGame} (h : x.LF 0)
Goal: x⁻¹ = -(-x).inv'
-- SetTheory.PGame.inv_one_equiv
theorem inv_one_equiv : (1⁻¹ : PGame) ≈ 1 
Goal: 1⁻¹ ≈ 1
-- ne_of_ne_of_eq'
lemma ne_of_ne_of_eq' {α : Sort*} {a c b : α} (hab : (a : α) ≠ c) (hbc : a = b) : b ≠ c 
Arguments: {α : Sort u_1} {a c b : α} (hab : a ≠ c) (hbc : a = b)
Goal: b ≠ c
-- Mathlib.Meta.Positivity.lt_of_le_of_ne'
lemma lt_of_le_of_ne' {a b : A} [PartialOrder A] :
    (a : A) ≤ b → b ≠ a → a < b 
Arguments: {A : Type u_1} {a b : A} [PartialOrder A]
Goal: a ≤ b → b ≠ a → a < b
-- Mathlib.Meta.Positivity.pos_of_isNat
lemma pos_of_isNat {n : ℕ} [StrictOrderedSemiring A]
    (h : NormNum.IsNat e n) (w : Nat.ble 1 n = true) : 0 < (e : A) 
Arguments: {A : Type u_1} {e : A} {n : ℕ} [StrictOrderedSemiring A] (h : Mathlib.Meta.NormNum.IsNat e n) (w : Nat.ble 1 n = true)
Goal: 0 < e
-- Mathlib.Meta.Positivity.nonneg_of_isNat
lemma nonneg_of_isNat {n : ℕ} [OrderedSemiring A]
    (h : NormNum.IsNat e n) : 0 ≤ (e : A) 
Arguments: {A : Type u_1} {e : A} {n : ℕ} [OrderedSemiring A] (h : Mathlib.Meta.NormNum.IsNat e n)
Goal: 0 ≤ e
-- Mathlib.Meta.Positivity.nz_of_isNegNat
lemma nz_of_isNegNat {n : ℕ} [StrictOrderedRing A]
    (h : NormNum.IsInt e (.negOfNat n)) (w : Nat.ble 1 n = true) : (e : A) ≠ 0 
Arguments: {A : Type u_1} {e : A} {n : ℕ} [StrictOrderedRing A] (h : Mathlib.Meta.NormNum.IsInt e (Int.negOfNat n)) (w : Nat.ble 1 n = true)
Goal: e ≠ 0
-- Mathlib.Meta.Positivity.pos_of_isRat
lemma pos_of_isRat {n : ℤ} {d : ℕ} [LinearOrderedRing A] :
    (NormNum.IsRat e n d) → (decide (0 < n)) → ((0 : A) < (e : A))
  
Arguments: {A : Type u_1} {e : A} {n : ℤ} {d : ℕ} [LinearOrderedRing A]
Goal: Mathlib.Meta.NormNum.IsRat e n d → decide (0 < n) = true → 0 < e
-- Mathlib.Meta.Positivity.nonneg_of_isRat
lemma nonneg_of_isRat {n : ℤ} {d : ℕ} [LinearOrderedRing A] :
    (NormNum.IsRat e n d) → (decide (n = 0)) → (0 ≤ (e : A))
  
Arguments: {A : Type u_1} {e : A} {n : ℤ} {d : ℕ} [LinearOrderedRing A]
Goal: Mathlib.Meta.NormNum.IsRat e n d → decide (n = 0) = true → 0 ≤ e
-- Mathlib.Meta.Positivity.nz_of_isRat
lemma nz_of_isRat {n : ℤ} {d : ℕ} [LinearOrderedRing A] :
    (NormNum.IsRat e n d) → (decide (n < 0)) → ((e : A) ≠ 0)
  
Arguments: {A : Type u_1} {e : A} {n : ℤ} {d : ℕ} [LinearOrderedRing A]
Goal: Mathlib.Meta.NormNum.IsRat e n d → decide (n < 0) = true → e ≠ 0
-- Mathlib.Tactic.Monoidal.evalComp_nil_cons
theorem evalComp_nil_cons {f g h i j : C} (α : f ⟶ g) (β : g ⟶ h) (η : h ⟶ i) (ηs : i ⟶ j) :
    α ≫ (β ≫ η ≫ ηs) = (α ≫ β) ≫ η ≫ ηs 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g h i j : C} (α : f ⟶ g) (β : g ⟶ h) (η : h ⟶ i) (ηs : i ⟶ j)
Goal: CategoryTheory.CategoryStruct.comp α (CategoryTheory.CategoryStruct.comp β (CategoryTheory.CategoryStruct.comp η ηs)) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp α β) (CategoryTheory.CategoryStruct.comp η ηs)
-- Mathlib.Tactic.Monoidal.evalComp_nil_nil
@[nolint synTaut]
theorem evalComp_nil_nil {f g h : C} (α : f ⟶ g) (β : g ⟶ h) :
    α ≫ β = α ≫ β 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g h : C} (α : f ⟶ g) (β : g ⟶ h)
Goal: CategoryTheory.CategoryStruct.comp α β = CategoryTheory.CategoryStruct.comp α β