l3lab/ntp-mathlib huggingface dataset:
theorem short_birthday (x : PGame.{u}) : [Short x] → x.birthday < Ordinal.omega := by
  -- Porting note: Again `induction` is used instead of `pgame_wf_tac`
  induction x with
  | mk xl xr xL xR ihl ihr =>
    intro hs
    rcases hs with ⟨sL, sR⟩
    rw [birthday, max_lt_iff]
    constructor
    all_goals
      rw [← Cardinal.ord_aleph0]
      refine'
        Cardinal.lsub_lt_ord_of_isRegular.{u, u} Cardinal.isRegular_aleph0
          (Cardinal.lt_aleph0_of_finite _) fun i => _
      rw [Cardinal.ord_aleph0]
    · apply ihl
    · 

Proof state:
case mk.mk.right
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
ihl : ∀ (a : xl) [inst : Short (xL a)], birthday (xL a) < Ordinal.omega
ihr : ∀ (a : xr) [inst : Short (xR a)], birthday (xR a) < Ordinal.omega
inst✝¹ : Fintype xl
inst✝ : Fintype xr
sL : (i : xl) → Short (xL i)
sR : (j : xr) → Short (xR j)
i : xr
⊢ birthday (xR i) < Ordinal.omega

Next tactic:
apply ihr
/-- This leads to infinite loops if made into an instance. -/
def Short.ofIsEmpty {l r xL xR} [IsEmpty l] [IsEmpty r] : Short (PGame.mk l r xL xR) := by
  

Proof state:
l r : Type ?u.148317
xL : l → PGame
xR : r → PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
⊢ Short (PGame.mk l r xL xR)

Next tactic:
have : Fintype l := Fintype.ofIsEmpty
/-- This leads to infinite loops if made into an instance. -/
def Short.ofIsEmpty {l r xL xR} [IsEmpty l] [IsEmpty r] : Short (PGame.mk l r xL xR) := by
  have : Fintype l := Fintype.ofIsEmpty
  

Proof state:
l r : Type ?u.148317
xL : l → PGame
xR : r → PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
this : Fintype l
⊢ Short (PGame.mk l r xL xR)

Next tactic:
have : Fintype r := Fintype.ofIsEmpty
/-- This leads to infinite loops if made into an instance. -/
def Short.ofIsEmpty {l r xL xR} [IsEmpty l] [IsEmpty r] : Short (PGame.mk l r xL xR) := by
  have : Fintype l := Fintype.ofIsEmpty
  have : Fintype r := Fintype.ofIsEmpty
  

Proof state:
l r : Type ?u.148317
xL : l → PGame
xR : r → PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
this✝ : Fintype l
this : Fintype r
⊢ Short (PGame.mk l r xL xR)

