l3lab/ntp-mathlib huggingface dataset:
attribute [-instance] subsingleton_short in
theorem subsingleton_short_example : ∀ x : PGame, Subsingleton (Short x)
  | mk xl xr xL xR =>
    ⟨fun a b => by
      cases a; cases b
      congr!
      · funext x
        apply @Subsingleton.elim _ (subsingleton_short_example (xL x))
        -- Decreasing goal in Lean 4 is `Subsequent (xL x) (mk α β L R)`
        -- where `α`, `β`, `L`, and `R` are fresh hypotheses only propositionally
        -- equal to `xl`, `xr`, `xL`, and `xR`.
        -- (In Lean 3 it was `(mk xl xr xL xR)` instead.)
      · funext x
        apply @Subsingleton.elim _ (subsingleton_short_example (xR x))⟩
termination_by subsingleton_short_example x => x
-- We need to unify a bunch of hypotheses before `pgame_wf_tac` can work.
decreasing_by {
  subst_vars
  simp only [mk.injEq, heq_eq_eq, true_and] at *
  

Proof state:
α✝ β✝ : Type u_1
L✝ : α✝ → PGame
R✝ : β✝ → PGame
L xL : α✝ → PGame
inst✝³ : Fintype α✝
x✝⁵ : (i : α✝) → Short (xL i)
inst✝² : Fintype α✝
x✝⁴ : (i : α✝) → Short (xL i)
R xR : β✝ → PGame
inst✝¹ : Fintype β✝
x✝³ : (j : β✝) → Short (xR j)
inst✝ : Fintype β✝
x✝² : (j : β✝) → Short (xR j)
x : β✝
x✝¹ : ∀ (y : PGame), InvImage WellFoundedRelation.rel (fun a => a) y (mk α✝ β✝ L R) → Subsingleton (Short y)
x✝ : ∀ (y : PGame), InvImage WellFoundedRelation.rel (fun a => a) y (mk α✝ β✝ xL xR) → Subsingleton (Short y)
h✝¹ : xL = L ∧ xR = R
h✝ : xL = L✝ ∧ xR = R✝
⊢ InvImage WellFoundedRelation.rel (fun a => a) (xR x) (mk α✝ β✝ L R)

Next tactic:
casesm* _ ∧ _
attribute [-instance] subsingleton_short in
theorem subsingleton_short_example : ∀ x : PGame, Subsingleton (Short x)
  | mk xl xr xL xR =>
    ⟨fun a b => by
      cases a; cases b
      congr!
      · funext x
        apply @Subsingleton.elim _ (subsingleton_short_example (xL x))
        -- Decreasing goal in Lean 4 is `Subsequent (xL x) (mk α β L R)`
        -- where `α`, `β`, `L`, and `R` are fresh hypotheses only propositionally
        -- equal to `xl`, `xr`, `xL`, and `xR`.
        -- (In Lean 3 it was `(mk xl xr xL xR)` instead.)
      · funext x
        apply @Subsingleton.elim _ (subsingleton_short_example (xR x))⟩
termination_by subsingleton_short_example x => x
-- We need to unify a bunch of hypotheses before `pgame_wf_tac` can work.
decreasing_by {
  subst_vars
  simp only [mk.injEq, heq_eq_eq, true_and] at *
  casesm* _ ∧ _
  

Proof state:
case intro.intro
α✝ β✝ : Type u_1
L✝ : α✝ → PGame
R✝ : β✝ → PGame
L xL : α✝ → PGame
inst✝³ : Fintype α✝
x✝⁵ : (i : α✝) → Short (xL i)
inst✝² : Fintype α✝
x✝⁴ : (i : α✝) → Short (xL i)
R xR : β✝ → PGame
inst✝¹ : Fintype β✝
x✝³ : (j : β✝) → Short (xR j)
inst✝ : Fintype β✝
x✝² : (j : β✝) → Short (xR j)
x : β✝
x✝¹ : ∀ (y : PGame), InvImage WellFoundedRelation.rel (fun a => a) y (mk α✝ β✝ L R) → Subsingleton (Short y)
x✝ : ∀ (y : PGame), InvImage WellFoundedRelation.rel (fun a => a) y (mk α✝ β✝ xL xR) → Subsingleton (Short y)
left✝¹ : xL = L
right✝¹ : xR = R
left✝ : xL = L✝
right✝ : xR = R✝
⊢ InvImage WellFoundedRelation.rel (fun a => a) (xR x) (mk α✝ β✝ L R)

Next tactic:
subst_vars
attribute [-instance] subsingleton_short in
theorem subsingleton_short_example : ∀ x : PGame, Subsingleton (Short x)
  | mk xl xr xL xR =>
    ⟨fun a b => by
      cases a; cases b
      congr!
      · funext x
        apply @Subsingleton.elim _ (subsingleton_short_example (xL x))
        -- Decreasing goal in Lean 4 is `Subsequent (xL x) (mk α β L R)`
        -- where `α`, `β`, `L`, and `R` are fresh hypotheses only propositionally
        -- equal to `xl`, `xr`, `xL`, and `xR`.
        -- (In Lean 3 it was `(mk xl xr xL xR)` instead.)
      · funext x
        apply @Subsingleton.elim _ (subsingleton_short_example (xR x))⟩
termination_by subsingleton_short_example x => x
-- We need to unify a bunch of hypotheses before `pgame_wf_tac` can work.
decreasing_by {
  subst_vars
  simp only [mk.injEq, heq_eq_eq, true_and] at *
  casesm* _ ∧ _
  subst_vars
  

Proof state:
case intro.intro
α✝ β✝ : Type u_1
xL : α✝ → PGame
inst✝³ : Fintype α✝
x✝⁵ : (i : α✝) → Short (xL i)
inst✝² : Fintype α✝
x✝⁴ : (i : α✝) → Short (xL i)
xR : β✝ → PGame
inst✝¹ : Fintype β✝
x✝³ : (j : β✝) → Short (xR j)
inst✝ : Fintype β✝
x✝² : (j : β✝) → Short (xR j)
x : β✝
x✝¹ x✝ : ∀ (y : PGame), InvImage WellFoundedRelation.rel (fun a => a) y (mk α✝ β✝ xL xR) → Subsingleton (Short y)
⊢ InvImage WellFoundedRelation.rel (fun a => a) (xR x) (mk α✝ β✝ xL xR)

Next tactic:
pgame_wf_tac
/-- A synonym for `Short.mk` that specifies the pgame in an implicit argument. -/
def Short.mk' {x : PGame} [Fintype x.LeftMoves] [Fintype x.RightMoves]
    (sL : ∀ i : x.LeftMoves, Short (x.moveLeft i))
    (sR : ∀ j : x.RightMoves, Short (x.moveRight j)) : Short x := by
  -- Porting note: Old proof relied on `unfreezingI`, which doesn't exist in Lean 4.
  

Proof state:
x : PGame
inst✝¹ : Fintype (LeftMoves x)
inst✝ : Fintype (RightMoves x)
sL : (i : LeftMoves x) → Short (moveLeft x i)
sR : (j : RightMoves x) → Short (moveRight x j)
⊢ Short x

Next tactic:
convert Short.mk sL sR
/-- A synonym for `Short.mk` that specifies the pgame in an implicit argument. -/
def Short.mk' {x : PGame} [Fintype x.LeftMoves] [Fintype x.RightMoves]
    (sL : ∀ i : x.LeftMoves, Short (x.moveLeft i))
    (sR : ∀ j : x.RightMoves, Short (x.moveRight j)) : Short x := by
  -- Porting note: Old proof relied on `unfreezingI`, which doesn't exist in Lean 4.
  convert Short.mk sL sR
  

Proof state:
case h.e'_1
x : PGame
inst✝¹ : Fintype (LeftMoves x)
inst✝ : Fintype (RightMoves x)
sL : (i : LeftMoves x) → Short (moveLeft x i)
sR : (j : RightMoves x) → Short (moveRight x j)
⊢ x = PGame.mk (LeftMoves x) (RightMoves x) (fun i => moveLeft x i) fun j => moveRight x j

Next tactic:
cases x
/-- A synonym for `Short.mk` that specifies the pgame in an implicit argument. -/
def Short.mk' {x : PGame} [Fintype x.LeftMoves] [Fintype x.RightMoves]
    (sL : ∀ i : x.LeftMoves, Short (x.moveLeft i))
    (sR : ∀ j : x.RightMoves, Short (x.moveRight j)) : Short x := by
  -- Porting note: Old proof relied on `unfreezingI`, which doesn't exist in Lean 4.
  convert Short.mk sL sR
  cases x
  

Proof state:
case h.e'_1.mk
α✝ β✝ : Type ?u.18267
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
inst✝¹ : Fintype (LeftMoves (PGame.mk α✝ β✝ a✝¹ a✝))
inst✝ : Fintype (RightMoves (PGame.mk α✝ β✝ a✝¹ a✝))
sL : (i : LeftMoves (PGame.mk α✝ β✝ a✝¹ a✝)) → Short (moveLeft (PGame.mk α✝ β✝ a✝¹ a✝) i)
sR : (j : RightMoves (PGame.mk α✝ β✝ a✝¹ a✝)) → Short (moveRight (PGame.mk α✝ β✝ a✝¹ a✝) j)
⊢ PGame.mk α✝ β✝ a✝¹ a✝ =
    PGame.mk (LeftMoves (PGame.mk α✝ β✝ a✝¹ a✝)) (RightMoves (PGame.mk α✝ β✝ a✝¹ a✝))
      (fun i => moveLeft (PGame.mk α✝ β✝ a✝¹ a✝) i) fun j => moveRight (PGame.mk α✝ β✝ a✝¹ a✝) j

Next tactic:
dsimp
/-- Extracting the `Fintype` instance for the indexing type for Left's moves in a short game.
This is an unindexed typeclass, so it can't be made a global instance.
-/
def fintypeLeft {α β : Type u} {L : α → PGame.{u}} {R : β → PGame.{u}} [S : Short ⟨α, β, L, R⟩] :
    Fintype α := by 

Proof state:
α β : Type u
L : α → PGame
R : β → PGame
S : Short (mk α β L R)
⊢ Fintype α

Next tactic:
cases' S with _ _ _ _ _ _ F _
/-- Extracting the `Fintype` instance for the indexing type for Left's moves in a short game.
This is an unindexed typeclass, so it can't be made a global instance.
-/
def fintypeLeft {α β : Type u} {L : α → PGame.{u}} {R : β → PGame.{u}} [S : Short ⟨α, β, L, R⟩] :
    Fintype α := by cases' S with _ _ _ _ _ _ F _; 

Proof state:
case mk
α β : Type u
L : α → PGame
R : β → PGame
F : Fintype α
inst✝ : Fintype β
x✝¹ : (i : α) → Short (L i)
x✝ : (j : β) → Short (R j)
⊢ Fintype α

Next tactic:
exact F
instance fintypeLeftMoves (x : PGame) [S : Short x] : Fintype x.LeftMoves := by
  

Proof state:
x : PGame
S : Short x
⊢ Fintype (LeftMoves x)

Next tactic:
cases S
instance fintypeLeftMoves (x : PGame) [S : Short x] : Fintype x.LeftMoves := by
  cases S; 

Proof state:
case mk
α✝ β✝ : Type ?u.19145
L✝ : α✝ → PGame
R✝ : β✝ → PGame
x✝¹ : (i : α✝) → Short (L✝ i)
x✝ : (j : β✝) → Short (R✝ j)
inst✝¹ : Fintype α✝
inst✝ : Fintype β✝
⊢ Fintype (LeftMoves (mk α✝ β✝ L✝ R✝))

Next tactic:
assumption
/-- Extracting the `Fintype` instance for the indexing type for Right's moves in a short game.
This is an unindexed typeclass, so it can't be made a global instance.
-/
def fintypeRight {α β : Type u} {L : α → PGame.{u}} {R : β → PGame.{u}} [S : Short ⟨α, β, L, R⟩] :
    Fintype β := by 

Proof state:
α β : Type u
L : α → PGame
R : β → PGame
S : Short (mk α β L R)
⊢ Fintype β

Next tactic:
cases' S with _ _ _ _ _ _ _ F
/-- Extracting the `Fintype` instance for the indexing type for Right's moves in a short game.
This is an unindexed typeclass, so it can't be made a global instance.
-/
def fintypeRight {α β : Type u} {L : α → PGame.{u}} {R : β → PGame.{u}} [S : Short ⟨α, β, L, R⟩] :
    Fintype β := by cases' S with _ _ _ _ _ _ _ F; 

Proof state:
case mk
α β : Type u
L : α → PGame
R : β → PGame
inst✝ : Fintype α
F : Fintype β
x✝¹ : (i : α) → Short (L i)
x✝ : (j : β) → Short (R j)
⊢ Fintype β

Next tactic:
exact F
instance fintypeRightMoves (x : PGame) [S : Short x] : Fintype x.RightMoves := by
  

Proof state:
x : PGame
S : Short x
⊢ Fintype (RightMoves x)

Next tactic:
cases S
instance fintypeRightMoves (x : PGame) [S : Short x] : Fintype x.RightMoves := by
  cases S; 

Proof state:
case mk
α✝ β✝ : Type ?u.20012
L✝ : α✝ → PGame
R✝ : β✝ → PGame
x✝¹ : (i : α✝) → Short (L✝ i)
x✝ : (j : β✝) → Short (R✝ j)
inst✝¹ : Fintype α✝
inst✝ : Fintype β✝
⊢ Fintype (RightMoves (mk α✝ β✝ L✝ R✝))

Next tactic:
assumption
instance moveLeftShort (x : PGame) [S : Short x] (i : x.LeftMoves) : Short (x.moveLeft i) := by
  

Proof state:
x : PGame
S : Short x
i : LeftMoves x
⊢ Short (moveLeft x i)

Next tactic:
cases' S with _ _ _ _ L _ _ _
instance moveLeftShort (x : PGame) [S : Short x] (i : x.LeftMoves) : Short (x.moveLeft i) := by
  cases' S with _ _ _ _ L _ _ _; 

Proof state:
case mk
α✝ β✝ : Type ?u.20275
L✝ : α✝ → PGame
R✝ : β✝ → PGame
L : (i : α✝) → Short (L✝ i)
x✝ : (j : β✝) → Short (R✝ j)
inst✝¹ : Fintype α✝
inst✝ : Fintype β✝
i : LeftMoves (mk α✝ β✝ L✝ R✝)
⊢ Short (moveLeft (mk α✝ β✝ L✝ R✝) i)

Next tactic:
apply L
/-- Extracting the `Short` instance for a move by Left.
This would be a dangerous instance potentially introducing new metavariables
in typeclass search, so we only make it an instance locally.
-/
def moveLeftShort' {xl xr} (xL xR) [S : Short (mk xl xr xL xR)] (i : xl) : Short (xL i) := by
  

Proof state:
xl xr : Type ?u.20551
xL : xl → PGame
xR : xr → PGame
S : Short (mk xl xr xL xR)
i : xl
⊢ Short (xL i)

Next tactic:
cases' S with _ _ _ _ L _ _ _
/-- Extracting the `Short` instance for a move by Left.
This would be a dangerous instance potentially introducing new metavariables
in typeclass search, so we only make it an instance locally.
-/
def moveLeftShort' {xl xr} (xL xR) [S : Short (mk xl xr xL xR)] (i : xl) : Short (xL i) := by
  cases' S with _ _ _ _ L _ _ _; 

Proof state:
case mk
xl xr : Type ?u.20588
xL : xl → PGame
xR : xr → PGame
i : xl
inst✝¹ : Fintype xl
inst✝ : Fintype xr
L : (i : xl) → Short (xL i)
x✝ : (j : xr) → Short (xR j)
⊢ Short (xL i)

Next tactic:
apply L
instance moveRightShort (x : PGame) [S : Short x] (j : x.RightMoves) : Short (x.moveRight j) := by
  

Proof state:
x : PGame
S : Short x
j : RightMoves x
⊢ Short (moveRight x j)

Next tactic:
cases' S with _ _ _ _ _ R _ _
instance moveRightShort (x : PGame) [S : Short x] (j : x.RightMoves) : Short (x.moveRight j) := by
  cases' S with _ _ _ _ _ R _ _; 

Proof state:
case mk
α✝ β✝ : Type ?u.21217
L✝ : α✝ → PGame
R✝ : β✝ → PGame
x✝ : (i : α✝) → Short (L✝ i)
R : (j : β✝) → Short (R✝ j)
inst✝¹ : Fintype α✝
inst✝ : Fintype β✝
j : RightMoves (mk α✝ β✝ L✝ R✝)
⊢ Short (moveRight (mk α✝ β✝ L✝ R✝) j)

Next tactic:
apply R
/-- Extracting the `Short` instance for a move by Right.
This would be a dangerous instance potentially introducing new metavariables
in typeclass search, so we only make it an instance locally.
-/
def moveRightShort' {xl xr} (xL xR) [S : Short (mk xl xr xL xR)] (j : xr) : Short (xR j) := by
  

Proof state:
xl xr : Type ?u.21493
xL : xl → PGame
xR : xr → PGame
S : Short (mk xl xr xL xR)
j : xr
⊢ Short (xR j)

Next tactic:
cases' S with _ _ _ _ _ R _ _
/-- Extracting the `Short` instance for a move by Right.
This would be a dangerous instance potentially introducing new metavariables
in typeclass search, so we only make it an instance locally.
-/
def moveRightShort' {xl xr} (xL xR) [S : Short (mk xl xr xL xR)] (j : xr) : Short (xR j) := by
  cases' S with _ _ _ _ _ R _ _; 

Proof state:
case mk
xl xr : Type ?u.21530
xL : xl → PGame
xR : xr → PGame
j : xr
inst✝¹ : Fintype xl
inst✝ : Fintype xr
x✝ : (i : xl) → Short (xL i)
R : (j : xr) → Short (xR j)
⊢ Short (xR j)

Next tactic:
apply R
theorem short_birthday (x : PGame.{u}) : [Short x] → x.birthday < Ordinal.omega := by
  -- Porting note: Again `induction` is used instead of `pgame_wf_tac`
  

Proof state:
x : PGame
⊢ ∀ [inst : Short x], birthday x < Ordinal.omega

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

Proof state:
case mk
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 : Short (mk xl xr xL xR)], birthday (mk xl xr xL xR) < Ordinal.omega

Next tactic:
| 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
    · apply ihr
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 =>
    

Proof state:
case mk
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 : Short (mk xl xr xL xR)], birthday (mk xl xr xL xR) < Ordinal.omega

Next tactic:
intro hs
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
    

Proof state:
case mk
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
hs : Short (mk xl xr xL xR)
⊢ birthday (mk xl xr xL xR) < Ordinal.omega

Next tactic:
rcases hs with ⟨sL, sR⟩
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⟩
    

Proof state:
case mk.mk
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)
⊢ birthday (mk xl xr xL xR) < Ordinal.omega

