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 ⌀ |
|---|---|---|---|---|---|---|
lt_omega0_opow {a b : Ordinal} (hb : b ≠ 0) :
a < ω ^ b ↔ ∃ c < b, ∃ n : ℕ, a < ω ^ c * n := by
refine ⟨fun ha ↦ ⟨_, lt_log_of_lt_opow hb ha, ?_⟩,
fun ⟨c, hc, n, hn⟩ ↦ hn.trans (omega0_opow_mul_nat_lt hc n)⟩
obtain ⟨n, hn⟩ := lt_omega0.1 (div_opow_log_lt a one_lt_omega0)
use n.succ
rw [natCast_succ, ← hn]
exact lt_mul_succ_div a (opow_ne_zero _ omega0_ne_zero) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Family"
] | Mathlib/SetTheory/Ordinal/Exponential.lean | lt_omega0_opow | null |
lt_omega0_opow_succ {a b : Ordinal} : a < ω ^ succ b ↔ ∃ n : ℕ, a < ω ^ b * n := by
refine ⟨fun ha ↦ ?_, fun ⟨n, hn⟩ ↦ hn.trans (omega0_opow_mul_nat_lt (lt_succ b) n)⟩
obtain ⟨c, hc, n, hn⟩ := (lt_omega0_opow (succ_ne_zero b)).1 ha
refine ⟨n, hn.trans_le (mul_le_mul_right' ?_ _)⟩
rwa [opow_le_opow_iff_right one_lt_omega0, ← lt_succ_iff]
/-! ### Interaction with `Nat.cast` -/
@[simp, norm_cast] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Family"
] | Mathlib/SetTheory/Ordinal/Exponential.lean | lt_omega0_opow_succ | null |
natCast_opow (m : ℕ) : ∀ n : ℕ, ↑(m ^ n : ℕ) = (m : Ordinal) ^ (n : Ordinal)
| 0 => by simp
| n + 1 => by
rw [pow_succ, natCast_mul, natCast_opow m n, Nat.cast_succ, add_one_eq_succ, opow_succ] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Family"
] | Mathlib/SetTheory/Ordinal/Exponential.lean | natCast_opow | null |
iSup_pow {o : Ordinal} (ho : 0 < o) : ⨆ n : ℕ, o ^ n = o ^ ω := by
simp_rw [← opow_natCast]
rcases (one_le_iff_pos.2 ho).lt_or_eq with ho₁ | rfl
· exact (isNormal_opow ho₁).apply_omega0
· rw [one_opow]
refine le_antisymm (Ordinal.iSup_le fun n => by rw [one_opow]) ?_
exact_mod_cast Ordinal.le_iSup _ 0 | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Family"
] | Mathlib/SetTheory/Ordinal/Exponential.lean | iSup_pow | null |
bfamilyOfFamily' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] (f : ι → α) :
∀ a < type r, α := fun a ha => f (enum r ⟨a, ha⟩) | def | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bfamilyOfFamily' | Converts a family indexed by a `Type u` to one indexed by an `Ordinal.{u}` using a specified
well-ordering. |
bfamilyOfFamily {ι : Type u} : (ι → α) → ∀ a < type (@WellOrderingRel ι), α :=
bfamilyOfFamily' WellOrderingRel | def | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bfamilyOfFamily | Converts a family indexed by a `Type u` to one indexed by an `Ordinal.{u}` using a well-ordering
given by the axiom of choice. |
familyOfBFamily' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] {o} (ho : type r = o)
(f : ∀ a < o, α) : ι → α := fun i =>
f (typein r i)
(by
rw [← ho]
exact typein_lt_type r i) | def | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | familyOfBFamily' | Converts a family indexed by an `Ordinal.{u}` to one indexed by a `Type u` using a specified
well-ordering. |
familyOfBFamily (o : Ordinal) (f : ∀ a < o, α) : o.toType → α :=
familyOfBFamily' (· < ·) (type_toType o) f
@[simp] | def | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | familyOfBFamily | Converts a family indexed by an `Ordinal.{u}` to one indexed by a `Type u` using a well-ordering
given by the axiom of choice. |
bfamilyOfFamily'_typein {ι} (r : ι → ι → Prop) [IsWellOrder ι r] (f : ι → α) (i) :
bfamilyOfFamily' r f (typein r i) (typein_lt_type r i) = f i := by
simp only [bfamilyOfFamily', enum_typein]
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bfamilyOfFamily'_typein | null |
bfamilyOfFamily_typein {ι} (f : ι → α) (i) :
bfamilyOfFamily f (typein _ i) (typein_lt_type _ i) = f i :=
bfamilyOfFamily'_typein _ f i | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bfamilyOfFamily_typein | null |
familyOfBFamily'_enum {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] {o}
(ho : type r = o) (f : ∀ a < o, α) (i hi) :
familyOfBFamily' r ho f (enum r ⟨i, by rwa [ho]⟩) = f i hi := by
simp only [familyOfBFamily', typein_enum] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | familyOfBFamily'_enum | null |
familyOfBFamily_enum (o : Ordinal) (f : ∀ a < o, α) (i hi) :
familyOfBFamily o f (enum (α := o.toType) (· < ·) ⟨i, hi.trans_eq (type_toType _).symm⟩)
= f i hi :=
familyOfBFamily'_enum _ (type_toType o) f _ _ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | familyOfBFamily_enum | null |
brange (o : Ordinal) (f : ∀ a < o, α) : Set α :=
{ a | ∃ i hi, f i hi = a } | def | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | brange | The range of a family indexed by ordinals. |
mem_brange {o : Ordinal} {f : ∀ a < o, α} {a} : a ∈ brange o f ↔ ∃ i hi, f i hi = a :=
Iff.rfl | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | mem_brange | null |
mem_brange_self {o} (f : ∀ a < o, α) (i hi) : f i hi ∈ brange o f :=
⟨i, hi, rfl⟩
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | mem_brange_self | null |
range_familyOfBFamily' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] {o}
(ho : type r = o) (f : ∀ a < o, α) : range (familyOfBFamily' r ho f) = brange o f := by
refine Set.ext fun a => ⟨?_, ?_⟩
· rintro ⟨b, rfl⟩
apply mem_brange_self
· rintro ⟨i, hi, rfl⟩
exact ⟨_, familyOfBFamily'_enum _ _ _ _ _⟩
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | range_familyOfBFamily' | null |
range_familyOfBFamily {o} (f : ∀ a < o, α) : range (familyOfBFamily o f) = brange o f :=
range_familyOfBFamily' _ _ f
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | range_familyOfBFamily | null |
brange_bfamilyOfFamily' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] (f : ι → α) :
brange _ (bfamilyOfFamily' r f) = range f := by
refine Set.ext fun a => ⟨?_, ?_⟩
· rintro ⟨i, hi, rfl⟩
apply mem_range_self
· rintro ⟨b, rfl⟩
exact ⟨_, _, bfamilyOfFamily'_typein _ _ _⟩
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | brange_bfamilyOfFamily' | null |
brange_bfamilyOfFamily {ι : Type u} (f : ι → α) : brange _ (bfamilyOfFamily f) = range f :=
brange_bfamilyOfFamily' _ _
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | brange_bfamilyOfFamily | null |
brange_const {o : Ordinal} (ho : o ≠ 0) {c : α} : (brange o fun _ _ => c) = {c} := by
rw [← range_familyOfBFamily]
exact @Set.range_const _ o.toType (toType_nonempty_iff_ne_zero.2 ho) c | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | brange_const | null |
comp_bfamilyOfFamily' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] (f : ι → α)
(g : α → β) : (fun i hi => g (bfamilyOfFamily' r f i hi)) = bfamilyOfFamily' r (g ∘ f) :=
rfl | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | comp_bfamilyOfFamily' | null |
comp_bfamilyOfFamily {ι : Type u} (f : ι → α) (g : α → β) :
(fun i hi => g (bfamilyOfFamily f i hi)) = bfamilyOfFamily (g ∘ f) :=
rfl | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | comp_bfamilyOfFamily | null |
comp_familyOfBFamily' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] {o}
(ho : type r = o) (f : ∀ a < o, α) (g : α → β) :
g ∘ familyOfBFamily' r ho f = familyOfBFamily' r ho fun i hi => g (f i hi) :=
rfl | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | comp_familyOfBFamily' | null |
comp_familyOfBFamily {o} (f : ∀ a < o, α) (g : α → β) :
g ∘ familyOfBFamily o f = familyOfBFamily o fun i hi => g (f i hi) :=
rfl
/-! ### Supremum of a family of ordinals -/ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | comp_familyOfBFamily | null |
bddAbove_range {ι : Type u} (f : ι → Ordinal.{max u v}) : BddAbove (Set.range f) :=
⟨(iSup (succ ∘ card ∘ f)).ord, by
rintro a ⟨i, rfl⟩
exact le_of_lt (Cardinal.lt_ord.2 ((lt_succ _).trans_le
(le_ciSup (Cardinal.bddAbove_range _) _)))⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bddAbove_range | The range of an indexed ordinal function, whose outputs live in a higher universe than the
inputs, is always bounded above. See `Ordinal.lsub` for an explicit bound. |
bddAbove_of_small (s : Set Ordinal.{u}) [h : Small.{u} s] : BddAbove s := by
obtain ⟨a, ha⟩ := bddAbove_range (fun x => ((@equivShrink s h).symm x).val)
use a
intro b hb
simpa using ha (mem_range_self (equivShrink s ⟨b, hb⟩)) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bddAbove_of_small | null |
bddAbove_iff_small {s : Set Ordinal.{u}} : BddAbove s ↔ Small.{u} s :=
⟨fun ⟨a, h⟩ => small_subset <| show s ⊆ Iic a from fun _ hx => h hx, fun _ =>
bddAbove_of_small _⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bddAbove_iff_small | null |
bddAbove_image {s : Set Ordinal.{u}} (hf : BddAbove s)
(f : Ordinal.{u} → Ordinal.{max u v}) : BddAbove (f '' s) := by
rw [bddAbove_iff_small] at hf ⊢
exact small_lift _ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bddAbove_image | null |
bddAbove_range_comp {ι : Type u} {f : ι → Ordinal.{v}} (hf : BddAbove (range f))
(g : Ordinal.{v} → Ordinal.{max v w}) : BddAbove (range (g ∘ f)) := by
rw [range_comp]
exact bddAbove_image hf g | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bddAbove_range_comp | null |
protected le_iSup {ι} (f : ι → Ordinal.{u}) [Small.{u} ι] : ∀ i, f i ≤ iSup f :=
le_ciSup (bddAbove_of_small _) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | le_iSup | `le_ciSup` whenever the input type is small in the output universe. This lemma sometimes
fails to infer `f` in simple cases and needs it to be given explicitly. |
protected iSup_le_iff {ι} {f : ι → Ordinal.{u}} {a : Ordinal.{u}} [Small.{u} ι] :
iSup f ≤ a ↔ ∀ i, f i ≤ a :=
ciSup_le_iff' (bddAbove_of_small _) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | iSup_le_iff | `ciSup_le_iff'` whenever the input type is small in the output universe. |
protected iSup_le {ι} {f : ι → Ordinal} {a} : (∀ i, f i ≤ a) → iSup f ≤ a :=
ciSup_le' | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | iSup_le | An alias of `ciSup_le'` for discoverability. |
protected lt_iSup_iff {ι} {f : ι → Ordinal.{u}} {a : Ordinal.{u}} [Small.{u} ι] :
a < iSup f ↔ ∃ i, a < f i :=
lt_ciSup_iff' (bddAbove_of_small _) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lt_iSup_iff | `lt_ciSup_iff'` whenever the input type is small in the output universe. |
succ_lt_iSup_of_ne_iSup {ι} {f : ι → Ordinal.{u}} [Small.{u} ι]
(hf : ∀ i, f i ≠ iSup f) {a} (hao : a < iSup f) : succ a < iSup f := by
by_contra! hoa
exact hao.not_ge (Ordinal.iSup_le fun i ↦ le_of_lt_succ <|
((Ordinal.le_iSup _ _).lt_of_ne (hf i)).trans_le hoa) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | succ_lt_iSup_of_ne_iSup | null |
iSup_eq_zero_iff {ι} {f : ι → Ordinal.{u}} [Small.{u} ι] :
iSup f = 0 ↔ ∀ i, f i = 0 := by
refine
⟨fun h i => ?_, fun h =>
le_antisymm (Ordinal.iSup_le fun i => Ordinal.le_zero.2 (h i)) (Ordinal.zero_le _)⟩
rw [← Ordinal.le_zero, ← h]
exact Ordinal.le_iSup f i | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | iSup_eq_zero_iff | null |
iSup_eq_of_range_eq {ι ι'} {f : ι → Ordinal} {g : ι' → Ordinal}
(h : Set.range f = Set.range g) : iSup f = iSup g :=
congr_arg _ h | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | iSup_eq_of_range_eq | null |
iSup_succ (o : Ordinal) : ⨆ a : Iio o, succ a.1 = o := by
apply (le_of_forall_lt _).antisymm'
· simp [Ordinal.iSup_le_iff]
· exact fun a ha ↦ (lt_succ a).trans_le <| Ordinal.le_iSup (fun x : Iio _ ↦ _) ⟨a, ha⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | iSup_succ | null |
iSup_sum {α β} (f : α ⊕ β → Ordinal.{u}) [Small.{u} α] [Small.{u} β] :
iSup f = max (⨆ a, f (Sum.inl a)) (⨆ b, f (Sum.inr b)) := by
apply (Ordinal.iSup_le _).antisymm (max_le _ _)
· rintro (i | i)
· exact le_max_of_le_left (Ordinal.le_iSup (fun x ↦ f (Sum.inl x)) i)
· exact le_max_of_le_right (Ordinal.le_iSup (fun x ↦ f (Sum.inr x)) i)
all_goals
apply csSup_le_csSup' (bddAbove_of_small _)
rintro i ⟨a, rfl⟩
apply mem_range_self | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | iSup_sum | null |
unbounded_range_of_le_iSup {α β : Type u} (r : α → α → Prop) [IsWellOrder α r] (f : β → α)
(h : type r ≤ ⨆ i, typein r (f i)) : Unbounded r (range f) :=
(not_bounded_iff _).1 fun ⟨x, hx⟩ =>
h.not_gt <| lt_of_le_of_lt
(Ordinal.iSup_le fun y => ((typein_lt_typein r).2 <| hx _ <| mem_range_self y).le)
(typein_lt_type r x) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | unbounded_range_of_le_iSup | null |
IsNormal.map_iSup_of_bddAbove {f : Ordinal.{u} → Ordinal.{v}} (H : IsNormal f)
{ι : Type*} (g : ι → Ordinal.{u}) (hg : BddAbove (range g))
[Nonempty ι] : f (⨆ i, g i) = ⨆ i, f (g i) :=
Order.IsNormal.map_iSup H hg | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | IsNormal.map_iSup_of_bddAbove | null |
IsNormal.map_iSup {f : Ordinal.{u} → Ordinal.{v}} (H : IsNormal f)
{ι : Type w} (g : ι → Ordinal.{u}) [Small.{u} ι] [Nonempty ι] :
f (⨆ i, g i) = ⨆ i, f (g i) :=
H.map_iSup_of_bddAbove g (bddAbove_of_small _) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | IsNormal.map_iSup | null |
IsNormal.map_sSup_of_bddAbove {f : Ordinal.{u} → Ordinal.{v}} (H : IsNormal f)
{s : Set Ordinal.{u}} (hs : BddAbove s) (hn : s.Nonempty) : f (sSup s) = sSup (f '' s) := by
have := hn.to_subtype
rw [sSup_eq_iSup', sSup_image', H.map_iSup_of_bddAbove]
rwa [Subtype.range_coe_subtype, setOf_mem_eq] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | IsNormal.map_sSup_of_bddAbove | null |
IsNormal.map_sSup {f : Ordinal.{u} → Ordinal.{v}} (H : IsNormal f)
{s : Set Ordinal.{u}} (hn : s.Nonempty) [Small.{u} s] : f (sSup s) = sSup (f '' s) :=
H.map_sSup_of_bddAbove (bddAbove_of_small s) hn | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | IsNormal.map_sSup | null |
IsNormal.apply_of_isSuccLimit {f : Ordinal.{u} → Ordinal.{v}} (H : IsNormal f) {o : Ordinal}
(ho : IsSuccLimit o) : f o = ⨆ a : Iio o, f a := by
have : Nonempty (Iio o) := ⟨0, ho.bot_lt⟩
rw [← H.map_iSup, ho.iSup_Iio]
@[deprecated (since := "2025-07-08")]
alias IsNormal.apply_of_isLimit := IsNormal.apply_of_isSuccLimit | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | IsNormal.apply_of_isSuccLimit | null |
sSup_ord (s : Set Cardinal) : (sSup s).ord = sSup (ord '' s) := by
obtain rfl | hn := s.eq_empty_or_nonempty
· simp
· by_cases hs : BddAbove s
· exact isNormal_ord.map_sSup hn hs
· rw [csSup_of_not_bddAbove hs, csSup_of_not_bddAbove (bddAbove_ord_image_iff.not.2 hs)]
simp | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | sSup_ord | null |
iSup_ord {ι} (f : ι → Cardinal) : (⨆ i, f i).ord = ⨆ i, (f i).ord := by
rw [iSup, iSup, sSup_ord, range_comp'] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | iSup_ord | null |
lift_card_sInf_compl_le (s : Set Ordinal.{u}) :
Cardinal.lift.{u + 1} (sInf sᶜ).card ≤ #s := by
rw [← mk_Iio_ordinal]
refine mk_le_mk_of_subset fun x (hx : x < _) ↦ ?_
rw [← not_notMem]
exact notMem_of_lt_csInf' hx | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lift_card_sInf_compl_le | null |
card_sInf_range_compl_le_lift {ι : Type u} (f : ι → Ordinal.{max u v}) :
(sInf (range f)ᶜ).card ≤ Cardinal.lift.{v} #ι := by
rw [← Cardinal.lift_le.{max u v + 1}, Cardinal.lift_lift]
apply (lift_card_sInf_compl_le _).trans
rw [← Cardinal.lift_id'.{u, max u v + 1} #(range _)]
exact mk_range_le_lift | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | card_sInf_range_compl_le_lift | null |
card_sInf_range_compl_le {ι : Type u} (f : ι → Ordinal.{u}) :
(sInf (range f)ᶜ).card ≤ #ι :=
Cardinal.lift_id #ι ▸ card_sInf_range_compl_le_lift f | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | card_sInf_range_compl_le | null |
sInf_compl_lt_lift_ord_succ {ι : Type u} (f : ι → Ordinal.{max u v}) :
sInf (range f)ᶜ < lift.{v} (succ #ι).ord := by
rw [lift_ord, Cardinal.lift_succ, ← card_le_iff]
exact card_sInf_range_compl_le_lift f | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | sInf_compl_lt_lift_ord_succ | null |
sInf_compl_lt_ord_succ {ι : Type u} (f : ι → Ordinal.{u}) :
sInf (range f)ᶜ < (succ #ι).ord :=
lift_id (succ #ι).ord ▸ sInf_compl_lt_lift_ord_succ f | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | sInf_compl_lt_ord_succ | null |
iSup_eq_iSup {ι ι' : Type u} (r : ι → ι → Prop) (r' : ι' → ι' → Prop) [IsWellOrder ι r]
[IsWellOrder ι' r'] {o : Ordinal} (ho : type r = o) (ho' : type r' = o) (f : ∀ a < o, Ordinal) :
iSup (familyOfBFamily' r ho f) = iSup (familyOfBFamily' r' ho' f) :=
iSup_eq_of_range_eq (by simp) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | iSup_eq_iSup | null |
bsup (o : Ordinal.{u}) (f : ∀ a < o, Ordinal.{max u v}) : Ordinal.{max u v} :=
iSup (familyOfBFamily o f)
@[simp] | def | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup | The supremum of a family of ordinals indexed by the set of ordinals less than some
`o : Ordinal.{u}`. This is a special case of `iSup` over the family provided by
`familyOfBFamily`. |
iSup_eq_bsup {o : Ordinal} (f : ∀ a < o, Ordinal) :
iSup (familyOfBFamily o f) = bsup o f :=
rfl | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | iSup_eq_bsup | null |
iSup'_eq_bsup {o : Ordinal} {ι} (r : ι → ι → Prop) [IsWellOrder ι r] (ho : type r = o)
(f : ∀ a < o, Ordinal) : iSup (familyOfBFamily' r ho f) = bsup o f :=
iSup_eq_iSup r _ ho _ f | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | iSup'_eq_bsup | null |
sSup_eq_bsup {o : Ordinal} (f : ∀ a < o, Ordinal) : sSup (brange o f) = bsup o f := by
congr
rw [range_familyOfBFamily]
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | sSup_eq_bsup | null |
bsup'_eq_iSup {ι} (r : ι → ι → Prop) [IsWellOrder ι r] (f : ι → Ordinal) :
bsup _ (bfamilyOfFamily' r f) = iSup f := by
simp +unfoldPartialApp only [← iSup'_eq_bsup r, enum_typein, familyOfBFamily', bfamilyOfFamily']
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup'_eq_iSup | null |
bsup_eq_iSup {ι} (f : ι → Ordinal) : bsup _ (bfamilyOfFamily f) = iSup f :=
bsup'_eq_iSup _ f | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_eq_iSup | null |
bsup_eq_bsup {ι : Type u} (r r' : ι → ι → Prop) [IsWellOrder ι r] [IsWellOrder ι r']
(f : ι → Ordinal.{max u v}) :
bsup.{_, v} _ (bfamilyOfFamily' r f) = bsup.{_, v} _ (bfamilyOfFamily' r' f) := by
rw [bsup'_eq_iSup, bsup'_eq_iSup]
@[congr] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_eq_bsup | null |
bsup_congr {o₁ o₂ : Ordinal.{u}} (f : ∀ a < o₁, Ordinal.{max u v}) (ho : o₁ = o₂) :
bsup.{_, v} o₁ f = bsup.{_, 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 | bsup_congr | null |
bsup_le_iff {o f a} : bsup.{u, v} o f ≤ a ↔ ∀ i h, f i h ≤ a :=
Ordinal.iSup_le_iff.trans
⟨fun h i hi => by
rw [← familyOfBFamily_enum o f]
exact h _, fun h _ => h _ _⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_le_iff | null |
bsup_le {o : Ordinal} {f : ∀ b < o, Ordinal} {a} :
(∀ i h, f i h ≤ a) → bsup.{u, v} o f ≤ a :=
bsup_le_iff.2 | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_le | null |
le_bsup {o} (f : ∀ a < o, Ordinal) (i h) : f i h ≤ bsup o f :=
bsup_le_iff.1 le_rfl _ _ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | le_bsup | null |
lt_bsup {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) {a} :
a < bsup.{_, v} o f ↔ ∃ i hi, a < f i hi := by
simpa only [not_forall, not_le] using not_congr (@bsup_le_iff.{_, v} _ f a) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lt_bsup | null |
IsNormal.bsup {f : Ordinal → Ordinal} (H : IsNormal f) {o : Ordinal} :
∀ (g : ∀ a < o, Ordinal), o ≠ 0 → f (bsup o g) = bsup o fun a h => f (g a h) :=
inductionOn o fun α r _ g h => by
haveI := type_ne_zero_iff_nonempty.1 h
rw [← iSup'_eq_bsup r, IsNormal.map_iSup H, ← iSup'_eq_bsup r] <;> rfl | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | IsNormal.bsup | null |
lt_bsup_of_ne_bsup {o : Ordinal.{u}} {f : ∀ a < o, Ordinal.{max u v}} :
(∀ i h, f i h ≠ bsup.{_, v} o f) ↔ ∀ i h, f i h < bsup.{_, v} o f :=
⟨fun hf _ _ => lt_of_le_of_ne (le_bsup _ _ _) (hf _ _), fun hf _ _ => ne_of_lt (hf _ _)⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lt_bsup_of_ne_bsup | null |
bsup_not_succ_of_ne_bsup {o : Ordinal.{u}} {f : ∀ a < o, Ordinal.{max u v}}
(hf : ∀ {i : Ordinal} (h : i < o), f i h ≠ bsup.{_, v} o f) (a) :
a < bsup.{_, v} o f → succ a < bsup.{_, v} o f := by
rw [← iSup_eq_bsup] at *
exact succ_lt_iSup_of_ne_iSup fun i => hf _
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_not_succ_of_ne_bsup | null |
bsup_eq_zero_iff {o} {f : ∀ a < o, Ordinal} : bsup o f = 0 ↔ ∀ i hi, f i hi = 0 := by
refine
⟨fun h i hi => ?_, fun h =>
le_antisymm (bsup_le fun i hi => Ordinal.le_zero.2 (h i hi)) (Ordinal.zero_le _)⟩
rw [← Ordinal.le_zero, ← h]
exact le_bsup f i hi | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_eq_zero_iff | null |
lt_bsup_of_limit {o : Ordinal} {f : ∀ a < o, Ordinal}
(hf : ∀ {a a'} (ha : a < o) (ha' : a' < o), a < a' → f a ha < f a' ha')
(ho : ∀ a < o, succ a < o) (i h) : f i h < bsup o f :=
(hf _ _ <| lt_succ i).trans_le (le_bsup f (succ i) <| ho _ h) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lt_bsup_of_limit | null |
bsup_succ_of_mono {o : Ordinal} {f : ∀ a < succ o, Ordinal}
(hf : ∀ {i j} (hi hj), i ≤ j → f i hi ≤ f j hj) : bsup _ f = f o (lt_succ o) :=
le_antisymm (bsup_le fun _i hi => hf _ _ <| le_of_lt_succ hi) (le_bsup _ _ _)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_succ_of_mono | null |
bsup_zero (f : ∀ a < (0 : Ordinal), Ordinal) : bsup 0 f = 0 :=
bsup_eq_zero_iff.2 fun i hi => (Ordinal.not_lt_zero i hi).elim | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_zero | null |
bsup_const {o : Ordinal.{u}} (ho : o ≠ 0) (a : Ordinal.{max u v}) :
(bsup.{_, v} o fun _ _ => a) = a :=
le_antisymm (bsup_le fun _ _ => le_rfl) (le_bsup _ 0 (Ordinal.pos_iff_ne_zero.2 ho))
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_const | null |
bsup_one (f : ∀ a < (1 : Ordinal), Ordinal) : bsup 1 f = f 0 zero_lt_one := by
simp_rw [← iSup_eq_bsup, ciSup_unique, familyOfBFamily, familyOfBFamily', typein_one_toType] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_one | null |
bsup_le_of_brange_subset {o o'} {f : ∀ a < o, Ordinal} {g : ∀ a < o', Ordinal}
(h : brange o f ⊆ brange o' g) : bsup.{u, max v w} o f ≤ bsup.{v, max u w} o' g :=
bsup_le fun i hi => by
obtain ⟨j, hj, hj'⟩ := h ⟨i, hi, rfl⟩
rw [← hj']
apply le_bsup | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_le_of_brange_subset | null |
bsup_eq_of_brange_eq {o o'} {f : ∀ a < o, Ordinal} {g : ∀ a < o', Ordinal}
(h : brange o f = brange o' g) : bsup.{u, max v w} o f = bsup.{v, max u w} o' g :=
(bsup_le_of_brange_subset.{u, v, w} h.le).antisymm (bsup_le_of_brange_subset.{v, u, w} h.ge) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | bsup_eq_of_brange_eq | null |
iSup_Iio_eq_bsup {o} {f : ∀ a < o, Ordinal} : ⨆ a : Iio o, f a.1 a.2 = bsup o f := by
simp_rw [Iio, bsup, iSup, range_familyOfBFamily, brange, range, Subtype.exists, mem_setOf]
@[deprecated (since := "2025-10-01")] alias sup_eq_sup := iSup_eq_iSup
@[deprecated (since := "2025-10-01")] alias sup_eq_bsup' := iSup'_eq_bsup
@[deprecated (since := "2025-10-01")] alias sup_eq_bsup := iSup_eq_bsup
@[deprecated (since := "2025-10-01")] alias bsup_eq_sup' := bsup'_eq_iSup
@[deprecated (since := "2025-10-01")] alias bsup_eq_sup := bsup_eq_iSup | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | iSup_Iio_eq_bsup | null |
lsub {ι : Type u} (f : ι → Ordinal.{max u v}) : Ordinal :=
iSup (succ ∘ f)
@[simp] | def | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lsub | The least strict upper bound of a family of ordinals. |
iSup_eq_lsub {ι} (f : ι → Ordinal) : iSup (succ ∘ f) = lsub f :=
rfl | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | iSup_eq_lsub | null |
lsub_le_iff {ι} {f : ι → Ordinal} {a} : lsub f ≤ a ↔ ∀ i, f i < a := by
simpa using Ordinal.iSup_le_iff (f := succ ∘ f) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lsub_le_iff | null |
lsub_le {ι} {f : ι → Ordinal} {a} : (∀ i, f i < a) → lsub f ≤ a :=
lsub_le_iff.2 | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lsub_le | null |
lt_lsub {ι} (f : ι → Ordinal) (i) : f i < lsub f :=
succ_le_iff.1 (Ordinal.le_iSup _ i) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lt_lsub | null |
lt_lsub_iff {ι} {f : ι → Ordinal} {a} : a < lsub f ↔ ∃ i, a ≤ f i := by
simpa only [not_forall, not_lt, not_le] using not_congr lsub_le_iff | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lt_lsub_iff | null |
iSup_le_lsub {ι} (f : ι → Ordinal) : iSup f ≤ lsub f :=
Ordinal.iSup_le fun i => (lt_lsub f i).le | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | iSup_le_lsub | null |
lsub_le_succ_iSup {ι} (f : ι → Ordinal) : lsub f ≤ succ (iSup f) :=
lsub_le fun i => lt_succ_iff.2 (Ordinal.le_iSup f i) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lsub_le_succ_iSup | null |
iSup_eq_lsub_or_succ_iSup_eq_lsub {ι} (f : ι → Ordinal) :
iSup f = lsub f ∨ succ (iSup f) = lsub f := by
rcases eq_or_lt_of_le (iSup_le_lsub f) with h | h
· exact Or.inl h
· exact Or.inr ((succ_le_of_lt h).antisymm (lsub_le_succ_iSup f)) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | iSup_eq_lsub_or_succ_iSup_eq_lsub | null |
succ_iSup_le_lsub_iff {ι} (f : ι → Ordinal) :
succ (iSup f) ≤ lsub f ↔ ∃ i, f i = iSup f := by
refine ⟨fun h => ?_, ?_⟩
· by_contra! hf
have := forall_congr' fun i ↦ (Ordinal.le_iSup f i).lt_iff_ne.symm
exact (succ_le_iff.1 h).ne ((iSup_le_lsub f).antisymm (lsub_le (this.1 hf)))
rintro ⟨_, hf⟩
rw [succ_le_iff, ← hf]
exact lt_lsub _ _ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | succ_iSup_le_lsub_iff | null |
succ_iSup_eq_lsub_iff {ι} (f : ι → Ordinal) :
succ (iSup f) = lsub f ↔ ∃ i, f i = iSup f :=
(lsub_le_succ_iSup f).ge_iff_eq'.symm.trans (succ_iSup_le_lsub_iff f) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | succ_iSup_eq_lsub_iff | null |
iSup_eq_lsub_iff {ι} (f : ι → Ordinal) :
iSup f = lsub f ↔ ∀ a < lsub f, succ a < lsub f := by
refine ⟨fun h => ?_, fun hf => le_antisymm (iSup_le_lsub f) (lsub_le fun i => ?_)⟩
· rw [← h]
exact fun a => succ_lt_iSup_of_ne_iSup fun i => (lsub_le_iff.1 (le_of_eq h.symm) i).ne
by_contra! hle
have heq := (succ_iSup_eq_lsub_iff f).2 ⟨i, le_antisymm (Ordinal.le_iSup _ _) hle⟩
have :=
hf _
(by
rw [← heq]
exact lt_succ (iSup f))
rw [heq] at this
exact this.false | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | iSup_eq_lsub_iff | null |
iSup_eq_lsub_iff_lt_iSup {ι} (f : ι → Ordinal) :
iSup f = lsub f ↔ ∀ i, f i < iSup f :=
⟨fun h i => by
rw [h]
apply lt_lsub, fun h => le_antisymm (iSup_le_lsub f) (lsub_le h)⟩
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | iSup_eq_lsub_iff_lt_iSup | null |
lsub_empty {ι} [h : IsEmpty ι] (f : ι → Ordinal) : lsub f = 0 := by
rw [← Ordinal.le_zero, lsub_le_iff]
exact h.elim | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lsub_empty | null |
lsub_pos {ι} [h : Nonempty ι] (f : ι → Ordinal) : 0 < lsub f :=
h.elim fun i => (Ordinal.zero_le _).trans_lt (lt_lsub f i)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lsub_pos | null |
lsub_eq_zero_iff {ι} (f : ι → Ordinal) :
lsub.{_, v} f = 0 ↔ IsEmpty ι := by
refine ⟨fun h => ⟨fun i => ?_⟩, fun h => @lsub_empty _ h _⟩
have := @lsub_pos.{_, v} _ ⟨i⟩ f
rw [h] at this
exact this.false
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lsub_eq_zero_iff | null |
lsub_const {ι} [Nonempty ι] (o : Ordinal) : (lsub fun _ : ι => o) = succ o :=
ciSup_const
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lsub_const | null |
lsub_unique {ι} [Unique ι] (f : ι → Ordinal) : lsub f = succ (f default) :=
ciSup_unique | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lsub_unique | null |
lsub_le_of_range_subset {ι ι'} {f : ι → Ordinal} {g : ι' → Ordinal}
(h : Set.range f ⊆ Set.range g) : lsub.{u, max v w} f ≤ lsub.{v, max u w} g :=
csSup_le_csSup' (bddAbove_range.{v, max u w} _)
(by convert Set.image_mono h <;> apply Set.range_comp) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lsub_le_of_range_subset | null |
lsub_eq_of_range_eq {ι ι'} {f : ι → Ordinal} {g : ι' → Ordinal}
(h : Set.range f = Set.range g) : lsub.{u, max v w} f = lsub.{v, max u w} g :=
(lsub_le_of_range_subset.{u, v, w} h.le).antisymm (lsub_le_of_range_subset.{v, u, w} h.ge)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lsub_eq_of_range_eq | null |
lsub_sum {α : Type u} {β : Type v} (f : α ⊕ β → Ordinal) :
lsub.{max u v, w} f =
max (lsub.{u, max v w} fun a => f (Sum.inl a)) (lsub.{v, max u w} fun b => f (Sum.inr b)) :=
iSup_sum _ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lsub_sum | null |
lsub_notMem_range {ι} (f : ι → Ordinal) :
lsub f ∉ Set.range f := fun ⟨i, h⟩ =>
h.not_lt (lt_lsub f i)
@[deprecated (since := "2025-05-23")] alias lsub_not_mem_range := lsub_notMem_range | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lsub_notMem_range | null |
nonempty_compl_range {ι : Type u} (f : ι → Ordinal.{max u v}) : (Set.range f)ᶜ.Nonempty :=
⟨_, lsub_notMem_range f⟩
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | nonempty_compl_range | null |
lsub_typein (o : Ordinal) : lsub.{u, u} (typein (α := o.toType) (· < ·)) = o :=
(lsub_le.{u, u} typein_lt_self).antisymm
(by
by_contra! h
have h := h.trans_eq (type_toType o).symm
simpa [typein_enum] using lt_lsub.{u, u} (typein (· < ·)) (enum (· < ·) ⟨_, h⟩)) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.Arithmetic"
] | Mathlib/SetTheory/Ordinal/Family.lean | lsub_typein | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.