l3lab/ntp-mathlib huggingface dataset:
theorem primorial_le_4_pow (n : ℕ) : n# ≤ 4 ^ n := by
  induction' n using Nat.strong_induction_on with n ihn
  cases' n with n; · rfl
  rcases n.even_or_odd with (⟨m, rfl⟩ | ho)
  · rcases m.eq_zero_or_pos with (rfl | hm)
    · decide
    calc
      (m + m + 1)# = (m + 1 + m)# := by rw [add_right_comm]
      _ ≤ (m + 1)# * choose (m + 1 + m) (m + 1) := primorial_add_le m.le_succ
      _ = (m + 1)# * choose (2 * m + 1) m := by rw [choose_symm_add, two_mul, add_right_comm]
      _ ≤ 4 ^ (m + 1) * 4 ^ m :=
        mul_le_mul' (ihn _ <| succ_lt_succ <| (lt_add_iff_pos_left _).2 hm) (choose_middle_le_pow _)
      _ ≤ 4 ^ (m + m + 1) := by rw [← pow_add, add_right_comm]
  · rcases Decidable.eq_or_ne n 1 with (rfl | hn)
    · 

Proof state:
case h.succ.inr.inl
ihn : ∀ m < succ 1, m# ≤ 4 ^ m
ho : Odd 1
⊢ succ 1# ≤ 4 ^ succ 1

Next tactic:
decide
theorem primorial_le_4_pow (n : ℕ) : n# ≤ 4 ^ n := by
  induction' n using Nat.strong_induction_on with n ihn
  cases' n with n; · rfl
  rcases n.even_or_odd with (⟨m, rfl⟩ | ho)
  · rcases m.eq_zero_or_pos with (rfl | hm)
    · decide
    calc
      (m + m + 1)# = (m + 1 + m)# := by rw [add_right_comm]
      _ ≤ (m + 1)# * choose (m + 1 + m) (m + 1) := primorial_add_le m.le_succ
      _ = (m + 1)# * choose (2 * m + 1) m := by rw [choose_symm_add, two_mul, add_right_comm]
      _ ≤ 4 ^ (m + 1) * 4 ^ m :=
        mul_le_mul' (ihn _ <| succ_lt_succ <| (lt_add_iff_pos_left _).2 hm) (choose_middle_le_pow _)
      _ ≤ 4 ^ (m + m + 1) := by rw [← pow_add, add_right_comm]
  · rcases Decidable.eq_or_ne n 1 with (rfl | hn)
    · decide
    · 

Proof state:
case h.succ.inr.inr
n : ℕ
ihn : ∀ m < succ n, m# ≤ 4 ^ m
ho : Odd n
hn : n ≠ 1
⊢ succ n# ≤ 4 ^ succ n

Next tactic:
calc
        (n + 1)# = n# := primorial_succ hn ho
        _ ≤ 4 ^ n := ihn n n.lt_succ_self
        _ ≤ 4 ^ (n + 1) := pow_le_pow_of_le_right four_pos n.le_succ
theorem numeric_def {x : PGame} :
    Numeric x ↔
      (∀ i j, x.moveLeft i < x.moveRight j) ∧
        (∀ i, Numeric (x.moveLeft i)) ∧ ∀ j, Numeric (x.moveRight j) := by
  

Proof state:
x : PGame
⊢ Numeric x ↔
    (∀ (i : LeftMoves x) (j : RightMoves x), moveLeft x i < moveRight x j) ∧
      (∀ (i : LeftMoves x), Numeric (moveLeft x i)) ∧ ∀ (j : RightMoves x), Numeric (moveRight x j)

Next tactic:
cases x
theorem numeric_def {x : PGame} :
    Numeric x ↔
      (∀ i j, x.moveLeft i < x.moveRight j) ∧
        (∀ i, Numeric (x.moveLeft i)) ∧ ∀ j, Numeric (x.moveRight j) := by
  cases x; 

Proof state:
case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ Numeric (mk α✝ β✝ a✝¹ a✝) ↔
    (∀ (i : LeftMoves (mk α✝ β✝ a✝¹ a✝)) (j : RightMoves (mk α✝ β✝ a✝¹ a✝)),
        moveLeft (mk α✝ β✝ a✝¹ a✝) i < moveRight (mk α✝ β✝ a✝¹ a✝) j) ∧
      (∀ (i : LeftMoves (mk α✝ β✝ a✝¹ a✝)), Numeric (moveLeft (mk α✝ β✝ a✝¹ a✝) i)) ∧
        ∀ (j : RightMoves (mk α✝ β✝ a✝¹ a✝)), Numeric (moveRight (mk α✝ β✝ a✝¹ a✝) j)

