Games described via "the state of the board".

We provide a simple mechanism for constructing combinatorial (pre-)games, by describing "the state of the board", and providing an upper bound on the number of turns remaining.

Implementation notes

We're very careful to produce a computable definition, so small games can be evaluated using decide. To achieve this, I've had to rely solely on induction on natural numbers: relying on general well-foundedness seems to be poisonous to computation?

See SetTheory/Game/Domineering for an example using this construction.

class SetTheory.PGame.State (S : Type u) : Type u

SetTheory.PGame.State S describes how to interpret s : S as a state of a combinatorial game. Use SetTheory.PGame.ofState s or SetTheory.Game.ofState s to construct the game.

SetTheory.PGame.State.l : S → Finset S and SetTheory.PGame.State.r : S → Finset S describe the states reachable by a move by Left or Right. SetTheory.PGame.State.turnBound : S → ℕ gives an upper bound on the number of possible turns remaining from this state.

• turnBound : S → ℕ

  Upper bound on the number of possible turns remaining from this state

• l : S → Finset S

  States reachable by a Left move

• r : S → Finset S

  States reachable by a Right move

• left_bound {s t : S} : t ∈ l s → turnBound t < turnBound s
• right_bound {s t : S} : t ∈ r s → turnBound t < turnBound s

theorem SetTheory.PGame.turnBound_ne_zero_of_left_move {S : Type u} [State S] {s t : S} (m : t ∈ State.l s) : State.turnBound s ≠ 0

theorem SetTheory.PGame.turnBound_ne_zero_of_right_move {S : Type u} [State S] {s t : S} (m : t ∈ State.r s) : State.turnBound s ≠ 0

theorem SetTheory.PGame.turnBound_of_left {S : Type u} [State S] {s t : S} (m : t ∈ State.l s) (n : ℕ) (h : State.turnBound s ≤ n + 1) : State.turnBound t ≤ n

theorem SetTheory.PGame.turnBound_of_right {S : Type u} [State S] {s t : S} (m : t ∈ State.r s) (n : ℕ) (h : State.turnBound s ≤ n + 1) : State.turnBound t ≤ n

def SetTheory.PGame.ofStateAux {S : Type u} [State S] (n : ℕ) (s : S) : State.turnBound s ≤ n → PGame

Construct a PGame from a state and a (not necessarily optimal) bound on the number of turns remaining.

def SetTheory.PGame.ofStateAuxRelabelling {S : Type u} [State S] (s : S) (n m : ℕ) (hn : State.turnBound s ≤ n) (hm : State.turnBound s ≤ m) : (ofStateAux n s hn).Relabelling (ofStateAux m s hm)

Two different (valid) turn bounds give equivalent games.

def SetTheory.PGame.ofState {S : Type u} [State S] (s : S) : PGame

Construct a combinatorial PGame from a state.

def SetTheory.PGame.leftMovesOfStateAux {S : Type u} [State S] (n : ℕ) {s : S} (h : State.turnBound s ≤ n) : (ofStateAux n s h).LeftMoves ≃ { t : S // t ∈ State.l s }

The equivalence between leftMoves for a PGame constructed using ofStateAux _ s _, and L s.

def SetTheory.PGame.leftMovesOfState {S : Type u} [State S] (s : S) : (ofState s).LeftMoves ≃ { t : S // t ∈ State.l s }

The equivalence between leftMoves for a PGame constructed using ofState s, and l s.

def SetTheory.PGame.rightMovesOfStateAux {S : Type u} [State S] (n : ℕ) {s : S} (h : State.turnBound s ≤ n) : (ofStateAux n s h).RightMoves ≃ { t : S // t ∈ State.r s }

The equivalence between rightMoves for a PGame constructed using ofStateAux _ s _, and R s.

def SetTheory.PGame.rightMovesOfState {S : Type u} [State S] (s : S) : (ofState s).RightMoves ≃ { t : S // t ∈ State.r s }

The equivalence between rightMoves for a PGame constructed using ofState s, and R s.

def SetTheory.PGame.relabellingMoveLeftAux {S : Type u} [State S] (n : ℕ) {s : S} (h : State.turnBound s ≤ n) (t : (ofStateAux n s h).LeftMoves) : ((ofStateAux n s h).moveLeft t).Relabelling (ofStateAux (n - 1) ↑((leftMovesOfStateAux n h) t) ⋯)

The relabelling showing moveLeft applied to a game constructed using ofStateAux has itself been constructed using ofStateAux.

def SetTheory.PGame.relabellingMoveLeft {S : Type u} [State S] (s : S) (t : (ofState s).LeftMoves) : ((ofState s).moveLeft t).Relabelling (ofState ↑((leftMovesOfState s).toFun t))

The relabelling showing moveLeft applied to a game constructed using of has itself been constructed using of.

def SetTheory.PGame.relabellingMoveRightAux {S : Type u} [State S] (n : ℕ) {s : S} (h : State.turnBound s ≤ n) (t : (ofStateAux n s h).RightMoves) : ((ofStateAux n s h).moveRight t).Relabelling (ofStateAux (n - 1) ↑((rightMovesOfStateAux n h) t) ⋯)

The relabelling showing moveRight applied to a game constructed using ofStateAux has itself been constructed using ofStateAux.

def SetTheory.PGame.relabellingMoveRight {S : Type u} [State S] (s : S) (t : (ofState s).RightMoves) : ((ofState s).moveRight t).Relabelling (ofState ↑((rightMovesOfState s).toFun t))

The relabelling showing moveRight applied to a game constructed using of has itself been constructed using of.

instance SetTheory.PGame.fintypeLeftMovesOfStateAux {S : Type u} [State S] (n : ℕ) (s : S) (h : State.turnBound s ≤ n) : Fintype (ofStateAux n s h).LeftMoves

instance SetTheory.PGame.fintypeRightMovesOfStateAux {S : Type u} [State S] (n : ℕ) (s : S) (h : State.turnBound s ≤ n) : Fintype (ofStateAux n s h).RightMoves

instance SetTheory.PGame.shortOfStateAux {S : Type u} [State S] (n : ℕ) {s : S} (h : State.turnBound s ≤ n) : (ofStateAux n s h).Short

instance SetTheory.PGame.shortOfState {S : Type u} [State S] (s : S) : (ofState s).Short

def SetTheory.Game.ofState {S : Type u} [PGame.State S] (s : S) : Game

Construct a combinatorial Game from a state.