l3lab/ntp-mathlib huggingface dataset:
instance shortAdd : ∀ (x y : PGame.{u}) [Short x] [Short y], Short (x + y)
  | mk xl xr xL xR, mk yl yr yL yR, _, _ => by
    apply Short.mk;
    all_goals
      rintro ⟨i⟩
      · apply shortAdd
      · 

Proof state:
case x.inr
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
x✝¹ : Short (mk xl xr xL xR)
x✝ : Short (mk yl yr yL yR)
val✝ : yr
⊢ Short
    (Sum.rec
      (fun i =>
        (fun a =>
            rec (motive := fun x => PGame → PGame)
              (fun xl xr a a IHxl IHxr y =>
                rec
                  (fun yl yr yL yR IHyl IHyr =>
                    let_fun y := mk yl yr yL yR;
                    mk (xl ⊕ yl) (xr ⊕ yr) (fun t => Sum.rec (fun i => IHxl i y) IHyl t) fun t =>
                      Sum.rec (fun i => IHxr i y) IHyr t)
                  y)
              (xR a))
          i (mk yl yr yL yR))
      (fun a =>
        rec
          (fun yl yr yL yR IHyl IHyr =>
            let_fun y := mk yl yr yL yR;
            mk (xl ⊕ yl) (xr ⊕ yr)
              (fun t =>
                Sum.rec
                  (fun i =>
                    (fun a =>
                        rec (motive := fun x => PGame → PGame)
                          (fun xl xr a a IHxl IHxr y =>
                            rec
                              (fun yl yr yL yR IHyl IHyr =>
                                let_fun y := mk yl yr yL yR;
                                mk (xl ⊕ yl) (xr ⊕ yr) (fun t => Sum.rec (fun i => IHxl i y) IHyl t) fun t =>
                                  Sum.rec (fun i => IHxr i y) IHyr t)
                              y)
                          (xL a))
                      i y)
                  IHyl t)
              fun t =>
              Sum.rec
                (fun i =>
                  (fun a =>
                      rec (motive := fun x => PGame → PGame)
                        (fun xl xr a a IHxl IHxr y =>
                          rec
                            (fun yl yr yL yR IHyl IHyr =>
                              let_fun y := mk yl yr yL yR;
                              mk (xl ⊕ yl) (xr ⊕ yr) (fun t => Sum.rec (fun i => IHxl i y) IHyl t) fun t =>
                                Sum.rec (fun i => IHxr i y) IHyr t)
                            y)
                        (xR a))
                    i y)
                IHyr t)
          (yR a))
      (Sum.inr val✝))

Next tactic:
change Short (mk xl xr xL xR + _)
instance shortAdd : ∀ (x y : PGame.{u}) [Short x] [Short y], Short (x + y)
  | mk xl xr xL xR, mk yl yr yL yR, _, _ => by
    apply Short.mk;
    all_goals
      rintro ⟨i⟩
      · apply shortAdd
      · change Short (mk xl xr xL xR + _); 

Proof state:
case x.inr
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
x✝¹ : Short (mk xl xr xL xR)
x✝ : Short (mk yl yr yL yR)
val✝ : yr
⊢ Short (mk xl xr xL xR + yR val✝)

Next tactic:
apply shortAdd
set_option linter.deprecated false in
instance shortBit0 (x : PGame.{u}) [Short x] : Short (bit0 x) := by 

Proof state:
x : PGame
inst✝ : Short x
⊢ Short (bit0 x)

Next tactic:
dsimp [bit0]
set_option linter.deprecated false in
instance shortBit0 (x : PGame.{u}) [Short x] : Short (bit0 x) := by dsimp [bit0]; 

Proof state:
x : PGame
inst✝ : Short x
⊢ Short (x + x)

Next tactic:
infer_instance
set_option linter.deprecated false in
instance shortBit1 (x : PGame.{u}) [Short x] : Short (bit1 x) := by 

Proof state:
x : PGame
inst✝ : Short x
⊢ Short (bit1 x)

Next tactic:
dsimp [bit1]
set_option linter.deprecated false in
instance shortBit1 (x : PGame.{u}) [Short x] : Short (bit1 x) := by dsimp [bit1]; 