Next tactic:
rfl
theorem left_lt_right {x : PGame} (o : Numeric x) (i : x.LeftMoves) (j : x.RightMoves) :
    x.moveLeft i < x.moveRight j := by 

Proof state:
x : PGame
o : Numeric x
i : LeftMoves x
j : RightMoves x
⊢ moveLeft x i < moveRight x j

Next tactic:
cases x
theorem left_lt_right {x : PGame} (o : Numeric x) (i : x.LeftMoves) (j : x.RightMoves) :
    x.moveLeft i < x.moveRight j := by cases x; 

Proof state:
case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
o : Numeric (PGame.mk α✝ β✝ a✝¹ a✝)
i : LeftMoves (PGame.mk α✝ β✝ a✝¹ a✝)
j : RightMoves (PGame.mk α✝ β✝ a✝¹ a✝)
⊢ moveLeft (PGame.mk α✝ β✝ a✝¹ a✝) i < moveRight (PGame.mk α✝ β✝ a✝¹ a✝) j

Next tactic:
exact o.1 i j
theorem moveLeft {x : PGame} (o : Numeric x) (i : x.LeftMoves) : Numeric (x.moveLeft i) := by
  

Proof state:
x : PGame
o : Numeric x
i : LeftMoves x
⊢ Numeric (PGame.moveLeft x i)

Next tactic:
cases x
theorem moveLeft {x : PGame} (o : Numeric x) (i : x.LeftMoves) : Numeric (x.moveLeft i) := by
  cases x; 

Proof state:
case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
o : Numeric (PGame.mk α✝ β✝ a✝¹ a✝)
i : LeftMoves (PGame.mk α✝ β✝ a✝¹ a✝)
⊢ Numeric (PGame.moveLeft (PGame.mk α✝ β✝ a✝¹ a✝) i)

Next tactic:
exact o.2.1 i
theorem moveRight {x : PGame} (o : Numeric x) (j : x.RightMoves) : Numeric (x.moveRight j) := by
  

Proof state:
x : PGame
o : Numeric x
j : RightMoves x
⊢ Numeric (PGame.moveRight x j)

Next tactic:
cases x
theorem moveRight {x : PGame} (o : Numeric x) (j : x.RightMoves) : Numeric (x.moveRight j) := by
  cases x; 

Proof state:
case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
o : Numeric (PGame.mk α✝ β✝ a✝¹ a✝)
j : RightMoves (PGame.mk α✝ β✝ a✝¹ a✝)
⊢ Numeric (PGame.moveRight (PGame.mk α✝ β✝ a✝¹ a✝) j)

Next tactic:
exact o.2.2 j
theorem Relabelling.numeric_imp {x y : PGame} (r : x ≡r y) (ox : Numeric x) : Numeric y := by
  

Proof state:
x y : PGame
r : x ≡r y
ox : Numeric x
⊢ Numeric y

Next tactic:
induction' x using PGame.moveRecOn with x IHl IHr generalizing y
theorem Relabelling.numeric_imp {x y : PGame} (r : x ≡r y) (ox : Numeric x) : Numeric y := by
  induction' x using PGame.moveRecOn with x IHl IHr generalizing y
  

Proof state:
case IH
x : PGame
IHl : ∀ (i : LeftMoves x) {y : PGame}, PGame.moveLeft x i ≡r y → Numeric (PGame.moveLeft x i) → Numeric y
IHr : ∀ (j : RightMoves x) {y : PGame}, PGame.moveRight x j ≡r y → Numeric (PGame.moveRight x j) → Numeric y
y : PGame
r : x ≡r y
ox : Numeric x
⊢ Numeric y

Next tactic:
apply Numeric.mk (fun i j => ?_) (fun i => ?_) fun j => ?_
theorem Relabelling.numeric_imp {x y : PGame} (r : x ≡r y) (ox : Numeric x) : Numeric y := by
  induction' x using PGame.moveRecOn with x IHl IHr generalizing y
  apply Numeric.mk (fun i j => ?_) (fun i => ?_) fun j => ?_
  · 

Proof state:
x : PGame
IHl : ∀ (i : LeftMoves x) {y : PGame}, PGame.moveLeft x i ≡r y → Numeric (PGame.moveLeft x i) → Numeric y
IHr : ∀ (j : RightMoves x) {y : PGame}, PGame.moveRight x j ≡r y → Numeric (PGame.moveRight x j) → Numeric y
y : PGame
r : x ≡r y
ox : Numeric x
i : LeftMoves y
j : RightMoves y
⊢ PGame.moveLeft y i < PGame.moveRight y j

