Documentation

Mathlib.SetTheory.Nimber.Basic

Nimbers #

The goal of this file is to define the nimbers, constructed as ordinals endowed with new arithmetical operations. The nim sum a + b is recursively defined as the least ordinal not equal to any a' + b or a + b' for a' < a and b' < b. There is also a nim product, defined in the Mathlib.SetTheory.Nimber.Field file.

Nim addition arises within the context of impartial games. By the Sprague-Grundy theorem, each impartial game is equivalent to some game of nim. If x ≈ nim o₁ and y ≈ nim o₂, then x + y ≈ nim (o₁ + o₂), where the ordinals are summed together as nimbers. Unfortunately, the nim product admits no such characterization.

Notation #

Following On Numbers And Games (p. 121), we define notation ∗o for the cast from Ordinal to Nimber. Note that for general n : ℕ, ∗n is not the same as ↑n. For instance, ∗2 ≠ 0, whereas ↑2 = ↑1 + ↑1 = 0.

Implementation notes #

The nimbers inherit the order from the ordinals - this makes working with minimum excluded values much more convenient. However, the fact that nimbers are of characteristic 2 prevents the order from interacting with the arithmetic in any nice way.

To reduce API duplication, we opt not to implement operations on Nimber on Ordinal. The order isomorphisms Ordinal.toNimber and Nimber.toOrdinal allow us to cast between them whenever needed.

Basic casts between `Ordinal` and `Nimber` #

def Nimber :

Type (u_1 + 1)

A type synonym for ordinals with nimber addition and multiplication.

Equations

Nimber = Ordinal.{?u.3}

Instances For

instance instNimberZero :

Equations

instNimberZero = Ordinal.zero

instance instNimberInhabited :

Inhabited Nimber

Equations

instNimberInhabited = Ordinal.inhabited

instance instNimberOne :

Equations

instNimberOne = Ordinal.one

instance instNimberNontrivial :

Nontrivial Nimber

Equations

instNimberNontrivial = Ordinal.nontrivial

instance instNimberWellFoundedRelation :

WellFoundedRelation Nimber

Equations

instNimberWellFoundedRelation = Ordinal.wellFoundedRelation

instance Nimber.instLinearOrder :

LinearOrder Nimber

Equations

Nimber.instLinearOrder = Ordinal.instLinearOrder

instance Nimber.instSuccOrder :

SuccOrder Nimber

Equations

Nimber.instSuccOrder = Ordinal.instSuccOrder

instance Nimber.instOrderBot :

OrderBot Nimber

Equations

Nimber.instOrderBot = Ordinal.instOrderBot

instance Nimber.instNoMaxOrder :

NoMaxOrder Nimber

Equations

Nimber.instNoMaxOrder = Ordinal.instNoMaxOrder

instance Nimber.instZeroLEOneClass :

ZeroLEOneClass Nimber

Equations

Nimber.instZeroLEOneClass = Ordinal.instZeroLEOneClass

instance Nimber.instNeZeroOne :

Equations

Nimber.instNeZeroOne = Ordinal.instNeZeroOne

@[match_pattern]

def Ordinal.toNimber :

Ordinal.{u_1} ≃o Nimber

The identity function between Ordinal and Nimber.

Equations

Ordinal.toNimber = OrderIso.refl Ordinal.{?u.3}

Instances For

@[match_pattern]

def Nimber.toOrdinal :

Nimber ≃o Ordinal.{u_1}

The identity function between Nimber and Ordinal.

Equations

Nimber.toOrdinal = OrderIso.refl Nimber

Instances For

def Nimber.«term∗_» :

Lean.ParserDescr

The identity function between Ordinal and Nimber.

Equations

Nimber.«term∗_» = Lean.ParserDescr.node `Nimber.«term∗_» 75 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol "∗") (Lean.ParserDescr.cat `term 75))

Instances For

@[simp]

theorem Nimber.toOrdinal_symm_eq :

Nimber.toOrdinal.symm = Ordinal.toNimber

@[simp]

theorem Nimber.toOrdinal_toNimber (a : Nimber) :

Ordinal.toNimber (Nimber.toOrdinal a) = a

theorem Nimber.lt_wf :

WellFounded fun (x1 x2 : Nimber) => x1 < x2

