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 ⌀ |
|---|---|---|---|---|---|---|
typein_surjOn (r : α → α → Prop) [IsWellOrder α r] :
Set.SurjOn (typein r) Set.univ (Set.Iio (type r)) :=
(typein r).surjOn | 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_surjOn | null |
@[simps! symm_apply_coe]
enum (r : α → α → Prop) [IsWellOrder α r] : (· < · : Iio (type r) → Iio (type r) → Prop) ≃r r :=
(typein r).subrelIso
@[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 | enum | A well order `r` is order-isomorphic to the set of ordinals smaller than `type r`.
`enum r ⟨o, h⟩` is the `o`-th element of `α` ordered by `r`.
That is, `enum` maps an initial segment of the ordinals, those less than the order type of `r`, to
the elements of `α`. |
typein_enum (r : α → α → Prop) [IsWellOrder α r] {o} (h : o < type r) :
typein r (enum r ⟨o, h⟩) = o :=
(typein r).apply_subrelIso _ | 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_enum | null |
enum_type {α β} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s]
(f : s ≺i r) {h : type s < type r} : enum r ⟨type s, h⟩ = f.top :=
(typein r).injective <| (typein_enum _ _).trans (typein_top _).symm
@[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 | enum_type | null |
enum_typein (r : α → α → Prop) [IsWellOrder α r] (a : α) :
enum r ⟨typein r a, typein_lt_type r a⟩ = a :=
enum_type (PrincipalSeg.ofElement r 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 | enum_typein | null |
enum_lt_enum {r : α → α → Prop} [IsWellOrder α r] {o₁ o₂ : Iio (type r)} :
r (enum r o₁) (enum r o₂) ↔ o₁ < o₂ :=
(enum _).map_rel_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 | enum_lt_enum | null |
enum_le_enum (r : α → α → Prop) [IsWellOrder α r] {o₁ o₂ : Iio (type r)} :
¬r (enum r o₁) (enum r o₂) ↔ o₂ ≤ o₁ := by
rw [enum_lt_enum (r := r), not_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 | enum_le_enum | null |
enum_le_enum' (a : Ordinal) {o₁ o₂ : Iio (type (· < ·))} :
enum (· < ·) o₁ ≤ enum (α := a.toType) (· < ·) o₂ ↔ o₁ ≤ o₂ := by
rw [← enum_le_enum, not_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 | enum_le_enum' | null |
enum_inj {r : α → α → Prop} [IsWellOrder α r] {o₁ o₂ : Iio (type r)} :
enum r o₁ = enum r o₂ ↔ o₁ = o₂ :=
EmbeddingLike.apply_eq_iff_eq _ | 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 | enum_inj | null |
enum_zero_le {r : α → α → Prop} [IsWellOrder α r] (h0 : 0 < type r) (a : α) :
¬r a (enum r ⟨0, h0⟩) := by
rw [← enum_typein r a, enum_le_enum r]
apply Ordinal.zero_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 | enum_zero_le | null |
enum_zero_le' {o : Ordinal} (h0 : 0 < o) (a : o.toType) :
enum (α := o.toType) (· < ·) ⟨0, type_toType _ ▸ h0⟩ ≤ a := by
rw [← not_lt]
apply enum_zero_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 | enum_zero_le' | null |
relIso_enum' {α β : Type u} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r]
[IsWellOrder β s] (f : r ≃r s) (o : Ordinal) :
∀ (hr : o < type r) (hs : o < type s), f (enum r ⟨o, hr⟩) = enum s ⟨o, hs⟩ := by
refine inductionOn o ?_; rintro γ t wo ⟨g⟩ ⟨h⟩
rw [enum_type g, enum_type (g.transRelIso f)]; 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 | relIso_enum' | null |
relIso_enum {α β : Type u} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r]
[IsWellOrder β s] (f : r ≃r s) (o : Ordinal) (hr : o < type r) :
f (enum r ⟨o, hr⟩) = enum s ⟨o, hr.trans_eq (Quotient.sound ⟨f⟩)⟩ :=
relIso_enum' _ _ _ _ | 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 | relIso_enum | null |
@[simps! -isSimp]
noncomputable enumIsoToType (o : Ordinal) : Set.Iio o ≃o o.toType where
toFun x := enum (α := o.toType) (· < ·) ⟨x.1, type_toType _ ▸ x.2⟩
invFun x := ⟨typein (α := o.toType) (· < ·) x, typein_lt_self x⟩
left_inv _ := Subtype.ext (typein_enum _ _)
right_inv _ := enum_typein _ _
map_rel_iff' := enum_le_enum' _ | 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 | enumIsoToType | The order isomorphism between ordinals less than `o` and `o.toType`. |
small_Iio (o : Ordinal.{u}) : Small.{u} (Iio o) :=
⟨_, ⟨(enumIsoToType _).toEquiv⟩⟩ | 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 | small_Iio | null |
small_Iic (o : Ordinal.{u}) : Small.{u} (Iic o) := by
rw [← Iio_union_right]
infer_instance | 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 | small_Iic | null |
small_Ico (a b : Ordinal.{u}) : Small.{u} (Ico a b) := small_subset Ico_subset_Iio_self | 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 | small_Ico | null |
small_Icc (a b : Ordinal.{u}) : Small.{u} (Icc a b) := small_subset Icc_subset_Iic_self | 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 | small_Icc | null |
small_Ioo (a b : Ordinal.{u}) : Small.{u} (Ioo a b) := small_subset Ioo_subset_Iio_self | 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 | small_Ioo | null |
small_Ioc (a b : Ordinal.{u}) : Small.{u} (Ioc a b) := small_subset Ioc_subset_Iic_self | 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 | small_Ioc | null |
toTypeOrderBot {o : Ordinal} (ho : o ≠ 0) : OrderBot o.toType where
bot := (enum (· < ·)) ⟨0, _⟩
bot_le := enum_zero_le' (by rwa [Ordinal.pos_iff_ne_zero]) | 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 | `o.toType` is an `OrderBot` whenever `o ≠ 0`. |
enum_zero_eq_bot {o : Ordinal} (ho : 0 < o) :
enum (α := o.toType) (· < ·) ⟨0, by rwa [type_toType]⟩ =
have H := toTypeOrderBot (o := o) (by rintro rfl; simp at ho)
(⊥ : o.toType) :=
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 | enum_zero_eq_bot | null |
lt_wf : @WellFounded Ordinal (· < ·) :=
wellFounded_iff_wellFounded_subrel.mpr (·.induction_on fun ⟨_, _, wo⟩ ↦
RelHomClass.wellFounded (enum _) wo.wf) | 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_wf | null |
wellFoundedRelation : WellFoundedRelation Ordinal :=
⟨(· < ·), lt_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 | wellFoundedRelation | null |
wellFoundedLT : WellFoundedLT Ordinal :=
⟨lt_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 | wellFoundedLT | null |
induction {p : Ordinal.{u} → Prop} (i : Ordinal.{u}) (h : ∀ j, (∀ k, k < j → p k) → p j) :
p i :=
lt_wf.induction i 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 | induction | Reformulation of well-founded induction on ordinals as a lemma that works with the
`induction` tactic, as in `induction i using Ordinal.induction with | h i IH => ?_`. |
typein_apply {α β} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s]
(f : r ≼i s) (a : α) : typein s (f a) = typein r a := by
rw [← f.transPrincipal_apply _ a, (f.transPrincipal _).eq]
/-! ### Cardinality of 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 | typein_apply | null |
card : Ordinal → Cardinal :=
Quotient.map WellOrder.α fun _ _ ⟨e⟩ => ⟨e.toEquiv⟩
@[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 | card | The cardinal of an ordinal is the cardinality of any type on which a relation with that order
type is defined. |
card_type (r : α → α → Prop) [IsWellOrder α r] : card (type r) = #α :=
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_type | null |
card_typein {r : α → α → Prop} [IsWellOrder α r] (x : α) :
#{ y // r y x } = (typein r x).card :=
rfl
@[gcongr] | 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 | null |
card_le_card {o₁ o₂ : Ordinal} : o₁ ≤ o₂ → card o₁ ≤ card o₂ :=
inductionOn o₁ fun _ _ _ => inductionOn o₂ fun _ _ _ ⟨⟨⟨f, _⟩, _⟩⟩ => ⟨f⟩
@[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_card | null |
card_zero : card 0 = 0 := mk_eq_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 | card_zero | null |
card_one : card 1 = 1 := mk_eq_one _
/-! ### Lifting ordinals to a higher universe -/ | 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_one | null |
@[pp_with_univ]
lift (o : Ordinal.{v}) : Ordinal.{max v u} :=
Quotient.liftOn o (fun w => type <| ULift.down ⁻¹'o w.r) fun ⟨_, r, _⟩ ⟨_, s, _⟩ ⟨f⟩ =>
Quot.sound
⟨(RelIso.preimage Equiv.ulift r).trans <| f.trans (RelIso.preimage Equiv.ulift s).symm⟩
@[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 | lift | The universe lift operation for ordinals, which embeds `Ordinal.{u}` as
a proper initial segment of `Ordinal.{v}` for `v > u`. For the initial segment version,
see `liftInitialSeg`. |
type_uLift (r : α → α → Prop) [IsWellOrder α r] :
type (ULift.down ⁻¹'o r) = lift.{v} (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 | type_uLift | null |
_root_.RelIso.ordinal_lift_type_eq {r : α → α → Prop} {s : β → β → Prop}
[IsWellOrder α r] [IsWellOrder β s] (f : r ≃r s) : lift.{v} (type r) = lift.{u} (type s) :=
((RelIso.preimage Equiv.ulift r).trans <|
f.trans (RelIso.preimage Equiv.ulift s).symm).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 | _root_.RelIso.ordinal_lift_type_eq | null |
type_preimage {α β : Type u} (r : α → α → Prop) [IsWellOrder α r] (f : β ≃ α) :
type (f ⁻¹'o r) = type r :=
(RelIso.preimage f r).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 | type_preimage | null |
type_lift_preimage (r : α → α → Prop) [IsWellOrder α r]
(f : β ≃ α) : lift.{u} (type (f ⁻¹'o r)) = lift.{v} (type r) :=
(RelIso.preimage f r).ordinal_lift_type_eq | 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_lift_preimage | null |
lift_umax : lift.{max u v, u} = lift.{v, u} :=
funext fun a =>
inductionOn a fun _ r _ =>
Quotient.sound ⟨(RelIso.preimage Equiv.ulift r).trans (RelIso.preimage Equiv.ulift r).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 | lift_umax | `lift.{max u v, u}` equals `lift.{v, u}`.
Unfortunately, the simp lemma doesn't seem to work. |
lift_id' (a : Ordinal) : lift a = a :=
inductionOn a fun _ r _ => Quotient.sound ⟨RelIso.preimage Equiv.ulift 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 | lift_id' | An ordinal lifted to a lower or equal universe equals itself.
Unfortunately, the simp lemma doesn't work. |
@[simp]
lift_id : ∀ a, lift.{u, u} a = a :=
lift_id'.{u, u} | 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_id | An ordinal lifted to the same universe equals itself. |
@[simp]
lift_uzero (a : Ordinal.{u}) : lift.{0} a = a :=
lift_id' 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 | lift_uzero | An ordinal lifted to the zero universe equals itself. |
lift_type_le {α : Type u} {β : Type v} {r s} [IsWellOrder α r] [IsWellOrder β s] :
lift.{max v w} (type r) ≤ lift.{max u w} (type s) ↔ Nonempty (r ≼i s) := by
constructor <;> refine fun ⟨f⟩ ↦ ⟨?_⟩
· exact (RelIso.preimage Equiv.ulift r).symm.toInitialSeg.trans
(f.trans (RelIso.preimage Equiv.ulift s).toInitialSeg)
· exact (RelIso.preimage Equiv.ulift r).toInitialSeg.trans
(f.trans (RelIso.preimage Equiv.ulift s).symm.toInitialSeg) | 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_type_le | null |
lift_type_eq {α : Type u} {β : Type v} {r s} [IsWellOrder α r] [IsWellOrder β s] :
lift.{max v w} (type r) = lift.{max u w} (type s) ↔ Nonempty (r ≃r s) := by
refine Quotient.eq'.trans ⟨?_, ?_⟩ <;> refine fun ⟨f⟩ ↦ ⟨?_⟩
· exact (RelIso.preimage Equiv.ulift r).symm.trans <| f.trans (RelIso.preimage Equiv.ulift s)
· exact (RelIso.preimage Equiv.ulift r).trans <| f.trans (RelIso.preimage Equiv.ulift s).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 | lift_type_eq | null |
lift_type_lt {α : Type u} {β : Type v} {r s} [IsWellOrder α r] [IsWellOrder β s] :
lift.{max v w} (type r) < lift.{max u w} (type s) ↔ Nonempty (r ≺i s) := by
constructor <;> refine fun ⟨f⟩ ↦ ⟨?_⟩
· exact (f.relIsoTrans (RelIso.preimage Equiv.ulift r).symm).transInitial
(RelIso.preimage Equiv.ulift s).toInitialSeg
· exact (f.relIsoTrans (RelIso.preimage Equiv.ulift r)).transInitial
(RelIso.preimage Equiv.ulift s).symm.toInitialSeg
@[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 | lift_type_lt | null |
lift_le {a b : Ordinal} : lift.{u, v} a ≤ lift.{u, v} b ↔ a ≤ b :=
inductionOn₂ a b fun α r _ β s _ => by
rw [← lift_umax]
exact lift_type_le.{_,_,u}
@[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 | lift_le | null |
lift_inj {a b : Ordinal} : lift.{u, v} a = lift.{u, v} b ↔ a = b := by
simp_rw [le_antisymm_iff, lift_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 | lift_inj | null |
lift_lt {a b : Ordinal} : lift.{u, v} a < lift.{u, v} b ↔ a < b := by
simp_rw [lt_iff_le_not_ge, lift_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 | lift_lt | null |
lift_typein_top {r : α → α → Prop} {s : β → β → Prop}
[IsWellOrder α r] [IsWellOrder β s] (f : r ≺i s) : lift.{u} (typein s f.top) = lift (type r) :=
f.subrelIso.ordinal_lift_type_eq | 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_typein_top | null |
liftInitialSeg : Ordinal.{v} ≤i Ordinal.{max u v} := by
refine ⟨RelEmbedding.ofMonotone lift.{u} (by simp),
fun a b ↦ Ordinal.inductionOn₂ a b fun α r _ β s _ h ↦ ?_⟩
rw [RelEmbedding.ofMonotone_coe, ← lift_id'.{max u v} (type s),
← lift_umax.{v, u}, lift_type_lt] at h
obtain ⟨f⟩ := h
use typein r f.top
rw [RelEmbedding.ofMonotone_coe, ← lift_umax, lift_typein_top, lift_id']
@[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 | liftInitialSeg | Initial segment version of the lift operation on ordinals, embedding `Ordinal.{u}` in
`Ordinal.{v}` as an initial segment when `u ≤ v`. |
liftInitialSeg_coe : (liftInitialSeg.{v, u} : Ordinal → Ordinal) = lift.{v, u} :=
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 | liftInitialSeg_coe | null |
lift_lift (a : Ordinal.{u}) : lift.{w} (lift.{v} a) = lift.{max v w} a :=
(liftInitialSeg.trans liftInitialSeg).eq liftInitialSeg a
@[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 | lift_lift | null |
lift_zero : lift 0 = 0 :=
type_eq_zero_of_empty _
@[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 | lift_zero | null |
lift_one : lift 1 = 1 :=
type_eq_one_of_unique _
@[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 | lift_one | null |
lift_card (a) : Cardinal.lift.{u, v} (card a) = card (lift.{u} a) :=
inductionOn a fun _ _ _ => 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 | lift_card | null |
mem_range_lift_of_le {a : Ordinal.{u}} {b : Ordinal.{max u v}} (h : b ≤ lift.{v} a) :
b ∈ Set.range lift.{v} :=
liftInitialSeg.mem_range_of_le 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 | mem_range_lift_of_le | null |
le_lift_iff {a : Ordinal.{u}} {b : Ordinal.{max u v}} :
b ≤ lift.{v} a ↔ ∃ a' ≤ a, lift.{v} a' = b :=
liftInitialSeg.le_apply_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_lift_iff | null |
lt_lift_iff {a : Ordinal.{u}} {b : Ordinal.{max u v}} :
b < lift.{v} a ↔ ∃ a' < a, lift.{v} a' = b :=
liftInitialSeg.lt_apply_iff
/-! ### The first infinite ordinal ω -/ | 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_lift_iff | null |
omega0 : Ordinal.{u} :=
lift (typeLT ℕ)
@[inherit_doc]
scoped notation "ω" => Ordinal.omega0 | 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 | omega0 | `ω` is the first infinite ordinal, defined as the order type of `ℕ`. |
@[simp]
type_nat_lt : typeLT ℕ = ω :=
(lift_id _).symm
@[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_nat_lt | Note that the presence of this lemma makes `simp [omega0]` form a loop. |
card_omega0 : 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 | card_omega0 | null |
lift_omega0 : lift ω = ω :=
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_omega0 | null |
add : Add Ordinal.{u} :=
⟨fun o₁ o₂ => Quotient.liftOn₂ o₁ o₂ (fun ⟨_, r, _⟩ ⟨_, s, _⟩ => type (Sum.Lex r s))
fun _ _ _ _ ⟨f⟩ ⟨g⟩ => (RelIso.sumLexCongr f g).ordinal_type_eq⟩ | 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 | add | `o₁ + o₂` is the order on the disjoint union of `o₁` and `o₂` obtained by declaring that
every element of `o₁` is smaller than every element of `o₂`. |
addMonoidWithOne : AddMonoidWithOne Ordinal.{u} where
add := (· + ·)
zero := 0
one := 1
zero_add o := inductionOn o fun α _ _ => (RelIso.emptySumLex _ _).ordinal_type_eq
add_zero o := inductionOn o fun α _ _ => (RelIso.sumLexEmpty _ _).ordinal_type_eq
add_assoc o₁ o₂ o₃ :=
Quotient.inductionOn₃ o₁ o₂ o₃ fun ⟨α, r, _⟩ ⟨β, s, _⟩ ⟨γ, t, _⟩ =>
Quot.sound
⟨⟨sumAssoc _ _ _, by
intro a b
rcases a with (⟨a | a⟩ | a) <;> rcases b with (⟨b | b⟩ | b) <;>
simp only [sumAssoc_apply_inl_inl, sumAssoc_apply_inl_inr, sumAssoc_apply_inr,
Sum.lex_inl_inl, Sum.lex_inr_inr, Sum.Lex.sep, Sum.lex_inr_inl]⟩⟩
nsmul := nsmulRec
@[simp] | 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 | addMonoidWithOne | null |
card_add (o₁ o₂ : Ordinal) : card (o₁ + o₂) = card o₁ + card o₂ :=
inductionOn o₁ fun _ __ => inductionOn o₂ fun _ _ _ => 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_add | null |
type_sum_lex {α β : Type u} (r : α → α → Prop) (s : β → β → Prop) [IsWellOrder α r]
[IsWellOrder β s] : type (Sum.Lex r s) = type r + type s :=
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_sum_lex | null |
card_nat (n : ℕ) : card.{u} n = n := by
induction n <;> [simp; simp only [card_add, card_one, Nat.cast_succ, *]]
@[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_nat | null |
card_ofNat (n : ℕ) [n.AtLeastTwo] :
card.{u} ofNat(n) = OfNat.ofNat n :=
card_nat n | 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_ofNat | null |
instAddLeftMono : AddLeftMono Ordinal.{u} where
elim c a b := by
refine inductionOn₃ a b c fun α r _ β s _ γ t _ ⟨f⟩ ↦
(RelEmbedding.ofMonotone (Sum.recOn · Sum.inl (Sum.inr ∘ f)) ?_).ordinal_type_le
simp [f.map_rel_iff] | 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 | instAddLeftMono | null |
instAddRightMono : AddRightMono Ordinal.{u} where
elim c a b := by
refine inductionOn₃ a b c fun α r _ β s _ γ t _ ⟨f⟩ ↦
(RelEmbedding.ofMonotone (Sum.recOn · (Sum.inl ∘ f) Sum.inr) ?_).ordinal_type_le
simp [f.map_rel_iff] | 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 | instAddRightMono | null |
le_add_right (a b : Ordinal) : a ≤ a + b := by
simpa only [add_zero] using add_le_add_left (Ordinal.zero_le b) 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 | le_add_right | null |
le_add_left (a b : Ordinal) : a ≤ b + a := by
simpa only [zero_add] using add_le_add_right (Ordinal.zero_le b) 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 | le_add_left | null |
max_zero_left : ∀ a : Ordinal, max 0 a = a :=
max_bot_left | 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 | max_zero_left | null |
max_zero_right : ∀ a : Ordinal, max a 0 = a :=
max_bot_right
@[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 | max_zero_right | null |
max_eq_zero {a b : Ordinal} : max a b = 0 ↔ a = 0 ∧ b = 0 :=
max_eq_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 | max_eq_zero | null |
sInf_empty : sInf (∅ : Set Ordinal) = 0 :=
dif_neg Set.not_nonempty_empty
/-! ### Successor order properties -/ | 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 | sInf_empty | null |
private succ_le_iff' {a b : Ordinal} : a + 1 ≤ b ↔ a < b := by
refine inductionOn₂ a b fun α r _ β s _ ↦ ⟨?_, ?_⟩ <;> rintro ⟨f⟩
· refine ⟨((InitialSeg.leAdd _ _).trans f).toPrincipalSeg fun h ↦ ?_⟩
simpa using h (f (Sum.inr PUnit.unit))
· apply (RelEmbedding.ofMonotone (Sum.recOn · f fun _ ↦ f.top) ?_).ordinal_type_le
simpa [f.map_rel_iff] using f.lt_top | 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 | succ_le_iff' | null |
@[simp]
add_one_eq_succ (o : Ordinal) : o + 1 = succ o :=
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 | add_one_eq_succ | null |
succ_zero : succ (0 : Ordinal) = 1 :=
zero_add 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 | succ_zero | null |
succ_one : succ (1 : Ordinal) = 2 := by congr; simp only [Nat.unaryCast, zero_add] | 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 | succ_one | null |
add_succ (o₁ o₂ : Ordinal) : o₁ + succ o₂ = succ (o₁ + o₂) :=
(add_assoc _ _ _).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 | add_succ | null |
one_le_iff_ne_zero {o : Ordinal} : 1 ≤ o ↔ o ≠ 0 := by
rw [Order.one_le_iff_pos, Ordinal.pos_iff_ne_zero] | 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_iff_ne_zero | null |
succ_pos (o : Ordinal) : 0 < succ o :=
bot_lt_succ o | 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 | succ_pos | null |
succ_ne_zero (o : Ordinal) : succ o ≠ 0 :=
ne_of_gt <| succ_pos o
@[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 | succ_ne_zero | null |
lt_one_iff_zero {a : Ordinal} : a < 1 ↔ a = 0 := by
simpa using @lt_succ_bot_iff _ _ _ 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 | lt_one_iff_zero | null |
le_one_iff {a : Ordinal} : a ≤ 1 ↔ a = 0 ∨ a = 1 := by
simpa using @le_succ_bot_iff _ _ _ a _
@[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 | le_one_iff | null |
card_succ (o : Ordinal) : card (succ o) = card o + 1 := by
simp only [← add_one_eq_succ, card_add, card_one] | 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_succ | null |
natCast_succ (n : ℕ) : ↑n.succ = succ (n : Ordinal) :=
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 | natCast_succ | null |
uniqueIioOne : Unique (Iio (1 : Ordinal)) where
default := ⟨0, zero_lt_one' Ordinal⟩
uniq a := Subtype.ext <| lt_one_iff_zero.1 a.2
@[simp] | 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 | uniqueIioOne | null |
Iio_one_default_eq : (default : Iio (1 : Ordinal)) = ⟨0, zero_lt_one' Ordinal⟩ :=
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 | Iio_one_default_eq | null |
uniqueToTypeOne : Unique (toType 1) where
default := enum (α := toType 1) (· < ·) ⟨0, by simp⟩
uniq a := by
rw [← enum_typein (α := toType 1) (· < ·) a]
congr
rw [← lt_one_iff_zero]
apply typein_lt_self | 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 | uniqueToTypeOne | null |
one_toType_eq (x : toType 1) : x = enum (· < ·) ⟨0, by simp⟩ :=
Unique.eq_default x
/-! ### Extra properties of typein and enum -/
@[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_toType_eq | null |
typein_one_toType (x : toType 1) : typein (α := toType 1) (· < ·) x = 0 := by
rw [one_toType_eq x, typein_enum] | 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_one_toType | null |
typein_le_typein' (o : Ordinal) {x y : o.toType} :
typein (α := o.toType) (· < ·) x ≤ typein (α := o.toType) (· < ·) y ↔ x ≤ y := 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 | typein_le_typein' | null |
le_enum_succ {o : Ordinal} (a : (succ o).toType) :
a ≤ enum (α := (succ o).toType) (· < ·) ⟨o, (type_toType _ ▸ lt_succ o)⟩ := by
rw [← enum_typein (α := (succ o).toType) (· < ·) a, enum_le_enum', Subtype.mk_le_mk,
← lt_succ_iff]
apply typein_lt_self
/-! ### Universal ordinal -/ | 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_enum_succ | null |
@[pp_with_univ, nolint checkUnivs]
univ : Ordinal.{max (u + 1) v} :=
lift.{v, u + 1} (typeLT 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 | `univ.{u v}` is the order type of the ordinals of `Type u` as a member
of `Ordinal.{v}` (when `u < v`). It is an inaccessible cardinal. |
univ_id : univ.{u, u + 1} = typeLT 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 |
liftPrincipalSeg : Ordinal.{u} <i Ordinal.{max (u + 1) v} :=
⟨↑liftInitialSeg.{max (u + 1) v, u}, univ.{u, v}, by
refine fun b => inductionOn b ?_; intro β s _
rw [univ, ← lift_umax]; constructor <;> intro h
· obtain ⟨a, e⟩ := h
rw [← e]
refine inductionOn a ?_
intro α r _
exact lift_type_lt.{u, u + 1, max (u + 1) v}.2 ⟨typein r⟩
· rw [← lift_id (type s)] at h ⊢
obtain ⟨f⟩ := lift_type_lt.{_,_,v}.1 h
obtain ⟨f, a, hf⟩ := f
exists a
induction a using inductionOn with
| H a r =>
refine lift_type_eq.{u, max (u + 1) v, max (u + 1) v}.2
⟨(RelIso.ofSurjective (RelEmbedding.ofMonotone ?_ ?_) ?_).symm⟩
· exact fun b => enum r ⟨f b, (hf _).1 ⟨_, rfl⟩⟩
· refine fun a b h => (typein_lt_typein r).1 ?_
rw [typein_enum, typein_enum]
exact f.map_rel_iff.2 h
· intro a'
obtain ⟨b, e⟩ := (hf _).2 (typein_lt_type _ a')
exists b
simp only [RelEmbedding.ofMonotone_coe]
simp [e]⟩
@[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 | liftPrincipalSeg | Principal segment version of the lift operation on ordinals, embedding `Ordinal.{u}` in
`Ordinal.{v}` as a principal segment when `u < v`. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.