Next tactic:
rw [← lt_congr (r.moveLeftSymm i).equiv (r.moveRightSymm j).equiv]
theorem Relabelling.numeric_imp {x y : PGame} (r : x ≡r y) (ox : Numeric x) : Numeric y := by
  induction' x using PGame.moveRecOn with x IHl IHr generalizing y
  apply Numeric.mk (fun i j => ?_) (fun i => ?_) fun j => ?_
  · rw [← lt_congr (r.moveLeftSymm i).equiv (r.moveRightSymm j).equiv]
    

Proof state:
x : PGame
IHl : ∀ (i : LeftMoves x) {y : PGame}, PGame.moveLeft x i ≡r y → Numeric (PGame.moveLeft x i) → Numeric y
IHr : ∀ (j : RightMoves x) {y : PGame}, PGame.moveRight x j ≡r y → Numeric (PGame.moveRight x j) → Numeric y
y : PGame
r : x ≡r y
ox : Numeric x
i : LeftMoves y
j : RightMoves y
⊢ PGame.moveLeft x ((leftMovesEquiv r).symm i) < PGame.moveRight x ((rightMovesEquiv r).symm j)

Next tactic:
apply ox.left_lt_right
theorem Relabelling.numeric_imp {x y : PGame} (r : x ≡r y) (ox : Numeric x) : Numeric y := by
  induction' x using PGame.moveRecOn with x IHl IHr generalizing y
  apply Numeric.mk (fun i j => ?_) (fun i => ?_) fun j => ?_
  · rw [← lt_congr (r.moveLeftSymm i).equiv (r.moveRightSymm j).equiv]
    apply ox.left_lt_right
  · 

Proof state:
x : PGame
IHl : ∀ (i : LeftMoves x) {y : PGame}, PGame.moveLeft x i ≡r y → Numeric (PGame.moveLeft x i) → Numeric y
IHr : ∀ (j : RightMoves x) {y : PGame}, PGame.moveRight x j ≡r y → Numeric (PGame.moveRight x j) → Numeric y
y : PGame
r : x ≡r y
ox : Numeric x
i : LeftMoves y
⊢ Numeric (PGame.moveLeft y i)

Next tactic:
exact IHl _ (r.moveLeftSymm i) (ox.moveLeft _)
theorem Relabelling.numeric_imp {x y : PGame} (r : x ≡r y) (ox : Numeric x) : Numeric y := by
  induction' x using PGame.moveRecOn with x IHl IHr generalizing y
  apply Numeric.mk (fun i j => ?_) (fun i => ?_) fun j => ?_
  · rw [← lt_congr (r.moveLeftSymm i).equiv (r.moveRightSymm j).equiv]
    apply ox.left_lt_right
  · exact IHl _ (r.moveLeftSymm i) (ox.moveLeft _)
  · 

Proof state:
x : PGame
IHl : ∀ (i : LeftMoves x) {y : PGame}, PGame.moveLeft x i ≡r y → Numeric (PGame.moveLeft x i) → Numeric y
IHr : ∀ (j : RightMoves x) {y : PGame}, PGame.moveRight x j ≡r y → Numeric (PGame.moveRight x j) → Numeric y
y : PGame
r : x ≡r y
ox : Numeric x
j : RightMoves y
⊢ Numeric (PGame.moveRight y j)

Next tactic:
exact IHr _ (r.moveRightSymm j) (ox.moveRight _)
theorem lf_asymm {x y : PGame} (ox : Numeric x) (oy : Numeric y) : x ⧏ y → ¬y ⧏ x := by
  

Proof state:
x y : PGame
ox : Numeric x
oy : Numeric y
⊢ x ⧏ y → ¬y ⧏ x

Next tactic:
refine' numeric_rec (C := fun x => ∀ z (_oz : Numeric z), x ⧏ z → ¬z ⧏ x)
    (fun xl xr xL xR hx _oxl _oxr IHxl IHxr => _) x ox y oy
theorem lf_asymm {x y : PGame} (ox : Numeric x) (oy : Numeric y) : x ⧏ y → ¬y ⧏ x := by
  refine' numeric_rec (C := fun x => ∀ z (_oz : Numeric z), x ⧏ z → ¬z ⧏ x)
    (fun xl xr xL xR hx _oxl _oxr IHxl IHxr => _) x ox y oy
  

Proof state:
x y : PGame
ox : Numeric x
oy : Numeric y
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
hx : ∀ (i : xl) (j : xr), xL i < xR j
_oxl : ∀ (i : xl), Numeric (xL i)
_oxr : ∀ (i : xr), Numeric (xR i)
IHxl : ∀ (i : xl), (fun x => ∀ (z : PGame), Numeric z → x ⧏ z → ¬z ⧏ x) (xL i)
IHxr : ∀ (i : xr), (fun x => ∀ (z : PGame), Numeric z → x ⧏ z → ¬z ⧏ x) (xR i)
⊢ (fun x => ∀ (z : PGame), Numeric z → x ⧏ z → ¬z ⧏ x) (mk xl xr xL xR)

