Documentation

Mathlib.SetTheory.Game.Nim

Nim and the Sprague-Grundy theorem #

This file contains the definition for nim for any ordinal o. In the game of nim o₁ both players may move to nim o₂ for any o₂ < o₁. We also define a Grundy value for an impartial game G and prove the Sprague-Grundy theorem, that G is equivalent to nim (grundyValue G). Finally, we prove that the grundy value of a sum G + H corresponds to the nimber sum of the individual grundy values.

Implementation details #

The pen-and-paper definition of nim defines the possible moves of nim o to be Set.Iio o. However, this definition does not work for us because it would make the type of nim Ordinal.{u} → SetTheory.PGame.{u + 1}, which would make it impossible for us to state the Sprague-Grundy theorem, since that requires the type of nim to be Ordinal.{u} → SetTheory.PGame.{u}. For this reason, we instead use o.toType for the possible moves. We expose toLeftMovesNim and toRightMovesNim to conveniently convert an ordinal less than o into a left or right move of nim o, and vice versa.

@[irreducible]

noncomputable def SetTheory.PGame.nim (o : Ordinal.{u}) :

The definition of single-heap nim, which can be viewed as a pile of stones where each player can take a positive number of stones from it on their turn.

Equations

One or more equations did not get rendered due to their size.

Instances For

@[deprecated "you can use `rw [nim]` directly" (since := "2025-01-23")]

theorem SetTheory.PGame.nim_def (o : Ordinal.{u_1}) :

nim o = mk o.toType o.toType (fun (x : o.toType) => nim ↑(o.enumIsoToType.symm x)) fun (x : o.toType) => nim ↑(o.enumIsoToType.symm x)

theorem SetTheory.PGame.leftMoves_nim (o : Ordinal.{u_1}) :

(nim o).LeftMoves = o.toType

theorem SetTheory.PGame.rightMoves_nim (o : Ordinal.{u_1}) :

(nim o).RightMoves = o.toType

theorem SetTheory.PGame.moveLeft_nim_hEq (o : Ordinal.{u_1}) :

HEq (nim o).moveLeft fun (i : o.toType) => nim ↑(o.enumIsoToType.symm i)

theorem SetTheory.PGame.moveRight_nim_hEq (o : Ordinal.{u_1}) :

HEq (nim o).moveRight fun (i : o.toType) => nim ↑(o.enumIsoToType.symm i)

noncomputable def SetTheory.PGame.toLeftMovesNim {o : Ordinal.{u_1}} :

↑(Set.Iio o) ≃ (nim o).LeftMoves

Turns an ordinal less than o into a left move for nim o and vice versa.

Equations

SetTheory.PGame.toLeftMovesNim = o.enumIsoToType.trans (Equiv.cast ⋯)

Instances For

noncomputable def SetTheory.PGame.toRightMovesNim {o : Ordinal.{u_1}} :

↑(Set.Iio o) ≃ (nim o).RightMoves

Turns an ordinal less than o into a right move for nim o and vice versa.

Equations

SetTheory.PGame.toRightMovesNim = o.enumIsoToType.trans (Equiv.cast ⋯)

Instances For

@[simp]

theorem SetTheory.PGame.toLeftMovesNim_symm_lt {o : Ordinal.{u_1}} (i : (nim o).LeftMoves) :

↑(toLeftMovesNim.symm i) < o

@[simp]

theorem SetTheory.PGame.toRightMovesNim_symm_lt {o : Ordinal.{u_1}} (i : (nim o).RightMoves) :

↑(toRightMovesNim.symm i) < o

@[simp]

theorem SetTheory.PGame.moveLeft_nim {o : Ordinal.{u_1}} (i : (nim o).LeftMoves) :

(nim o).moveLeft i = nim ↑(toLeftMovesNim.symm i)

@[deprecated SetTheory.PGame.moveLeft_nim (since := "2024-10-30")]

theorem SetTheory.PGame.moveLeft_nim' {o : Ordinal.{u_1}} (i : (nim o).LeftMoves) :

