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 ⌀ |
|---|---|---|---|---|---|---|
div_self {a : Ordinal} (h : a ≠ 0) : a / a = 1 := by
simpa only [mul_one] using mul_div_cancel 1 h | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | div_self | null |
mul_sub (a b c : Ordinal) : a * (b - c) = a * b - a * c :=
if a0 : a = 0 then by simp only [a0, zero_mul, sub_self]
else
eq_of_forall_ge_iff fun d => by rw [sub_le, ← le_div a0, sub_le, ← le_div a0, mul_add_div _ a0] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mul_sub | null |
isSuccLimit_add_iff {a b : Ordinal} :
IsSuccLimit (a + b) ↔ IsSuccLimit b ∨ b = 0 ∧ IsSuccLimit a := by
constructor <;> intro h
· by_cases h' : b = 0
· rw [h', add_zero] at h
right
exact ⟨h', h⟩
left
rw [← add_sub_cancel a b]
apply isSuccLimit_sub h
suffices a + 0 < a + b by simpa only [add_zero] using this
rwa [add_lt_add_iff_left, Ordinal.pos_iff_ne_zero]
rcases h with (h | ⟨rfl, h⟩)
· exact isSuccLimit_add a h
· simpa only [add_zero] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | isSuccLimit_add_iff | null |
isSuccLimit_add_iff_of_isSuccLimit {a b : Ordinal} (h : IsSuccLimit a) :
IsSuccLimit (a + b) ↔ IsSuccPrelimit b := by
rw [isSuccLimit_add_iff]
obtain rfl | hb := eq_or_ne b 0
· simpa
· simp [hb, isSuccLimit_iff]
@[deprecated (since := "2025-07-09")]
alias isLimit_add_iff := isSuccLimit_add_iff | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | isSuccLimit_add_iff_of_isSuccLimit | null |
dvd_add_iff : ∀ {a b c : Ordinal}, a ∣ b → (a ∣ b + c ↔ a ∣ c)
| a, _, c, ⟨b, rfl⟩ =>
⟨fun ⟨d, e⟩ => ⟨d - b, by rw [mul_sub, ← e, add_sub_cancel]⟩, fun ⟨d, e⟩ => by
rw [e, ← mul_add]
apply dvd_mul_right⟩ | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | dvd_add_iff | null |
div_mul_cancel : ∀ {a b : Ordinal}, a ≠ 0 → a ∣ b → a * (b / a) = b
| a, _, a0, ⟨b, rfl⟩ => by rw [mul_div_cancel _ a0] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | div_mul_cancel | null |
le_of_dvd : ∀ {a b : Ordinal}, b ≠ 0 → a ∣ b → a ≤ b
| a, _, b0, ⟨b, e⟩ => by
subst e
simpa only [mul_one] using
mul_le_mul_left'
(one_le_iff_ne_zero.2 fun h : b = 0 => by simp [h] at b0)
a | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | le_of_dvd | null |
dvd_antisymm {a b : Ordinal} (h₁ : a ∣ b) (h₂ : b ∣ a) : a = b :=
if a0 : a = 0 then by subst a; exact (eq_zero_of_zero_dvd h₁).symm
else
if b0 : b = 0 then by subst b; exact eq_zero_of_zero_dvd h₂
else (le_of_dvd b0 h₁).antisymm (le_of_dvd a0 h₂) | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | dvd_antisymm | null |
isAntisymm : IsAntisymm Ordinal (· ∣ ·) :=
⟨@dvd_antisymm⟩ | instance | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | isAntisymm | null |
mod : Mod Ordinal :=
⟨fun a b => a - b * (a / b)⟩ | instance | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mod | `a % b` is the unique ordinal `o'` satisfying
`a = b * o + o'` with `o' < b`. |
mod_def (a b : Ordinal) : a % b = a - b * (a / b) :=
rfl | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mod_def | null |
mod_le (a b : Ordinal) : a % b ≤ a :=
sub_le_self a _
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mod_le | null |
mod_zero (a : Ordinal) : a % 0 = a := by simp only [mod_def, div_zero, zero_mul, sub_zero] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mod_zero | null |
mod_eq_of_lt {a b : Ordinal} (h : a < b) : a % b = a := by
simp only [mod_def, div_eq_zero_of_lt h, mul_zero, sub_zero]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mod_eq_of_lt | null |
zero_mod (b : Ordinal) : 0 % b = 0 := by simp only [mod_def, zero_div, mul_zero, sub_self] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | zero_mod | null |
div_add_mod (a b : Ordinal) : b * (a / b) + a % b = a :=
Ordinal.add_sub_cancel_of_le <| mul_div_le _ _ | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | div_add_mod | null |
mod_lt (a) {b : Ordinal} (h : b ≠ 0) : a % b < b :=
(add_lt_add_iff_left (b * (a / b))).1 <| by rw [div_add_mod]; exact lt_mul_div_add a h
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mod_lt | null |
mod_self (a : Ordinal) : a % a = 0 :=
if a0 : a = 0 then by simp only [a0, zero_mod]
else by simp only [mod_def, div_self a0, mul_one, sub_self]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mod_self | null |
mod_one (a : Ordinal) : a % 1 = 0 := by simp only [mod_def, div_one, one_mul, sub_self] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mod_one | null |
dvd_of_mod_eq_zero {a b : Ordinal} (H : a % b = 0) : b ∣ a :=
⟨a / b, by simpa [H] using (div_add_mod a b).symm⟩ | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | dvd_of_mod_eq_zero | null |
mod_eq_zero_of_dvd {a b : Ordinal} (H : b ∣ a) : a % b = 0 := by
rcases H with ⟨c, rfl⟩
rcases eq_or_ne b 0 with (rfl | hb)
· simp
· simp [mod_def, hb] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mod_eq_zero_of_dvd | null |
dvd_iff_mod_eq_zero {a b : Ordinal} : b ∣ a ↔ a % b = 0 :=
⟨mod_eq_zero_of_dvd, dvd_of_mod_eq_zero⟩
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | dvd_iff_mod_eq_zero | null |
mul_add_mod_self (x y z : Ordinal) : (x * y + z) % x = z % x := by
rcases eq_or_ne x 0 with rfl | hx
· simp
· rwa [mod_def, mul_add_div, mul_add, ← sub_sub, add_sub_cancel, mod_def]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mul_add_mod_self | null |
mul_mod (x y : Ordinal) : x * y % x = 0 := by
simpa using mul_add_mod_self x y 0 | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mul_mod | null |
mul_add_mod_mul {w x : Ordinal} (hw : w < x) (y z : Ordinal) :
(x * y + w) % (x * z) = x * (y % z) + w := by
rw [mod_def, mul_add_div_mul hw]
apply sub_eq_of_add_eq
rw [← add_assoc, mul_assoc, ← mul_add, div_add_mod] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mul_add_mod_mul | null |
mul_mod_mul (x y z : Ordinal) : (x * y) % (x * z) = x * (y % z) := by
obtain rfl | hx := Ordinal.eq_zero_or_pos x
· simp
· convert mul_add_mod_mul hx y z using 1 <;>
rw [add_zero] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mul_mod_mul | null |
mod_mod_of_dvd (a : Ordinal) {b c : Ordinal} (h : c ∣ b) : a % b % c = a % c := by
nth_rw 2 [← div_add_mod a b]
rcases h with ⟨d, rfl⟩
rw [mul_assoc, mul_add_mod_self]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mod_mod_of_dvd | null |
mod_mod (a b : Ordinal) : a % b % b = a % b :=
mod_mod_of_dvd a dvd_rfl
/-! ### Casting naturals into ordinals, compatibility with operations -/ | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mod_mod | null |
instCharZero : CharZero Ordinal := by
refine ⟨fun a b h ↦ ?_⟩
rwa [← Cardinal.ord_nat, ← Cardinal.ord_nat, Cardinal.ord_inj, Nat.cast_inj] at h
@[simp] | instance | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | instCharZero | null |
one_add_natCast (m : ℕ) : 1 + (m : Ordinal) = succ m := by
rw [← Nat.cast_one, ← Nat.cast_add, add_comm]
rfl
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | one_add_natCast | null |
one_add_ofNat (m : ℕ) [m.AtLeastTwo] :
1 + (ofNat(m) : Ordinal) = Order.succ (OfNat.ofNat m : Ordinal) :=
one_add_natCast m
@[simp, norm_cast] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | one_add_ofNat | null |
natCast_mul (m : ℕ) : ∀ n : ℕ, ((m * n : ℕ) : Ordinal) = m * n
| 0 => by simp
| n + 1 => by rw [Nat.mul_succ, Nat.cast_add, natCast_mul m n, Nat.cast_succ, mul_add_one]
@[simp, norm_cast] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | natCast_mul | null |
natCast_sub (m n : ℕ) : ((m - n : ℕ) : Ordinal) = m - n := by
rcases le_total m n with h | h
· rw [tsub_eq_zero_iff_le.2 h, Ordinal.sub_eq_zero_iff_le.2 (Nat.cast_le.2 h), Nat.cast_zero]
· rw [← add_left_cancel_iff (a := ↑n), ← Nat.cast_add, add_tsub_cancel_of_le h,
Ordinal.add_sub_cancel_of_le (Nat.cast_le.2 h)]
@[simp, norm_cast] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | natCast_sub | null |
natCast_div (m n : ℕ) : ((m / n : ℕ) : Ordinal) = m / n := by
rcases eq_or_ne n 0 with (rfl | hn)
· simp
· have hn' : (n : Ordinal) ≠ 0 := Nat.cast_ne_zero.2 hn
apply le_antisymm
· rw [le_div hn', ← natCast_mul, Nat.cast_le, mul_comm]
apply Nat.div_mul_le_self
· rw [div_le hn', ← add_one_eq_succ, ← Nat.cast_succ, ← natCast_mul, Nat.cast_lt, mul_comm,
← Nat.div_lt_iff_lt_mul (Nat.pos_of_ne_zero hn)]
apply Nat.lt_succ_self
@[simp, norm_cast] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | natCast_div | null |
natCast_mod (m n : ℕ) : ((m % n : ℕ) : Ordinal) = m % n := by
rw [← add_left_cancel_iff, div_add_mod, ← natCast_div, ← natCast_mul, ← Nat.cast_add,
Nat.div_add_mod]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | natCast_mod | null |
lift_natCast : ∀ n : ℕ, lift.{u, v} n = n
| 0 => by simp
| n + 1 => by simp [lift_natCast n]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | lift_natCast | null |
lift_ofNat (n : ℕ) [n.AtLeastTwo] :
lift.{u, v} ofNat(n) = OfNat.ofNat n :=
lift_natCast n
/-! ### Properties of `ω` -/ | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | lift_ofNat | null |
lt_omega0 {o : Ordinal} : o < ω ↔ ∃ n : ℕ, o = n := by
simp_rw [← Cardinal.ord_aleph0, Cardinal.lt_ord, lt_aleph0, card_eq_nat] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | lt_omega0 | null |
nat_lt_omega0 (n : ℕ) : ↑n < ω :=
lt_omega0.2 ⟨_, rfl⟩ | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | nat_lt_omega0 | null |
eq_nat_or_omega0_le (o : Ordinal) : (∃ n : ℕ, o = n) ∨ ω ≤ o := by
obtain ho | ho := lt_or_ge o ω
· exact Or.inl <| lt_omega0.1 ho
· exact Or.inr ho
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | eq_nat_or_omega0_le | null |
omega0_pos : 0 < ω :=
nat_lt_omega0 0
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | omega0_pos | null |
omega0_ne_zero : ω ≠ 0 :=
omega0_pos.ne'
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | omega0_ne_zero | null |
one_lt_omega0 : 1 < ω := by simpa only [Nat.cast_one] using nat_lt_omega0 1 | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | one_lt_omega0 | null |
isSuccLimit_omega0 : IsSuccLimit ω := by
rw [isSuccLimit_iff, isSuccPrelimit_iff_succ_lt]
refine ⟨omega0_ne_zero, fun o h => ?_⟩
obtain ⟨n, rfl⟩ := lt_omega0.1 h
exact nat_lt_omega0 (n + 1)
@[deprecated (since := "2025-07-09")]
alias isLimit_omega0 := isSuccLimit_omega0
@[deprecated (since := "2025-07-09")]
alias nat_lt_limit := natCast_lt_of_isSuccLimit | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | isSuccLimit_omega0 | null |
omega0_le {o : Ordinal} : ω ≤ o ↔ ∀ n : ℕ, ↑n ≤ o :=
⟨fun h n => (nat_lt_omega0 _).le.trans h, fun H =>
le_of_forall_lt fun a h => by
let ⟨n, e⟩ := lt_omega0.1 h
rw [e, ← succ_le_iff]; exact H (n + 1)⟩ | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | omega0_le | null |
omega0_le_of_isSuccLimit {o} (h : IsSuccLimit o) : ω ≤ o :=
omega0_le.2 fun n => le_of_lt <| natCast_lt_of_isSuccLimit h n
@[deprecated (since := "2025-07-09")]
alias omega0_le_of_isLimit := omega0_le_of_isSuccLimit | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | omega0_le_of_isSuccLimit | null |
natCast_add_omega0 (n : ℕ) : n + ω = ω := by
refine le_antisymm (le_of_forall_lt fun a ha ↦ ?_) (le_add_left _ _)
obtain ⟨b, hb', hb⟩ := (lt_add_iff omega0_ne_zero).1 ha
obtain ⟨m, rfl⟩ := lt_omega0.1 hb'
apply hb.trans_lt
exact_mod_cast nat_lt_omega0 (n + m) | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | natCast_add_omega0 | null |
one_add_omega0 : 1 + ω = ω :=
mod_cast natCast_add_omega0 1 | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | one_add_omega0 | null |
add_omega0 {a : Ordinal} (h : a < ω) : a + ω = ω := by
obtain ⟨n, rfl⟩ := lt_omega0.1 h
exact natCast_add_omega0 n
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | add_omega0 | null |
natCast_add_of_omega0_le {o} (h : ω ≤ o) (n : ℕ) : n + o = o := by
rw [← Ordinal.add_sub_cancel_of_le h, ← add_assoc, natCast_add_omega0]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | natCast_add_of_omega0_le | null |
one_add_of_omega0_le {o} (h : ω ≤ o) : 1 + o = o :=
mod_cast natCast_add_of_omega0_le h 1
open Ordinal | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | one_add_of_omega0_le | null |
isSuccLimit_iff_omega0_dvd {a : Ordinal} : IsSuccLimit a ↔ a ≠ 0 ∧ ω ∣ a := by
refine ⟨fun l => ⟨l.ne_bot, ⟨a / ω, le_antisymm ?_ (mul_div_le _ _)⟩⟩, fun h => ?_⟩
· refine l.le_iff_forall_le.2 fun x hx => le_of_lt ?_
rw [← div_lt omega0_ne_zero, ← succ_le_iff, le_div omega0_ne_zero, mul_succ,
add_le_iff_of_isSuccLimit isSuccLimit_omega0]
intro b hb
rcases lt_omega0.1 hb with ⟨n, rfl⟩
exact
(add_le_add_right (mul_div_le _ _) _).trans
(lt_sub.1 <| natCast_lt_of_isSuccLimit (isSuccLimit_sub l hx) _).le
· rcases h with ⟨a0, b, rfl⟩
refine isSuccLimit_mul_left isSuccLimit_omega0 (Ordinal.pos_iff_ne_zero.2 <| mt ?_ a0)
intro e
simp only [e, mul_zero]
@[deprecated (since := "2025-07-09")]
alias isLimit_iff_omega0_dvd := isSuccLimit_iff_omega0_dvd
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | isSuccLimit_iff_omega0_dvd | null |
natCast_mod_omega0 (n : ℕ) : n % ω = n :=
mod_eq_of_lt (nat_lt_omega0 n) | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | natCast_mod_omega0 | null |
@[simp]
add_one_of_aleph0_le {c} (h : ℵ₀ ≤ c) : c + 1 = c := by
rw [add_comm, ← card_ord c, ← card_one, ← card_add, one_add_of_omega0_le]
rwa [← ord_aleph0, ord_le_ord] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | add_one_of_aleph0_le | null |
isSuccLimit_ord {c} (co : ℵ₀ ≤ c) : IsSuccLimit (ord c) := by
rw [isSuccLimit_iff, isSuccPrelimit_iff_succ_lt]
refine ⟨fun h => aleph0_ne_zero ?_, fun a => lt_imp_lt_of_le_imp_le fun h => ?_⟩
· rw [← Ordinal.le_zero, ord_le] at h
simpa only [card_zero, nonpos_iff_eq_zero] using co.trans h
· rw [ord_le] at h ⊢
rwa [← @add_one_of_aleph0_le (card a), ← card_succ]
rw [← ord_le, ← IsSuccLimit.le_succ_iff, ord_le]
· exact co.trans h
· rw [ord_aleph0]
exact Ordinal.isSuccLimit_omega0
@[deprecated (since := "2025-07-09")]
alias isLimit_ord := isSuccLimit_ord | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | isSuccLimit_ord | null |
noMaxOrder {c} (h : ℵ₀ ≤ c) : NoMaxOrder c.ord.toType :=
toType_noMax_of_succ_lt fun _ ↦ (isSuccLimit_ord h).succ_lt | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | noMaxOrder | null |
WellOrder : Type (u + 1) where
/-- The underlying type of the order. -/
α : Type u
/-- The underlying relation of the order. -/
r : α → α → Prop
/-- The proposition that `r` is a well-ordering for `α`. -/
wo : IsWellOrder α r
attribute [instance] WellOrder.wo | structure | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | WellOrder | Bundled structure registering a well order on a type. Ordinals will be defined as a quotient
of this type. |
inhabited : Inhabited WellOrder :=
⟨⟨PEmpty, _, inferInstanceAs (IsWellOrder PEmpty EmptyRelation)⟩⟩ | instance | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | inhabited | null |
Ordinal.isEquivalent : Setoid WellOrder where
r := fun ⟨_, r, _⟩ ⟨_, s, _⟩ => Nonempty (r ≃r s)
iseqv :=
⟨fun _ => ⟨RelIso.refl _⟩, fun ⟨e⟩ => ⟨e.symm⟩, fun ⟨e₁⟩ ⟨e₂⟩ => ⟨e₁.trans e₂⟩⟩ | instance | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | Ordinal.isEquivalent | Equivalence relation on well orders on arbitrary types in universe `u`, given by order
isomorphism. |
@[pp_with_univ]
Ordinal : Type (u + 1) :=
Quotient Ordinal.isEquivalent | 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 | Ordinal | `Ordinal.{u}` is the type of well orders in `Type u`, up to order isomorphism. |
Ordinal.toType (o : Ordinal.{u}) : Type u :=
o.out.α | 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 | Ordinal.toType | A "canonical" type order-isomorphic to the ordinal `o`, living in the same universe. This is
defined through the axiom of choice.
Use this over `Iio o` only when it is paramount to have a `Type u` rather than a `Type (u + 1)`. |
hasWellFounded_toType (o : Ordinal) : WellFoundedRelation o.toType :=
⟨o.out.r, o.out.wo.wf⟩ | instance | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | hasWellFounded_toType | null |
linearOrder_toType (o : Ordinal) : LinearOrder o.toType :=
@IsWellOrder.linearOrder _ o.out.r o.out.wo | instance | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | linearOrder_toType | null |
wellFoundedLT_toType_lt (o : Ordinal) : WellFoundedLT o.toType :=
o.out.wo.toIsWellFounded | instance | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | wellFoundedLT_toType_lt | null |
type (r : α → α → Prop) [wo : IsWellOrder α r] : Ordinal :=
⟦⟨α, r, wo⟩⟧ | 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 | type | The order type of a well order is an ordinal. |
@[elab_as_elim]
inductionOn {C : Ordinal → Prop} (o : Ordinal)
(H : ∀ (α r) [IsWellOrder α r], C (type r)) : C o :=
Quot.inductionOn o fun ⟨α, r, wo⟩ => @H α r wo | 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 | inductionOn | `typeLT α` is an abbreviation for the order type of the `<` relation of `α`. -/
scoped notation "typeLT " α:70 => @Ordinal.type α (· < ·) inferInstance
instance zero : Zero Ordinal :=
⟨type <| @EmptyRelation PEmpty⟩
instance inhabited : Inhabited Ordinal :=
⟨0⟩
instance one : One Ordinal :=
⟨type <| @EmptyRelation PUnit⟩
@[simp]
theorem type_toType (o : Ordinal) : typeLT o.toType = o :=
o.out_eq
theorem type_eq {α β} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s] :
type r = type s ↔ Nonempty (r ≃r s) :=
Quotient.eq'
theorem _root_.RelIso.ordinal_type_eq {α β} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r]
[IsWellOrder β s] (h : r ≃r s) : type r = type s :=
type_eq.2 ⟨h⟩
theorem type_eq_zero_of_empty (r) [IsWellOrder α r] [IsEmpty α] : type r = 0 :=
(RelIso.relIsoOfIsEmpty r _).ordinal_type_eq
@[simp]
theorem type_eq_zero_iff_isEmpty [IsWellOrder α r] : type r = 0 ↔ IsEmpty α :=
⟨fun h =>
let ⟨s⟩ := type_eq.1 h
s.toEquiv.isEmpty,
@type_eq_zero_of_empty α r _⟩
theorem type_ne_zero_iff_nonempty [IsWellOrder α r] : type r ≠ 0 ↔ Nonempty α := by simp
theorem type_ne_zero_of_nonempty (r) [IsWellOrder α r] [h : Nonempty α] : type r ≠ 0 :=
type_ne_zero_iff_nonempty.2 h
theorem type_pEmpty : type (@EmptyRelation PEmpty) = 0 :=
rfl
theorem type_empty : type (@EmptyRelation Empty) = 0 :=
type_eq_zero_of_empty _
theorem type_eq_one_of_unique (r) [IsWellOrder α r] [Nonempty α] [Subsingleton α] : type r = 1 := by
cases nonempty_unique α
exact (RelIso.ofUniqueOfIrrefl r _).ordinal_type_eq
@[simp]
theorem type_eq_one_iff_unique [IsWellOrder α r] : type r = 1 ↔ Nonempty (Unique α) :=
⟨fun h ↦ let ⟨s⟩ := type_eq.1 h; ⟨s.toEquiv.unique⟩,
fun ⟨_⟩ ↦ type_eq_one_of_unique r⟩
theorem type_pUnit : type (@EmptyRelation PUnit) = 1 :=
rfl
theorem type_unit : type (@EmptyRelation Unit) = 1 :=
rfl
@[simp]
theorem toType_empty_iff_eq_zero {o : Ordinal} : IsEmpty o.toType ↔ o = 0 := by
rw [← @type_eq_zero_iff_isEmpty o.toType (· < ·), type_toType]
instance isEmpty_toType_zero : IsEmpty (toType 0) :=
toType_empty_iff_eq_zero.2 rfl
@[simp]
theorem toType_nonempty_iff_ne_zero {o : Ordinal} : Nonempty o.toType ↔ o ≠ 0 := by
rw [← @type_ne_zero_iff_nonempty o.toType (· < ·), type_toType]
protected theorem one_ne_zero : (1 : Ordinal) ≠ 0 :=
type_ne_zero_of_nonempty _
instance nontrivial : Nontrivial Ordinal.{u} :=
⟨⟨1, 0, Ordinal.one_ne_zero⟩⟩
/-- `Quotient.inductionOn` specialized to ordinals.
Not to be confused with well-founded recursion `Ordinal.induction`. |
@[elab_as_elim]
inductionOn₂ {C : Ordinal → Ordinal → Prop} (o₁ o₂ : Ordinal)
(H : ∀ (α r) [IsWellOrder α r] (β s) [IsWellOrder β s], C (type r) (type s)) : C o₁ o₂ :=
Quotient.inductionOn₂ o₁ o₂ fun ⟨α, r, wo₁⟩ ⟨β, s, wo₂⟩ => @H α r wo₁ β s wo₂ | 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 | inductionOn₂ | `Quotient.inductionOn₂` specialized to ordinals.
Not to be confused with well-founded recursion `Ordinal.induction`. |
@[elab_as_elim]
inductionOn₃ {C : Ordinal → Ordinal → Ordinal → Prop} (o₁ o₂ o₃ : Ordinal)
(H : ∀ (α r) [IsWellOrder α r] (β s) [IsWellOrder β s] (γ t) [IsWellOrder γ t],
C (type r) (type s) (type t)) : C o₁ o₂ o₃ :=
Quotient.inductionOn₃ o₁ o₂ o₃ fun ⟨α, r, wo₁⟩ ⟨β, s, wo₂⟩ ⟨γ, t, wo₃⟩ =>
@H α r wo₁ β s wo₂ γ t wo₃
open Classical in | 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 | inductionOn₃ | `Quotient.inductionOn₃` specialized to ordinals.
Not to be confused with well-founded recursion `Ordinal.induction`. |
@[elab_as_elim]
inductionOnWellOrder {C : Ordinal → Prop} (o : Ordinal)
(H : ∀ (α) [LinearOrder α] [WellFoundedLT α], C (typeLT α)) : C o :=
inductionOn o fun α r wo ↦ @H α (linearOrderOfSTO r) wo.toIsWellFounded
open Classical in | 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 | inductionOnWellOrder | To prove a result on ordinals, it suffices to prove it for order types of well-orders. |
liftOnWellOrder {δ : Sort v} (o : Ordinal) (f : ∀ (α) [LinearOrder α] [WellFoundedLT α], δ)
(c : ∀ (α) [LinearOrder α] [WellFoundedLT α] (β) [LinearOrder β] [WellFoundedLT β],
typeLT α = typeLT β → f α = f β) : δ :=
Quotient.liftOn o (fun w ↦ @f w.α (linearOrderOfSTO w.r) w.wo.toIsWellFounded)
fun w₁ w₂ h ↦ @c
w₁.α (linearOrderOfSTO w₁.r) w₁.wo.toIsWellFounded
w₂.α (linearOrderOfSTO w₂.r) w₂.wo.toIsWellFounded
(Quotient.sound h)
@[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 | liftOnWellOrder | To define a function on ordinals, it suffices to define them on order types of well-orders.
Since `LinearOrder` is data-carrying, `liftOnWellOrder_type` is not a definitional equality, unlike
`Quotient.liftOn_mk` which is always def-eq. |
liftOnWellOrder_type {δ : Sort v} (f : ∀ (α) [LinearOrder α] [WellFoundedLT α], δ)
(c : ∀ (α) [LinearOrder α] [WellFoundedLT α] (β) [LinearOrder β] [WellFoundedLT β],
typeLT α = typeLT β → f α = f β) {γ} [LinearOrder γ] [WellFoundedLT γ] :
liftOnWellOrder (typeLT γ) f c = f γ := by
change Quotient.liftOn' ⟦_⟧ _ _ = _
rw [Quotient.liftOn'_mk]
congr
exact LinearOrder.ext_lt fun _ _ ↦ Iff.rfl
/-! ### The order on ordinals -/ | 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 | liftOnWellOrder_type | null |
partialOrder : PartialOrder Ordinal where
le a b :=
Quotient.liftOn₂ a b (fun ⟨_, r, _⟩ ⟨_, s, _⟩ => Nonempty (r ≼i s))
fun _ _ _ _ ⟨f⟩ ⟨g⟩ => propext
⟨fun ⟨h⟩ => ⟨f.symm.toInitialSeg.trans <| h.trans g.toInitialSeg⟩, fun ⟨h⟩ =>
⟨f.toInitialSeg.trans <| h.trans g.symm.toInitialSeg⟩⟩
lt a b :=
Quotient.liftOn₂ a b (fun ⟨_, r, _⟩ ⟨_, s, _⟩ => Nonempty (r ≺i s))
fun _ _ _ _ ⟨f⟩ ⟨g⟩ => propext
⟨fun ⟨h⟩ => ⟨PrincipalSeg.relIsoTrans f.symm <| h.transRelIso g⟩,
fun ⟨h⟩ => ⟨PrincipalSeg.relIsoTrans f <| h.transRelIso g.symm⟩⟩
le_refl := Quot.ind fun ⟨_, _, _⟩ => ⟨InitialSeg.refl _⟩
le_trans a b c :=
Quotient.inductionOn₃ a b c fun _ _ _ ⟨f⟩ ⟨g⟩ => ⟨f.trans g⟩
lt_iff_le_not_ge a b :=
Quotient.inductionOn₂ a b fun _ _ =>
⟨fun ⟨f⟩ => ⟨⟨f⟩, fun ⟨g⟩ => (f.transInitial g).irrefl⟩, fun ⟨⟨f⟩, h⟩ =>
f.principalSumRelIso.recOn (fun g => ⟨g⟩) fun g => (h ⟨g.symm.toInitialSeg⟩).elim⟩
le_antisymm a b :=
Quotient.inductionOn₂ a b fun _ _ ⟨h₁⟩ ⟨h₂⟩ =>
Quot.sound ⟨InitialSeg.antisymm h₁ h₂⟩ | instance | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | partialOrder | For `Ordinal`:
* less-equal is defined such that well orders `r` and `s` satisfy `type r ≤ type s` if there exists
a function embedding `r` as an *initial* segment of `s`.
* less-than is defined such that well orders `r` and `s` satisfy `type r < type s` if there exists
a function embedding `r` as a *principal* segment of `s`.
Note that most of the relevant results on initial and principal segments are proved in the
`Order.InitialSeg` file. |
_root_.InitialSeg.ordinal_type_le {α β} {r : α → α → Prop} {s : β → β → Prop}
[IsWellOrder α r] [IsWellOrder β s] (h : r ≼i s) : type r ≤ type s :=
⟨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 | _root_.InitialSeg.ordinal_type_le | null |
_root_.RelEmbedding.ordinal_type_le {α β} {r : α → α → Prop} {s : β → β → Prop}
[IsWellOrder α r] [IsWellOrder β s] (h : r ↪r s) : type r ≤ type s :=
⟨h.collapse⟩ | 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 | _root_.RelEmbedding.ordinal_type_le | null |
_root_.PrincipalSeg.ordinal_type_lt {α β} {r : α → α → Prop} {s : β → β → Prop}
[IsWellOrder α r] [IsWellOrder β s] (h : r ≺i s) : type r < type s :=
⟨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 | _root_.PrincipalSeg.ordinal_type_lt | null |
protected zero_le (o : Ordinal) : 0 ≤ o :=
inductionOn o fun _ r _ => (InitialSeg.ofIsEmpty _ r).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 | zero_le | null |
@[simp]
bot_eq_zero : (⊥ : Ordinal) = 0 :=
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 | bot_eq_zero | null |
instIsEmptyIioZero : IsEmpty (Iio (0 : Ordinal)) := by
simp [← bot_eq_zero] | instance | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | instIsEmptyIioZero | null |
protected le_zero {o : Ordinal} : o ≤ 0 ↔ o = 0 :=
le_bot_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 | le_zero | null |
protected pos_iff_ne_zero {o : Ordinal} : 0 < o ↔ o ≠ 0 :=
bot_lt_iff_ne_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 | pos_iff_ne_zero | null |
protected not_lt_zero (o : Ordinal) : ¬o < 0 :=
not_lt_bot | 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 | not_lt_zero | null |
eq_zero_or_pos : ∀ a : Ordinal, a = 0 ∨ 0 < a :=
eq_bot_or_bot_lt | 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 | eq_zero_or_pos | null |
instNeZeroOne : NeZero (1 : Ordinal) :=
⟨Ordinal.one_ne_zero⟩ | instance | SetTheory | [
"Mathlib.Algebra.Order.SuccPred",
"Mathlib.Data.Sum.Order",
"Mathlib.Order.IsNormal",
"Mathlib.SetTheory.Cardinal.Basic",
"Mathlib.Tactic.PPWithUniv"
] | Mathlib/SetTheory/Ordinal/Basic.lean | instNeZeroOne | null |
type_le_iff {α β} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r]
[IsWellOrder β s] : type r ≤ type s ↔ Nonempty (r ≼i s) :=
Iff.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 | type_le_iff | null |
type_le_iff' {α β} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r]
[IsWellOrder β s] : type r ≤ type s ↔ Nonempty (r ↪r s) :=
⟨fun ⟨f⟩ => ⟨f⟩, fun ⟨f⟩ => ⟨f.collapse⟩⟩ | 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_le_iff' | null |
type_lt_iff {α β} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r]
[IsWellOrder β s] : type r < type s ↔ Nonempty (r ≺i s) :=
Iff.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 | type_lt_iff | null |
initialSegToType {α β : Ordinal} (h : α ≤ β) : α.toType ≤i β.toType := by
apply Classical.choice (type_le_iff.mp _)
rwa [type_toType, type_toType] | 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 | initialSegToType | Given two ordinals `α ≤ β`, then `initialSegToType α β` is the initial segment embedding of
`α.toType` into `β.toType`. |
principalSegToType {α β : Ordinal} (h : α < β) : α.toType <i β.toType := by
apply Classical.choice (type_lt_iff.mp _)
rwa [type_toType, type_toType]
/-! ### Enumerating elements in a well-order with ordinals -/ | 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 | principalSegToType | Given two ordinals `α < β`, then `principalSegToType α β` is the principal segment embedding
of `α.toType` into `β.toType`. |
typein (r : α → α → Prop) [IsWellOrder α r] : @PrincipalSeg α Ordinal.{u} r (· < ·) := by
refine ⟨RelEmbedding.ofMonotone _ fun a b ha ↦
((PrincipalSeg.ofElement r a).codRestrict _ ?_ ?_).ordinal_type_lt, type r, fun a ↦ ⟨?_, ?_⟩⟩
· rintro ⟨c, hc⟩
exact trans hc ha
· exact ha
· rintro ⟨b, rfl⟩
exact (PrincipalSeg.ofElement _ _).ordinal_type_lt
· refine inductionOn a ?_
rintro β s wo ⟨g⟩
exact ⟨_, g.subrelIso.ordinal_type_eq⟩
@[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 | typein | The order type of an element inside a well order.
This is registered as a principal segment embedding into the ordinals, with top `type r`. |
type_subrel (r : α → α → Prop) [IsWellOrder α r] (a : α) :
type (Subrel r (r · a)) = typein r a :=
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 | type_subrel | null |
top_typein (r : α → α → Prop) [IsWellOrder α r] : (typein r).top = type r :=
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 | top_typein | null |
typein_lt_type (r : α → α → Prop) [IsWellOrder α r] (a : α) : typein r a < type r :=
(typein r).lt_top a | 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 | typein_lt_type | null |
typein_lt_self {o : Ordinal} (i : o.toType) : typein (α := o.toType) (· < ·) i < o := by
simp_rw [← type_toType o]
apply typein_lt_type
@[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 | typein_lt_self | null |
typein_top {α β} {r : α → α → Prop} {s : β → β → Prop}
[IsWellOrder α r] [IsWellOrder β s] (f : r ≺i s) : typein s f.top = type r :=
f.subrelIso.ordinal_type_eq
@[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 | typein_top | null |
typein_lt_typein (r : α → α → Prop) [IsWellOrder α r] {a b : α} :
typein r a < typein r b ↔ r a b :=
(typein r).map_rel_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 | typein_lt_typein | null |
typein_le_typein (r : α → α → Prop) [IsWellOrder α r] {a b : α} :
typein r a ≤ typein r b ↔ ¬r b a := by
rw [← not_lt, typein_lt_typein] | 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 | typein_le_typein | null |
typein_injective (r : α → α → Prop) [IsWellOrder α r] : Injective (typein r) :=
(typein r).injective | 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 | typein_injective | null |
typein_inj (r : α → α → Prop) [IsWellOrder α r] {a b} : typein r a = typein r b ↔ a = b :=
(typein_injective r).eq_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 | typein_inj | null |
mem_range_typein_iff (r : α → α → Prop) [IsWellOrder α r] {o} :
o ∈ Set.range (typein r) ↔ o < type r :=
(typein r).mem_range_iff_rel | 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_typein_iff | null |
typein_surj (r : α → α → Prop) [IsWellOrder α r] {o} (h : o < type r) :
o ∈ Set.range (typein r) :=
(typein r).mem_range_of_rel_top 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 | typein_surj | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.