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 ⌀ |
|---|---|---|---|---|---|---|
iSup_typein_limit {o : Ordinal.{u}} (ho : ∀ a, a < o → succ a < o) :
iSup (typein ((· < ·) : o.toType → o.toType → Prop)) = o := by
rw [(iSup_eq_lsub_iff.{u, u} (typein (· < ·))).2] <;> rw [lsub_typein o]
assumption
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | iSup_typein_limit | null |
iSup_typein_succ {o : Ordinal} :
iSup (typein ((· < ·) : (succ o).toType → (succ o).toType → Prop)) = o := by
rcases iSup_eq_lsub_or_succ_iSup_eq_lsub
(typein ((· < ·) : (succ o).toType → (succ o).toType → Prop)) with h | h
· rw [iSup_eq_lsub_iff] at h
simp only [lsub_typein] at h
exact (h o (lt_succ o)).false.elim
rw [← succ_eq_succ_iff, h]
apply lsub_typein
@[deprecated (since := "2025-10-01")] alias sup_eq_lsub := iSup_eq_lsub
@[deprecated (since := "2025-10-01")] alias sup_le_lsub := iSup_le_lsub
@[deprecated (since := "2025-10-01")] alias lsub_le_sup_succ := lsub_le_succ_iSup
@[deprecated (since := "2025-10-01")] alias sup_eq_lsub_or_sup_succ_eq_lsub :=
iSup_eq_lsub_or_succ_iSup_eq_lsub
@[deprecated (since := "2025-10-01")] alias sup_succ_le_lsub := succ_iSup_le_lsub_iff
@[deprecated (since := "2025-10-01")] alias sup_succ_eq_lsub := succ_iSup_eq_lsub_iff
@[deprecated (since := "2025-10-01")] alias sup_eq_lsub_iff_succ := iSup_eq_lsub_iff
@[deprecated (since := "2025-10-01")] alias sup_eq_lsub_iff_lt_sup := iSup_eq_lsub_iff_lt_iSup
@[deprecated (since := "2025-10-01")] alias sup_typein_limit := iSup_typein_limit
@[deprecated (since := "2025-10-01")] alias sup_typein_succ := iSup_typein_succ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | iSup_typein_succ | null |
blsub (o : Ordinal.{u}) (f : ∀ a < o, Ordinal.{max u v}) : Ordinal.{max u v} :=
bsup.{_, v} o fun a ha => succ (f a ha)
@[simp] | def | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | blsub | The least strict upper bound of a family of ordinals indexed by the set of ordinals less than
some `o : Ordinal.{u}`.
This is to `lsub` as `bsup` is to `sup`. |
bsup_eq_blsub (o : Ordinal.{u}) (f : ∀ a < o, Ordinal.{max u v}) :
(bsup.{_, v} o fun a ha => succ (f a ha)) = blsub.{_, v} o f :=
rfl | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_eq_blsub | null |
lsub_eq_blsub' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] {o} (ho : type r = o)
(f : ∀ a < o, Ordinal) : lsub (familyOfBFamily' r ho f) = blsub o f :=
iSup'_eq_bsup r ho fun a ha => succ (f a ha) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lsub_eq_blsub' | null |
lsub_eq_lsub {ι ι' : Type u} (r : ι → ι → Prop) (r' : ι' → ι' → Prop) [IsWellOrder ι r]
[IsWellOrder ι' r'] {o} (ho : type r = o) (ho' : type r' = o)
(f : ∀ a < o, Ordinal.{max u v}) :
lsub.{_, v} (familyOfBFamily' r ho f) = lsub.{_, v} (familyOfBFamily' r' ho' f) := by
rw [lsub_eq_blsub', lsub_eq_blsub']
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lsub_eq_lsub | null |
lsub_eq_blsub {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
lsub.{_, v} (familyOfBFamily o f) = blsub.{_, v} o f :=
lsub_eq_blsub' _ _ _
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lsub_eq_blsub | null |
blsub_eq_lsub' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r]
(f : ι → Ordinal.{max u v}) : blsub.{_, v} _ (bfamilyOfFamily' r f) = lsub.{_, v} f :=
bsup'_eq_iSup r (succ ∘ f) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | blsub_eq_lsub' | null |
blsub_eq_blsub {ι : Type u} (r r' : ι → ι → Prop) [IsWellOrder ι r] [IsWellOrder ι r']
(f : ι → Ordinal.{max u v}) :
blsub.{_, v} _ (bfamilyOfFamily' r f) = blsub.{_, v} _ (bfamilyOfFamily' r' f) := by
rw [blsub_eq_lsub', blsub_eq_lsub']
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | blsub_eq_blsub | null |
blsub_eq_lsub {ι : Type u} (f : ι → Ordinal.{max u v}) :
blsub.{_, v} _ (bfamilyOfFamily f) = lsub.{_, v} f :=
blsub_eq_lsub' _ _
@[congr] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | blsub_eq_lsub | null |
blsub_congr {o₁ o₂ : Ordinal.{u}} (f : ∀ a < o₁, Ordinal.{max u v}) (ho : o₁ = o₂) :
blsub.{_, v} o₁ f = blsub.{_, v} o₂ fun a h => f a (h.trans_eq ho.symm) := by
subst ho
rfl | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | blsub_congr | null |
blsub_le_iff {o : Ordinal.{u}} {f : ∀ a < o, Ordinal.{max u v}} {a} :
blsub.{_, v} o f ≤ a ↔ ∀ i h, f i h < a := by
convert bsup_le_iff.{_, v} (f := fun a ha => succ (f a ha)) (a := a) using 2
simp_rw [succ_le_iff] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | blsub_le_iff | null |
blsub_le {o : Ordinal} {f : ∀ b < o, Ordinal} {a} : (∀ i h, f i h < a) → blsub o f ≤ a :=
blsub_le_iff.2 | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | blsub_le | null |
lt_blsub {o} (f : ∀ a < o, Ordinal) (i h) : f i h < blsub o f :=
blsub_le_iff.1 le_rfl _ _ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lt_blsub | null |
lt_blsub_iff {o : Ordinal.{u}} {f : ∀ b < o, Ordinal.{max u v}} {a} :
a < blsub.{_, v} o f ↔ ∃ i hi, a ≤ f i hi := by
simpa only [not_forall, not_lt, not_le] using not_congr (@blsub_le_iff.{_, v} _ f a) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lt_blsub_iff | null |
bsup_le_blsub {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
bsup.{_, v} o f ≤ blsub.{_, v} o f :=
bsup_le fun i h => (lt_blsub f i h).le | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_le_blsub | null |
blsub_le_bsup_succ {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
blsub.{_, v} o f ≤ succ (bsup.{_, v} o f) :=
blsub_le fun i h => lt_succ_iff.2 (le_bsup f i h) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | blsub_le_bsup_succ | null |
bsup_eq_blsub_or_succ_bsup_eq_blsub {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
bsup.{_, v} o f = blsub.{_, v} o f ∨ succ (bsup.{_, v} o f) = blsub.{_, v} o f := by
rw [← iSup_eq_bsup, ← lsub_eq_blsub]
exact iSup_eq_lsub_or_succ_iSup_eq_lsub _ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_eq_blsub_or_succ_bsup_eq_blsub | null |
bsup_succ_le_blsub {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
succ (bsup.{_, v} o f) ≤ blsub.{_, v} o f ↔ ∃ i hi, f i hi = bsup.{_, v} o f := by
refine ⟨fun h => ?_, ?_⟩
· by_contra! hf
exact
ne_of_lt (succ_le_iff.1 h)
(le_antisymm (bsup_le_blsub f) (blsub_le (lt_bsup_of_ne_bsup.1 hf)))
rintro ⟨_, _, hf⟩
rw [succ_le_iff, ← hf]
exact lt_blsub _ _ _ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_succ_le_blsub | null |
bsup_succ_eq_blsub {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
succ (bsup.{_, v} o f) = blsub.{_, v} o f ↔ ∃ i hi, f i hi = bsup.{_, v} o f :=
(blsub_le_bsup_succ f).ge_iff_eq'.symm.trans (bsup_succ_le_blsub f) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_succ_eq_blsub | null |
bsup_eq_blsub_iff_succ {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
bsup.{_, v} o f = blsub.{_, v} o f ↔ ∀ a < blsub.{_, v} o f, succ a < blsub.{_, v} o f := by
rw [← iSup_eq_bsup, ← lsub_eq_blsub]
apply iSup_eq_lsub_iff | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_eq_blsub_iff_succ | null |
bsup_eq_blsub_iff_lt_bsup {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
bsup.{_, v} o f = blsub.{_, v} o f ↔ ∀ i hi, f i hi < bsup.{_, v} o f :=
⟨fun h i => by
rw [h]
apply lt_blsub, fun h => le_antisymm (bsup_le_blsub f) (blsub_le h)⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_eq_blsub_iff_lt_bsup | null |
bsup_eq_blsub_of_lt_succ_limit {o : Ordinal.{u}} (ho : IsSuccLimit o)
{f : ∀ a < o, Ordinal.{max u v}} (hf : ∀ a ha, f a ha < f (succ a) (ho.succ_lt ha)) :
bsup.{_, v} o f = blsub.{_, v} o f := by
rw [bsup_eq_blsub_iff_lt_bsup]
exact fun i hi => (hf i hi).trans_le (le_bsup f _ _) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_eq_blsub_of_lt_succ_limit | null |
blsub_succ_of_mono {o : Ordinal.{u}} {f : ∀ a < succ o, Ordinal.{max u v}}
(hf : ∀ {i j} (hi hj), i ≤ j → f i hi ≤ f j hj) : blsub.{_, v} _ f = succ (f o (lt_succ o)) :=
bsup_succ_of_mono fun {_ _} hi hj h => succ_le_succ (hf hi hj h)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | blsub_succ_of_mono | null |
blsub_eq_zero_iff {o} {f : ∀ a < o, Ordinal} : blsub o f = 0 ↔ o = 0 := by
rw [← lsub_eq_blsub, lsub_eq_zero_iff]
exact toType_empty_iff_eq_zero
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | blsub_eq_zero_iff | null |
blsub_zero (f : ∀ a < (0 : Ordinal), Ordinal) : blsub 0 f = 0 := by rw [blsub_eq_zero_iff] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | blsub_zero | null |
blsub_pos {o : Ordinal} (ho : 0 < o) (f : ∀ a < o, Ordinal) : 0 < blsub o f :=
(Ordinal.zero_le _).trans_lt (lt_blsub f 0 ho) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | blsub_pos | null |
blsub_type {α : Type u} (r : α → α → Prop) [IsWellOrder α r]
(f : ∀ a < type r, Ordinal.{max u v}) :
blsub.{_, v} (type r) f = lsub.{_, v} fun a => f (typein r a) (typein_lt_type _ _) :=
eq_of_forall_ge_iff fun o => by
rw [blsub_le_iff, lsub_le_iff]
exact ⟨fun H b => H _ _, fun H i h => by simpa only [typein_enum] using H (enum r ⟨i, h⟩)⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | blsub_type | null |
blsub_const {o : Ordinal} (ho : o ≠ 0) (a : Ordinal) :
(blsub.{u, v} o fun _ _ => a) = succ a :=
bsup_const.{u, v} ho (succ a)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | blsub_const | null |
blsub_one (f : ∀ a < (1 : Ordinal), Ordinal) : blsub 1 f = succ (f 0 zero_lt_one) :=
bsup_one _
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | blsub_one | null |
blsub_id : ∀ o, (blsub.{u, u} o fun x _ => x) = o :=
lsub_typein | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | blsub_id | null |
bsup_id_limit {o : Ordinal} : (∀ a < o, succ a < o) → (bsup.{u, u} o fun x _ => x) = o :=
iSup_typein_limit
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_id_limit | null |
bsup_id_succ (o) : (bsup.{u, u} (succ o) fun x _ => x) = o :=
iSup_typein_succ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_id_succ | null |
blsub_le_of_brange_subset {o o'} {f : ∀ a < o, Ordinal} {g : ∀ a < o', Ordinal}
(h : brange o f ⊆ brange o' g) : blsub.{u, max v w} o f ≤ blsub.{v, max u w} o' g :=
bsup_le_of_brange_subset.{u, v, w} fun a ⟨b, hb, hb'⟩ => by
obtain ⟨c, hc, hc'⟩ := h ⟨b, hb, rfl⟩
simp_rw [← hc'] at hb'
exact ⟨c, hc, hb'⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | blsub_le_of_brange_subset | null |
blsub_eq_of_brange_eq {o o'} {f : ∀ a < o, Ordinal} {g : ∀ a < o', Ordinal}
(h : { o | ∃ i hi, f i hi = o } = { o | ∃ i hi, g i hi = o }) :
blsub.{u, max v w} o f = blsub.{v, max u w} o' g :=
(blsub_le_of_brange_subset.{u, v, w} h.le).antisymm (blsub_le_of_brange_subset.{v, u, w} h.ge) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | blsub_eq_of_brange_eq | null |
bsup_comp {o o' : Ordinal.{max u v}} {f : ∀ a < o, Ordinal.{max u v w}}
(hf : ∀ {i j} (hi) (hj), i ≤ j → f i hi ≤ f j hj) {g : ∀ a < o', Ordinal.{max u v}}
(hg : blsub.{_, u} o' g = o) :
(bsup.{_, w} o' fun a ha => f (g a ha) (by rw [← hg]; apply lt_blsub)) = bsup.{_, w} o f := by
apply le_antisymm <;> refine bsup_le fun i hi => ?_
· apply le_bsup
· rw [← hg, lt_blsub_iff] at hi
rcases hi with ⟨j, hj, hj'⟩
exact (hf _ _ hj').trans (le_bsup _ _ _) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_comp | null |
blsub_comp {o o' : Ordinal.{max u v}} {f : ∀ a < o, Ordinal.{max u v w}}
(hf : ∀ {i j} (hi) (hj), i ≤ j → f i hi ≤ f j hj) {g : ∀ a < o', Ordinal.{max u v}}
(hg : blsub.{_, u} o' g = o) :
(blsub.{_, w} o' fun a ha => f (g a ha) (by rw [← hg]; apply lt_blsub)) = blsub.{_, w} o f :=
@bsup_comp.{u, v, w} o _ (fun a ha => succ (f a ha))
(fun {_ _} _ _ h => succ_le_succ_iff.2 (hf _ _ h)) g hg | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | blsub_comp | null |
IsNormal.bsup_eq {f : Ordinal.{u} → Ordinal.{max u v}} (H : IsNormal f) {o : Ordinal.{u}}
(h : IsSuccLimit o) : (Ordinal.bsup.{_, v} o fun x _ => f x) = f o := by
rw [← IsNormal.bsup.{u, u, v} H (fun x _ => x) h.ne_bot, bsup_id_limit fun _ ↦ h.succ_lt] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | IsNormal.bsup_eq | null |
IsNormal.blsub_eq {f : Ordinal.{u} → Ordinal.{max u v}} (H : IsNormal f) {o : Ordinal.{u}}
(h : IsSuccLimit o) : (blsub.{_, v} o fun x _ => f x) = f o := by
rw [← IsNormal.bsup_eq.{u, v} H h, bsup_eq_blsub_of_lt_succ_limit h]
exact fun a _ => H.strictMono (lt_succ a) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | IsNormal.blsub_eq | null |
isNormal_iff_lt_succ_and_bsup_eq {f : Ordinal.{u} → Ordinal.{max u v}} :
IsNormal f ↔ (∀ a, f a < f (succ a)) ∧
∀ o, IsSuccLimit o → (bsup.{_, v} o fun x _ => f x) = f o :=
⟨fun h => ⟨fun a ↦ h.strictMono (lt_succ a), @IsNormal.bsup_eq f h⟩, fun ⟨h₁, h₂⟩ =>
.of_succ_lt h₁ fun ho ↦ by
rw [← h₂ _ ho]
simpa [IsLUB, upperBounds, lowerBounds, IsLeast, bsup_le_iff] using le_bsup _⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | isNormal_iff_lt_succ_and_bsup_eq | null |
isNormal_iff_lt_succ_and_blsub_eq {f : Ordinal.{u} → Ordinal.{max u v}} :
IsNormal f ↔ (∀ a, f a < f (succ a)) ∧
∀ o, IsSuccLimit o → (blsub.{_, v} o fun x _ => f x) = f o := by
rw [isNormal_iff_lt_succ_and_bsup_eq.{u, v}, and_congr_right_iff]
intro h
constructor <;> intro H o ho <;> have := H o ho <;>
rwa [← bsup_eq_blsub_of_lt_succ_limit ho fun a _ => h a] at * | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | isNormal_iff_lt_succ_and_blsub_eq | null |
IsNormal.eq_iff_zero_and_succ {f g : Ordinal.{u} → Ordinal.{u}} (hf : IsNormal f)
(hg : IsNormal g) : f = g ↔ f 0 = g 0 ∧ ∀ a, f a = g a → f (succ a) = g (succ a) :=
Order.IsNormal.ext hf hg | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | IsNormal.eq_iff_zero_and_succ | null |
not_surjective_of_ordinal {α : Type*} [Small.{u} α] (f : α → Ordinal.{u}) :
¬ Surjective f := by
intro h
obtain ⟨a, ha⟩ := h (⨆ i, succ (f i))
apply ha.not_lt
rw [Ordinal.lt_iSup_iff]
exact ⟨a, Order.lt_succ _⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | not_surjective_of_ordinal | null |
not_injective_of_ordinal {α : Type*} [Small.{u} α] (f : Ordinal.{u} → α) :
¬ Injective f := fun h ↦ not_surjective_of_ordinal _ (invFun_surjective h)
@[deprecated (since := "2025-08-21")]
alias not_surjective_of_ordinal_of_small := not_surjective_of_ordinal
@[deprecated (since := "2025-08-21")]
alias not_injective_of_ordinal_of_small := not_injective_of_ordinal | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | not_injective_of_ordinal | null |
not_small_ordinal : ¬Small.{u} Ordinal.{max u v} := fun h =>
@not_injective_of_ordinal _ h _ fun _a _b => Ordinal.lift_inj.{v, u}.1 | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | not_small_ordinal | The type of ordinals in universe `u` is not `Small.{u}`. This is the type-theoretic analog of
the Burali-Forti paradox. |
Ordinal.uncountable : Uncountable Ordinal.{u} :=
Uncountable.of_not_small not_small_ordinal.{u} | instance | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | Ordinal.uncountable | null |
Ordinal.not_bddAbove_compl_of_small (s : Set Ordinal.{u}) [hs : Small.{u} s] :
¬BddAbove sᶜ := by
rw [bddAbove_iff_small]
intro h
have := small_union s sᶜ
rw [union_compl_self, small_univ_iff] at this
exact not_small_ordinal this | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | Ordinal.not_bddAbove_compl_of_small | null |
@[simp]
iSup_natCast : iSup Nat.cast = ω :=
(Ordinal.iSup_le fun n => (nat_lt_omega0 n).le).antisymm <| omega0_le.2 <| Ordinal.le_iSup _ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | iSup_natCast | null |
IsNormal.apply_omega0 {f : Ordinal.{u} → Ordinal.{v}} (hf : IsNormal f) :
⨆ n : ℕ, f n = f ω := by rw [← iSup_natCast, hf.map_iSup]
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | IsNormal.apply_omega0 | null |
iSup_add_nat (o : Ordinal) : ⨆ n : ℕ, o + n = o + ω :=
(isNormal_add_right o).apply_omega0
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | iSup_add_nat | null |
iSup_mul_nat (o : Ordinal) : ⨆ n : ℕ, o * n = o * ω := by
rcases eq_zero_or_pos o with (rfl | ho)
· rw [zero_mul]
exact iSup_eq_zero_iff.2 fun n => zero_mul (n : Ordinal)
· exact (isNormal_mul_right ho).apply_omega0 | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | iSup_mul_nat | null |
nfpFamily (f : ι → Ordinal.{u} → Ordinal.{u}) (a : Ordinal.{u}) : Ordinal :=
⨆ i, List.foldr f a i | def | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | nfpFamily | The next common fixed point, at least `a`, for a family of normal functions.
This is defined for any family of functions, as the supremum of all values reachable by applying
finitely many functions in the family to `a`.
`Ordinal.nfpFamily_fp` shows this is a fixed point, `Ordinal.le_nfpFamily` shows it's at
least `a`, and `Ordinal.nfpFamily_le_fp` shows this is the least ordinal with these properties. |
foldr_le_nfpFamily [Small.{u} ι] (f : ι → Ordinal.{u} → Ordinal.{u}) (a l) :
List.foldr f a l ≤ nfpFamily f a :=
Ordinal.le_iSup _ _ | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | foldr_le_nfpFamily | null |
le_nfpFamily [Small.{u} ι] (f : ι → Ordinal.{u} → Ordinal.{u}) (a) : a ≤ nfpFamily f a :=
foldr_le_nfpFamily f a [] | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | le_nfpFamily | null |
lt_nfpFamily_iff [Small.{u} ι] {a b} : a < nfpFamily f b ↔ ∃ l, a < List.foldr f b l :=
Ordinal.lt_iSup_iff | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | lt_nfpFamily_iff | null |
nfpFamily_le_iff [Small.{u} ι] {a b} : nfpFamily f a ≤ b ↔ ∀ l, List.foldr f a l ≤ b :=
Ordinal.iSup_le_iff | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | nfpFamily_le_iff | null |
nfpFamily_le {a b} : (∀ l, List.foldr f a l ≤ b) → nfpFamily f a ≤ b :=
Ordinal.iSup_le | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | nfpFamily_le | null |
nfpFamily_monotone [Small.{u} ι] (hf : ∀ i, Monotone (f i)) : Monotone (nfpFamily f) :=
fun _ _ h ↦ nfpFamily_le <| fun l ↦ (List.foldr_monotone hf l h).trans (foldr_le_nfpFamily _ _ l) | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | nfpFamily_monotone | null |
apply_lt_nfpFamily [Small.{u} ι] (H : ∀ i, IsNormal (f i)) {a b}
(hb : b < nfpFamily f a) (i) : f i b < nfpFamily f a :=
let ⟨l, hl⟩ := lt_nfpFamily_iff.1 hb
lt_nfpFamily_iff.2 ⟨i::l, (H i).strictMono hl⟩ | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | apply_lt_nfpFamily | null |
apply_lt_nfpFamily_iff [Nonempty ι] [Small.{u} ι] (H : ∀ i, IsNormal (f i)) {a b} :
(∀ i, f i b < nfpFamily f a) ↔ b < nfpFamily f a := by
refine ⟨fun h ↦ ?_, apply_lt_nfpFamily H⟩
let ⟨l, hl⟩ := lt_nfpFamily_iff.1 (h (Classical.arbitrary ι))
exact lt_nfpFamily_iff.2 <| ⟨l, (H _).le_apply.trans_lt hl⟩ | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | apply_lt_nfpFamily_iff | null |
nfpFamily_le_apply [Nonempty ι] [Small.{u} ι] (H : ∀ i, IsNormal (f i)) {a b} :
(∃ i, nfpFamily f a ≤ f i b) ↔ nfpFamily f a ≤ b := by
rw [← not_iff_not]
push_neg
exact apply_lt_nfpFamily_iff H | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | nfpFamily_le_apply | null |
nfpFamily_le_fp (H : ∀ i, Monotone (f i)) {a b} (ab : a ≤ b) (h : ∀ i, f i b ≤ b) :
nfpFamily f a ≤ b := by
apply Ordinal.iSup_le fun l ↦ ?_
induction l generalizing a with
| nil => exact ab
| cons i l IH => exact (H i (IH ab)).trans (h i) | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | nfpFamily_le_fp | null |
nfpFamily_fp [Small.{u} ι] {i} (H : IsNormal (f i)) (a) :
f i (nfpFamily f a) = nfpFamily f a := by
rw [nfpFamily, H.map_iSup]
apply le_antisymm <;> refine Ordinal.iSup_le fun l => ?_
· exact Ordinal.le_iSup _ (i::l)
· exact H.le_apply.trans (Ordinal.le_iSup _ _) | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | nfpFamily_fp | null |
apply_le_nfpFamily [Small.{u} ι] [hι : Nonempty ι] (H : ∀ i, IsNormal (f i)) {a b} :
(∀ i, f i b ≤ nfpFamily f a) ↔ b ≤ nfpFamily f a := by
refine ⟨fun h => ?_, fun h i => ?_⟩
· obtain ⟨i⟩ := hι
exact (H i).le_apply.trans (h i)
· rw [← nfpFamily_fp (H i)]
exact (H i).monotone h | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | apply_le_nfpFamily | null |
nfpFamily_eq_self [Small.{u} ι] {a} (h : ∀ i, f i a = a) : nfpFamily f a = a := by
apply (Ordinal.iSup_le ?_).antisymm (le_nfpFamily f a)
intro l
rw [List.foldr_fixed' h l] | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | nfpFamily_eq_self | null |
not_bddAbove_fp_family [Small.{u} ι] (H : ∀ i, IsNormal (f i)) :
¬ BddAbove (⋂ i, Function.fixedPoints (f i)) := by
rw [not_bddAbove_iff]
refine fun a ↦ ⟨nfpFamily f (succ a), ?_, (lt_succ a).trans_le (le_nfpFamily f _)⟩
rintro _ ⟨i, rfl⟩
exact nfpFamily_fp (H i) _ | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | not_bddAbove_fp_family | A generalization of the fixed point lemma for normal functions: any family of normal functions
has an unbounded set of common fixed points. |
derivFamily (f : ι → Ordinal.{u} → Ordinal.{u}) (o : Ordinal.{u}) : Ordinal.{u} :=
limitRecOn o (nfpFamily f 0) (fun _ IH => nfpFamily f (succ IH))
fun a _ g => ⨆ b : Set.Iio a, g _ b.2
@[simp] | def | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | derivFamily | The derivative of a family of normal functions is the sequence of their common fixed points.
This is defined for all functions such that `Ordinal.derivFamily_zero`,
`Ordinal.derivFamily_succ`, and `Ordinal.derivFamily_limit` are satisfied. |
derivFamily_zero (f : ι → Ordinal → Ordinal) :
derivFamily f 0 = nfpFamily f 0 :=
limitRecOn_zero ..
@[simp] | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | derivFamily_zero | null |
derivFamily_succ (f : ι → Ordinal → Ordinal) (o) :
derivFamily f (succ o) = nfpFamily f (succ (derivFamily f o)) :=
limitRecOn_succ .. | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | derivFamily_succ | null |
derivFamily_limit (f : ι → Ordinal → Ordinal) {o} :
IsSuccLimit o → derivFamily f o = ⨆ b : Set.Iio o, derivFamily f b :=
limitRecOn_limit _ _ _ _ | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | derivFamily_limit | null |
isNormal_derivFamily [Small.{u} ι] (f : ι → Ordinal.{u} → Ordinal.{u}) :
IsNormal (derivFamily f) := by
refine IsNormal.of_succ_lt (fun o ↦ ?_) @fun o h ↦ ?_
· rw [derivFamily_succ, ← succ_le_iff]
exact le_nfpFamily _ _
· rw [derivFamily_limit _ h, Set.image_eq_range]
have := h.nonempty_Iio.to_subtype
exact isLUB_ciSup (bddAbove_of_small _) | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | isNormal_derivFamily | null |
derivFamily_strictMono [Small.{u} ι] (f : ι → Ordinal.{u} → Ordinal.{u}) :
StrictMono (derivFamily f) :=
(isNormal_derivFamily f).strictMono | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | derivFamily_strictMono | null |
derivFamily_fp [Small.{u} ι] {i} (H : IsNormal (f i)) (o : Ordinal) :
f i (derivFamily f o) = derivFamily f o := by
induction o using limitRecOn with
| zero =>
rw [derivFamily_zero]
exact nfpFamily_fp H 0
| succ =>
rw [derivFamily_succ]
exact nfpFamily_fp H _
| limit o l IH =>
have := l.nonempty_Iio.to_subtype
rw [derivFamily_limit _ l, H.map_iSup]
refine eq_of_forall_ge_iff fun c => ?_
rw [Ordinal.iSup_le_iff, Ordinal.iSup_le_iff]
refine forall_congr' fun a ↦ ?_
rw [IH _ a.2] | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | derivFamily_fp | null |
le_iff_derivFamily [Small.{u} ι] (H : ∀ i, IsNormal (f i)) {a} :
(∀ i, f i a ≤ a) ↔ ∃ o, derivFamily f o = a :=
⟨fun ha => by
suffices ∀ (o), a ≤ derivFamily f o → ∃ o, derivFamily f o = a from
this a (isNormal_derivFamily _).le_apply
intro o
induction o using limitRecOn with
| zero =>
intro h₁
refine ⟨0, le_antisymm ?_ h₁⟩
rw [derivFamily_zero]
exact nfpFamily_le_fp (fun i => (H i).monotone) (Ordinal.zero_le _) ha
| succ o IH =>
intro h₁
rcases le_or_gt a (derivFamily f o) with h | h
· exact IH h
refine ⟨succ o, le_antisymm ?_ h₁⟩
rw [derivFamily_succ]
exact nfpFamily_le_fp (fun i => (H i).monotone) (succ_le_of_lt h) ha
| limit o l IH =>
intro h₁
rcases eq_or_lt_of_le h₁ with h | h
· exact ⟨_, h.symm⟩
rw [derivFamily_limit _ l, ← not_le, Ordinal.iSup_le_iff, not_forall] at h
obtain ⟨o', h⟩ := h
exact IH o' o'.2 (le_of_not_ge h),
fun ⟨_, e⟩ i => e ▸ (derivFamily_fp (H i) _).le⟩ | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | le_iff_derivFamily | null |
fp_iff_derivFamily [Small.{u} ι] (H : ∀ i, IsNormal (f i)) {a} :
(∀ i, f i a = a) ↔ ∃ o, derivFamily f o = a :=
Iff.trans ⟨fun h i => le_of_eq (h i), fun h i => (H i).le_iff_eq.1 (h i)⟩ (le_iff_derivFamily H) | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | fp_iff_derivFamily | null |
mem_range_derivFamily [Small.{u} ι] (H : ∀ i, IsNormal (f i)) {a} :
a ∈ Set.range (derivFamily f) ↔ ∀ i, f i a = a :=
(fp_iff_derivFamily H).symm | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | mem_range_derivFamily | null |
derivFamily_eq_enumOrd [Small.{u} ι] (H : ∀ i, IsNormal (f i)) :
derivFamily f = enumOrd (⋂ i, Function.fixedPoints (f i)) := by
rw [eq_comm, eq_enumOrd _ (not_bddAbove_fp_family H)]
use (isNormal_derivFamily f).strictMono
rw [Set.range_eq_iff]
refine ⟨?_, fun a ha => ?_⟩
· rintro a S ⟨i, hi⟩
rw [← hi]
exact derivFamily_fp (H i) a
rw [Set.mem_iInter] at ha
rwa [← fp_iff_derivFamily H] | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | derivFamily_eq_enumOrd | For a family of normal functions, `Ordinal.derivFamily` enumerates the common fixed points. |
nfp (f : Ordinal → Ordinal) : Ordinal → Ordinal :=
nfpFamily fun _ : Unit => f | def | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | nfp | The next fixed point function, the least fixed point of the normal function `f`, at least `a`.
This is defined as `nfpFamily` applied to a family consisting only of `f`. |
nfp_eq_nfpFamily (f : Ordinal → Ordinal) : nfp f = nfpFamily fun _ : Unit => f :=
rfl | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | nfp_eq_nfpFamily | null |
iSup_iterate_eq_nfp (f : Ordinal.{u} → Ordinal.{u}) (a : Ordinal.{u}) :
⨆ n : ℕ, f^[n] a = nfp f a := by
apply le_antisymm
· rw [Ordinal.iSup_le_iff]
intro n
rw [← List.length_replicate (n := n) (a := Unit.unit), ← List.foldr_const f a]
exact Ordinal.le_iSup _ _
· apply Ordinal.iSup_le
intro l
rw [List.foldr_const f a l]
exact Ordinal.le_iSup _ _ | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | iSup_iterate_eq_nfp | null |
iterate_le_nfp (f a n) : f^[n] a ≤ nfp f a := by
rw [← iSup_iterate_eq_nfp]
exact Ordinal.le_iSup (fun n ↦ f^[n] a) n | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | iterate_le_nfp | null |
le_nfp (f a) : a ≤ nfp f a :=
iterate_le_nfp f a 0 | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | le_nfp | null |
lt_nfp_iff {a b} : a < nfp f b ↔ ∃ n, a < f^[n] b := by
rw [← iSup_iterate_eq_nfp]
exact Ordinal.lt_iSup_iff | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | lt_nfp_iff | null |
nfp_le_iff {a b} : nfp f a ≤ b ↔ ∀ n, f^[n] a ≤ b := by
rw [← iSup_iterate_eq_nfp]
exact Ordinal.iSup_le_iff | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | nfp_le_iff | null |
nfp_le {a b} : (∀ n, f^[n] a ≤ b) → nfp f a ≤ b :=
nfp_le_iff.2
@[simp] | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | nfp_le | null |
nfp_id : nfp id = id := by
ext
simp_rw [← iSup_iterate_eq_nfp, iterate_id]
exact ciSup_const | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | nfp_id | null |
nfp_monotone (hf : Monotone f) : Monotone (nfp f) :=
nfpFamily_monotone fun _ => hf | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | nfp_monotone | null |
iterate_lt_nfp (hf : StrictMono f) {a} (h : a < f a) (n : ℕ) : f^[n] a < nfp f a := by
apply (hf.iterate n h).trans_le
rw [← iterate_succ_apply]
exact iterate_le_nfp .. | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | iterate_lt_nfp | null |
IsNormal.apply_lt_nfp (H : IsNormal f) {a b} : f b < nfp f a ↔ b < nfp f a := by
unfold nfp
rw [← @apply_lt_nfpFamily_iff Unit (fun _ => f) _ _ (fun _ => H) a b]
exact ⟨fun h _ => h, fun h => h Unit.unit⟩ | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | IsNormal.apply_lt_nfp | null |
IsNormal.nfp_le_apply (H : IsNormal f) {a b} : nfp f a ≤ f b ↔ nfp f a ≤ b :=
le_iff_le_iff_lt_iff_lt.2 H.apply_lt_nfp | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | IsNormal.nfp_le_apply | null |
nfp_le_fp (H : Monotone f) {a b} (ab : a ≤ b) (h : f b ≤ b) : nfp f a ≤ b :=
nfpFamily_le_fp (fun _ => H) ab fun _ => h | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | nfp_le_fp | null |
IsNormal.nfp_fp (H : IsNormal f) : ∀ a, f (nfp f a) = nfp f a :=
@nfpFamily_fp Unit (fun _ => f) _ () H | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | IsNormal.nfp_fp | null |
IsNormal.apply_le_nfp (H : IsNormal f) {a b} : f b ≤ nfp f a ↔ b ≤ nfp f a :=
⟨H.le_apply.trans, fun h => by simpa only [H.nfp_fp] using H.le_iff.2 h⟩ | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | IsNormal.apply_le_nfp | null |
nfp_eq_self {a} (h : f a = a) : nfp f a = a :=
nfpFamily_eq_self fun _ => h | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | nfp_eq_self | null |
not_bddAbove_fp (H : IsNormal f) : ¬ BddAbove (Function.fixedPoints f) := by
convert not_bddAbove_fp_family fun _ : Unit => H
exact (Set.iInter_const _).symm | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | not_bddAbove_fp | The fixed point lemma for normal functions: any normal function has an unbounded set of
fixed points. |
deriv (f : Ordinal → Ordinal) : Ordinal → Ordinal :=
derivFamily fun _ : Unit => f | def | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | deriv | The derivative of a normal function `f` is the sequence of fixed points of `f`.
This is defined as `Ordinal.derivFamily` applied to a trivial family consisting only of `f`. |
deriv_eq_derivFamily (f : Ordinal → Ordinal) : deriv f = derivFamily fun _ : Unit => f :=
rfl
@[simp] | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | deriv_eq_derivFamily | null |
deriv_zero_right (f) : deriv f 0 = nfp f 0 :=
derivFamily_zero _
@[simp] | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | deriv_zero_right | null |
deriv_succ (f o) : deriv f (succ o) = nfp f (succ (deriv f o)) :=
derivFamily_succ _ _ | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | deriv_succ | null |
deriv_limit (f) {o} : IsSuccLimit o → deriv f o = ⨆ a : {a // a < o}, deriv f a :=
derivFamily_limit _ | theorem | SetTheory | [
"Mathlib.Logic.Small.List",
"Mathlib.SetTheory.Ordinal.Enum",
"Mathlib.SetTheory.Ordinal.Exponential"
] | Mathlib/SetTheory/Ordinal/FixedPoint.lean | deriv_limit | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.