Next tactic:
refine' numeric_rec fun yl yr yL yR hy oyl oyr _IHyl _IHyr => _
theorem lf_asymm {x y : PGame} (ox : Numeric x) (oy : Numeric y) : x ⧏ y → ¬y ⧏ x := by
  refine' numeric_rec (C := fun x => ∀ z (_oz : Numeric z), x ⧏ z → ¬z ⧏ x)
    (fun xl xr xL xR hx _oxl _oxr IHxl IHxr => _) x ox y oy
  refine' numeric_rec fun yl yr yL yR hy oyl oyr _IHyl _IHyr => _
  

Proof state:
x y : PGame
ox : Numeric x
oy : Numeric y
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
hx : ∀ (i : xl) (j : xr), xL i < xR j
_oxl : ∀ (i : xl), Numeric (xL i)
_oxr : ∀ (i : xr), Numeric (xR i)
IHxl : ∀ (i : xl), (fun x => ∀ (z : PGame), Numeric z → x ⧏ z → ¬z ⧏ x) (xL i)
IHxr : ∀ (i : xr), (fun x => ∀ (z : PGame), Numeric z → x ⧏ z → ¬z ⧏ x) (xR i)
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
hy : ∀ (i : yl) (j : yr), yL i < yR j
oyl : ∀ (i : yl), Numeric (yL i)
oyr : ∀ (i : yr), Numeric (yR i)
_IHyl : ∀ (i : yl), mk xl xr xL xR ⧏ yL i → ¬yL i ⧏ mk xl xr xL xR
_IHyr : ∀ (i : yr), mk xl xr xL xR ⧏ yR i → ¬yR i ⧏ mk xl xr xL xR
⊢ mk xl xr xL xR ⧏ mk yl yr yL yR → ¬mk yl yr yL yR ⧏ mk xl xr xL xR

Next tactic:
rw [mk_lf_mk, mk_lf_mk]
theorem lf_asymm {x y : PGame} (ox : Numeric x) (oy : Numeric y) : x ⧏ y → ¬y ⧏ x := by
  refine' numeric_rec (C := fun x => ∀ z (_oz : Numeric z), x ⧏ z → ¬z ⧏ x)
    (fun xl xr xL xR hx _oxl _oxr IHxl IHxr => _) x ox y oy
  refine' numeric_rec fun yl yr yL yR hy oyl oyr _IHyl _IHyr => _
  rw [mk_lf_mk, mk_lf_mk]; 

Proof state:
x y : PGame
ox : Numeric x
oy : Numeric y
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
hx : ∀ (i : xl) (j : xr), xL i < xR j
_oxl : ∀ (i : xl), Numeric (xL i)
_oxr : ∀ (i : xr), Numeric (xR i)
IHxl : ∀ (i : xl), (fun x => ∀ (z : PGame), Numeric z → x ⧏ z → ¬z ⧏ x) (xL i)
IHxr : ∀ (i : xr), (fun x => ∀ (z : PGame), Numeric z → x ⧏ z → ¬z ⧏ x) (xR i)
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
hy : ∀ (i : yl) (j : yr), yL i < yR j
oyl : ∀ (i : yl), Numeric (yL i)
oyr : ∀ (i : yr), Numeric (yR i)
_IHyl : ∀ (i : yl), mk xl xr xL xR ⧏ yL i → ¬yL i ⧏ mk xl xr xL xR
_IHyr : ∀ (i : yr), mk xl xr xL xR ⧏ yR i → ¬yR i ⧏ mk xl xr xL xR
⊢ ((∃ i, mk xl xr xL xR ≤ yL i) ∨ ∃ j, xR j ≤ mk yl yr yL yR) →
    ¬((∃ i, mk yl yr yL yR ≤ xL i) ∨ ∃ j, yR j ≤ mk xl xr xL xR)

Next tactic:
rintro (⟨i, h₁⟩ | ⟨j, h₁⟩) (⟨i, h₂⟩ | ⟨j, h₂⟩)
theorem lf_asymm {x y : PGame} (ox : Numeric x) (oy : Numeric y) : x ⧏ y → ¬y ⧏ x := by
  refine' numeric_rec (C := fun x => ∀ z (_oz : Numeric z), x ⧏ z → ¬z ⧏ x)
    (fun xl xr xL xR hx _oxl _oxr IHxl IHxr => _) x ox y oy
  refine' numeric_rec fun yl yr yL yR hy oyl oyr _IHyl _IHyr => _
  rw [mk_lf_mk, mk_lf_mk]; rintro (⟨i, h₁⟩ | ⟨j, h₁⟩) (⟨i, h₂⟩ | ⟨j, h₂⟩)
  · 

