File: Mathlib/SetTheory/Game/Short.lean

full_name: SetTheory.PGame.Short.mk
code: /-- A short game is a game with a finite set of moves at every turn. -/
inductive Short : PGame.{u} → Type (u + 1)
  | mk :
    ∀ {α β : Type u} {L : α → PGame.{u}} {R : β → PGame.{u}} (_ : ∀ i : α, Short (L i))
      (_ : ∀ j : β, Short (R j)) [Fintype α] [Fintype β], Short ⟨α, β, L, R⟩
goal: ((i : α) → (L i).Short) →
  ((j : β) → (R j).Short) → [inst : Fintype α] → [inst : Fintype β] → (SetTheory.PGame.mk α β L R).Short

full_name: SetTheory.PGame.Short
code: /-- A short game is a game with a finite set of moves at every turn. -/
inductive Short : PGame.{u} → Type (u + 1)
  | mk :
    ∀ {α β : Type u} {L : α → PGame.{u}} {R : β → PGame.{u}} (_ : ∀ i : α, Short (L i))
      (_ : ∀ j : β, Short (R j)) [Fintype α] [Fintype β], Short ⟨α, β, L, R⟩
goal: SetTheory.PGame → Type (u + 1)

full_name: SetTheory.PGame.subsingleton_short
code: instance subsingleton_short (x : PGame) : Subsingleton (Short x) 
goal: Subsingleton x.Short

full_name: SetTheory.PGame.subsingleton_short_example
code: theorem subsingleton_short_example : ∀ x : PGame, Subsingleton (Short x)
  
goal: Subsingleton x.Short

full_name: SetTheory.PGame.Short.mk'
code: /-- 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 
goal: x.Short

full_name: SetTheory.PGame.fintypeLeft
code: /-- 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 α 
goal: Fintype α

full_name: SetTheory.PGame.fintypeLeftMoves
code: instance fintypeLeftMoves (x : PGame) [S : Short x] : Fintype x.LeftMoves 
goal: Fintype x.LeftMoves

full_name: SetTheory.PGame.fintypeRight
code: /-- 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 β 
goal: Fintype β

full_name: SetTheory.PGame.fintypeRightMoves
code: instance fintypeRightMoves (x : PGame) [S : Short x] : Fintype x.RightMoves 
goal: Fintype x.RightMoves

full_name: SetTheory.PGame.moveLeftShort
code: instance moveLeftShort (x : PGame) [S : Short x] (i : x.LeftMoves) : Short (x.moveLeft i) 
goal: (x.moveLeft i).Short

full_name: SetTheory.PGame.moveLeftShort'
code: /-- 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) 
goal: (xL i).Short

full_name: SetTheory.PGame.moveRightShort
code: instance moveRightShort (x : PGame) [S : Short x] (j : x.RightMoves) : Short (x.moveRight j) 
goal: (x.moveRight j).Short

full_name: SetTheory.PGame.moveRightShort'
code: /-- 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) 
goal: (xR j).Short

full_name: SetTheory.PGame.short_birthday
code: theorem short_birthday (x : PGame.{u}) : [Short x] → x.birthday < Ordinal.omega 
goal: x.birthday < Ordinal.omega

full_name: SetTheory.PGame.Short.ofIsEmpty
code: /-- 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) 
goal: (SetTheory.PGame.mk l r xL xR).Short

full_name: SetTheory.PGame.short0
code: instance short0 : Short 0 
goal: SetTheory.PGame.Short 0

full_name: SetTheory.PGame.short1
code: instance short1 : Short 1 
goal: SetTheory.PGame.Short 1

full_name: SetTheory.PGame.ListShort.nil
code: /-- Evidence that every `PGame` in a list is `Short`. -/
class inductive ListShort : List PGame.{u} → Type (u + 1)
  | nil : ListShort []
  -- Porting note: We introduce `cons` as a separate instance because attempting to use
  -- `[ListShort tl]` as a constructor argument errors saying that `ListShort tl` is not a class.
  -- Is this a bug in `class inductive`?
  | cons' {hd : PGame.{u}} {tl : List PGame.{u}} : Short hd → ListShort tl → ListShort (hd::tl)
goal: SetTheory.PGame.ListShort []

