Documentation

CombinatorialGames.Nimber.SimplestExtension.Closure

Closures #

We define groupClosure, ringClosure, and fieldClosure, which represent the smallest nimber equal or greater to another, which satisfies IsGroup, IsRing, or IsField.

The analogous algClosure is defined in Nimber.SimplestExtension.Algebraic.

For Mathlib #

@[simp]
theorem Subring.coe_eq_univ {R : Type u_1} [Ring R] {H : Subring R} :
↑H = Set.univ ↔ H = ⊤
@[simp]
theorem Subfield.coe_eq_univ {R : Type u_1} [Field R] {H : Subfield R} :
↑H = Set.univ ↔ H = ⊤
@[simp]
theorem Subfield.toSubring_eq_top {R : Type u_1} [Field R] {H : Subfield R} :
theorem IsClub.exists_between_closure {α : Type u_2} [LinearOrder α] [WellFoundedLT α] [NoMaxOrder α] [SuccOrder α] {s : Set α} (hs : IsClub s) {x : α} (hx : ∃ y ∈ s, y ≤ x) {c : α → α} (hc : ∀ (x : α), x ≤ c x) (hc' : ∀ (x : α), c x ∈ s) :
∃ l ∈ s, l ≤ x ∧ x < c (Order.succ l)

The intended use of this theorem is for c some kind of closure operator, e.g. the smallest element in the set that's ≥ than the input.

Groups #

noncomputable def Nimber.groupClosure (x : Nimber) :

Returns the smallest IsGroup that's at least x.

Equations
Instances For
    theorem Nimber.groupClosure_of_not_isGroup {x : Nimber} (h : ¬x.IsGroup) (hx₀ : x ≠ 0) :
    x.groupClosure = of (2 ^ (Ordinal.log 2 (val x) + 1))
    theorem Nimber.exists_isGroup_between {x : Nimber} (hx : x ≠ 0) :
    ∃ (l : Nimber), l.IsGroup ∧ ∃ (u : Nimber), u.IsGroup ∧ l ≤ x ∧ x < u ∧ ∀ (z : Nimber), z.IsGroup → l < z → u ≤ z

    The normal enumerator function for groups. (This is equal to ∗(2 ^ x).)

    Equations
    Instances For
      theorem Nimber.enumGroup_natCast (n : ℕ) :
      enumGroup ↑n = of (2 ^ n)

      Rings #

      noncomputable def Nimber.ringClosure (x : Nimber) :

      Returns the smallest IsRing that's at least x.

      Equations
      Instances For
        theorem Nimber.exists_isRing_between {x : Nimber} (hx : 1 < x) :
        ∃ (l : Nimber), l.IsRing ∧ ∃ (u : Nimber), u.IsRing ∧ l ≤ x ∧ x < u ∧ ∀ (z : Nimber), z.IsRing → l < z → u ≤ z
        theorem Nimber.exists_isRing_between' {x : Nimber} (hx : 1 < x) :
        ∃ (l : Nimber), l.IsRing ∧ l ≤ x ∧ x < (Order.succ l).ringClosure

        Fields #

        noncomputable def Nimber.fieldClosure (x : Nimber) :

        Returns the smallest IsField that's at least x.

        Equations
        Instances For
          theorem Nimber.exists_isField_between {x : Nimber} (hx : 1 < x) :
          ∃ (l : Nimber), l.IsField ∧ ∃ (u : Nimber), u.IsField ∧ l ≤ x ∧ x < u ∧ ∀ (z : Nimber), z.IsField → l < z → u ≤ z
          theorem Nimber.exists_isField_between' {x : Nimber} (hx : 1 < x) :
          ∃ (l : Nimber), l.IsField ∧ l ≤ x ∧ x < (Order.succ l).fieldClosure