Proof state:
case inl.intro.inl.intro
x y : PGame
ox : Numeric x
oy : Numeric y
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
hx : ∀ (i : xl) (j : xr), xL i < xR j
_oxl : ∀ (i : xl), Numeric (xL i)
_oxr : ∀ (i : xr), Numeric (xR i)
IHxl : ∀ (i : xl), (fun x => ∀ (z : PGame), Numeric z → x ⧏ z → ¬z ⧏ x) (xL i)
IHxr : ∀ (i : xr), (fun x => ∀ (z : PGame), Numeric z → x ⧏ z → ¬z ⧏ x) (xR i)
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
hy : ∀ (i : yl) (j : yr), yL i < yR j
oyl : ∀ (i : yl), Numeric (yL i)
oyr : ∀ (i : yr), Numeric (yR i)
_IHyl : ∀ (i : yl), mk xl xr xL xR ⧏ yL i → ¬yL i ⧏ mk xl xr xL xR
_IHyr : ∀ (i : yr), mk xl xr xL xR ⧏ yR i → ¬yR i ⧏ mk xl xr xL xR
i✝ : yl
h₁ : mk xl xr xL xR ≤ yL i✝
i : xl
h₂ : mk yl yr yL yR ≤ xL i
⊢ False

Next tactic:
exact IHxl _ _ (oyl _) (h₁.moveLeft_lf _) (h₂.moveLeft_lf _)
theorem lf_asymm {x y : PGame} (ox : Numeric x) (oy : Numeric y) : x ⧏ y → ¬y ⧏ x := by
  refine' numeric_rec (C := fun x => ∀ z (_oz : Numeric z), x ⧏ z → ¬z ⧏ x)
    (fun xl xr xL xR hx _oxl _oxr IHxl IHxr => _) x ox y oy
  refine' numeric_rec fun yl yr yL yR hy oyl oyr _IHyl _IHyr => _
  rw [mk_lf_mk, mk_lf_mk]; rintro (⟨i, h₁⟩ | ⟨j, h₁⟩) (⟨i, h₂⟩ | ⟨j, h₂⟩)
  · exact IHxl _ _ (oyl _) (h₁.moveLeft_lf _) (h₂.moveLeft_lf _)
  · 

Proof state:
case inl.intro.inr.intro
x y : PGame
ox : Numeric x
oy : Numeric y
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
hx : ∀ (i : xl) (j : xr), xL i < xR j
_oxl : ∀ (i : xl), Numeric (xL i)
_oxr : ∀ (i : xr), Numeric (xR i)
IHxl : ∀ (i : xl), (fun x => ∀ (z : PGame), Numeric z → x ⧏ z → ¬z ⧏ x) (xL i)
IHxr : ∀ (i : xr), (fun x => ∀ (z : PGame), Numeric z → x ⧏ z → ¬z ⧏ x) (xR i)
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
hy : ∀ (i : yl) (j : yr), yL i < yR j
oyl : ∀ (i : yl), Numeric (yL i)
oyr : ∀ (i : yr), Numeric (yR i)
_IHyl : ∀ (i : yl), mk xl xr xL xR ⧏ yL i → ¬yL i ⧏ mk xl xr xL xR
_IHyr : ∀ (i : yr), mk xl xr xL xR ⧏ yR i → ¬yR i ⧏ mk xl xr xL xR
i : yl
h₁ : mk xl xr xL xR ≤ yL i
j : yr
h₂ : yR j ≤ mk xl xr xL xR
⊢ False

Next tactic:
exact (le_trans h₂ h₁).not_gf (lf_of_lt (hy _ _))
theorem lf_asymm {x y : PGame} (ox : Numeric x) (oy : Numeric y) : x ⧏ y → ¬y ⧏ x := by
  refine' numeric_rec (C := fun x => ∀ z (_oz : Numeric z), x ⧏ z → ¬z ⧏ x)
    (fun xl xr xL xR hx _oxl _oxr IHxl IHxr => _) x ox y oy
  refine' numeric_rec fun yl yr yL yR hy oyl oyr _IHyl _IHyr => _
  rw [mk_lf_mk, mk_lf_mk]; rintro (⟨i, h₁⟩ | ⟨j, h₁⟩) (⟨i, h₂⟩ | ⟨j, h₂⟩)
  · exact IHxl _ _ (oyl _) (h₁.moveLeft_lf _) (h₂.moveLeft_lf _)
  · exact (le_trans h₂ h₁).not_gf (lf_of_lt (hy _ _))
  · 

