Documentation

Mathlib.SetTheory.Game.State

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.

source
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
Instances
    source
    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
    source
    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
    source
    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
    source
    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
    source
    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.

    Equations
    • One or more equations did not get rendered due to their size.
    Instances For
    source
    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.

    Equations
    • One or more equations did not get rendered due to their size.
    source
    def SetTheory.PGame.ofState {S : Type u} [State S] (s : S) :
    PGame

    Construct a combinatorial PGame from a state.

    Equations
    Instances For
    source
    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.

    Equations
    • One or more equations did not get rendered due to their size.
    source
    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.

    Equations
    source
    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.

    Equations
    • One or more equations did not get rendered due to their size.
    source
    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.

    Equations
    source
    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.

    Equations
    • One or more equations did not get rendered due to their size.
    source
    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.

    Equations
    • One or more equations did not get rendered due to their size.
    source
    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.

    Equations
    • One or more equations did not get rendered due to their size.
    source
    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.

    Equations
    • One or more equations did not get rendered due to their size.
    source
    instance SetTheory.PGame.fintypeLeftMovesOfStateAux {S : Type u} [State S] (n : ℕ) (s : S) (h : State.turnBound s ≤ n) :
    Fintype (ofStateAux n s h).LeftMoves
    Equations
    source
    instance SetTheory.PGame.fintypeRightMovesOfStateAux {S : Type u} [State S] (n : ℕ) (s : S) (h : State.turnBound s ≤ n) :
    Fintype (ofStateAux n s h).RightMoves
    Equations
    source
    instance SetTheory.PGame.shortOfStateAux {S : Type u} [State S] (n : ℕ) {s : S} (h : State.turnBound s ≤ n) :
    (ofStateAux n s h).Short
    Equations
    • One or more equations did not get rendered due to their size.
    source
    instance SetTheory.PGame.shortOfState {S : Type u} [State S] (s : S) :
    (ofState s).Short
    Equations
    source
    def SetTheory.Game.ofState {S : Type u} [PGame.State S] (s : S) :
    Game

    Construct a combinatorial Game from a state.

    Equations