(nim o).moveLeft i = nim ↑(toLeftMovesNim.symm i)

Alias of SetTheory.PGame.moveLeft_nim.

theorem SetTheory.PGame.moveLeft_toLeftMovesNim {o : Ordinal.{u_1}} (i : ↑(Set.Iio o)) :

(nim o).moveLeft (toLeftMovesNim i) = nim ↑i

@[simp]

theorem SetTheory.PGame.moveRight_nim {o : Ordinal.{u_1}} (i : (nim o).RightMoves) :

(nim o).moveRight i = nim ↑(toRightMovesNim.symm i)

@[deprecated SetTheory.PGame.moveRight_nim (since := "2024-10-30")]

theorem SetTheory.PGame.moveRight_nim' {o : Ordinal.{u_1}} (i : (nim o).RightMoves) :

(nim o).moveRight i = nim ↑(toRightMovesNim.symm i)

Alias of SetTheory.PGame.moveRight_nim.

theorem SetTheory.PGame.moveRight_toRightMovesNim {o : Ordinal.{u_1}} (i : ↑(Set.Iio o)) :

(nim o).moveRight (toRightMovesNim i) = nim ↑i

def SetTheory.PGame.leftMovesNimRecOn {o : Ordinal.{u_2}} {P : (nim o).LeftMoves → Sort u_1} (i : (nim o).LeftMoves) (H : (a : Ordinal.{u_2}) → (H : a < o) → P (toLeftMovesNim ⟨a, H⟩)) :

P i

A recursion principle for left moves of a nim game.

Equations

SetTheory.PGame.leftMovesNimRecOn i H = ⋯.mpr (H ((Ordinal.typein fun (x1 x2 : o.toType) => x1 < x2).toRelEmbedding ((Equiv.cast ⋯).symm i)) ⋯)

Instances For

def SetTheory.PGame.rightMovesNimRecOn {o : Ordinal.{u_2}} {P : (nim o).RightMoves → Sort u_1} (i : (nim o).RightMoves) (H : (a : Ordinal.{u_2}) → (H : a < o) → P (toRightMovesNim ⟨a, H⟩)) :

P i

A recursion principle for right moves of a nim game.

Equations

SetTheory.PGame.rightMovesNimRecOn i H = ⋯.mpr (H ((Ordinal.typein fun (x1 x2 : o.toType) => x1 < x2).toRelEmbedding ((Equiv.cast ⋯).symm i)) ⋯)

Instances For

instance SetTheory.PGame.isEmpty_nim_zero_leftMoves :

IsEmpty (nim 0).LeftMoves

instance SetTheory.PGame.isEmpty_nim_zero_rightMoves :

IsEmpty (nim 0).RightMoves

def SetTheory.PGame.nimZeroRelabelling :

(nim 0).Relabelling 0

nim 0 has exactly the same moves as 0.

Equations

SetTheory.PGame.nimZeroRelabelling = SetTheory.PGame.Relabelling.isEmpty (SetTheory.PGame.nim 0)

Instances For

theorem SetTheory.PGame.nim_zero_equiv :

noncomputable instance SetTheory.PGame.uniqueNimOneLeftMoves :

Unique (nim 1).LeftMoves

Equations

SetTheory.PGame.uniqueNimOneLeftMoves = (Equiv.cast SetTheory.PGame.uniqueNimOneLeftMoves.proof_1).unique

noncomputable instance SetTheory.PGame.uniqueNimOneRightMoves :

Unique (nim 1).RightMoves

Equations

SetTheory.PGame.uniqueNimOneRightMoves = (Equiv.cast SetTheory.PGame.uniqueNimOneRightMoves.proof_1).unique

@[simp]

theorem SetTheory.PGame.default_nim_one_leftMoves_eq :

default = toLeftMovesNim ⟨0, ⋯⟩

@[simp]

theorem SetTheory.PGame.default_nim_one_rightMoves_eq :

default = toRightMovesNim ⟨0, ⋯⟩

@[simp]