Proof state:
case inr.intro.inl.intro
x y : PGame
ox : Numeric x
oy : Numeric y
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
hx : ∀ (i : xl) (j : xr), xL i < xR j
_oxl : ∀ (i : xl), Numeric (xL i)
_oxr : ∀ (i : xr), Numeric (xR i)
IHxl : ∀ (i : xl), (fun x => ∀ (z : PGame), Numeric z → x ⧏ z → ¬z ⧏ x) (xL i)
IHxr : ∀ (i : xr), (fun x => ∀ (z : PGame), Numeric z → x ⧏ z → ¬z ⧏ x) (xR i)
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
hy : ∀ (i : yl) (j : yr), yL i < yR j
oyl : ∀ (i : yl), Numeric (yL i)
oyr : ∀ (i : yr), Numeric (yR i)
_IHyl : ∀ (i : yl), mk xl xr xL xR ⧏ yL i → ¬yL i ⧏ mk xl xr xL xR
_IHyr : ∀ (i : yr), mk xl xr xL xR ⧏ yR i → ¬yR i ⧏ mk xl xr xL xR
j : xr
h₁ : xR j ≤ mk yl yr yL yR
i : xl
h₂ : mk yl yr yL yR ≤ xL i
⊢ False

Next tactic:
exact (le_trans h₁ h₂).not_gf (lf_of_lt (hx _ _))
theorem lf_asymm {x y : PGame} (ox : Numeric x) (oy : Numeric y) : x ⧏ y → ¬y ⧏ x := by
  refine' numeric_rec (C := fun x => ∀ z (_oz : Numeric z), x ⧏ z → ¬z ⧏ x)
    (fun xl xr xL xR hx _oxl _oxr IHxl IHxr => _) x ox y oy
  refine' numeric_rec fun yl yr yL yR hy oyl oyr _IHyl _IHyr => _
  rw [mk_lf_mk, mk_lf_mk]; rintro (⟨i, h₁⟩ | ⟨j, h₁⟩) (⟨i, h₂⟩ | ⟨j, h₂⟩)
  · exact IHxl _ _ (oyl _) (h₁.moveLeft_lf _) (h₂.moveLeft_lf _)
  · exact (le_trans h₂ h₁).not_gf (lf_of_lt (hy _ _))
  · exact (le_trans h₁ h₂).not_gf (lf_of_lt (hx _ _))
  · 

Proof state:
case inr.intro.inr.intro
x y : PGame
ox : Numeric x
oy : Numeric y
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
hx : ∀ (i : xl) (j : xr), xL i < xR j
_oxl : ∀ (i : xl), Numeric (xL i)
_oxr : ∀ (i : xr), Numeric (xR i)
IHxl : ∀ (i : xl), (fun x => ∀ (z : PGame), Numeric z → x ⧏ z → ¬z ⧏ x) (xL i)
IHxr : ∀ (i : xr), (fun x => ∀ (z : PGame), Numeric z → x ⧏ z → ¬z ⧏ x) (xR i)
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
hy : ∀ (i : yl) (j : yr), yL i < yR j
oyl : ∀ (i : yl), Numeric (yL i)
oyr : ∀ (i : yr), Numeric (yR i)
_IHyl : ∀ (i : yl), mk xl xr xL xR ⧏ yL i → ¬yL i ⧏ mk xl xr xL xR
_IHyr : ∀ (i : yr), mk xl xr xL xR ⧏ yR i → ¬yR i ⧏ mk xl xr xL xR
j✝ : xr
h₁ : xR j✝ ≤ mk yl yr yL yR
j : yr
h₂ : yR j ≤ mk xl xr xL xR
⊢ False

Next tactic:
exact IHxr _ _ (oyr _) (h₁.lf_moveRight _) (h₂.lf_moveRight _)
/-- Definition of `x ≤ y` on numeric pre-games, in terms of `<` -/
theorem le_iff_forall_lt {x y : PGame} (ox : x.Numeric) (oy : y.Numeric) :
    x ≤ y ↔ (∀ i, x.moveLeft i < y) ∧ ∀ j, x < y.moveRight j := by
  

Proof state:
x y : PGame
ox : Numeric x
oy : Numeric y
⊢ x ≤ y ↔ (∀ (i : LeftMoves x), moveLeft x i < y) ∧ ∀ (j : RightMoves y), x < moveRight y j

Next tactic:
refine' le_iff_forall_lf.trans (and_congr _ _)
/-- Definition of `x ≤ y` on numeric pre-games, in terms of `<` -/
theorem le_iff_forall_lt {x y : PGame} (ox : x.Numeric) (oy : y.Numeric) :
    x ≤ y ↔ (∀ i, x.moveLeft i < y) ∧ ∀ j, x < y.moveRight j := by
  refine' le_iff_forall_lf.trans (and_congr _ _) <;>
      

