fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
toGame_lf_iff {a b : Ordinal} : Game.LF a.toGame b.toGame ↔ a < b :=
toPGame_lf_iff | theorem | SetTheory | [
"Mathlib.SetTheory.Game.Basic",
"Mathlib.SetTheory.Ordinal.NaturalOps",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Ordinal.lean | toGame_lf_iff | null |
toGame_le_iff {a b : Ordinal} : a.toGame ≤ b.toGame ↔ a ≤ b :=
toPGame_le_iff | theorem | SetTheory | [
"Mathlib.SetTheory.Game.Basic",
"Mathlib.SetTheory.Ordinal.NaturalOps",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Ordinal.lean | toGame_le_iff | null |
toGame_lt_iff {a b : Ordinal} : a.toGame < b.toGame ↔ a < b :=
toPGame_lt_iff | theorem | SetTheory | [
"Mathlib.SetTheory.Game.Basic",
"Mathlib.SetTheory.Ordinal.NaturalOps",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Ordinal.lean | toGame_lt_iff | null |
toGame_inj {a b : Ordinal} : a.toGame = b.toGame ↔ a = b :=
toGame.inj | theorem | SetTheory | [
"Mathlib.SetTheory.Game.Basic",
"Mathlib.SetTheory.Ordinal.NaturalOps",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Ordinal.lean | toGame_inj | null |
toPGame_nadd (a b : Ordinal) : (a ♯ b).toPGame ≈ a.toPGame + b.toPGame := by
refine ⟨le_of_forall_lf (fun i => ?_) isEmptyElim, le_of_forall_lf (fun i => ?_) isEmptyElim⟩
· rw [toPGame_moveLeft']
rcases lt_nadd_iff.1 (toLeftMovesToPGame_symm_lt i) with (⟨c, hc, hc'⟩ | ⟨c, hc, hc'⟩) <;>
rw [← toPGame_le_iff, le_congr_right (toPGame_nadd _ _)] at hc' <;>
apply lf_of_le_of_lf hc'
· apply add_lf_add_right
rwa [toPGame_lf_iff]
· apply add_lf_add_left
rwa [toPGame_lf_iff]
· apply leftMoves_add_cases i <;>
intro i <;>
let wf := toLeftMovesToPGame_symm_lt i <;>
(try rw [add_moveLeft_inl]) <;>
(try rw [add_moveLeft_inr]) <;>
rw [toPGame_moveLeft', ← lf_congr_left (toPGame_nadd _ _), toPGame_lf_iff]
· exact nadd_lt_nadd_right wf _
· exact nadd_lt_nadd_left wf _
termination_by (a, b) | theorem | SetTheory | [
"Mathlib.SetTheory.Game.Basic",
"Mathlib.SetTheory.Ordinal.NaturalOps",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Ordinal.lean | toPGame_nadd | The natural addition of ordinals corresponds to their sum as games. |
toGame_nadd (a b : Ordinal) : (a ♯ b).toGame = a.toGame + b.toGame :=
game_eq (toPGame_nadd a b) | theorem | SetTheory | [
"Mathlib.SetTheory.Game.Basic",
"Mathlib.SetTheory.Ordinal.NaturalOps",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Ordinal.lean | toGame_nadd | null |
toPGame_nmul (a b : Ordinal) : (a ⨳ b).toPGame ≈ a.toPGame * b.toPGame := by
refine ⟨le_of_forall_lf (fun i => ?_) isEmptyElim, le_of_forall_lf (fun i => ?_) isEmptyElim⟩
· rw [toPGame_moveLeft']
rcases lt_nmul_iff.1 (toLeftMovesToPGame_symm_lt i) with ⟨c, hc, d, hd, h⟩
rw [← toPGame_le_iff, le_iff_game_le, mk_toPGame, mk_toPGame, toGame_nadd _ _, toGame_nadd _ _,
← le_sub_iff_add_le] at h
refine lf_of_le_of_lf h <| (lf_congr_left ?_).1 <| moveLeft_lf <| toLeftMovesMul <| Sum.inl
⟨toLeftMovesToPGame ⟨c, hc⟩, toLeftMovesToPGame ⟨d, hd⟩⟩
simp only [mul_moveLeft_inl, toPGame_moveLeft', Equiv.symm_apply_apply, equiv_iff_game_eq,
quot_sub, quot_add]
repeat rw [← game_eq (toPGame_nmul _ _)]
rfl
· apply leftMoves_mul_cases i _ isEmptyElim
intro i j
rw [mul_moveLeft_inl, toPGame_moveLeft', toPGame_moveLeft', lf_iff_game_lf,
quot_sub, quot_add, ← Game.not_le, le_sub_iff_add_le]
repeat rw [← game_eq (toPGame_nmul _ _)]
simp_rw [mk_toPGame, ← toGame_nadd]
apply toPGame_lf (nmul_nadd_lt _ _) <;>
exact toLeftMovesToPGame_symm_lt _
termination_by (a, b) | theorem | SetTheory | [
"Mathlib.SetTheory.Game.Basic",
"Mathlib.SetTheory.Ordinal.NaturalOps",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Ordinal.lean | toPGame_nmul | The natural multiplication of ordinals corresponds to their product as pre-games. |
toGame_nmul (a b : Ordinal) : (a ⨳ b).toGame = ⟦a.toPGame * b.toPGame⟧ :=
game_eq (toPGame_nmul a b)
@[simp] -- used to be a norm_cast lemma | theorem | SetTheory | [
"Mathlib.SetTheory.Game.Basic",
"Mathlib.SetTheory.Ordinal.NaturalOps",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Ordinal.lean | toGame_nmul | null |
toGame_natCast : ∀ n : ℕ, toGame n = n
| 0 => Quot.sound (zeroToPGameRelabelling).equiv
| n + 1 => by
have : toGame 1 = 1 := Quot.sound oneToPGameRelabelling.equiv
rw [Nat.cast_add, ← nadd_nat, toGame_nadd, toGame_natCast, Nat.cast_one, this]
rfl | theorem | SetTheory | [
"Mathlib.SetTheory.Game.Basic",
"Mathlib.SetTheory.Ordinal.NaturalOps",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Ordinal.lean | toGame_natCast | null |
toPGame_natCast (n : ℕ) : toPGame n ≈ n := by
rw [PGame.equiv_iff_game_eq, mk_toPGame, toGame_natCast, quot_natCast] | theorem | SetTheory | [
"Mathlib.SetTheory.Game.Basic",
"Mathlib.SetTheory.Ordinal.NaturalOps",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Ordinal.lean | toPGame_natCast | null |
Short : PGame.{u} → Type (u + 1)
| mk :
∀ {α β : Type u} {L : α → PGame.{u}} {R : β → PGame.{u}} (_ : ∀ i : α, Short (L i))
(_ : ∀ j : β, Short (R j)) [Fintype α] [Fintype β], Short ⟨α, β, L, R⟩ | inductive | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | Short | A short game is a game with a finite set of moves at every turn. |
subsingleton_short (x : PGame) : Subsingleton (Short x) := by
induction x with
| mk xl xr xL xR =>
constructor
intro a b
cases a; cases b
congr!
attribute [-instance] subsingleton_short in | instance | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | subsingleton_short | null |
subsingleton_short_example : ∀ x : PGame, Subsingleton (Short x)
| mk xl xr xL xR =>
⟨fun a b => by
cases a; cases b
congr!
· funext x
apply @Subsingleton.elim _ (subsingleton_short_example (xL x))
· funext x
apply @Subsingleton.elim _ (subsingleton_short_example (xR x))⟩
termination_by x => x
decreasing_by all_goals {
subst_vars
simp only [mk.injEq, heq_eq_eq, true_and] at *
casesm* _ ∧ _
subst_vars
pgame_wf_tac
} | theorem | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | subsingleton_short_example | null |
Short.mk' {x : PGame} [Fintype x.LeftMoves] [Fintype x.RightMoves]
(sL : ∀ i : x.LeftMoves, Short (x.moveLeft i))
(sR : ∀ j : x.RightMoves, Short (x.moveRight j)) : Short x := by
convert Short.mk sL sR
cases x
dsimp
attribute [class] Short | def | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | Short.mk' | A synonym for `Short.mk` that specifies the pgame in an implicit argument. |
fintypeLeft {α β : Type u} {L : α → PGame.{u}} {R : β → PGame.{u}} [S : Short ⟨α, β, L, R⟩] :
Fintype α := by cases S; assumption
attribute [local instance] fintypeLeft | def | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | fintypeLeft | Extracting the `Fintype` instance for the indexing type for Left's moves in a short game.
This is an unindexed typeclass, so it can't be made a global instance. |
fintypeLeftMoves (x : PGame) [S : Short x] : Fintype x.LeftMoves := by
cases S; assumption | instance | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | fintypeLeftMoves | null |
fintypeRight {α β : Type u} {L : α → PGame.{u}} {R : β → PGame.{u}} [S : Short ⟨α, β, L, R⟩] :
Fintype β := by cases S; assumption
attribute [local instance] fintypeRight | def | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | fintypeRight | Extracting the `Fintype` instance for the indexing type for Right's moves in a short game.
This is an unindexed typeclass, so it can't be made a global instance. |
fintypeRightMoves (x : PGame) [S : Short x] : Fintype x.RightMoves := by
cases S; assumption | instance | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | fintypeRightMoves | null |
moveLeftShort (x : PGame) [S : Short x] (i : x.LeftMoves) : Short (x.moveLeft i) := by
obtain ⟨L, _⟩ := S; apply L | instance | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | moveLeftShort | null |
moveLeftShort' {xl xr} (xL xR) [S : Short (mk xl xr xL xR)] (i : xl) : Short (xL i) := by
obtain ⟨L, _⟩ := S; apply L
attribute [local instance] moveLeftShort' | def | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | moveLeftShort' | Extracting the `Short` instance for a move by Left.
This would be a dangerous instance potentially introducing new metavariables
in typeclass search, so we only make it an instance locally. |
moveRightShort (x : PGame) [S : Short x] (j : x.RightMoves) : Short (x.moveRight j) := by
obtain ⟨_, R⟩ := S; apply R | instance | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | moveRightShort | null |
moveRightShort' {xl xr} (xL xR) [S : Short (mk xl xr xL xR)] (j : xr) : Short (xR j) := by
obtain ⟨_, R⟩ := S; apply R
attribute [local instance] moveRightShort' | def | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | moveRightShort' | Extracting the `Short` instance for a move by Right.
This would be a dangerous instance potentially introducing new metavariables
in typeclass search, so we only make it an instance locally. |
short_birthday (x : PGame.{u}) : [Short x] → x.birthday < Ordinal.omega0 := by
induction x with
| mk xl xr xL xR ihl ihr =>
intro hs
rcases hs with ⟨sL, sR⟩
rw [birthday, max_lt_iff]
constructor
all_goals
rw [← Cardinal.ord_aleph0]
refine
Cardinal.lsub_lt_ord_of_isRegular.{u, u} Cardinal.isRegular_aleph0
(Cardinal.lt_aleph0_of_finite _) fun i => ?_
rw [Cardinal.ord_aleph0]
· apply ihl
· apply ihr | theorem | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | short_birthday | null |
Short.ofIsEmpty {l r xL xR} [IsEmpty l] [IsEmpty r] : Short (PGame.mk l r xL xR) := by
have : Fintype l := Fintype.ofIsEmpty
have : Fintype r := Fintype.ofIsEmpty
exact Short.mk isEmptyElim isEmptyElim | def | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | Short.ofIsEmpty | This leads to infinite loops if made into an instance. |
short0 : Short 0 :=
Short.ofIsEmpty | instance | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | short0 | null |
short1 : Short 1 :=
Short.mk (fun i => by cases i; infer_instance) fun j => by cases j | instance | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | short1 | null |
inductive ListShort : List PGame.{u} → Type (u + 1)
| nil : ListShort []
| cons' {hd : PGame.{u}} {tl : List PGame.{u}} : Short hd → ListShort tl → ListShort (hd::tl)
attribute [instance] ListShort.nil | class | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | inductive | Evidence that every `PGame` in a list is `Short`. |
ListShort.cons
(hd : PGame.{u}) [short_hd : Short hd] (tl : List PGame.{u}) [short_tl : ListShort tl] :
ListShort (hd::tl) :=
cons' short_hd short_tl | instance | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | ListShort.cons | null |
listShortGet :
∀ (L : List PGame.{u}) [ListShort L] (i : Nat) (h : i < List.length L), Short L[i]
| _::_, ListShort.cons' S _, 0, _ => S
| _::tl, ListShort.cons' _ S, n + 1, h =>
@listShortGet tl S n ((add_lt_add_iff_right 1).mp h) | instance | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | listShortGet | null |
shortOfLists : ∀ (L R : List PGame) [ListShort L] [ListShort R], Short (PGame.ofLists L R)
| L, R, _, _ => by
exact Short.mk (fun i ↦ inferInstance) fun j ↦ listShortGet R (↑j.down) (Fin.is_lt j.down) | instance | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | shortOfLists | null |
shortOfRelabelling : ∀ {x y : PGame.{u}}, Relabelling x y → Short x → Short y
| x, y, ⟨L, R, rL, rR⟩, S => by
haveI := Fintype.ofEquiv _ L
haveI := Fintype.ofEquiv _ R
exact
Short.mk'
(fun i => by rw [← L.right_inv i]; apply shortOfRelabelling (rL (L.symm i)) inferInstance)
fun j => by simpa using shortOfRelabelling (rR (R.symm j)) inferInstance | def | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | shortOfRelabelling | If `x` is a short game, and `y` is a relabelling of `x`, then `y` is also short. |
shortNeg : ∀ (x : PGame.{u}) [Short x], Short (-x)
| mk xl xr xL xR, _ => by
exact Short.mk (fun i => shortNeg _) fun i => shortNeg _ | instance | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | shortNeg | null |
shortAdd : ∀ (x y : PGame.{u}) [Short x] [Short y], Short (x + y)
| mk xl xr xL xR, mk yl yr yL yR, _, _ => by
apply Short.mk
all_goals
rintro ⟨i⟩
· apply shortAdd
· change Short (mk xl xr xL xR + _); apply shortAdd
termination_by x y => (x, y) | instance | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | shortAdd | null |
shortNat : ∀ n : ℕ, Short n
| 0 => PGame.short0
| n + 1 => @PGame.shortAdd _ _ (shortNat n) PGame.short1 | instance | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | shortNat | null |
shortOfNat (n : ℕ) [Nat.AtLeastTwo n] : Short ofNat(n) := shortNat n | instance | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | shortOfNat | null |
shortBit0 (x : PGame.{u}) [Short x] : Short (x + x) := by infer_instance | instance | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | shortBit0 | null |
shortBit1 (x : PGame.{u}) [Short x] : Short ((x + x) + 1) := shortAdd _ _ | instance | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | shortBit1 | null |
leLFDecidable : ∀ (x y : PGame.{u}) [Short x] [Short y], Decidable (x ≤ y) × Decidable (x ⧏ y)
| mk xl xr xL xR, mk yl yr yL yR, shortx, shorty => by
constructor
· refine @decidable_of_iff' _ _ mk_le_mk (id ?_)
have : Decidable (∀ (i : xl), xL i ⧏ mk yl yr yL yR) := by
apply @Fintype.decidableForallFintype xl _ ?_ _
intro i
apply (leLFDecidable _ _).2
have : Decidable (∀ (j : yr), mk xl xr xL xR ⧏ yR j) := by
apply @Fintype.decidableForallFintype yr _ ?_ _
intro i
apply (leLFDecidable _ _).2
exact inferInstanceAs (Decidable (_ ∧ _))
· refine @decidable_of_iff' _ _ mk_lf_mk (id ?_)
have : Decidable (∃ i, mk xl xr xL xR ≤ yL i) := by
apply @Fintype.decidableExistsFintype yl _ ?_ _
intro i
apply (leLFDecidable _ _).1
have : Decidable (∃ j, xR j ≤ mk yl yr yL yR) := by
apply @Fintype.decidableExistsFintype xr _ ?_ _
intro i
apply (leLFDecidable _ _).1
exact inferInstanceAs (Decidable (_ ∨ _))
termination_by x y => (x, y) | def | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | leLFDecidable | Auxiliary construction of decidability instances.
We build `Decidable (x ≤ y)` and `Decidable (x ⧏ y)` in a simultaneous induction.
Instances for the two projections separately are provided below. |
leDecidable (x y : PGame.{u}) [Short x] [Short y] : Decidable (x ≤ y) :=
(leLFDecidable x y).1 | instance | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | leDecidable | null |
lfDecidable (x y : PGame.{u}) [Short x] [Short y] : Decidable (x ⧏ y) :=
(leLFDecidable x y).2 | instance | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | lfDecidable | null |
ltDecidable (x y : PGame.{u}) [Short x] [Short y] : Decidable (x < y) :=
inferInstanceAs (Decidable (_ ∧ _)) | instance | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | ltDecidable | null |
equivDecidable (x y : PGame.{u}) [Short x] [Short y] : Decidable (x ≈ y) :=
inferInstanceAs (Decidable (_ ∧ _)) | instance | SetTheory | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.SetTheory.Cardinal.Regular",
"Mathlib.SetTheory.Game.Birthday",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/Short.lean | equivDecidable | null |
State (S : Type u) where
/-- Upper bound on the number of possible turns remaining from this state -/
turnBound : S → ℕ
/-- States reachable by a Left move -/
l : S → Finset S
/-- States reachable by a Right move -/
r : S → Finset S
left_bound : ∀ {s t : S}, t ∈ l s → turnBound t < turnBound s
right_bound : ∀ {s t : S}, t ∈ r s → turnBound t < turnBound s
open State
variable {S : Type u} [State S] | class | SetTheory | [
"Mathlib.SetTheory.Game.Short",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/State.lean | State | `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_ne_zero_of_left_move {s t : S} (m : t ∈ l s) : turnBound s ≠ 0 := by
intro h
have t := left_bound m
rw [h] at t
exact Nat.not_succ_le_zero _ t | theorem | SetTheory | [
"Mathlib.SetTheory.Game.Short",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/State.lean | turnBound_ne_zero_of_left_move | null |
turnBound_ne_zero_of_right_move {s t : S} (m : t ∈ r s) : turnBound s ≠ 0 := by
intro h
have t := right_bound m
cutsat | theorem | SetTheory | [
"Mathlib.SetTheory.Game.Short",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/State.lean | turnBound_ne_zero_of_right_move | null |
turnBound_of_left {s t : S} (m : t ∈ l s) (n : ℕ) (h : turnBound s ≤ n + 1) :
turnBound t ≤ n :=
Nat.le_of_lt_succ (Nat.lt_of_lt_of_le (left_bound m) h) | theorem | SetTheory | [
"Mathlib.SetTheory.Game.Short",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/State.lean | turnBound_of_left | null |
turnBound_of_right {s t : S} (m : t ∈ r s) (n : ℕ) (h : turnBound s ≤ n + 1) :
turnBound t ≤ n :=
Nat.le_of_lt_succ (Nat.lt_of_lt_of_le (right_bound m) h) | theorem | SetTheory | [
"Mathlib.SetTheory.Game.Short",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/State.lean | turnBound_of_right | null |
ofStateAux : ∀ (n : ℕ) (s : S), turnBound s ≤ n → PGame
| 0, s, h =>
PGame.mk { t // t ∈ l s } { t // t ∈ r s }
(fun t => by exfalso; exact turnBound_ne_zero_of_left_move t.2 (nonpos_iff_eq_zero.mp h))
fun t => by exfalso; exact turnBound_ne_zero_of_right_move t.2 (nonpos_iff_eq_zero.mp h)
| n + 1, s, h =>
PGame.mk { t // t ∈ l s } { t // t ∈ r s }
(fun t => ofStateAux n t (turnBound_of_left t.2 n h)) fun t =>
ofStateAux n t (turnBound_of_right t.2 n h) | def | SetTheory | [
"Mathlib.SetTheory.Game.Short",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/State.lean | ofStateAux | Construct a `PGame` from a state and a (not necessarily optimal) bound on the number of
turns remaining. |
ofStateAuxRelabelling :
∀ (s : S) (n m : ℕ) (hn : turnBound s ≤ n) (hm : turnBound s ≤ m),
Relabelling (ofStateAux n s hn) (ofStateAux m s hm)
| s, 0, 0, hn, hm => by
dsimp [PGame.ofStateAux]
fconstructor
· rfl
· rfl
· intro i; dsimp at i; exfalso
exact turnBound_ne_zero_of_left_move i.2 (nonpos_iff_eq_zero.mp hn)
· intro j; dsimp at j; exfalso
exact turnBound_ne_zero_of_right_move j.2 (nonpos_iff_eq_zero.mp hm)
| s, 0, m + 1, hn, hm => by
dsimp [PGame.ofStateAux]
fconstructor
· rfl
· rfl
· intro i; dsimp at i; exfalso
exact turnBound_ne_zero_of_left_move i.2 (nonpos_iff_eq_zero.mp hn)
· intro j; dsimp at j; exfalso
exact turnBound_ne_zero_of_right_move j.2 (nonpos_iff_eq_zero.mp hn)
| s, n + 1, 0, hn, hm => by
dsimp [PGame.ofStateAux]
fconstructor
· rfl
· rfl
· intro i; dsimp at i; exfalso
exact turnBound_ne_zero_of_left_move i.2 (nonpos_iff_eq_zero.mp hm)
· intro j; dsimp at j; exfalso
exact turnBound_ne_zero_of_right_move j.2 (nonpos_iff_eq_zero.mp hm)
| s, n + 1, m + 1, hn, hm => by
dsimp [PGame.ofStateAux]
fconstructor
· rfl
· rfl
· intro i
apply ofStateAuxRelabelling
· intro j
apply ofStateAuxRelabelling | def | SetTheory | [
"Mathlib.SetTheory.Game.Short",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/State.lean | ofStateAuxRelabelling | Two different (valid) turn bounds give equivalent games. |
ofState (s : S) : PGame :=
ofStateAux (turnBound s) s (refl _) | def | SetTheory | [
"Mathlib.SetTheory.Game.Short",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/State.lean | ofState | Construct a combinatorial `PGame` from a state. |
leftMovesOfStateAux (n : ℕ) {s : S} (h : turnBound s ≤ n) :
LeftMoves (ofStateAux n s h) ≃ { t // t ∈ l s } := by induction n <;> rfl | def | SetTheory | [
"Mathlib.SetTheory.Game.Short",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/State.lean | leftMovesOfStateAux | The equivalence between `leftMoves` for a `PGame` constructed using `ofStateAux _ s _`, and
`L s`. |
leftMovesOfState (s : S) : LeftMoves (ofState s) ≃ { t // t ∈ l s } :=
leftMovesOfStateAux _ _ | def | SetTheory | [
"Mathlib.SetTheory.Game.Short",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/State.lean | leftMovesOfState | The equivalence between `leftMoves` for a `PGame` constructed using `ofState s`, and `l s`. |
rightMovesOfStateAux (n : ℕ) {s : S} (h : turnBound s ≤ n) :
RightMoves (ofStateAux n s h) ≃ { t // t ∈ r s } := by induction n <;> rfl | def | SetTheory | [
"Mathlib.SetTheory.Game.Short",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/State.lean | rightMovesOfStateAux | The equivalence between `rightMoves` for a `PGame` constructed using `ofStateAux _ s _`, and
`R s`. |
rightMovesOfState (s : S) : RightMoves (ofState s) ≃ { t // t ∈ r s } :=
rightMovesOfStateAux _ _ | def | SetTheory | [
"Mathlib.SetTheory.Game.Short",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/State.lean | rightMovesOfState | The equivalence between `rightMoves` for a `PGame` constructed using `ofState s`, and
`R s`. |
relabellingMoveLeftAux (n : ℕ) {s : S} (h : turnBound s ≤ n)
(t : LeftMoves (ofStateAux n s h)) :
Relabelling (moveLeft (ofStateAux n s h) t)
(ofStateAux (n - 1) ((leftMovesOfStateAux n h) t : S)
(turnBound_of_left ((leftMovesOfStateAux n h) t).2 (n - 1)
(Nat.le_trans h le_tsub_add))) := by
induction n
· have t' := (leftMovesOfStateAux 0 h) t
exfalso; exact turnBound_ne_zero_of_left_move t'.2 (nonpos_iff_eq_zero.mp h)
· rfl | def | SetTheory | [
"Mathlib.SetTheory.Game.Short",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/State.lean | relabellingMoveLeftAux | The relabelling showing `moveLeft` applied to a game constructed using `ofStateAux`
has itself been constructed using `ofStateAux`. |
relabellingMoveLeft (s : S) (t : LeftMoves (ofState s)) :
Relabelling (moveLeft (ofState s) t) (ofState ((leftMovesOfState s).toFun t : S)) := by
trans
· apply relabellingMoveLeftAux
· apply ofStateAuxRelabelling | def | SetTheory | [
"Mathlib.SetTheory.Game.Short",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/State.lean | relabellingMoveLeft | The relabelling showing `moveLeft` applied to a game constructed using `of`
has itself been constructed using `of`. |
relabellingMoveRightAux (n : ℕ) {s : S} (h : turnBound s ≤ n)
(t : RightMoves (ofStateAux n s h)) :
Relabelling (moveRight (ofStateAux n s h) t)
(ofStateAux (n - 1) ((rightMovesOfStateAux n h) t : S)
(turnBound_of_right ((rightMovesOfStateAux n h) t).2 (n - 1)
(Nat.le_trans h le_tsub_add))) := by
induction n
· have t' := (rightMovesOfStateAux 0 h) t
exfalso; exact turnBound_ne_zero_of_right_move t'.2 (nonpos_iff_eq_zero.mp h)
· rfl | def | SetTheory | [
"Mathlib.SetTheory.Game.Short",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/State.lean | relabellingMoveRightAux | The relabelling showing `moveRight` applied to a game constructed using `ofStateAux`
has itself been constructed using `ofStateAux`. |
relabellingMoveRight (s : S) (t : RightMoves (ofState s)) :
Relabelling (moveRight (ofState s) t) (ofState ((rightMovesOfState s).toFun t : S)) := by
trans
· apply relabellingMoveRightAux
· apply ofStateAuxRelabelling | def | SetTheory | [
"Mathlib.SetTheory.Game.Short",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/State.lean | relabellingMoveRight | The relabelling showing `moveRight` applied to a game constructed using `of`
has itself been constructed using `of`. |
fintypeLeftMovesOfStateAux (n : ℕ) (s : S) (h : turnBound s ≤ n) :
Fintype (LeftMoves (ofStateAux n s h)) := by
apply Fintype.ofEquiv _ (leftMovesOfStateAux _ _).symm | instance | SetTheory | [
"Mathlib.SetTheory.Game.Short",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/State.lean | fintypeLeftMovesOfStateAux | null |
fintypeRightMovesOfStateAux (n : ℕ) (s : S) (h : turnBound s ≤ n) :
Fintype (RightMoves (ofStateAux n s h)) := by
apply Fintype.ofEquiv _ (rightMovesOfStateAux _ _).symm | instance | SetTheory | [
"Mathlib.SetTheory.Game.Short",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/State.lean | fintypeRightMovesOfStateAux | null |
shortOfStateAux : ∀ (n : ℕ) {s : S} (h : turnBound s ≤ n), Short (ofStateAux n s h)
| 0, s, h =>
Short.mk'
(fun i => by
have i := (leftMovesOfStateAux _ _).toFun i
exfalso
exact turnBound_ne_zero_of_left_move i.2 (nonpos_iff_eq_zero.mp h))
fun j => by
have j := (rightMovesOfStateAux _ _).toFun j
exfalso
exact turnBound_ne_zero_of_right_move j.2 (nonpos_iff_eq_zero.mp h)
| n + 1, _, h =>
Short.mk'
(fun i =>
shortOfRelabelling (relabellingMoveLeftAux (n + 1) h i).symm (shortOfStateAux n _))
fun j =>
shortOfRelabelling (relabellingMoveRightAux (n + 1) h j).symm (shortOfStateAux n _) | instance | SetTheory | [
"Mathlib.SetTheory.Game.Short",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/State.lean | shortOfStateAux | null |
shortOfState (s : S) : Short (ofState s) := by
dsimp [PGame.ofState]
infer_instance | instance | SetTheory | [
"Mathlib.SetTheory.Game.Short",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/State.lean | shortOfState | null |
ofState {S : Type u} [PGame.State S] (s : S) : Game :=
⟦PGame.ofState s⟧ | def | SetTheory | [
"Mathlib.SetTheory.Game.Short",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Game/State.lean | ofState | Construct a combinatorial `Game` from a state. |
Nimber : Type _ :=
Ordinal deriving Zero, Inhabited, One, Nontrivial, WellFoundedRelation | def | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | Nimber | A type synonym for ordinals with nimber addition and multiplication. |
Nimber.instLinearOrder : LinearOrder Nimber := Ordinal.instLinearOrder | instance | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | Nimber.instLinearOrder | null |
Nimber.instSuccOrder : SuccOrder Nimber := Ordinal.instSuccOrder | instance | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | Nimber.instSuccOrder | null |
Nimber.instOrderBot : OrderBot Nimber := Ordinal.instOrderBot | instance | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | Nimber.instOrderBot | null |
Nimber.instNoMaxOrder : NoMaxOrder Nimber := Ordinal.instNoMaxOrder | instance | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | Nimber.instNoMaxOrder | null |
Nimber.instZeroLEOneClass : ZeroLEOneClass Nimber := Ordinal.instZeroLEOneClass | instance | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | Nimber.instZeroLEOneClass | null |
Nimber.instNeZeroOne : NeZero (1 : Nimber) := Ordinal.instNeZeroOne | instance | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | Nimber.instNeZeroOne | null |
@[match_pattern]
Ordinal.toNimber : Ordinal ≃o Nimber :=
OrderIso.refl _ | def | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | Ordinal.toNimber | The identity function between `Ordinal` and `Nimber`. |
@[match_pattern]
Nimber.toOrdinal : Nimber ≃o Ordinal :=
OrderIso.refl _
@[inherit_doc]
scoped[Nimber] prefix:75 "∗" => Ordinal.toNimber | def | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | Nimber.toOrdinal | The identity function between `Nimber` and `Ordinal`. |
@[simp]
toOrdinal_symm_eq : Nimber.toOrdinal.symm = Ordinal.toNimber :=
rfl
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | toOrdinal_symm_eq | null |
toOrdinal_toNimber (a : Nimber) : ∗(Nimber.toOrdinal a) = a :=
rfl | theorem | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | toOrdinal_toNimber | null |
lt_wf : @WellFounded Nimber (· < ·) :=
Ordinal.lt_wf | theorem | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | lt_wf | null |
@[simp]
bot_eq_zero : ⊥ = 0 :=
rfl
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | bot_eq_zero | null |
toOrdinal_zero : toOrdinal 0 = 0 :=
rfl
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | toOrdinal_zero | null |
toOrdinal_one : toOrdinal 1 = 1 :=
rfl
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | toOrdinal_one | null |
toOrdinal_eq_zero {a} : toOrdinal a = 0 ↔ a = 0 :=
Iff.rfl
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | toOrdinal_eq_zero | null |
toOrdinal_eq_one {a} : toOrdinal a = 1 ↔ a = 1 :=
Iff.rfl
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | toOrdinal_eq_one | null |
toOrdinal_max (a b : Nimber) : toOrdinal (max a b) = max (toOrdinal a) (toOrdinal b) :=
rfl
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | toOrdinal_max | null |
toOrdinal_min (a b : Nimber) : toOrdinal (min a b) = min (toOrdinal a) (toOrdinal b) :=
rfl | theorem | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | toOrdinal_min | null |
succ_def (a : Nimber) : succ a = ∗(toOrdinal a + 1) :=
rfl | theorem | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | succ_def | null |
@[elab_as_elim, cases_eliminator, induction_eliminator]
protected rec {β : Nimber → Sort*} (h : ∀ a, β (∗a)) : ∀ a, β a := fun a =>
h (toOrdinal a) | def | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | rec | A recursor for `Nimber`. Use as `induction x`. |
induction {p : Nimber → Prop} : ∀ (i) (_ : ∀ j, (∀ k, k < j → p k) → p j), p i :=
Ordinal.induction | theorem | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | induction | `Ordinal.induction` but for `Nimber`. |
protected le_zero {a : Nimber} : a ≤ 0 ↔ a = 0 :=
Ordinal.le_zero | theorem | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | le_zero | null |
protected not_lt_zero (a : Nimber) : ¬ a < 0 :=
Ordinal.not_lt_zero a | theorem | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | not_lt_zero | null |
protected pos_iff_ne_zero {a : Nimber} : 0 < a ↔ a ≠ 0 :=
Ordinal.pos_iff_ne_zero | theorem | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | pos_iff_ne_zero | null |
lt_one_iff_zero {a : Nimber} : a < 1 ↔ a = 0 :=
Ordinal.lt_one_iff_zero | theorem | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | lt_one_iff_zero | null |
one_le_iff_ne_zero {a : Nimber} : 1 ≤ a ↔ a ≠ 0 :=
Ordinal.one_le_iff_ne_zero | theorem | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | one_le_iff_ne_zero | null |
eq_nat_of_le_nat {a : Nimber} {b : ℕ} (h : a ≤ ∗b) : ∃ c : ℕ, a = ∗c :=
Ordinal.lt_omega0.1 (h.trans_lt (nat_lt_omega0 b)) | theorem | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | eq_nat_of_le_nat | null |
small_Iio (a : Nimber.{u}) : Small.{u} (Set.Iio a) := Ordinal.small_Iio a | instance | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | small_Iio | null |
small_Iic (a : Nimber.{u}) : Small.{u} (Set.Iic a) := Ordinal.small_Iic a | instance | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | small_Iic | null |
small_Ico (a b : Nimber.{u}) : Small.{u} (Set.Ico a b) := Ordinal.small_Ico a b | instance | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | small_Ico | null |
small_Icc (a b : Nimber.{u}) : Small.{u} (Set.Icc a b) := Ordinal.small_Icc a b | instance | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | small_Icc | null |
small_Ioo (a b : Nimber.{u}) : Small.{u} (Set.Ioo a b) := Ordinal.small_Ioo a b | instance | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | small_Ioo | null |
small_Ioc (a b : Nimber.{u}) : Small.{u} (Set.Ioc a b) := Ordinal.small_Ioc a b | instance | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | small_Ioc | null |
not_bddAbove_compl_of_small (s : Set Nimber.{u}) [Small.{u} s] : ¬ BddAbove sᶜ :=
Ordinal.not_bddAbove_compl_of_small s | theorem | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | not_bddAbove_compl_of_small | null |
not_small_nimber : ¬ Small.{u} Nimber.{max u v} :=
not_small_ordinal | theorem | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | not_small_nimber | null |
Nimber.uncountable : Uncountable Nimber :=
Ordinal.uncountable
open Nimber | instance | SetTheory | [
"Mathlib.Data.Nat.Bitwise",
"Mathlib.SetTheory.Ordinal.Family",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/Nimber/Basic.lean | Nimber.uncountable | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.