theorem SetTheory.PGame.toLeftMovesNim_one_symm (i : (nim 1).LeftMoves) :

toLeftMovesNim.symm i = ⟨0, ⋯⟩

@[simp]

theorem SetTheory.PGame.toRightMovesNim_one_symm (i : (nim 1).RightMoves) :

toRightMovesNim.symm i = ⟨0, ⋯⟩

theorem SetTheory.PGame.nim_one_moveLeft (x : (nim 1).LeftMoves) :

(nim 1).moveLeft x = nim 0

theorem SetTheory.PGame.nim_one_moveRight (x : (nim 1).RightMoves) :

(nim 1).moveRight x = nim 0

def SetTheory.PGame.nimOneRelabelling :

(nim 1).Relabelling star

nim 1 has exactly the same moves as star.

Equations

One or more equations did not get rendered due to their size.

Instances For

theorem SetTheory.PGame.nim_one_equiv :

@[simp]

theorem SetTheory.PGame.nim_birthday (o : Ordinal.{u_1}) :

(nim o).birthday = o

@[simp]

theorem SetTheory.PGame.neg_nim (o : Ordinal.{u_1}) :

instance SetTheory.PGame.impartial_nim (o : Ordinal.{u_1}) :

(nim o).Impartial

theorem SetTheory.PGame.nim_fuzzy_zero_of_ne_zero {o : Ordinal.{u_1}} (ho : o ≠ 0) :

(nim o).Fuzzy 0

@[simp]

theorem SetTheory.PGame.nim_add_equiv_zero_iff (o₁ o₂ : Ordinal.{u_1}) :

nim o₁ + nim o₂ ≈ 0 ↔ o₁ = o₂

@[simp]

theorem SetTheory.PGame.nim_add_fuzzy_zero_iff {o₁ o₂ : Ordinal.{u_1}} :

(nim o₁ + nim o₂).Fuzzy 0 ↔ o₁ ≠ o₂

@[simp]

theorem SetTheory.PGame.nim_equiv_iff_eq {o₁ o₂ : Ordinal.{u_1}} :

nim o₁ ≈ nim o₂ ↔ o₁ = o₂

@[irreducible]

noncomputable def SetTheory.PGame.grundyValue (G : PGame) :

The Grundy value of an impartial game is recursively defined as the minimum excluded value (the infimum of the complement) of the Grundy values of either its left or right options.

This is the ordinal which corresponds to the game of nim that the game is equivalent to.

This function takes a value in Nimber. This is a type synonym for the ordinals which has the same ordering, but addition in Nimber is such that it corresponds to the grundy value of the addition of games. See that file for more information on nimbers and their arithmetic.

Equations

G.grundyValue = sInf (Set.range fun (i : G.LeftMoves) => (G.moveLeft i).grundyValue)ᶜ

Instances For

theorem SetTheory.PGame.grundyValue_eq_sInf_moveLeft (G : PGame) :

G.grundyValue = sInf (Set.range (grundyValue ∘ G.moveLeft))ᶜ

@[deprecated SetTheory.PGame.grundyValue_eq_sInf_moveLeft (since := "2024-09-16")]

theorem SetTheory.PGame.grundyValue_eq_mex_left (G : PGame) :

G.grundyValue = Ordinal.mex fun (i : G.LeftMoves) => (G.moveLeft i).grundyValue

theorem SetTheory.PGame.grundyValue_ne_moveLeft {G : PGame} (i : G.LeftMoves) :

(G.moveLeft i).grundyValue ≠ G.grundyValue

theorem SetTheory.PGame.le_grundyValue_of_Iio_subset_moveLeft {G : PGame} {o : Nimber} (h : Set.Iio o ⊆ Set.range (grundyValue ∘ G.moveLeft)) :

o ≤ G.grundyValue

theorem SetTheory.PGame.exists_grundyValue_moveLeft_of_lt {G : PGame} {o : Nimber} (h : o < G.grundyValue) :

∃ (i : G.LeftMoves), (G.moveLeft i).grundyValue = o