full_name: SetTheory.PGame.ListShort.cons'
code: /-- Evidence that every `PGame` in a list is `Short`. -/
class inductive ListShort : List PGame.{u} → Type (u + 1)
  | nil : ListShort []
  -- Porting note: We introduce `cons` as a separate instance because attempting to use
  -- `[ListShort tl]` as a constructor argument errors saying that `ListShort tl` is not a class.
  -- Is this a bug in `class inductive`?
  | cons' {hd : PGame.{u}} {tl : List PGame.{u}} : Short hd → ListShort tl → ListShort (hd::tl)
goal: hd.Short → SetTheory.PGame.ListShort tl → SetTheory.PGame.ListShort (hd :: tl)

full_name: SetTheory.PGame.ListShort
code: /-- Evidence that every `PGame` in a list is `Short`. -/
class inductive ListShort : List PGame.{u} → Type (u + 1)
  | nil : ListShort []
  -- Porting note: We introduce `cons` as a separate instance because attempting to use
  -- `[ListShort tl]` as a constructor argument errors saying that `ListShort tl` is not a class.
  -- Is this a bug in `class inductive`?
  | cons' {hd : PGame.{u}} {tl : List PGame.{u}} : Short hd → ListShort tl → ListShort (hd::tl)
goal: List SetTheory.PGame → Type (u + 1)

full_name: SetTheory.PGame.ListShort.cons
code: instance ListShort.cons (hd : PGame.{u}) [short_hd : Short hd]
                        (tl : List PGame.{u}) [short_tl : ListShort tl] :
    ListShort (hd::tl) 
goal: SetTheory.PGame.ListShort (hd :: tl)

full_name: SetTheory.PGame.listShortGet
code: instance listShortGet :
    ∀ (L : List PGame.{u}) [ListShort L] (i : Nat) (h : i < List.length L), Short L[i]
  
goal: L[i].Short

full_name: SetTheory.PGame.shortOfLists
code: instance shortOfLists : ∀ (L R : List PGame) [ListShort L] [ListShort R], Short (PGame.ofLists L R)
  
goal: (SetTheory.PGame.ofLists L R).Short

full_name: SetTheory.PGame.shortOfRelabelling
code: /-- 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
  
goal: x.Relabelling y → x.Short → y.Short

full_name: SetTheory.PGame.shortNeg
code: instance shortNeg : ∀ (x : PGame.{u}) [Short x], Short (-x)
  
goal: (-x).Short

full_name: SetTheory.PGame.shortAdd
code: instance shortAdd : ∀ (x y : PGame.{u}) [Short x] [Short y], Short (x + y)
  
goal: (x + y).Short

full_name: SetTheory.PGame.shortNat
code: instance shortNat : ∀ n : ℕ, Short n
  
goal: (↑n).Short

full_name: SetTheory.PGame.shortOfNat
code: instance shortOfNat (n : ℕ) [Nat.AtLeastTwo n] : Short (no_index (OfNat.ofNat n)) 
goal: (OfNat.ofNat n).Short

full_name: SetTheory.PGame.shortBit0
code: instance shortBit0 (x : PGame.{u}) [Short x] : Short (x + x) 
goal: (x + x).Short

full_name: SetTheory.PGame.shortBit1
code: instance shortBit1 (x : PGame.{u}) [Short x] : Short ((x + x) + 1) 
goal: (x + x + 1).Short

full_name: SetTheory.PGame.leLFDecidable
code: /-- 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)
  
goal: Decidable (x ≤ y) × Decidable (x.LF y)

full_name: SetTheory.PGame.leDecidable
code: instance leDecidable (x y : PGame.{u}) [Short x] [Short y] : Decidable (x ≤ y) 
goal: Decidable (x ≤ y)

full_name: SetTheory.PGame.lfDecidable
code: instance lfDecidable (x y : PGame.{u}) [Short x] [Short y] : Decidable (x ⧏ y) 
goal: Decidable (x.LF y)

full_name: SetTheory.PGame.ltDecidable
code: instance ltDecidable (x y : PGame.{u}) [Short x] [Short y] : Decidable (x < y) 
goal: Decidable (x < y)

full_name: SetTheory.PGame.equivDecidable
code: instance equivDecidable (x y : PGame.{u}) [Short x] [Short y] : Decidable (x ≈ y) 
goal: Decidable (x ≈ y)