instance Nimber.instWellFoundedLT :

WellFoundedLT Nimber

Equations

Nimber.instWellFoundedLT = Ordinal.wellFoundedLT

instance Nimber.instConditionallyCompleteLinearOrderBot :

ConditionallyCompleteLinearOrderBot Nimber

Equations

Nimber.instConditionallyCompleteLinearOrderBot = WellFoundedLT.conditionallyCompleteLinearOrderBot Nimber

@[simp]

theorem Nimber.bot_eq_zero :

@[simp]

theorem Nimber.toOrdinal_zero :

Nimber.toOrdinal 0 = 0

@[simp]

theorem Nimber.toOrdinal_one :

Nimber.toOrdinal 1 = 1

@[simp]

theorem Nimber.toOrdinal_eq_zero {a : Nimber} :

Nimber.toOrdinal a = 0 ↔ a = 0

@[simp]

theorem Nimber.toOrdinal_eq_one {a : Nimber} :

Nimber.toOrdinal a = 1 ↔ a = 1

@[simp]

theorem Nimber.toOrdinal_max (a b : Nimber) :

Nimber.toOrdinal (a ⊔ b) = Nimber.toOrdinal a ⊔ Nimber.toOrdinal b

@[simp]

theorem Nimber.toOrdinal_min (a b : Nimber) :

Nimber.toOrdinal (a ⊓ b) = Nimber.toOrdinal a ⊓ Nimber.toOrdinal b

theorem Nimber.succ_def (a : Nimber) :

Order.succ a = Ordinal.toNimber (Nimber.toOrdinal a + 1)

def Nimber.rec {β : Nimber → Sort u_1} (h : (a : Ordinal.{u_2}) → β (Ordinal.toNimber a)) (a : Nimber) :

β a

A recursor for Nimber. Use as induction x.

Equations

Nimber.rec h a = h (Nimber.toOrdinal a)

Instances For

theorem Nimber.induction {p : Nimber → Prop} (i : Nimber) :

(∀ (j : Nimber), (∀ k < j, p k) → p j) → p i

Ordinal.induction but for Nimber.

theorem Nimber.le_zero {a : Nimber} :

a ≤ 0 ↔ a = 0

theorem Nimber.not_lt_zero (a : Nimber) :

¬a < 0

theorem Nimber.pos_iff_ne_zero {a : Nimber} :

0 < a ↔ a ≠ 0

theorem Nimber.lt_one_iff_zero {a : Nimber} :

a < 1 ↔ a = 0

theorem Nimber.eq_nat_of_le_nat {a : Nimber} {b : ℕ} (h : a ≤ Ordinal.toNimber ↑b) :

∃ (c : ℕ), a = Ordinal.toNimber ↑c

instance Nimber.small_Iio (a : Nimber) :

Small.{u, u + 1} ↑(Set.Iio a)

Equations

⋯ = ⋯

instance Nimber.small_Iic (a : Nimber) :

Small.{u, u + 1} ↑(Set.Iic a)

Equations

⋯ = ⋯

instance Nimber.small_Ico (a b : Nimber) :

Small.{u, u + 1} ↑(Set.Ico a b)

Equations

⋯ = ⋯

instance Nimber.small_Icc (a b : Nimber) :

Small.{u, u + 1} ↑(Set.Icc a b)

Equations

⋯ = ⋯

instance Nimber.small_Ioo (a b : Nimber) :

Small.{u, u + 1} ↑(Set.Ioo a b)

Equations

⋯ = ⋯

instance Nimber.small_Ioc (a b : Nimber) :

Small.{u, u + 1} ↑(Set.Ioc a b)

Equations

⋯ = ⋯

theorem Nimber.not_bddAbove_compl_of_small (s : Set Nimber) [Small.{u, u + 1} ↑s] :

¬BddAbove sᶜ

theorem not_small_nimber :

¬Small.{u, max (u + 1) (v + 1)} Nimber

@[simp]

theorem Ordinal.toNimber_symm_eq :

Ordinal.toNimber.symm = Nimber.toOrdinal

@[simp]

theorem Ordinal.toNimber_toOrdinal (a : Ordinal.{u_1}) :

Nimber.toOrdinal (Ordinal.toNimber a) = a

