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 ⌀ |
|---|---|---|---|---|---|---|
liftPrincipalSeg_coe :
(liftPrincipalSeg.{u, v} : Ordinal → Ordinal) = lift.{max (u + 1) v} :=
rfl
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | liftPrincipalSeg_coe | null |
liftPrincipalSeg_top : (liftPrincipalSeg.{u, v}).top = univ.{u, v} :=
rfl | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | liftPrincipalSeg_top | null |
liftPrincipalSeg_top' : liftPrincipalSeg.{u, u + 1}.top = typeLT Ordinal := by
simp only [liftPrincipalSeg_top, univ_id] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | liftPrincipalSeg_top' | null |
@[simp]
mk_toType (o : Ordinal) : #o.toType = o.card :=
(Ordinal.card_type _).symm.trans <| by rw [Ordinal.type_toType] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | mk_toType | null |
ord (c : Cardinal) : Ordinal :=
Quot.liftOn c (fun α : Type u => ⨅ r : { r // IsWellOrder α r }, @type α r.1 r.2) <| by
rintro α β ⟨f⟩
refine congr_arg sInf <| ext fun o ↦ ⟨?_, ?_⟩ <;>
rintro ⟨⟨r, hr⟩, rfl⟩ <;>
refine ⟨⟨_, RelIso.IsWellOrder.preimage r ?_⟩, type_preimage _ _⟩
exacts [f.symm, f] | def | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord | The ordinal corresponding to a cardinal `c` is the least ordinal
whose cardinal is `c`. For the order-embedding version, see `ord.order_embedding`. |
ord_eq_Inf (α : Type u) : ord #α = ⨅ r : { r // IsWellOrder α r }, @type α r.1 r.2 :=
rfl | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_eq_Inf | null |
ord_eq (α) : ∃ (r : α → α → Prop) (wo : IsWellOrder α r), ord #α = @type α r wo :=
let ⟨r, wo⟩ := ciInf_mem fun r : { r // IsWellOrder α r } => @type α r.1 r.2
⟨r.1, r.2, wo.symm⟩ | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_eq | There exists a well-order on `α` whose order type is exactly `ord #α`. |
ord_le_type (r : α → α → Prop) [h : IsWellOrder α r] : ord #α ≤ type r :=
ciInf_le' _ (Subtype.mk r h) | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_le_type | null |
ord_le {c o} : ord c ≤ o ↔ c ≤ o.card := by
refine c.inductionOn fun α ↦ o.inductionOn fun β s _ ↦ ?_
let ⟨r, _, e⟩ := ord_eq α
constructor <;> intro h
· rw [e] at h
exact card_le_card h
· obtain ⟨f⟩ := h
have g := RelEmbedding.preimage f s
have := RelEmbedding.isWellOrder g
exact (ord_le_type _).trans g.ordinal_type_le | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_le | null |
gc_ord_card : GaloisConnection ord card := fun _ _ => ord_le | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | gc_ord_card | null |
lt_ord {c o} : o < ord c ↔ o.card < c :=
gc_ord_card.lt_iff_lt
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | lt_ord | null |
card_ord (c) : (ord c).card = c :=
c.inductionOn fun α ↦ let ⟨r, _, e⟩ := ord_eq α; e ▸ card_type r | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | card_ord | null |
card_surjective : Function.Surjective card :=
fun c ↦ ⟨_, card_ord c⟩ | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | card_surjective | null |
bddAbove_ord_image_iff {s : Set Cardinal} : BddAbove (ord '' s) ↔ BddAbove s :=
gc_ord_card.bddAbove_l_image | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | bddAbove_ord_image_iff | null |
gciOrdCard : GaloisCoinsertion ord card :=
gc_ord_card.toGaloisCoinsertion fun c => c.card_ord.le | def | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | gciOrdCard | Galois coinsertion between `Cardinal.ord` and `Ordinal.card`. |
ord_card_le (o : Ordinal) : o.card.ord ≤ o :=
gc_ord_card.l_u_le _ | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_card_le | null |
lt_ord_succ_card (o : Ordinal) : o < (succ o.card).ord :=
lt_ord.2 <| lt_succ _ | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | lt_ord_succ_card | null |
card_le_iff {o : Ordinal} {c : Cardinal} : o.card ≤ c ↔ o < (succ c).ord := by
rw [lt_ord, lt_succ_iff] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | card_le_iff | null |
card_le_of_le_ord {o : Ordinal} {c : Cardinal} (ho : o ≤ c.ord) : o.card ≤ c := by
rw [← card_ord c]; exact Ordinal.card_le_card ho
@[mono] | lemma | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | card_le_of_le_ord | A variation on `Cardinal.lt_ord` using `≤`: If `o` is no greater than the
initial ordinal of cardinality `c`, then its cardinal is no greater than `c`.
The converse, however, is false (for instance, `o = ω+1` and `c = ℵ₀`). |
ord_strictMono : StrictMono ord :=
gciOrdCard.strictMono_l
@[mono] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_strictMono | null |
ord_mono : Monotone ord :=
gc_ord_card.monotone_l
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_mono | null |
ord_le_ord {c₁ c₂} : ord c₁ ≤ ord c₂ ↔ c₁ ≤ c₂ :=
gciOrdCard.l_le_l_iff
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_le_ord | null |
ord_lt_ord {c₁ c₂} : ord c₁ < ord c₂ ↔ c₁ < c₂ :=
ord_strictMono.lt_iff_lt
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_lt_ord | null |
ord_zero : ord 0 = 0 :=
gc_ord_card.l_bot
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_zero | null |
ord_nat (n : ℕ) : ord n = n := by
apply (ord_le.2 (card_nat n).ge).antisymm
induction n with
| zero => exact Ordinal.zero_le _
| succ n IH => exact (IH.trans_lt <| by simpa using Nat.cast_lt.2 n.lt_succ_self).succ_le
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_nat | null |
ord_ofNat (n : ℕ) [n.AtLeastTwo] : ord ofNat(n) = OfNat.ofNat n :=
ord_nat n
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_ofNat | null |
ord_one : ord 1 = 1 := by simpa using ord_nat 1 | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_one | null |
isNormal_ord : Order.IsNormal ord where
strictMono := ord_strictMono
mem_lowerBounds_upperBounds_of_isSuccLimit := by
intro a ha
simp_rw [lowerBounds, upperBounds, mem_setOf, forall_mem_image, ord_le]
refine fun b H ↦ le_of_forall_lt fun c hc ↦ ?_
simpa using H (ha.succ_lt hc)
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | isNormal_ord | null |
ord_aleph0 : ord.{u} ℵ₀ = ω := by
refine le_antisymm (ord_le.2 le_rfl) <| le_of_forall_lt fun o h ↦ ?_
rcases Ordinal.lt_lift_iff.1 h with ⟨o, ho, rfl⟩
rw [lt_ord, ← lift_card, lift_lt_aleph0, ← typein_enum _ ho]
exact lt_aleph0_iff_fintype.2 ⟨Set.fintypeLTNat _⟩
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_aleph0 | null |
lift_ord (c) : Ordinal.lift.{u,v} (ord c) = ord (lift.{u,v} c) := by
refine le_antisymm (le_of_forall_lt fun a ha => ?_) ?_
· rcases Ordinal.lt_lift_iff.1 ha with ⟨a, _, rfl⟩
rwa [lt_ord, ← lift_card, lift_lt, ← lt_ord, ← Ordinal.lift_lt]
· rw [ord_le, ← lift_card, card_ord] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | lift_ord | null |
mk_ord_toType (c : Cardinal) : #c.ord.toType = c := by simp | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | mk_ord_toType | null |
card_typein_lt (r : α → α → Prop) [IsWellOrder α r] (x : α) (h : ord #α = type r) :
card (typein r x) < #α := by
rw [← lt_ord, h]
apply typein_lt_type | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | card_typein_lt | null |
card_typein_toType_lt (c : Cardinal) (x : c.ord.toType) :
card (typein (α := c.ord.toType) (· < ·) x) < c := by
rw [← lt_ord]
apply typein_lt_self | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | card_typein_toType_lt | null |
mk_Iio_ord_toType {c : Cardinal} (i : c.ord.toType) : #(Iio i) < c :=
card_typein_toType_lt c i | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | mk_Iio_ord_toType | null |
ord_injective : Injective ord := by
intro c c' h
rw [← card_ord c, ← card_ord c', h]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_injective | null |
ord_inj {a b : Cardinal} : a.ord = b.ord ↔ a = b :=
ord_injective.eq_iff
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_inj | null |
ord_eq_zero {a : Cardinal} : a.ord = 0 ↔ a = 0 :=
ord_injective.eq_iff' ord_zero
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_eq_zero | null |
ord_eq_one {a : Cardinal} : a.ord = 1 ↔ a = 1 :=
ord_injective.eq_iff' ord_one
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_eq_one | null |
omega0_le_ord {a : Cardinal} : ω ≤ a.ord ↔ ℵ₀ ≤ a := by
rw [← ord_aleph0, ord_le_ord]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | omega0_le_ord | null |
ord_le_omega0 {a : Cardinal} : a.ord ≤ ω ↔ a ≤ ℵ₀ := by
rw [← ord_aleph0, ord_le_ord]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_le_omega0 | null |
ord_lt_omega0 {a : Cardinal} : a.ord < ω ↔ a < ℵ₀ :=
le_iff_le_iff_lt_iff_lt.1 omega0_le_ord
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_lt_omega0 | null |
omega0_lt_ord {a : Cardinal} : ω < a.ord ↔ ℵ₀ < a :=
le_iff_le_iff_lt_iff_lt.1 ord_le_omega0
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | omega0_lt_ord | null |
ord_eq_omega0 {a : Cardinal} : a.ord = ω ↔ a = ℵ₀ :=
ord_injective.eq_iff' ord_aleph0 | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_eq_omega0 | null |
ord.orderEmbedding : Cardinal ↪o Ordinal :=
RelEmbedding.orderEmbeddingOfLTEmbedding
(RelEmbedding.ofMonotone Cardinal.ord fun _ _ => Cardinal.ord_lt_ord.2)
@[simp] | def | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord.orderEmbedding | The ordinal corresponding to a cardinal `c` is the least ordinal
whose cardinal is `c`. This is the order-embedding version. For the regular function, see `ord`. |
ord.orderEmbedding_coe : (ord.orderEmbedding : Cardinal → Ordinal) = ord :=
rfl | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord.orderEmbedding_coe | null |
@[pp_with_univ, nolint checkUnivs]
univ :=
lift.{v, u + 1} #Ordinal | def | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | univ | The cardinal `univ` is the cardinality of ordinal `univ`, or
equivalently the cardinal of `Ordinal.{u}`, or `Cardinal.{u}`,
as an element of `Cardinal.{v}` (when `u < v`). |
univ_id : univ.{u, u + 1} = #Ordinal :=
lift_id _
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | univ_id | null |
lift_univ : lift.{w} univ.{u, v} = univ.{u, max v w} :=
lift_lift _ | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | lift_univ | null |
univ_umax : univ.{u, max (u + 1) v} = univ.{u, v} :=
congr_fun lift_umax _ | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | univ_umax | null |
lift_lt_univ (c : Cardinal) : lift.{u + 1, u} c < univ.{u, u + 1} := by
simpa only [liftPrincipalSeg_coe, lift_ord, lift_succ, ord_le, succ_le_iff] using
le_of_lt (liftPrincipalSeg.{u, u + 1}.lt_top (succ c).ord) | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | lift_lt_univ | null |
lift_lt_univ' (c : Cardinal) : lift.{max (u + 1) v, u} c < univ.{u, v} := by
have := lift_lt.{_, max (u+1) v}.2 (lift_lt_univ c)
rw [lift_lift, lift_univ, univ_umax.{u,v}] at this
exact this | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | lift_lt_univ' | null |
aleph0_lt_univ : ℵ₀ < univ.{u, v} := by
simpa using lift_lt_univ' ℵ₀ | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | aleph0_lt_univ | null |
nat_lt_univ (n : ℕ) : n < univ.{u, v} :=
(nat_lt_aleph0 n).trans aleph0_lt_univ | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | nat_lt_univ | null |
univ_pos : 0 < univ.{u, v} :=
aleph0_pos.trans aleph0_lt_univ | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | univ_pos | null |
univ_ne_zero : univ.{u, v} ≠ 0 :=
univ_pos.ne'
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | univ_ne_zero | null |
ord_univ : ord univ.{u, v} = Ordinal.univ.{u, v} := by
refine le_antisymm (ord_card_le _) <| le_of_forall_lt fun o h => lt_ord.2 ?_
have := liftPrincipalSeg.mem_range_of_rel_top (by simpa only [liftPrincipalSeg_coe] using h)
rcases this with ⟨o, h'⟩
rw [← h', liftPrincipalSeg_coe, ← lift_card]
apply lift_lt_univ' | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ord_univ | null |
lt_univ {c} : c < univ.{u, u + 1} ↔ ∃ c', c = lift.{u + 1, u} c' :=
⟨fun h => by
have := ord_lt_ord.2 h
rw [ord_univ] at this
obtain ⟨o, e⟩ := liftPrincipalSeg.mem_range_of_rel_top (by simpa only [liftPrincipalSeg_top])
have := card_ord c
rw [← e, liftPrincipalSeg_coe, ← lift_card] at this
exact ⟨_, this.symm⟩, fun ⟨_, e⟩ => e.symm ▸ lift_lt_univ _⟩ | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | lt_univ | null |
lt_univ' {c} : c < univ.{u, v} ↔ ∃ c', c = lift.{max (u + 1) v, u} c' :=
⟨fun h => by
let ⟨a, h', e⟩ := lt_lift_iff.1 h
rw [← univ_id] at h'
rcases lt_univ.{u}.1 h' with ⟨c', rfl⟩
exact ⟨c', by simp only [e.symm, lift_lift]⟩, fun ⟨_, e⟩ => e.symm ▸ lift_lt_univ' _⟩ | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | lt_univ' | null |
IsStrongLimit.univ : IsStrongLimit univ.{u, v} :=
⟨univ_ne_zero, fun c h ↦ let ⟨w, h⟩ := lt_univ'.1 h; lt_univ'.2 ⟨2 ^ w, by simp [h]⟩⟩ | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | IsStrongLimit.univ | null |
small_iff_lift_mk_lt_univ {α : Type u} :
Small.{v} α ↔ Cardinal.lift.{v+1,_} #α < univ.{v, max u (v + 1)} := by
rw [lt_univ']
constructor
· rintro ⟨β, e⟩
exact ⟨#β, lift_mk_eq.{u, _, v + 1}.2 e⟩
· rintro ⟨c, hc⟩
exact ⟨⟨c.out, lift_mk_eq.{u, _, v + 1}.1 (hc.trans (congr rfl c.mk_out.symm))⟩⟩ | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | small_iff_lift_mk_lt_univ | null |
noncomputable toTypeOrderBot {c : Cardinal} (hc : c ≠ 0) :
OrderBot c.ord.toType :=
Ordinal.toTypeOrderBot (fun h ↦ hc (ord_injective (by simpa using h))) | def | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | toTypeOrderBot | If a cardinal `c` is nonzero, then `c.ord.toType` has a least element. |
@[simp]
card_univ : card univ.{u,v} = Cardinal.univ.{u,v} :=
rfl
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | card_univ | null |
nat_le_card {o} {n : ℕ} : (n : Cardinal) ≤ card o ↔ (n : Ordinal) ≤ o := by
rw [← Cardinal.ord_le, Cardinal.ord_nat]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | nat_le_card | null |
one_le_card {o} : 1 ≤ card o ↔ 1 ≤ o := by
simpa using nat_le_card (n := 1)
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | one_le_card | null |
ofNat_le_card {o} {n : ℕ} [n.AtLeastTwo] :
(ofNat(n) : Cardinal) ≤ card o ↔ (OfNat.ofNat n : Ordinal) ≤ o :=
nat_le_card
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ofNat_le_card | null |
aleph0_le_card {o} : ℵ₀ ≤ card o ↔ ω ≤ o := by
rw [← ord_le, ord_aleph0]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | aleph0_le_card | null |
card_lt_aleph0 {o} : card o < ℵ₀ ↔ o < ω :=
le_iff_le_iff_lt_iff_lt.1 aleph0_le_card
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | card_lt_aleph0 | null |
nat_lt_card {o} {n : ℕ} : (n : Cardinal) < card o ↔ (n : Ordinal) < o := by
rw [← succ_le_iff, ← succ_le_iff, ← nat_succ, nat_le_card]
rfl
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | nat_lt_card | null |
zero_lt_card {o} : 0 < card o ↔ 0 < o := by
simpa using nat_lt_card (n := 0)
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | zero_lt_card | null |
one_lt_card {o} : 1 < card o ↔ 1 < o := by
simpa using nat_lt_card (n := 1)
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | one_lt_card | null |
ofNat_lt_card {o} {n : ℕ} [n.AtLeastTwo] :
(ofNat(n) : Cardinal) < card o ↔ (OfNat.ofNat n : Ordinal) < o :=
nat_lt_card
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | ofNat_lt_card | null |
card_lt_nat {o} {n : ℕ} : card o < n ↔ o < n :=
lt_iff_lt_of_le_iff_le nat_le_card
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | card_lt_nat | null |
card_lt_ofNat {o} {n : ℕ} [n.AtLeastTwo] :
card o < ofNat(n) ↔ o < OfNat.ofNat n :=
card_lt_nat
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | card_lt_ofNat | null |
card_le_nat {o} {n : ℕ} : card o ≤ n ↔ o ≤ n :=
le_iff_le_iff_lt_iff_lt.2 nat_lt_card
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | card_le_nat | null |
card_le_one {o} : card o ≤ 1 ↔ o ≤ 1 := by
simpa using card_le_nat (n := 1)
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | card_le_one | null |
card_le_ofNat {o} {n : ℕ} [n.AtLeastTwo] :
card o ≤ ofNat(n) ↔ o ≤ OfNat.ofNat n :=
card_le_nat
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | card_le_ofNat | null |
card_eq_nat {o} {n : ℕ} : card o = n ↔ o = n := by
simp only [le_antisymm_iff, card_le_nat, nat_le_card]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | card_eq_nat | null |
card_eq_zero {o} : card o = 0 ↔ o = 0 := by
simpa using card_eq_nat (n := 0)
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | card_eq_zero | null |
card_eq_one {o} : card o = 1 ↔ o = 1 := by
simpa using card_eq_nat (n := 1) | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | card_eq_one | null |
mem_range_lift_of_card_le {a : Cardinal.{u}} {b : Ordinal.{max u v}}
(h : card b ≤ Cardinal.lift.{v, u} a) : b ∈ Set.range lift.{v, u} := by
rw [card_le_iff, ← lift_succ, ← lift_ord] at h
exact mem_range_lift_of_le h.le
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | mem_range_lift_of_card_le | null |
card_eq_ofNat {o} {n : ℕ} [n.AtLeastTwo] :
card o = ofNat(n) ↔ o = OfNat.ofNat n :=
card_eq_nat
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | card_eq_ofNat | null |
type_fintype (r : α → α → Prop) [IsWellOrder α r] [Fintype α] :
type r = Fintype.card α := by rw [← card_eq_nat, card_type, mk_fintype] | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | type_fintype | null |
type_fin (n : ℕ) : typeLT (Fin n) = n := by simp | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | type_fin | null |
List.Sorted.lt_ord_of_lt [LinearOrder α] [WellFoundedLT α] {l m : List α}
{o : Ordinal} (hl : l.Sorted (· > ·)) (hm : m.Sorted (· > ·)) (hmltl : m < l)
(hlt : ∀ i ∈ l, Ordinal.typein (α := α) (· < ·) i < o) :
∀ i ∈ m, Ordinal.typein (α := α) (· < ·) i < o := by
replace hmltl : List.Lex (· < ·) m l := hmltl
cases l with
| nil => simp at hmltl
| cons a as =>
cases m with
| nil => intro i hi; simp at hi
| cons b bs =>
intro i hi
suffices h : i ≤ a by refine lt_of_le_of_lt ?_ (hlt a mem_cons_self); simpa
cases hi with
| head as => exact List.head_le_of_lt hmltl
| tail b hi => exact le_of_lt (lt_of_lt_of_le (List.rel_of_sorted_cons hm _ hi)
(List.head_le_of_lt hmltl)) | theorem | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | List.Sorted.lt_ord_of_lt | null |
@[elab_as_elim]
protected rec (b : Ordinal) {C : Ordinal → Sort*} (H0 : C 0)
(H : ∀ o, o ≠ 0 → C (o % b ^ log b o) → C o) (o : Ordinal) : C o :=
if h : o = 0 then h ▸ H0 else H o h (CNF.rec b H0 H (o % b ^ log b o))
termination_by o
decreasing_by exact mod_opow_log_lt_self b h
@[deprecated (since := "2025-08-18")]
noncomputable alias _root_.Ordinal.CNFRec := CNF.rec
@[simp] | def | SetTheory | [
"Mathlib.Data.Finsupp.AList",
"Mathlib.SetTheory.Ordinal.Exponential",
"Mathlib.SetTheory.Ordinal.Family"
] | Mathlib/SetTheory/Ordinal/CantorNormalForm.lean | rec | Inducts on the base `b` expansion of an ordinal. |
rec_zero {C : Ordinal → Sort*} (b : Ordinal) (H0 : C 0)
(H : ∀ o, o ≠ 0 → C (o % b ^ log b o) → C o) : CNF.rec b H0 H 0 = H0 := by
rw [CNF.rec, dif_pos rfl]
@[deprecated (since := "2025-08-18")]
alias _root_.Ordinal.CNFRec_zero := rec_zero | theorem | SetTheory | [
"Mathlib.Data.Finsupp.AList",
"Mathlib.SetTheory.Ordinal.Exponential",
"Mathlib.SetTheory.Ordinal.Family"
] | Mathlib/SetTheory/Ordinal/CantorNormalForm.lean | rec_zero | null |
rec_pos (b : Ordinal) {o : Ordinal} {C : Ordinal → Sort*} (ho : o ≠ 0) (H0 : C 0)
(H : ∀ o, o ≠ 0 → C (o % b ^ log b o) → C o) :
CNF.rec b H0 H o = H o ho (@CNF.rec b C H0 H _) := by
rw [CNF.rec, dif_neg]
@[deprecated (since := "2025-08-18")]
alias _root_.Ordinal.CNFRec_pos := rec_pos | theorem | SetTheory | [
"Mathlib.Data.Finsupp.AList",
"Mathlib.SetTheory.Ordinal.Exponential",
"Mathlib.SetTheory.Ordinal.Family"
] | Mathlib/SetTheory/Ordinal/CantorNormalForm.lean | rec_pos | null |
@[pp_nodot]
_root_.Ordinal.CNF (b o : Ordinal) : List (Ordinal × Ordinal) :=
CNF.rec b [] (fun o _ IH ↦ (log b o, o / b ^ log b o)::IH) o
@[simp] | def | SetTheory | [
"Mathlib.Data.Finsupp.AList",
"Mathlib.SetTheory.Ordinal.Exponential",
"Mathlib.SetTheory.Ordinal.Family"
] | Mathlib/SetTheory/Ordinal/CantorNormalForm.lean | _root_.Ordinal.CNF | The Cantor normal form of an ordinal `o` is the list of coefficients and exponents in the
base-`b` expansion of `o`.
We special-case `CNF 0 o = CNF 1 o = [(0, o)]` for `o ≠ 0`.
`CNF b (b ^ u₁ * v₁ + b ^ u₂ * v₂) = [(u₁, v₁), (u₂, v₂)]` |
zero_right (b : Ordinal) : CNF b 0 = [] :=
rec_zero b _ _
@[deprecated (since := "2025-08-18")]
alias _root_.Ordinal.CNF_zero := zero_right | theorem | SetTheory | [
"Mathlib.Data.Finsupp.AList",
"Mathlib.SetTheory.Ordinal.Exponential",
"Mathlib.SetTheory.Ordinal.Family"
] | Mathlib/SetTheory/Ordinal/CantorNormalForm.lean | zero_right | null |
protected ne_zero {b o : Ordinal} (ho : o ≠ 0) :
CNF b o = (log b o, o / b ^ log b o)::CNF b (o % b ^ log b o) :=
rec_pos b ho _ _
@[deprecated (since := "2025-08-18")]
alias _root_.Ordinal.CNF_ne_zero := CNF.ne_zero | theorem | SetTheory | [
"Mathlib.Data.Finsupp.AList",
"Mathlib.SetTheory.Ordinal.Exponential",
"Mathlib.SetTheory.Ordinal.Family"
] | Mathlib/SetTheory/Ordinal/CantorNormalForm.lean | ne_zero | Recursive definition for the Cantor normal form. |
protected zero_left {o : Ordinal} (ho : o ≠ 0) : CNF 0 o = [(0, o)] := by
simp [CNF.ne_zero ho]
@[deprecated (since := "2025-08-18")]
alias _root_.Ordinal.zero_CNF := CNF.zero_left | theorem | SetTheory | [
"Mathlib.Data.Finsupp.AList",
"Mathlib.SetTheory.Ordinal.Exponential",
"Mathlib.SetTheory.Ordinal.Family"
] | Mathlib/SetTheory/Ordinal/CantorNormalForm.lean | zero_left | null |
protected one_left {o : Ordinal} (ho : o ≠ 0) : CNF 1 o = [(0, o)] := by
simp [CNF.ne_zero ho]
@[deprecated (since := "2025-08-18")]
alias _root_.Ordinal.one_CNF := CNF.one_left | theorem | SetTheory | [
"Mathlib.Data.Finsupp.AList",
"Mathlib.SetTheory.Ordinal.Exponential",
"Mathlib.SetTheory.Ordinal.Family"
] | Mathlib/SetTheory/Ordinal/CantorNormalForm.lean | one_left | null |
protected of_le_one {b o : Ordinal} (hb : b ≤ 1) (ho : o ≠ 0) : CNF b o = [(0, o)] := by
rcases le_one_iff.1 hb with (rfl | rfl)
exacts [CNF.zero_left ho, CNF.one_left ho]
@[deprecated (since := "2025-08-18")]
alias _root_.Ordinal.CNF_of_le_one := CNF.of_le_one | theorem | SetTheory | [
"Mathlib.Data.Finsupp.AList",
"Mathlib.SetTheory.Ordinal.Exponential",
"Mathlib.SetTheory.Ordinal.Family"
] | Mathlib/SetTheory/Ordinal/CantorNormalForm.lean | of_le_one | null |
protected of_lt {b o : Ordinal} (ho : o ≠ 0) (hb : o < b) : CNF b o = [(0, o)] := by
rw [CNF.ne_zero ho, log_eq_zero hb, opow_zero, div_one, mod_one, zero_right]
@[deprecated (since := "2025-08-18")]
alias _root_.Ordinal.CNF_of_lt := CNF.of_lt | theorem | SetTheory | [
"Mathlib.Data.Finsupp.AList",
"Mathlib.SetTheory.Ordinal.Exponential",
"Mathlib.SetTheory.Ordinal.Family"
] | Mathlib/SetTheory/Ordinal/CantorNormalForm.lean | of_lt | null |
protected foldr (b o : Ordinal) : (CNF b o).foldr (fun p r ↦ b ^ p.1 * p.2 + r) 0 = o := by
refine CNF.rec b ?_ ?_ o
· rw [zero_right, foldr_nil]
· intro o ho IH
rw [CNF.ne_zero ho, foldr_cons, IH, div_add_mod]
@[deprecated (since := "2025-08-18")]
alias _root_.Ordinal.CNF_foldr := CNF.foldr | theorem | SetTheory | [
"Mathlib.Data.Finsupp.AList",
"Mathlib.SetTheory.Ordinal.Exponential",
"Mathlib.SetTheory.Ordinal.Family"
] | Mathlib/SetTheory/Ordinal/CantorNormalForm.lean | foldr | Evaluating the Cantor normal form of an ordinal returns the ordinal. |
fst_le_log {b o : Ordinal.{u}} {x : Ordinal × Ordinal} : x ∈ CNF b o → x.1 ≤ log b o := by
refine CNF.rec b ?_ (fun o ho H ↦ ?_) o
· simp
· rw [CNF.ne_zero ho, mem_cons]
rintro (rfl | h)
· rfl
· exact (H h).trans (log_mono_right _ (mod_opow_log_lt_self b ho).le)
@[deprecated (since := "2025-08-18")]
alias _root_.Ordinal.CNF_fst_le_log := fst_le_log | theorem | SetTheory | [
"Mathlib.Data.Finsupp.AList",
"Mathlib.SetTheory.Ordinal.Exponential",
"Mathlib.SetTheory.Ordinal.Family"
] | Mathlib/SetTheory/Ordinal/CantorNormalForm.lean | fst_le_log | Every exponent in the Cantor normal form `CNF b o` is less or equal to `log b o`. |
lt_snd {b o : Ordinal.{u}} {x : Ordinal × Ordinal} : x ∈ CNF b o → 0 < x.2 := by
refine CNF.rec b (by simp) (fun o ho IH ↦ ?_) o
rw [CNF.ne_zero ho]
rintro (h | ⟨_, h⟩)
· exact div_opow_log_pos b ho
· exact IH h
@[deprecated (since := "2025-08-18")]
alias _root_.Ordinal.CNF_lt_snd := lt_snd | theorem | SetTheory | [
"Mathlib.Data.Finsupp.AList",
"Mathlib.SetTheory.Ordinal.Exponential",
"Mathlib.SetTheory.Ordinal.Family"
] | Mathlib/SetTheory/Ordinal/CantorNormalForm.lean | lt_snd | Every coefficient in a Cantor normal form is positive. |
snd_lt {b o : Ordinal.{u}} (hb : 1 < b) {x : Ordinal × Ordinal} :
x ∈ CNF b o → x.2 < b := by
refine CNF.rec b ?_ (fun o ho IH ↦ ?_) o
· simp
· rw [CNF.ne_zero ho]
intro h
obtain rfl | h := mem_cons.mp h
· exact div_opow_log_lt o hb
· exact IH h
@[deprecated (since := "2025-08-18")]
alias _root_.Ordinal.CNF_snd_lt := snd_lt | theorem | SetTheory | [
"Mathlib.Data.Finsupp.AList",
"Mathlib.SetTheory.Ordinal.Exponential",
"Mathlib.SetTheory.Ordinal.Family"
] | Mathlib/SetTheory/Ordinal/CantorNormalForm.lean | snd_lt | Every coefficient in the Cantor normal form `CNF b o` is less than `b`. |
protected sorted (b o : Ordinal) : ((CNF b o).map Prod.fst).Sorted (· > ·) := by
refine CNF.rec b ?_ (fun o ho IH ↦ ?_) o
· rw [zero_right]
exact sorted_nil
· rcases le_or_gt b 1 with hb | hb
· rw [CNF.of_le_one hb ho]
exact sorted_singleton _
· obtain hob | hbo := lt_or_ge o b
· rw [CNF.of_lt ho hob]
exact sorted_singleton _
· rw [CNF.ne_zero ho, map_cons, sorted_cons]
refine ⟨fun a H ↦ ?_, IH⟩
rw [mem_map] at H
rcases H with ⟨⟨a, a'⟩, H, rfl⟩
exact (fst_le_log H).trans_lt (log_mod_opow_log_lt_log_self hb hbo)
@[deprecated (since := "2025-08-18")]
alias _root_.Ordinal.CNF_sorted := CNF.sorted | theorem | SetTheory | [
"Mathlib.Data.Finsupp.AList",
"Mathlib.SetTheory.Ordinal.Exponential",
"Mathlib.SetTheory.Ordinal.Family"
] | Mathlib/SetTheory/Ordinal/CantorNormalForm.lean | sorted | The exponents of the Cantor normal form are decreasing. |
private nodupKeys (b o : Ordinal) : (map Prod.toSigma (CNF b o)).NodupKeys := by
rw [NodupKeys, List.keys, map_map, Prod.fst_comp_toSigma]
exact (CNF.sorted ..).nodup
/-! ### Cantor normal form as a finsupp -/
open AList Finsupp | theorem | SetTheory | [
"Mathlib.Data.Finsupp.AList",
"Mathlib.SetTheory.Ordinal.Exponential",
"Mathlib.SetTheory.Ordinal.Family"
] | Mathlib/SetTheory/Ordinal/CantorNormalForm.lean | nodupKeys | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.