Next tactic:
rw [birthday, max_lt_iff]
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]
    

Proof state:
case mk.mk
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)
⊢ (Ordinal.lsub fun i => birthday (xL i)) < Ordinal.omega ∧ (Ordinal.lsub fun i => birthday (xR i)) < Ordinal.omega

Next tactic:
constructor
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
    

Proof state:
case mk.mk.left
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)
⊢ (Ordinal.lsub fun i => birthday (xL i)) < Ordinal.omega
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)
⊢ (Ordinal.lsub fun i => birthday (xR i)) < Ordinal.omega

Next tactic:
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]
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
      

Proof state:
case mk.mk.left
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)
⊢ (Ordinal.lsub fun i => birthday (xL i)) < Ordinal.omega

Next tactic:
rw [← Cardinal.ord_aleph0]
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]
      

Proof state:
case mk.mk.left
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)
⊢ (Ordinal.lsub fun i => birthday (xL i)) < Cardinal.ord Cardinal.aleph0

Next tactic:
refine'
        Cardinal.lsub_lt_ord_of_isRegular.{u, u} Cardinal.isRegular_aleph0
          (Cardinal.lt_aleph0_of_finite _) fun i => _
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 => _
      

Proof state:
case mk.mk.left
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 : xl
⊢ birthday (xL i) < Cardinal.ord Cardinal.aleph0

Next tactic:
rw [Cardinal.ord_aleph0]
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
      

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)
⊢ (Ordinal.lsub fun i => birthday (xR i)) < Ordinal.omega

Next tactic:
rw [← Cardinal.ord_aleph0]
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]
      

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)
⊢ (Ordinal.lsub fun i => birthday (xR i)) < Cardinal.ord Cardinal.aleph0

Next tactic:
refine'
        Cardinal.lsub_lt_ord_of_isRegular.{u, u} Cardinal.isRegular_aleph0
          (Cardinal.lt_aleph0_of_finite _) fun i => _
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 => _
      

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) < Cardinal.ord Cardinal.aleph0

Next tactic:
rw [Cardinal.ord_aleph0]
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]
    · 

Proof state:
case mk.mk.left
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 : xl
⊢ birthday (xL i) < Ordinal.omega

Next tactic:
apply ihl