theorem SetTheory.PGame.grundyValue_le_of_forall_moveLeft {G : PGame} {o : Nimber} (h : ∀ (i : G.LeftMoves), (G.moveLeft i).grundyValue ≠ o) :

G.grundyValue ≤ o

@[irreducible]

theorem SetTheory.PGame.equiv_nim_grundyValue (G : PGame) [G.Impartial] :

G ≈ nim (Nimber.toOrdinal G.grundyValue)

The Sprague-Grundy theorem states that every impartial game is equivalent to a game of nim, namely the game of nim corresponding to the game's Grundy value.

theorem SetTheory.PGame.grundyValue_eq_iff_equiv_nim {G : PGame} [G.Impartial] {o : Nimber} :

G.grundyValue = o ↔ G ≈ nim (Nimber.toOrdinal o)

@[simp]

theorem SetTheory.PGame.nim_grundyValue (o : Ordinal.{u}) :

(nim o).grundyValue = Ordinal.toNimber o

theorem SetTheory.PGame.grundyValue_eq_iff_equiv (G H : PGame) [G.Impartial] [H.Impartial] :

G.grundyValue = H.grundyValue ↔ G ≈ H

@[simp]

theorem SetTheory.PGame.grundyValue_zero :

grundyValue 0 = 0

theorem SetTheory.PGame.grundyValue_iff_equiv_zero (G : PGame) [G.Impartial] :

G.grundyValue = 0 ↔ G ≈ 0

@[simp]

theorem SetTheory.PGame.grundyValue_star :

star.grundyValue = 1

@[simp]

theorem SetTheory.PGame.grundyValue_neg (G : PGame) [G.Impartial] :

(-G).grundyValue = G.grundyValue

theorem SetTheory.PGame.grundyValue_eq_sInf_moveRight (G : PGame) [G.Impartial] :

G.grundyValue = sInf (Set.range (grundyValue ∘ G.moveRight))ᶜ

@[deprecated SetTheory.PGame.grundyValue_eq_sInf_moveRight (since := "2024-09-16")]

theorem SetTheory.PGame.grundyValue_eq_mex_right (G : PGame) [G.Impartial] :

G.grundyValue = Ordinal.mex fun (i : G.RightMoves) => (G.moveRight i).grundyValue

theorem SetTheory.PGame.grundyValue_ne_moveRight {G : PGame} [G.Impartial] (i : G.RightMoves) :

(G.moveRight i).grundyValue ≠ G.grundyValue

theorem SetTheory.PGame.le_grundyValue_of_Iio_subset_moveRight {G : PGame} [G.Impartial] {o : Nimber} (h : Set.Iio o ⊆ Set.range (grundyValue ∘ G.moveRight)) :

o ≤ G.grundyValue

theorem SetTheory.PGame.exists_grundyValue_moveRight_of_lt {G : PGame} [G.Impartial] {o : Nimber} (h : o < G.grundyValue) :

∃ (i : G.RightMoves), (G.moveRight i).grundyValue = o

theorem SetTheory.PGame.grundyValue_le_of_forall_moveRight {G : PGame} [G.Impartial] {o : Nimber} (h : ∀ (i : G.RightMoves), (G.moveRight i).grundyValue ≠ o) :

G.grundyValue ≤ o

@[irreducible]

theorem SetTheory.PGame.grundyValue_nim_add_nim (x y : Ordinal.{u_1}) :

(nim x + nim y).grundyValue = Ordinal.toNimber x + Ordinal.toNimber y

The Grundy value of the sum of two nim games equals their nimber addition.

theorem SetTheory.PGame.nim_add_nim_equiv (x y : Ordinal.{u_1}) :

nim x + nim y ≈ nim (Nimber.toOrdinal (Ordinal.toNimber x + Ordinal.toNimber y))

@[simp]

theorem SetTheory.PGame.grundyValue_add (G H : PGame) [G.Impartial] [H.Impartial] :

(G + H).grundyValue = G.grundyValue + H.grundyValue