Proof state:
x : PGame
inst✝ : Short x
⊢ Short (bit0 x + 1)

Next tactic:
infer_instance
/-- Auxiliary construction of decidability instances.
We build `Decidable (x ≤ y)` and `Decidable (x ⧏ y)` in a simultaneous induction.
Instances for the two projections separately are provided below.
-/
def leLFDecidable : ∀ (x y : PGame.{u}) [Short x] [Short y], Decidable (x ≤ y) × Decidable (x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR, shortx, shorty => by
    

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
shortx : Short (mk xl xr xL xR)
shorty : Short (mk yl yr yL yR)
⊢ Decidable (mk xl xr xL xR ≤ mk yl yr yL yR) × Decidable (mk xl xr xL xR ⧏ mk yl yr yL yR)

Next tactic:
constructor
/-- Auxiliary construction of decidability instances.
We build `Decidable (x ≤ y)` and `Decidable (x ⧏ y)` in a simultaneous induction.
Instances for the two projections separately are provided below.
-/
def leLFDecidable : ∀ (x y : PGame.{u}) [Short x] [Short y], Decidable (x ≤ y) × Decidable (x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR, shortx, shorty => by
    constructor
    · 

Proof state:
case fst
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
shortx : Short (mk xl xr xL xR)
shorty : Short (mk yl yr yL yR)
⊢ Decidable (mk xl xr xL xR ≤ mk yl yr yL yR)

Next tactic:
refine' @decidable_of_iff' _ _ mk_le_mk (id _)
/-- Auxiliary construction of decidability instances.
We build `Decidable (x ≤ y)` and `Decidable (x ⧏ y)` in a simultaneous induction.
Instances for the two projections separately are provided below.
-/
def leLFDecidable : ∀ (x y : PGame.{u}) [Short x] [Short y], Decidable (x ≤ y) × Decidable (x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR, shortx, shorty => by
    constructor
    · refine' @decidable_of_iff' _ _ mk_le_mk (id _)
      

Proof state:
case fst
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
shortx : Short (mk xl xr xL xR)
shorty : Short (mk yl yr yL yR)
⊢ Decidable ((∀ (i : xl), xL i ⧏ mk yl yr yL yR) ∧ ∀ (j : yr), mk xl xr xL xR ⧏ yR j)

Next tactic:
apply @And.decidable _ _ ?_ ?_
/-- Auxiliary construction of decidability instances.
We build `Decidable (x ≤ y)` and `Decidable (x ⧏ y)` in a simultaneous induction.
Instances for the two projections separately are provided below.
-/
def leLFDecidable : ∀ (x y : PGame.{u}) [Short x] [Short y], Decidable (x ≤ y) × Decidable (x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR, shortx, shorty => by
    constructor
    · refine' @decidable_of_iff' _ _ mk_le_mk (id _)
      apply @And.decidable _ _ ?_ ?_
      · 

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
shortx : Short (mk xl xr xL xR)
shorty : Short (mk yl yr yL yR)
⊢ Decidable (∀ (i : xl), xL i ⧏ mk yl yr yL yR)

Next tactic:
apply @Fintype.decidableForallFintype xl _ ?_ _
/-- Auxiliary construction of decidability instances.
We build `Decidable (x ≤ y)` and `Decidable (x ⧏ y)` in a simultaneous induction.
Instances for the two projections separately are provided below.
-/
def leLFDecidable : ∀ (x y : PGame.{u}) [Short x] [Short y], Decidable (x ≤ y) × Decidable (x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR, shortx, shorty => by
    constructor
    · refine' @decidable_of_iff' _ _ mk_le_mk (id _)
      apply @And.decidable _ _ ?_ ?_
      · apply @Fintype.decidableForallFintype xl _ ?_ _
        

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
shortx : Short (mk xl xr xL xR)
shorty : Short (mk yl yr yL yR)
⊢ DecidablePred fun a => xL a ⧏ mk yl yr yL yR

Next tactic:
intro i
/-- Auxiliary construction of decidability instances.
We build `Decidable (x ≤ y)` and `Decidable (x ⧏ y)` in a simultaneous induction.
Instances for the two projections separately are provided below.
-/
def leLFDecidable : ∀ (x y : PGame.{u}) [Short x] [Short y], Decidable (x ≤ y) × Decidable (x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR, shortx, shorty => by
    constructor
    · refine' @decidable_of_iff' _ _ mk_le_mk (id _)
      apply @And.decidable _ _ ?_ ?_
      · apply @Fintype.decidableForallFintype xl _ ?_ _
        intro i
        

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
shortx : Short (mk xl xr xL xR)
shorty : Short (mk yl yr yL yR)
i : xl
⊢ Decidable ((fun a => xL a ⧏ mk yl yr yL yR) i)

Next tactic:
apply (leLFDecidable _ _).2
/-- Auxiliary construction of decidability instances.
We build `Decidable (x ≤ y)` and `Decidable (x ⧏ y)` in a simultaneous induction.
Instances for the two projections separately are provided below.
-/
def leLFDecidable : ∀ (x y : PGame.{u}) [Short x] [Short y], Decidable (x ≤ y) × Decidable (x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR, shortx, shorty => by
    constructor
    · refine' @decidable_of_iff' _ _ mk_le_mk (id _)
      apply @And.decidable _ _ ?_ ?_
      · apply @Fintype.decidableForallFintype xl _ ?_ _
        intro i
        apply (leLFDecidable _ _).2
      · 

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
shortx : Short (mk xl xr xL xR)
shorty : Short (mk yl yr yL yR)
⊢ Decidable (∀ (j : yr), mk xl xr xL xR ⧏ yR j)

Next tactic:
apply @Fintype.decidableForallFintype yr _ ?_ _
/-- Auxiliary construction of decidability instances.
We build `Decidable (x ≤ y)` and `Decidable (x ⧏ y)` in a simultaneous induction.
Instances for the two projections separately are provided below.
-/
def leLFDecidable : ∀ (x y : PGame.{u}) [Short x] [Short y], Decidable (x ≤ y) × Decidable (x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR, shortx, shorty => by
    constructor
    · refine' @decidable_of_iff' _ _ mk_le_mk (id _)
      apply @And.decidable _ _ ?_ ?_
      · apply @Fintype.decidableForallFintype xl _ ?_ _
        intro i
        apply (leLFDecidable _ _).2
      · apply @Fintype.decidableForallFintype yr _ ?_ _
        

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
shortx : Short (mk xl xr xL xR)
shorty : Short (mk yl yr yL yR)
⊢ DecidablePred fun a => mk xl xr xL xR ⧏ yR a

Next tactic:
intro i
/-- Auxiliary construction of decidability instances.
We build `Decidable (x ≤ y)` and `Decidable (x ⧏ y)` in a simultaneous induction.
Instances for the two projections separately are provided below.
-/
def leLFDecidable : ∀ (x y : PGame.{u}) [Short x] [Short y], Decidable (x ≤ y) × Decidable (x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR, shortx, shorty => by
    constructor
    · refine' @decidable_of_iff' _ _ mk_le_mk (id _)
      apply @And.decidable _ _ ?_ ?_
      · apply @Fintype.decidableForallFintype xl _ ?_ _
        intro i
        apply (leLFDecidable _ _).2
      · apply @Fintype.decidableForallFintype yr _ ?_ _
        intro i
        

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
shortx : Short (mk xl xr xL xR)
shorty : Short (mk yl yr yL yR)
i : yr
⊢ Decidable ((fun a => mk xl xr xL xR ⧏ yR a) i)

Next tactic:
apply (leLFDecidable _ _).2
/-- Auxiliary construction of decidability instances.
We build `Decidable (x ≤ y)` and `Decidable (x ⧏ y)` in a simultaneous induction.
Instances for the two projections separately are provided below.
-/
def leLFDecidable : ∀ (x y : PGame.{u}) [Short x] [Short y], Decidable (x ≤ y) × Decidable (x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR, shortx, shorty => by
    constructor
    · refine' @decidable_of_iff' _ _ mk_le_mk (id _)
      apply @And.decidable _ _ ?_ ?_
      · apply @Fintype.decidableForallFintype xl _ ?_ _
        intro i
        apply (leLFDecidable _ _).2
      · apply @Fintype.decidableForallFintype yr _ ?_ _
        intro i
        apply (leLFDecidable _ _).2
    · 

Proof state:
case snd
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
shortx : Short (mk xl xr xL xR)
shorty : Short (mk yl yr yL yR)
⊢ Decidable (mk xl xr xL xR ⧏ mk yl yr yL yR)

Next tactic:
refine' @decidable_of_iff' _ _ mk_lf_mk (id _)
/-- Auxiliary construction of decidability instances.
We build `Decidable (x ≤ y)` and `Decidable (x ⧏ y)` in a simultaneous induction.
Instances for the two projections separately are provided below.
-/
def leLFDecidable : ∀ (x y : PGame.{u}) [Short x] [Short y], Decidable (x ≤ y) × Decidable (x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR, shortx, shorty => by
    constructor
    · refine' @decidable_of_iff' _ _ mk_le_mk (id _)
      apply @And.decidable _ _ ?_ ?_
      · apply @Fintype.decidableForallFintype xl _ ?_ _
        intro i
        apply (leLFDecidable _ _).2
      · apply @Fintype.decidableForallFintype yr _ ?_ _
        intro i
        apply (leLFDecidable _ _).2
    · refine' @decidable_of_iff' _ _ mk_lf_mk (id _)
      

Proof state:
case snd
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
shortx : Short (mk xl xr xL xR)
shorty : Short (mk yl yr yL yR)
⊢ Decidable ((∃ i, mk xl xr xL xR ≤ yL i) ∨ ∃ j, xR j ≤ mk yl yr yL yR)

Next tactic:
apply @Or.decidable _ _ ?_ ?_
/-- Auxiliary construction of decidability instances.
We build `Decidable (x ≤ y)` and `Decidable (x ⧏ y)` in a simultaneous induction.
Instances for the two projections separately are provided below.
-/
def leLFDecidable : ∀ (x y : PGame.{u}) [Short x] [Short y], Decidable (x ≤ y) × Decidable (x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR, shortx, shorty => by
    constructor
    · refine' @decidable_of_iff' _ _ mk_le_mk (id _)
      apply @And.decidable _ _ ?_ ?_
      · apply @Fintype.decidableForallFintype xl _ ?_ _
        intro i
        apply (leLFDecidable _ _).2
      · apply @Fintype.decidableForallFintype yr _ ?_ _
        intro i
        apply (leLFDecidable _ _).2
    · refine' @decidable_of_iff' _ _ mk_lf_mk (id _)
      apply @Or.decidable _ _ ?_ ?_
      · 

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
shortx : Short (mk xl xr xL xR)
shorty : Short (mk yl yr yL yR)
⊢ Decidable (∃ i, mk xl xr xL xR ≤ yL i)

Next tactic:
apply @Fintype.decidableExistsFintype yl _ ?_ _
/-- Auxiliary construction of decidability instances.
We build `Decidable (x ≤ y)` and `Decidable (x ⧏ y)` in a simultaneous induction.
Instances for the two projections separately are provided below.
-/
def leLFDecidable : ∀ (x y : PGame.{u}) [Short x] [Short y], Decidable (x ≤ y) × Decidable (x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR, shortx, shorty => by
    constructor
    · refine' @decidable_of_iff' _ _ mk_le_mk (id _)
      apply @And.decidable _ _ ?_ ?_
      · apply @Fintype.decidableForallFintype xl _ ?_ _
        intro i
        apply (leLFDecidable _ _).2
      · apply @Fintype.decidableForallFintype yr _ ?_ _
        intro i
        apply (leLFDecidable _ _).2
    · refine' @decidable_of_iff' _ _ mk_lf_mk (id _)
      apply @Or.decidable _ _ ?_ ?_
      · apply @Fintype.decidableExistsFintype yl _ ?_ _
        

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
shortx : Short (mk xl xr xL xR)
shorty : Short (mk yl yr yL yR)
⊢ DecidablePred fun a => mk xl xr xL xR ≤ yL a

Next tactic:
intro i
/-- Auxiliary construction of decidability instances.
We build `Decidable (x ≤ y)` and `Decidable (x ⧏ y)` in a simultaneous induction.
Instances for the two projections separately are provided below.
-/
def leLFDecidable : ∀ (x y : PGame.{u}) [Short x] [Short y], Decidable (x ≤ y) × Decidable (x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR, shortx, shorty => by
    constructor
    · refine' @decidable_of_iff' _ _ mk_le_mk (id _)
      apply @And.decidable _ _ ?_ ?_
      · apply @Fintype.decidableForallFintype xl _ ?_ _
        intro i
        apply (leLFDecidable _ _).2
      · apply @Fintype.decidableForallFintype yr _ ?_ _
        intro i
        apply (leLFDecidable _ _).2
    · refine' @decidable_of_iff' _ _ mk_lf_mk (id _)
      apply @Or.decidable _ _ ?_ ?_
      · apply @Fintype.decidableExistsFintype yl _ ?_ _
        intro i
        

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
shortx : Short (mk xl xr xL xR)
shorty : Short (mk yl yr yL yR)
i : yl
⊢ Decidable ((fun a => mk xl xr xL xR ≤ yL a) i)

Next tactic:
apply (leLFDecidable _ _).1
/-- Auxiliary construction of decidability instances.
We build `Decidable (x ≤ y)` and `Decidable (x ⧏ y)` in a simultaneous induction.
Instances for the two projections separately are provided below.
-/
def leLFDecidable : ∀ (x y : PGame.{u}) [Short x] [Short y], Decidable (x ≤ y) × Decidable (x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR, shortx, shorty => by
    constructor
    · refine' @decidable_of_iff' _ _ mk_le_mk (id _)
      apply @And.decidable _ _ ?_ ?_
      · apply @Fintype.decidableForallFintype xl _ ?_ _
        intro i
        apply (leLFDecidable _ _).2
      · apply @Fintype.decidableForallFintype yr _ ?_ _
        intro i
        apply (leLFDecidable _ _).2
    · refine' @decidable_of_iff' _ _ mk_lf_mk (id _)
      apply @Or.decidable _ _ ?_ ?_
      · apply @Fintype.decidableExistsFintype yl _ ?_ _
        intro i
        apply (leLFDecidable _ _).1
      · 

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
shortx : Short (mk xl xr xL xR)
shorty : Short (mk yl yr yL yR)
⊢ Decidable (∃ j, xR j ≤ mk yl yr yL yR)

Next tactic:
apply @Fintype.decidableExistsFintype xr _ ?_ _
/-- Auxiliary construction of decidability instances.
We build `Decidable (x ≤ y)` and `Decidable (x ⧏ y)` in a simultaneous induction.
Instances for the two projections separately are provided below.
-/
def leLFDecidable : ∀ (x y : PGame.{u}) [Short x] [Short y], Decidable (x ≤ y) × Decidable (x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR, shortx, shorty => by
    constructor
    · refine' @decidable_of_iff' _ _ mk_le_mk (id _)
      apply @And.decidable _ _ ?_ ?_
      · apply @Fintype.decidableForallFintype xl _ ?_ _
        intro i
        apply (leLFDecidable _ _).2
      · apply @Fintype.decidableForallFintype yr _ ?_ _
        intro i
        apply (leLFDecidable _ _).2
    · refine' @decidable_of_iff' _ _ mk_lf_mk (id _)
      apply @Or.decidable _ _ ?_ ?_
      · apply @Fintype.decidableExistsFintype yl _ ?_ _
        intro i
        apply (leLFDecidable _ _).1
      · apply @Fintype.decidableExistsFintype xr _ ?_ _
        

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
shortx : Short (mk xl xr xL xR)
shorty : Short (mk yl yr yL yR)
⊢ DecidablePred fun a => xR a ≤ mk yl yr yL yR

Next tactic:
intro i
/-- Auxiliary construction of decidability instances.
We build `Decidable (x ≤ y)` and `Decidable (x ⧏ y)` in a simultaneous induction.
Instances for the two projections separately are provided below.
-/
def leLFDecidable : ∀ (x y : PGame.{u}) [Short x] [Short y], Decidable (x ≤ y) × Decidable (x ⧏ y)
  | mk xl xr xL xR, mk yl yr yL yR, shortx, shorty => by
    constructor
    · refine' @decidable_of_iff' _ _ mk_le_mk (id _)
      apply @And.decidable _ _ ?_ ?_
      · apply @Fintype.decidableForallFintype xl _ ?_ _
        intro i
        apply (leLFDecidable _ _).2
      · apply @Fintype.decidableForallFintype yr _ ?_ _
        intro i
        apply (leLFDecidable _ _).2
    · refine' @decidable_of_iff' _ _ mk_lf_mk (id _)
      apply @Or.decidable _ _ ?_ ?_
      · apply @Fintype.decidableExistsFintype yl _ ?_ _
        intro i
        apply (leLFDecidable _ _).1
      · apply @Fintype.decidableExistsFintype xr _ ?_ _
        intro i
        

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
yl yr : Type u
yL : yl → PGame
yR : yr → PGame
shortx : Short (mk xl xr xL xR)
shorty : Short (mk yl yr yL yR)
i : xr
⊢ Decidable ((fun a => xR a ≤ mk yl yr yL yR) i)

Next tactic:
apply (leLFDecidable _ _).1
example : Short 0 := by 

Proof state:
⊢ Short 0

Next tactic:
infer_instance
example : Short 1 := by 

Proof state:
⊢ Short 1

Next tactic:
infer_instance
example : Short 2 := by 

Proof state:
⊢ Short 2

Next tactic:
infer_instance
example : Short (-2) := by 

Proof state:
⊢ Short (-2)

Next tactic:
infer_instance
example : Short (ofLists [0] [1]) := by 

Proof state:
⊢ Short (ofLists [0] [1])

Next tactic:
infer_instance
example : Short (ofLists [-2, -1] [1]) := by 

Proof state:
⊢ Short (ofLists [-2, -1] [1])

Next tactic:
infer_instance
example : Short (0 + 0) := by 

Proof state:
⊢ Short (0 + 0)

Next tactic:
infer_instance
example : Decidable ((1 : PGame) ≤ 1) := by 

Proof state:
⊢ Decidable (1 ≤ 1)

Next tactic:
infer_instance
noncomputable instance : Unique (AddUnits ℝ≥0∞) where
  default := 0
  uniq a := AddUnits.ext <| le_zero_iff.1 <| by 

Proof state:
α : Type u_1
β : Type u_2
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : AddUnits ℝ≥0∞
⊢ ↑a ≤ 0

Next tactic:
rw [← a.add_neg]
noncomputable instance : Unique (AddUnits ℝ≥0∞) where
  default := 0
  uniq a := AddUnits.ext <| le_zero_iff.1 <| by rw [← a.add_neg]; 

Proof state:
α : Type u_1
β : Type u_2
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : AddUnits ℝ≥0∞
⊢ ↑a ≤ ↑a + ↑(-a)

Next tactic:
exact le_self_add
@[simp]
theorem ofReal_toReal {a : ℝ≥0∞} (h : a ≠ ∞) : ENNReal.ofReal a.toReal = a := by
  

Proof state:
α : Type u_1
β : Type u_2
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
h : a ≠ ⊤
⊢ ENNReal.ofReal (ENNReal.toReal a) = a

Next tactic:
simp [ENNReal.toReal, ENNReal.ofReal, h]
theorem coe_toNNReal_le_self : ∀ {a : ℝ≥0∞}, ↑a.toNNReal ≤ a
  | ofNNReal r => by 

Proof state:
α : Type u_1
β : Type u_2
a b c d : ℝ≥0∞
r✝ p q r : ℝ≥0
⊢ ↑(ENNReal.toNNReal ↑r) ≤ ↑r

Next tactic:
rw [toNNReal_coe]
theorem coe_nnreal_eq (r : ℝ≥0) : (r : ℝ≥0∞) = ENNReal.ofReal r := by
  

Proof state:
α : Type u_1
β : Type u_2
a b c d : ℝ≥0∞
r✝ p q r : ℝ≥0
⊢ ↑r = ENNReal.ofReal ↑r

Next tactic:
rw [ENNReal.ofReal, Real.toNNReal_coe]
@[simp] theorem ofReal_zero : ENNReal.ofReal (0 : ℝ) = 0 := by 

Proof state:
α : Type u_1
β : Type u_2
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ ENNReal.ofReal 0 = 0

Next tactic:
simp [ENNReal.ofReal]
@[simp] theorem ofReal_one : ENNReal.ofReal (1 : ℝ) = (1 : ℝ≥0∞) := by 

Proof state:
α : Type u_1
β : Type u_2
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ ENNReal.ofReal 1 = 1

Next tactic:
simp [ENNReal.ofReal]
theorem exists_ne_top {p : ℝ≥0∞ → Prop} : (∃ a : ℝ≥0∞, a ≠ ∞ ∧ p a) ↔ ∃ r : ℝ≥0, p r := by
  

Proof state:
α : Type u_1
β : Type u_2
a b c d : ℝ≥0∞
r p✝ q : ℝ≥0
p : ℝ≥0∞ → Prop
⊢ (∃ a, a ≠ ⊤ ∧ p a) ↔ ∃ r, p ↑r

Next tactic:
simp only [exists_ne_top', ← exists_prop]
theorem toReal_eq_zero_iff (x : ℝ≥0∞) : x.toReal = 0 ↔ x = 0 ∨ x = ∞ := by
  

Proof state:
α : Type u_1
β : Type u_2
a b c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
⊢ ENNReal.toReal x = 0 ↔ x = 0 ∨ x = ⊤

Next tactic:
simp [ENNReal.toReal, toNNReal_eq_zero_iff]
theorem toNNReal_eq_one_iff (x : ℝ≥0∞) : x.toNNReal = 1 ↔ x = 1 :=
  WithTop.untop'_eq_iff.trans <| by 

Proof state:
α : Type u_1
β : Type u_2
a b c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
⊢ x = ↑1 ∨ x = ⊤ ∧ 1 = 0 ↔ x = 1

Next tactic:
simp
theorem toReal_eq_one_iff (x : ℝ≥0∞) : x.toReal = 1 ↔ x = 1 := by
  

Proof state:
α : Type u_1
β : Type u_2
a b c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
⊢ ENNReal.toReal x = 1 ↔ x = 1

Next tactic:
rw [ENNReal.toReal, NNReal.coe_eq_one, ENNReal.toNNReal_eq_one_iff]
@[simp]
theorem ofReal_toReal_eq_iff : ENNReal.ofReal a.toReal = a ↔ a ≠ ⊤ :=
  ⟨fun h => by
    

Proof state:
α : Type u_1
β : Type u_2
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : ENNReal.ofReal (ENNReal.toReal a) = a
⊢ a ≠ ⊤

Next tactic:
rw [← h]
@[simp]
theorem ofReal_toReal_eq_iff : ENNReal.ofReal a.toReal = a ↔ a ≠ ⊤ :=
  ⟨fun h => by
    rw [← h]
    

Proof state:
α : Type u_1
β : Type u_2
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : ENNReal.ofReal (ENNReal.toReal a) = a
⊢ ENNReal.ofReal (ENNReal.toReal a) ≠ ⊤

Next tactic:
exact ofReal_ne_top
@[simp]
theorem toReal_ofReal_eq_iff {a : ℝ} : (ENNReal.ofReal a).toReal = a ↔ 0 ≤ a :=
  ⟨fun h => by
    

Proof state:
α : Type u_1
β : Type u_2
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ
h : ENNReal.toReal (ENNReal.ofReal a) = a
⊢ 0 ≤ a

Next tactic:
rw [← h]
@[simp]
theorem toReal_ofReal_eq_iff {a : ℝ} : (ENNReal.ofReal a).toReal = a ↔ 0 ≤ a :=
  ⟨fun h => by
    rw [← h]
    

Proof state:
α : Type u_1
β : Type u_2
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ
h : ENNReal.toReal (ENNReal.ofReal a) = a
⊢ 0 ≤ ENNReal.toReal (ENNReal.ofReal a)

Next tactic:
exact toReal_nonneg