@[simp]

theorem Ordinal.toNimber_zero :

Ordinal.toNimber 0 = 0

@[simp]

theorem Ordinal.toNimber_one :

Ordinal.toNimber 1 = 1

@[simp]

theorem Ordinal.toNimber_eq_zero {a : Ordinal.{u_1}} :

Ordinal.toNimber a = 0 ↔ a = 0

@[simp]

theorem Ordinal.toNimber_eq_one {a : Ordinal.{u_1}} :

Ordinal.toNimber a = 1 ↔ a = 1

@[simp]

theorem Ordinal.toNimber_max (a b : Ordinal.{u_1}) :

Ordinal.toNimber (a ⊔ b) = Ordinal.toNimber a ⊔ Ordinal.toNimber b

@[simp]

theorem Ordinal.toNimber_min (a b : Ordinal.{u_1}) :

Ordinal.toNimber (a ⊓ b) = Ordinal.toNimber a ⊓ Ordinal.toNimber b

Nimber addition #

@[irreducible]

def Nimber.add (a b : Nimber) :

Nimber addition is recursively defined so that a + b is the smallest nimber not equal to a' + b or a + b' for a' < a and b' < b.

Equations

a.add b = sInf {x : Nimber | (∃ (a' : Nimber) (_ : a' < a), a'.add b = x) ∨ ∃ (b' : Nimber) (_ : b' < b), a.add b' = x}ᶜ

Instances For

instance Nimber.instAdd :

Equations

Nimber.instAdd = { add := Nimber.add }

theorem Nimber.add_def (a b : Nimber) :

a + b = sInf {x : Nimber | (∃ a' < a, a' + b = x) ∨ ∃ b' < b, a + b' = x}ᶜ

theorem Nimber.exists_of_lt_add {a b c : Nimber} (h : c < a + b) :

(∃ a' < a, a' + b = c) ∨ ∃ b' < b, a + b' = c

theorem Nimber.add_le_of_forall_ne {a b c : Nimber} (h₁ : ∀ a' < a, a' + b ≠ c) (h₂ : ∀ b' < b, a + b' ≠ c) :

a + b ≤ c

instance Nimber.instIsLeftCancelAdd :

IsLeftCancelAdd Nimber

Equations

Nimber.instIsLeftCancelAdd = ⋯

instance Nimber.instIsRightCancelAdd :

IsRightCancelAdd Nimber

Equations

Nimber.instIsRightCancelAdd = ⋯

@[irreducible]

theorem Nimber.add_comm (a b : Nimber) :

a + b = b + a

@[irreducible]

theorem Nimber.add_eq_zero {a b : Nimber} :

a + b = 0 ↔ a = b

theorem Nimber.add_ne_zero_iff {a b : Nimber} :

a + b ≠ 0 ↔ a ≠ b

@[simp]

theorem Nimber.add_self (a : Nimber) :

a + a = 0

@[irreducible]

theorem Nimber.add_assoc (a b c : Nimber) :

a + b + c = a + (b + c)

@[irreducible]

theorem Nimber.add_zero (a : Nimber) :

a + 0 = a

theorem Nimber.zero_add (a : Nimber) :

0 + a = a

instance Nimber.instNeg :

Equations

Nimber.instNeg = { neg := id }

@[simp]

theorem Nimber.neg_eq (a : Nimber) :

-a = a

instance Nimber.instAddCommGroupWithOne :

AddCommGroupWithOne Nimber

Equations

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

@[simp]

theorem Nimber.add_cancel_right (a b : Nimber) :

a + b + b = a

@[simp]

theorem Nimber.add_cancel_left (a b : Nimber) :

a + (a + b) = b

theorem Nimber.add_trichotomy {a b c : Nimber} (h : a + b + c ≠ 0) :

b + c < a ∨ c + a < b ∨ a + b < c

theorem Nimber.lt_add_cases {a b c : Nimber} (h : a < b + c) :

a + c < b ∨ a + b < c

@[irreducible]

theorem Nimber.add_nat (a b : ℕ) :

Ordinal.toNimber ↑a + Ordinal.toNimber ↑b = Ordinal.toNimber ↑(a ^^^ b)

Nimber addition of naturals corresponds to the bitwise XOR operation.