Proof state:
case refine'_1
x y : PGame
ox : Numeric x
oy : Numeric y
⊢ (∀ (i : LeftMoves x), moveLeft x i ⧏ y) ↔ ∀ (i : LeftMoves x), moveLeft x i < y

Next tactic:
refine' forall_congr' fun i => lf_iff_lt _ _
/-- Definition of `x ≤ y` on numeric pre-games, in terms of `<` -/
theorem le_iff_forall_lt {x y : PGame} (ox : x.Numeric) (oy : y.Numeric) :
    x ≤ y ↔ (∀ i, x.moveLeft i < y) ∧ ∀ j, x < y.moveRight j := by
  refine' le_iff_forall_lf.trans (and_congr _ _) <;>
      

Proof state:
case refine'_2
x y : PGame
ox : Numeric x
oy : Numeric y
⊢ (∀ (j : RightMoves y), x ⧏ moveRight y j) ↔ ∀ (j : RightMoves y), x < moveRight y j

Next tactic:
refine' forall_congr' fun i => lf_iff_lt _ _
/-- Definition of `x ≤ y` on numeric pre-games, in terms of `<` -/
theorem le_iff_forall_lt {x y : PGame} (ox : x.Numeric) (oy : y.Numeric) :
    x ≤ y ↔ (∀ i, x.moveLeft i < y) ∧ ∀ j, x < y.moveRight j := by
  refine' le_iff_forall_lf.trans (and_congr _ _) <;>
      refine' forall_congr' fun i => lf_iff_lt _ _ <;>
    

Proof state:
case refine'_1.refine'_1
x y : PGame
ox : Numeric x
oy : Numeric y
i : LeftMoves x
⊢ Numeric (moveLeft x i)

Next tactic:
apply_rules [Numeric.moveLeft, Numeric.moveRight]
/-- Definition of `x ≤ y` on numeric pre-games, in terms of `<` -/
theorem le_iff_forall_lt {x y : PGame} (ox : x.Numeric) (oy : y.Numeric) :
    x ≤ y ↔ (∀ i, x.moveLeft i < y) ∧ ∀ j, x < y.moveRight j := by
  refine' le_iff_forall_lf.trans (and_congr _ _) <;>
      refine' forall_congr' fun i => lf_iff_lt _ _ <;>
    

Proof state:
case refine'_1.refine'_2
x y : PGame
ox : Numeric x
oy : Numeric y
i : LeftMoves x
⊢ Numeric y

Next tactic:
apply_rules [Numeric.moveLeft, Numeric.moveRight]
/-- Definition of `x ≤ y` on numeric pre-games, in terms of `<` -/
theorem le_iff_forall_lt {x y : PGame} (ox : x.Numeric) (oy : y.Numeric) :
    x ≤ y ↔ (∀ i, x.moveLeft i < y) ∧ ∀ j, x < y.moveRight j := by
  refine' le_iff_forall_lf.trans (and_congr _ _) <;>
      refine' forall_congr' fun i => lf_iff_lt _ _ <;>
    

Proof state:
case refine'_2.refine'_1
x y : PGame
ox : Numeric x
oy : Numeric y
i : RightMoves y
⊢ Numeric x

Next tactic:
apply_rules [Numeric.moveLeft, Numeric.moveRight]
/-- Definition of `x ≤ y` on numeric pre-games, in terms of `<` -/
theorem le_iff_forall_lt {x y : PGame} (ox : x.Numeric) (oy : y.Numeric) :
    x ≤ y ↔ (∀ i, x.moveLeft i < y) ∧ ∀ j, x < y.moveRight j := by
  refine' le_iff_forall_lf.trans (and_congr _ _) <;>
      refine' forall_congr' fun i => lf_iff_lt _ _ <;>
    

Proof state:
case refine'_2.refine'_2
x y : PGame
ox : Numeric x
oy : Numeric y
i : RightMoves y
⊢ Numeric (moveRight y i)

Next tactic:
apply_rules [Numeric.moveLeft, Numeric.moveRight]
/-- Definition of `x < y` on numeric pre-games, in terms of `≤` -/
theorem lt_iff_exists_le {x y : PGame} (ox : x.Numeric) (oy : y.Numeric) :
    x < y ↔ (∃ i, x ≤ y.moveLeft i) ∨ ∃ j, x.moveRight j ≤ y := by
  

Proof state:
x y : PGame
ox : Numeric x
oy : Numeric y
⊢ x < y ↔ (∃ i, x ≤ moveLeft y i) ∨ ∃ j, moveRight x j ≤ y