Next tactic:
exact Short.mk isEmptyElim isEmptyElim
instance short1 : Short 1 :=
  Short.mk (fun i => by 

Proof state:
i : PUnit.{?u.148865 + 1}
⊢ Short 0

Next tactic:
cases i
instance short1 : Short 1 :=
  Short.mk (fun i => by cases i; 

Proof state:
case unit
⊢ Short 0

Next tactic:
infer_instance
instance short1 : Short 1 :=
  Short.mk (fun i => by cases i; infer_instance) fun j => by 

Proof state:
j : PEmpty.{?u.148865 + 1}
⊢ Short (PEmpty.elim j)

Next tactic:
cases j
instance listShortGet :
    ∀ (L : List PGame.{u}) [ListShort L] (i : Fin (List.length L)), Short (List.get L i)
  | [], _, n => by
    

Proof state:
x✝ : ListShort []
n : Fin (List.length [])
⊢ Short (List.get [] n)

Next tactic:
exfalso
instance listShortGet :
    ∀ (L : List PGame.{u}) [ListShort L] (i : Fin (List.length L)), Short (List.get L i)
  | [], _, n => by
    exfalso
    

Proof state:
case h
x✝ : ListShort []
n : Fin (List.length [])
⊢ False

Next tactic:
rcases n with ⟨_, ⟨⟩⟩
instance listShortGet :
    ∀ (L : List PGame.{u}) [ListShort L] (i : Fin (List.length L)), Short (List.get L i)
  | [], _, n => by
    exfalso
    rcases n with ⟨_, ⟨⟩⟩
    -- Porting note: The proof errors unless `done` or a `;` is added after `rcases`
    

Proof state:

Next tactic:
done
set_option linter.deprecated false in
@[deprecated listShortGet]
instance listShortNthLe (L : List PGame.{u}) [ListShort L] (i : Fin (List.length L)) :
    Short (List.nthLe L i i.is_lt) := by
  

Proof state:
L : List PGame
inst✝ : ListShort L
i : Fin (List.length L)
⊢ Short (List.nthLe L ↑i (_ : ↑i < List.length L))

Next tactic:
rw [List.nthLe_eq]
set_option linter.deprecated false in
@[deprecated listShortGet]
instance listShortNthLe (L : List PGame.{u}) [ListShort L] (i : Fin (List.length L)) :
    Short (List.nthLe L i i.is_lt) := by
  rw [List.nthLe_eq]
  

Proof state:
L : List PGame
inst✝ : ListShort L
i : Fin (List.length L)
⊢ Short (List.get L { val := ↑i, isLt := (_ : ↑i < List.length L) })

Next tactic:
apply listShortGet
instance shortOfLists : ∀ (L R : List PGame) [ListShort L] [ListShort R], Short (PGame.ofLists L R)
  | L, R, _, _ => by
    

Proof state:
L R : List PGame
x✝¹ : ListShort L
x✝ : ListShort R
⊢ Short (ofLists L R)

Next tactic:
apply Short.mk
instance shortOfLists : ∀ (L R : List PGame) [ListShort L] [ListShort R], Short (PGame.ofLists L R)
  | L, R, _, _ => by
    apply Short.mk
    · 

Proof state:
case x
L R : List PGame
x✝¹ : ListShort L
x✝ : ListShort R
⊢ (i : ULift.{?u.152259, 0} (Fin (List.length L))) → Short (List.nthLe L ↑i.down (_ : ↑i.down < List.length L))

Next tactic:
intros
instance shortOfLists : ∀ (L R : List PGame) [ListShort L] [ListShort R], Short (PGame.ofLists L R)
  | L, R, _, _ => by
    apply Short.mk
    · intros; 

Proof state:
case x
L R : List PGame
x✝¹ : ListShort L
x✝ : ListShort R
i✝ : ULift.{?u.152259, 0} (Fin (List.length L))
⊢ Short (List.nthLe L ↑i✝.down (_ : ↑i✝.down < List.length L))

Next tactic:
infer_instance
instance shortOfLists : ∀ (L R : List PGame) [ListShort L] [ListShort R], Short (PGame.ofLists L R)
  | L, R, _, _ => by
    apply Short.mk
    · intros; infer_instance
    · 

Proof state:
case x
L R : List PGame
x✝¹ : ListShort L
x✝ : ListShort R
⊢ (j : ULift.{?u.152259, 0} (Fin (List.length R))) → Short (List.nthLe R ↑j.down (_ : ↑j.down < List.length R))

Next tactic:
intros
instance shortOfLists : ∀ (L R : List PGame) [ListShort L] [ListShort R], Short (PGame.ofLists L R)
  | L, R, _, _ => by
    apply Short.mk
    · intros; infer_instance
    · intros; 

Proof state:
case x
L R : List PGame
x✝¹ : ListShort L
x✝ : ListShort R
j✝ : ULift.{?u.152259, 0} (Fin (List.length R))
⊢ Short (List.nthLe R ↑j✝.down (_ : ↑j✝.down < List.length R))

Next tactic:
apply PGame.listShortGet
/-- If `x` is a short game, and `y` is a relabelling of `x`, then `y` is also short. -/
def shortOfRelabelling : ∀ {x y : PGame.{u}}, Relabelling x y → Short x → Short y
  | x, y, ⟨L, R, rL, rR⟩, S => by
    

Proof state:
x y : PGame
L : LeftMoves x ≃ LeftMoves y
R : RightMoves x ≃ RightMoves y
rL : (i : LeftMoves x) → moveLeft x i ≡r moveLeft y (L i)
rR : (j : RightMoves x) → moveRight x j ≡r moveRight y (R j)
S : Short x
⊢ Short y

Next tactic:
haveI := Fintype.ofEquiv _ L
/-- If `x` is a short game, and `y` is a relabelling of `x`, then `y` is also short. -/
def shortOfRelabelling : ∀ {x y : PGame.{u}}, Relabelling x y → Short x → Short y
  | x, y, ⟨L, R, rL, rR⟩, S => by
    haveI := Fintype.ofEquiv _ L
    

Proof state:
x y : PGame
L : LeftMoves x ≃ LeftMoves y
R : RightMoves x ≃ RightMoves y
rL : (i : LeftMoves x) → moveLeft x i ≡r moveLeft y (L i)
rR : (j : RightMoves x) → moveRight x j ≡r moveRight y (R j)
S : Short x
this : Fintype (LeftMoves y)
⊢ Short y

Next tactic:
haveI := Fintype.ofEquiv _ R
/-- If `x` is a short game, and `y` is a relabelling of `x`, then `y` is also short. -/
def shortOfRelabelling : ∀ {x y : PGame.{u}}, Relabelling x y → Short x → Short y
  | x, y, ⟨L, R, rL, rR⟩, S => by
    haveI := Fintype.ofEquiv _ L
    haveI := Fintype.ofEquiv _ R
    

Proof state:
x y : PGame
L : LeftMoves x ≃ LeftMoves y
R : RightMoves x ≃ RightMoves y
rL : (i : LeftMoves x) → moveLeft x i ≡r moveLeft y (L i)
rR : (j : RightMoves x) → moveRight x j ≡r moveRight y (R j)
S : Short x
this✝ : Fintype (LeftMoves y)
this : Fintype (RightMoves y)
⊢ Short y

Next tactic:
exact
      Short.mk'
        (fun i => by rw [← L.right_inv i]; apply shortOfRelabelling (rL (L.symm i)) inferInstance)
        fun j => by simpa using shortOfRelabelling (rR (R.symm j)) inferInstance
/-- If `x` is a short game, and `y` is a relabelling of `x`, then `y` is also short. -/
def shortOfRelabelling : ∀ {x y : PGame.{u}}, Relabelling x y → Short x → Short y
  | x, y, ⟨L, R, rL, rR⟩, S => by
    haveI := Fintype.ofEquiv _ L
    haveI := Fintype.ofEquiv _ R
    exact
      Short.mk'
        (fun i => by 

Proof state:
x y : PGame
L : LeftMoves x ≃ LeftMoves y
R : RightMoves x ≃ RightMoves y
rL : (i : LeftMoves x) → moveLeft x i ≡r moveLeft y (L i)
rR : (j : RightMoves x) → moveRight x j ≡r moveRight y (R j)
S : Short x
this✝ : Fintype (LeftMoves y)
this : Fintype (RightMoves y)
i : LeftMoves y
⊢ Short (moveLeft y i)

Next tactic:
rw [← L.right_inv i]
/-- If `x` is a short game, and `y` is a relabelling of `x`, then `y` is also short. -/
def shortOfRelabelling : ∀ {x y : PGame.{u}}, Relabelling x y → Short x → Short y
  | x, y, ⟨L, R, rL, rR⟩, S => by
    haveI := Fintype.ofEquiv _ L
    haveI := Fintype.ofEquiv _ R
    exact
      Short.mk'
        (fun i => by rw [← L.right_inv i]; 

Proof state:
x y : PGame
L : LeftMoves x ≃ LeftMoves y
R : RightMoves x ≃ RightMoves y
rL : (i : LeftMoves x) → moveLeft x i ≡r moveLeft y (L i)
rR : (j : RightMoves x) → moveRight x j ≡r moveRight y (R j)
S : Short x
this✝ : Fintype (LeftMoves y)
this : Fintype (RightMoves y)
i : LeftMoves y
⊢ Short (moveLeft y (Equiv.toFun L (Equiv.invFun L i)))

Next tactic:
apply shortOfRelabelling (rL (L.symm i)) inferInstance
/-- If `x` is a short game, and `y` is a relabelling of `x`, then `y` is also short. -/
def shortOfRelabelling : ∀ {x y : PGame.{u}}, Relabelling x y → Short x → Short y
  | x, y, ⟨L, R, rL, rR⟩, S => by
    haveI := Fintype.ofEquiv _ L
    haveI := Fintype.ofEquiv _ R
    exact
      Short.mk'
        (fun i => by rw [← L.right_inv i]; apply shortOfRelabelling (rL (L.symm i)) inferInstance)
        fun j => by 

Proof state:
x y : PGame
L : LeftMoves x ≃ LeftMoves y
R : RightMoves x ≃ RightMoves y
rL : (i : LeftMoves x) → moveLeft x i ≡r moveLeft y (L i)
rR : (j : RightMoves x) → moveRight x j ≡r moveRight y (R j)
S : Short x
this✝ : Fintype (LeftMoves y)
this : Fintype (RightMoves y)
j : RightMoves y
⊢ Short (moveRight y j)

Next tactic:
simpa using shortOfRelabelling (rR (R.symm j)) inferInstance
instance shortNeg : ∀ (x : PGame.{u}) [Short x], Short (-x)
  | mk xl xr xL xR, _ => by
    

Proof state:
xl xr : Type u
xL : xl → PGame
xR : xr → PGame
x✝ : Short (mk xl xr xL xR)
⊢ Short (-mk xl xr xL xR)

Next tactic:
exact Short.mk (fun i => shortNeg _) fun i => shortNeg _
instance shortAdd : ∀ (x y : PGame.{u}) [Short x] [Short y], Short (x + y)
  | mk xl xr xL xR, mk yl yr yL yR, _, _ => by
    

Proof state:
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)
⊢ Short (mk xl xr xL xR + mk yl yr yL yR)

Next tactic:
apply Short.mk
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
      

Proof state:
case x
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)
⊢ (i : xl ⊕ yl) →
    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)
                (xL 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)
            (yL a))
        i)

Next tactic:
rintro ⟨i⟩
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⟩
      · 

Proof state:
case x.inl
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)
i : xl
⊢ 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)
              (xL 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)
          (yL a))
      (Sum.inl i))

Next tactic:
apply shortAdd
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✝ : yl
⊢ 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)
              (xL 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)
          (yL 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✝ : yl
⊢ Short (mk xl xr xL xR + yL val✝)

Next tactic:
apply shortAdd
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
      

Proof state:
case x
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)
⊢ (j : xr ⊕ 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))
        j)

Next tactic:
rintro ⟨i⟩
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⟩
      · 

Proof state:
case x.inl
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)
i : xr
⊢ 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.inl i))

Next tactic:
apply shortAdd