Next tactic:
rw [← lf_iff_lt ox oy, lf_iff_exists_le]
/-- The definition of `x < y` on numeric pre-games, in terms of `<` two moves later. -/
theorem lt_def {x y : PGame} (ox : x.Numeric) (oy : y.Numeric) :
    x < y ↔
      (∃ i, (∀ i', x.moveLeft i' < y.moveLeft i) ∧ ∀ j, x < (y.moveLeft i).moveRight j) ∨
        ∃ j, (∀ i, (x.moveRight j).moveLeft i < y) ∧ ∀ j', x.moveRight j < y.moveRight j' := by
  

Proof state:
x y : PGame
ox : Numeric x
oy : Numeric y
⊢ x < y ↔
    (∃ i,
        (∀ (i' : LeftMoves x), moveLeft x i' < moveLeft y i) ∧
          ∀ (j : RightMoves (moveLeft y i)), x < moveRight (moveLeft y i) j) ∨
      ∃ j,
        (∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i < y) ∧
          ∀ (j' : RightMoves y), moveRight x j < moveRight y j'

Next tactic:
rw [← lf_iff_lt ox oy, lf_def]
/-- The definition of `x < y` on numeric pre-games, in terms of `<` two moves later. -/
theorem lt_def {x y : PGame} (ox : x.Numeric) (oy : y.Numeric) :
    x < y ↔
      (∃ i, (∀ i', x.moveLeft i' < y.moveLeft i) ∧ ∀ j, x < (y.moveLeft i).moveRight j) ∨
        ∃ j, (∀ i, (x.moveRight j).moveLeft i < y) ∧ ∀ j', x.moveRight j < y.moveRight j' := by
  rw [← lf_iff_lt ox oy, lf_def]
  

Proof state:
x y : PGame
ox : Numeric x
oy : Numeric y
⊢ ((∃ i,
        (∀ (i' : LeftMoves x), moveLeft x i' ⧏ moveLeft y i) ∧
          ∀ (j : RightMoves (moveLeft y i)), x ⧏ moveRight (moveLeft y i) j) ∨
      ∃ j,
        (∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i ⧏ y) ∧
          ∀ (j' : RightMoves y), moveRight x j ⧏ moveRight y j') ↔
    (∃ i,
        (∀ (i' : LeftMoves x), moveLeft x i' < moveLeft y i) ∧
          ∀ (j : RightMoves (moveLeft y i)), x < moveRight (moveLeft y i) j) ∨
      ∃ j,
        (∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i < y) ∧
          ∀ (j' : RightMoves y), moveRight x j < moveRight y j'

Next tactic:
refine' or_congr _ _
/-- The definition of `x < y` on numeric pre-games, in terms of `<` two moves later. -/
theorem lt_def {x y : PGame} (ox : x.Numeric) (oy : y.Numeric) :
    x < y ↔
      (∃ i, (∀ i', x.moveLeft i' < y.moveLeft i) ∧ ∀ j, x < (y.moveLeft i).moveRight j) ∨
        ∃ j, (∀ i, (x.moveRight j).moveLeft i < y) ∧ ∀ j', x.moveRight j < y.moveRight j' := by
  rw [← lf_iff_lt ox oy, lf_def]
  refine' or_congr _ _ <;> 

Proof state:
case refine'_1
x y : PGame
ox : Numeric x
oy : Numeric y
⊢ (∃ i,
      (∀ (i' : LeftMoves x), moveLeft x i' ⧏ moveLeft y i) ∧
        ∀ (j : RightMoves (moveLeft y i)), x ⧏ moveRight (moveLeft y i) j) ↔
    ∃ i,
      (∀ (i' : LeftMoves x), moveLeft x i' < moveLeft y i) ∧
        ∀ (j : RightMoves (moveLeft y i)), x < moveRight (moveLeft y i) j

Next tactic:
refine' exists_congr fun x_1 => _
/-- The definition of `x < y` on numeric pre-games, in terms of `<` two moves later. -/
theorem lt_def {x y : PGame} (ox : x.Numeric) (oy : y.Numeric) :
    x < y ↔
      (∃ i, (∀ i', x.moveLeft i' < y.moveLeft i) ∧ ∀ j, x < (y.moveLeft i).moveRight j) ∨
        ∃ j, (∀ i, (x.moveRight j).moveLeft i < y) ∧ ∀ j', x.moveRight j < y.moveRight j' := by
  rw [← lf_iff_lt ox oy, lf_def]
  refine' or_congr _ _ <;> 

Proof state:
case refine'_2
x y : PGame
ox : Numeric x
oy : Numeric y
⊢ (∃ j,
      (∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i ⧏ y) ∧
        ∀ (j' : RightMoves y), moveRight x j ⧏ moveRight y j') ↔
    ∃ j,
      (∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i < y) ∧
        ∀ (j' : RightMoves y), moveRight x j < moveRight y j'

Next tactic:
refine' exists_congr fun x_1 => _