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 ⌀ |
|---|---|---|---|---|---|---|
three_le {α : Type*} (h : 3 ≤ #α) (x : α) (y : α) : ∃ z : α, z ≠ x ∧ z ≠ y := by
have : ↑(3 : ℕ) ≤ #α := by simpa using h
have : ↑(2 : ℕ) < #α := by rwa [← succ_le_iff, ← Cardinal.nat_succ]
have := exists_notMem_of_length_lt [x, y] this
simpa [not_or] using this
/-! ### `powerlt` operation -/ | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | three_le | null |
powerlt (a b : Cardinal.{u}) : Cardinal.{u} :=
⨆ c : Iio b, a ^ (c : Cardinal)
@[inherit_doc]
infixl:80 " ^< " => powerlt | def | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | powerlt | The function `a ^< b`, defined as the supremum of `a ^ c` for `c < b`. |
le_powerlt {b c : Cardinal.{u}} (a) (h : c < b) : (a^c) ≤ a ^< b := by
refine le_ciSup (f := fun y : Iio b => a ^ (y : Cardinal)) ?_ ⟨c, h⟩
rw [← image_eq_range]
exact bddAbove_image.{u, u} _ bddAbove_Iio | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | le_powerlt | null |
powerlt_le {a b c : Cardinal.{u}} : a ^< b ≤ c ↔ ∀ x < b, a ^ x ≤ c := by
rw [powerlt, ciSup_le_iff']
· simp
· rw [← image_eq_range]
exact bddAbove_image.{u, u} _ bddAbove_Iio | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | powerlt_le | null |
powerlt_le_powerlt_left {a b c : Cardinal} (h : b ≤ c) : a ^< b ≤ a ^< c :=
powerlt_le.2 fun _ hx => le_powerlt a <| hx.trans_le h | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | powerlt_le_powerlt_left | null |
powerlt_mono_left (a) : Monotone fun c => a ^< c := fun _ _ => powerlt_le_powerlt_left | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | powerlt_mono_left | null |
powerlt_succ {a b : Cardinal} (h : a ≠ 0) : a ^< succ b = a ^ b :=
(powerlt_le.2 fun _ h' => power_le_power_left h <| le_of_lt_succ h').antisymm <|
le_powerlt a (lt_succ b) | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | powerlt_succ | null |
powerlt_min {a b c : Cardinal} : a ^< min b c = min (a ^< b) (a ^< c) :=
(powerlt_mono_left a).map_min | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | powerlt_min | null |
powerlt_max {a b c : Cardinal} : a ^< max b c = max (a ^< b) (a ^< c) :=
(powerlt_mono_left a).map_max | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | powerlt_max | null |
zero_powerlt {a : Cardinal} (h : a ≠ 0) : 0 ^< a = 1 := by
apply (powerlt_le.2 fun c _ => zero_power_le _).antisymm
rw [← power_zero]
exact le_powerlt 0 (pos_iff_ne_zero.2 h)
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | zero_powerlt | null |
powerlt_zero {a : Cardinal} : a ^< 0 = 0 := by
convert Cardinal.iSup_of_empty _
exact Subtype.isEmpty_of_false fun x => mem_Iio.not.mpr (Cardinal.zero_le x).not_gt | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | powerlt_zero | null |
cof (r : α → α → Prop) : Cardinal :=
sInf { c | ∃ S : Set α, (∀ a, ∃ b ∈ S, r a b) ∧ #S = c } | def | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof | Cofinality of a reflexive order `≼`. This is the smallest cardinality
of a subset `S : Set α` such that `∀ a, ∃ b ∈ S, a ≼ b`. |
private cof_nonempty (r : α → α → Prop) [IsRefl α r] :
{ c | ∃ S : Set α, (∀ a, ∃ b ∈ S, r a b) ∧ #S = c }.Nonempty :=
⟨_, Set.univ, fun a => ⟨a, ⟨⟩, refl _⟩, rfl⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_nonempty | The set in the definition of `Order.cof` is nonempty. |
cof_le (r : α → α → Prop) {S : Set α} (h : ∀ a, ∃ b ∈ S, r a b) : cof r ≤ #S :=
csInf_le' ⟨S, h, rfl⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_le | null |
le_cof [IsRefl α r] (c : Cardinal) :
c ≤ cof r ↔ ∀ {S : Set α}, (∀ a, ∃ b ∈ S, r a b) → c ≤ #S := by
rw [cof, le_csInf_iff'' (cof_nonempty r)]
use fun H S h => H _ ⟨S, h, rfl⟩
rintro H d ⟨S, h, rfl⟩
exact H h | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | le_cof | null |
private cof_le_lift [IsRefl β s] (f : r ≃r s) :
Cardinal.lift.{v} (Order.cof r) ≤ Cardinal.lift.{u} (Order.cof s) := by
rw [Order.cof, Order.cof, lift_sInf, lift_sInf, le_csInf_iff'' ((Order.cof_nonempty s).image _)]
rintro - ⟨-, ⟨u, H, rfl⟩, rfl⟩
apply csInf_le'
refine ⟨_, ⟨f.symm '' u, fun a => ?_, rfl⟩, lift_mk_eq'.2 ⟨(f.symm.toEquiv.image u).symm⟩⟩
rcases H (f a) with ⟨b, hb, hb'⟩
refine ⟨f.symm b, mem_image_of_mem _ hb, f.map_rel_iff.1 ?_⟩
rwa [RelIso.apply_symm_apply] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_le_lift | null |
cof_eq_lift [IsRefl β s] (f : r ≃r s) :
Cardinal.lift.{v} (Order.cof r) = Cardinal.lift.{u} (Order.cof s) :=
have := f.toRelEmbedding.isRefl
(f.cof_le_lift).antisymm (f.symm.cof_le_lift) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_eq_lift | null |
cof_eq {α β : Type u} {r : α → α → Prop} {s} [IsRefl β s] (f : r ≃r s) :
Order.cof r = Order.cof s :=
lift_inj.1 (f.cof_eq_lift) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_eq | null |
cof (o : Ordinal.{u}) : Cardinal.{u} :=
o.liftOn (fun a ↦ Order.cof (swap a.rᶜ)) fun _ _ ⟨f⟩ ↦ f.compl.swap.cof_eq | def | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof | Cofinality of an ordinal. This is the smallest cardinal of a subset `S` of the ordinal which is
unbounded, in the sense `∀ a, ∃ b ∈ S, a ≤ b`.
In particular, `cof 0 = 0` and `cof (succ o) = 1`. |
cof_type (r : α → α → Prop) [IsWellOrder α r] : (type r).cof = Order.cof (swap rᶜ) :=
rfl | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_type | null |
cof_type_lt [LinearOrder α] [IsWellOrder α (· < ·)] :
(@type α (· < ·) _).cof = @Order.cof α (· ≤ ·) := by
rw [cof_type, compl_lt, swap_ge] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_type_lt | null |
cof_eq_cof_toType (o : Ordinal) : o.cof = @Order.cof o.toType (· ≤ ·) := by
conv_lhs => rw [← type_toType o, cof_type_lt] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_eq_cof_toType | null |
le_cof_type [IsWellOrder α r] {c} : c ≤ cof (type r) ↔ ∀ S, Unbounded r S → c ≤ #S :=
(le_csInf_iff'' (Order.cof_nonempty _)).trans
⟨fun H S h => H _ ⟨S, h, rfl⟩, by
rintro H d ⟨S, h, rfl⟩
exact H _ h⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | le_cof_type | null |
cof_type_le [IsWellOrder α r] {S : Set α} (h : Unbounded r S) : cof (type r) ≤ #S :=
le_cof_type.1 le_rfl S h | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_type_le | null |
lt_cof_type [IsWellOrder α r] {S : Set α} : #S < cof (type r) → Bounded r S := by
simpa using not_imp_not.2 cof_type_le | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | lt_cof_type | null |
cof_eq (r : α → α → Prop) [IsWellOrder α r] : ∃ S, Unbounded r S ∧ #S = cof (type r) :=
csInf_mem (Order.cof_nonempty (swap rᶜ)) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_eq | null |
ord_cof_eq (r : α → α → Prop) [IsWellOrder α r] :
∃ S, Unbounded r S ∧ type (Subrel r (· ∈ S)) = (cof (type r)).ord := by
let ⟨S, hS, e⟩ := cof_eq r
let ⟨s, _, e'⟩ := Cardinal.ord_eq S
let T : Set α := { a | ∃ aS : a ∈ S, ∀ b : S, s b ⟨_, aS⟩ → r b a }
suffices Unbounded r T by
refine ⟨T, this, le_antisymm ?_ (Cardinal.ord_le.2 <| cof_type_le this)⟩
rw [← e, e']
refine
(RelEmbedding.ofMonotone
(fun a : T =>
(⟨a,
let ⟨aS, _⟩ := a.2
aS⟩ :
S))
fun a b h => ?_).ordinal_type_le
rcases a with ⟨a, aS, ha⟩
rcases b with ⟨b, bS, hb⟩
change s ⟨a, _⟩ ⟨b, _⟩
refine ((trichotomous_of s _ _).resolve_left fun hn => ?_).resolve_left ?_
· exact asymm h (ha _ hn)
· intro e
injection e with e
subst b
exact irrefl _ h
intro a
have : { b : S | ¬r b a }.Nonempty :=
let ⟨b, bS, ba⟩ := hS a
⟨⟨b, bS⟩, ba⟩
let b := (IsWellFounded.wf : WellFounded s).min _ this
have ba : ¬r b a := IsWellFounded.wf.min_mem _ this
refine ⟨b, ⟨b.2, fun c => not_imp_not.1 fun h => ?_⟩, ba⟩
rw [show ∀ b : S, (⟨b, b.2⟩ : S) = b by intro b; cases b; rfl]
exact IsWellFounded.wf.not_lt_min _ this (IsOrderConnected.neg_trans h ba)
/-! ### Cofinality of suprema and least strict upper bounds -/ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | ord_cof_eq | null |
private card_mem_cof {o} : ∃ (ι : _) (f : ι → Ordinal), lsub.{u, u} f = o ∧ #ι = o.card :=
⟨_, _, lsub_typein o, mk_toType o⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | card_mem_cof | null |
cof_lsub_def_nonempty (o) :
{ a : Cardinal | ∃ (ι : _) (f : ι → Ordinal), lsub.{u, u} f = o ∧ #ι = a }.Nonempty :=
⟨_, card_mem_cof⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_lsub_def_nonempty | The set in the `lsub` characterization of `cof` is nonempty. |
cof_eq_sInf_lsub (o : Ordinal.{u}) : cof o =
sInf { a : Cardinal | ∃ (ι : Type u) (f : ι → Ordinal), lsub.{u, u} f = o ∧ #ι = a } := by
refine le_antisymm (le_csInf (cof_lsub_def_nonempty o) ?_) (csInf_le' ?_)
· rintro a ⟨ι, f, hf, rfl⟩
rw [← type_toType o]
refine
(cof_type_le fun a => ?_).trans
(@mk_le_of_injective _ _
(fun s : typein ((· < ·) : o.toType → o.toType → Prop) ⁻¹' Set.range f =>
Classical.choose s.prop)
fun s t hst => by
let H := congr_arg f hst
rwa [Classical.choose_spec s.prop, Classical.choose_spec t.prop, typein_inj,
Subtype.coe_inj] at H)
have := typein_lt_self a
simp_rw [← hf, lt_lsub_iff] at this
obtain ⟨i, hi⟩ := this
refine ⟨enum (α := o.toType) (· < ·) ⟨f i, ?_⟩, ?_, ?_⟩
· rw [type_toType, ← hf]
apply lt_lsub
· rw [mem_preimage, typein_enum]
exact mem_range_self i
· rwa [← typein_le_typein, typein_enum]
· rcases cof_eq (α := o.toType) (· < ·) with ⟨S, hS, hS'⟩
let f : S → Ordinal := fun s => typein LT.lt s.val
refine ⟨S, f, le_antisymm (lsub_le fun i => typein_lt_self (o := o) i)
(le_of_forall_lt fun a ha => ?_), by rwa [type_toType o] at hS'⟩
rw [← type_toType o] at ha
rcases hS (enum (· < ·) ⟨a, ha⟩) with ⟨b, hb, hb'⟩
rw [← typein_le_typein, typein_enum] at hb'
exact hb'.trans_lt (lt_lsub.{u, u} f ⟨b, hb⟩)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_eq_sInf_lsub | null |
lift_cof (o) : Cardinal.lift.{u, v} (cof o) = cof (Ordinal.lift.{u, v} o) := by
refine inductionOn o fun α r _ ↦ ?_
rw [← type_uLift, cof_type, cof_type, ← Cardinal.lift_id'.{v, u} (Order.cof _),
← Cardinal.lift_umax]
apply RelIso.cof_eq_lift ⟨Equiv.ulift.symm, _⟩
simp [swap] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | lift_cof | null |
cof_le_card (o) : cof o ≤ card o := by
rw [cof_eq_sInf_lsub]
exact csInf_le' card_mem_cof | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_le_card | null |
cof_ord_le (c : Cardinal) : c.ord.cof ≤ c := by simpa using cof_le_card c.ord | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_ord_le | null |
ord_cof_le (o : Ordinal.{u}) : o.cof.ord ≤ o :=
(ord_le_ord.2 (cof_le_card o)).trans (ord_card_le o) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | ord_cof_le | null |
exists_lsub_cof (o : Ordinal) :
∃ (ι : _) (f : ι → Ordinal), lsub.{u, u} f = o ∧ #ι = cof o := by
rw [cof_eq_sInf_lsub]
exact csInf_mem (cof_lsub_def_nonempty o) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | exists_lsub_cof | null |
cof_lsub_le {ι} (f : ι → Ordinal) : cof (lsub.{u, u} f) ≤ #ι := by
rw [cof_eq_sInf_lsub]
exact csInf_le' ⟨ι, f, rfl, rfl⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_lsub_le | null |
cof_lsub_le_lift {ι} (f : ι → Ordinal) :
cof (lsub.{u, v} f) ≤ Cardinal.lift.{v, u} #ι := by
rw [← mk_uLift.{u, v}]
convert cof_lsub_le.{max u v} fun i : ULift.{v, u} ι => f i.down
exact
lsub_eq_of_range_eq.{u, max u v, max u v}
(Set.ext fun x => ⟨fun ⟨i, hi⟩ => ⟨ULift.up.{v, u} i, hi⟩, fun ⟨i, hi⟩ => ⟨_, hi⟩⟩) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_lsub_le_lift | null |
le_cof_iff_lsub {o : Ordinal} {a : Cardinal} :
a ≤ cof o ↔ ∀ {ι} (f : ι → Ordinal), lsub.{u, u} f = o → a ≤ #ι := by
rw [cof_eq_sInf_lsub]
exact
(le_csInf_iff'' (cof_lsub_def_nonempty o)).trans
⟨fun H ι f hf => H _ ⟨ι, f, hf, rfl⟩, fun H b ⟨ι, f, hf, hb⟩ => by
rw [← hb]
exact H _ hf⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | le_cof_iff_lsub | null |
lsub_lt_ord_lift {ι} {f : ι → Ordinal} {c : Ordinal}
(hι : Cardinal.lift.{v, u} #ι < c.cof)
(hf : ∀ i, f i < c) : lsub.{u, v} f < c :=
lt_of_le_of_ne (lsub_le hf) fun h => by
subst h
exact (cof_lsub_le_lift.{u, v} f).not_gt hι | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | lsub_lt_ord_lift | null |
lsub_lt_ord {ι} {f : ι → Ordinal} {c : Ordinal} (hι : #ι < c.cof) :
(∀ i, f i < c) → lsub.{u, u} f < c :=
lsub_lt_ord_lift (by rwa [(#ι).lift_id]) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | lsub_lt_ord | null |
cof_iSup_le_lift {ι} {f : ι → Ordinal} (H : ∀ i, f i < iSup f) :
cof (iSup f) ≤ Cardinal.lift.{v, u} #ι := by
rw [← iSup_eq_lsub_iff_lt_iSup] at H
rw [H]
exact cof_lsub_le_lift f | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_iSup_le_lift | null |
cof_iSup_le {ι} {f : ι → Ordinal} (H : ∀ i, f i < iSup f) :
cof (iSup f) ≤ #ι := by
rw [← (#ι).lift_id]
exact cof_iSup_le_lift H | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_iSup_le | null |
iSup_lt_ord_lift {ι} {f : ι → Ordinal} {c : Ordinal} (hι : Cardinal.lift.{v, u} #ι < c.cof)
(hf : ∀ i, f i < c) : iSup f < c :=
(iSup_le_lsub f).trans_lt (lsub_lt_ord_lift hι hf) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | iSup_lt_ord_lift | null |
iSup_lt_ord {ι} {f : ι → Ordinal} {c : Ordinal} (hι : #ι < c.cof) :
(∀ i, f i < c) → iSup f < c :=
iSup_lt_ord_lift (by rwa [(#ι).lift_id]) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | iSup_lt_ord | null |
iSup_lt_lift {ι} {f : ι → Cardinal} {c : Cardinal}
(hι : Cardinal.lift.{v, u} #ι < c.ord.cof)
(hf : ∀ i, f i < c) : iSup f < c := by
rw [← ord_lt_ord, iSup_ord]
refine iSup_lt_ord_lift hι fun i => ?_
rw [ord_lt_ord]
apply hf | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | iSup_lt_lift | null |
iSup_lt {ι} {f : ι → Cardinal} {c : Cardinal} (hι : #ι < c.ord.cof) :
(∀ i, f i < c) → iSup f < c :=
iSup_lt_lift (by rwa [(#ι).lift_id]) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | iSup_lt | null |
nfpFamily_lt_ord_lift {ι} {f : ι → Ordinal → Ordinal} {c} (hc : ℵ₀ < cof c)
(hc' : Cardinal.lift.{v, u} #ι < cof c) (hf : ∀ (i), ∀ b < c, f i b < c) {a} (ha : a < c) :
nfpFamily f a < c := by
refine iSup_lt_ord_lift ((Cardinal.lift_le.2 (mk_list_le_max ι)).trans_lt ?_) fun l => ?_
· rw [lift_max]
apply max_lt _ hc'
rwa [Cardinal.lift_aleph0]
· induction l with
| nil => exact ha
| cons i l H => exact hf _ _ H | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | nfpFamily_lt_ord_lift | null |
nfpFamily_lt_ord {ι} {f : ι → Ordinal → Ordinal} {c} (hc : ℵ₀ < cof c) (hc' : #ι < cof c)
(hf : ∀ (i), ∀ b < c, f i b < c) {a} : a < c → nfpFamily.{u, u} f a < c :=
nfpFamily_lt_ord_lift hc (by rwa [(#ι).lift_id]) hf | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | nfpFamily_lt_ord | null |
nfp_lt_ord {f : Ordinal → Ordinal} {c} (hc : ℵ₀ < cof c) (hf : ∀ i < c, f i < c) {a} :
a < c → nfp f a < c :=
nfpFamily_lt_ord_lift hc (by simpa using Cardinal.one_lt_aleph0.trans hc) fun _ => hf | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | nfp_lt_ord | null |
exists_blsub_cof (o : Ordinal) :
∃ f : ∀ a < (cof o).ord, Ordinal, blsub.{u, u} _ f = o := by
rcases exists_lsub_cof o with ⟨ι, f, hf, hι⟩
rcases Cardinal.ord_eq ι with ⟨r, hr, hι'⟩
rw [← @blsub_eq_lsub' ι r hr] at hf
rw [← hι, hι']
exact ⟨_, hf⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | exists_blsub_cof | null |
le_cof_iff_blsub {b : Ordinal} {a : Cardinal} :
a ≤ cof b ↔ ∀ {o} (f : ∀ a < o, Ordinal), blsub.{u, u} o f = b → a ≤ o.card :=
le_cof_iff_lsub.trans
⟨fun H o f hf => by simpa using H _ hf, fun H ι f hf => by
rcases Cardinal.ord_eq ι with ⟨r, hr, hι'⟩
rw [← @blsub_eq_lsub' ι r hr] at hf
simpa using H _ hf⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | le_cof_iff_blsub | null |
cof_blsub_le_lift {o} (f : ∀ a < o, Ordinal) :
cof (blsub.{u, v} o f) ≤ Cardinal.lift.{v, u} o.card := by
rw [← mk_toType o]
exact cof_lsub_le_lift _ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_blsub_le_lift | null |
cof_blsub_le {o} (f : ∀ a < o, Ordinal) : cof (blsub.{u, u} o f) ≤ o.card := by
rw [← o.card.lift_id]
exact cof_blsub_le_lift f | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_blsub_le | null |
blsub_lt_ord_lift {o : Ordinal.{u}} {f : ∀ a < o, Ordinal} {c : Ordinal}
(ho : Cardinal.lift.{v, u} o.card < c.cof) (hf : ∀ i hi, f i hi < c) : blsub.{u, v} o f < c :=
lt_of_le_of_ne (blsub_le hf) fun h =>
ho.not_ge (by simpa [← iSup_ord, hf, h] using cof_blsub_le_lift.{u, v} f) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | blsub_lt_ord_lift | null |
blsub_lt_ord {o : Ordinal} {f : ∀ a < o, Ordinal} {c : Ordinal} (ho : o.card < c.cof)
(hf : ∀ i hi, f i hi < c) : blsub.{u, u} o f < c :=
blsub_lt_ord_lift (by rwa [o.card.lift_id]) hf | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | blsub_lt_ord | null |
cof_bsup_le_lift {o : Ordinal} {f : ∀ a < o, Ordinal} (H : ∀ i h, f i h < bsup.{u, v} o f) :
cof (bsup.{u, v} o f) ≤ Cardinal.lift.{v, u} o.card := by
rw [← bsup_eq_blsub_iff_lt_bsup.{u, v}] at H
rw [H]
exact cof_blsub_le_lift.{u, v} f | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_bsup_le_lift | null |
cof_bsup_le {o : Ordinal} {f : ∀ a < o, Ordinal} :
(∀ i h, f i h < bsup.{u, u} o f) → cof (bsup.{u, u} o f) ≤ o.card := by
rw [← o.card.lift_id]
exact cof_bsup_le_lift | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_bsup_le | null |
bsup_lt_ord_lift {o : Ordinal} {f : ∀ a < o, Ordinal} {c : Ordinal}
(ho : Cardinal.lift.{v, u} o.card < c.cof) (hf : ∀ i hi, f i hi < c) : bsup.{u, v} o f < c :=
(bsup_le_blsub f).trans_lt (blsub_lt_ord_lift ho hf) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | bsup_lt_ord_lift | null |
bsup_lt_ord {o : Ordinal} {f : ∀ a < o, Ordinal} {c : Ordinal} (ho : o.card < c.cof) :
(∀ i hi, f i hi < c) → bsup.{u, u} o f < c :=
bsup_lt_ord_lift (by rwa [o.card.lift_id])
/-! ### Basic results -/
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | bsup_lt_ord | null |
cof_zero : cof 0 = 0 := by
refine LE.le.antisymm ?_ (Cardinal.zero_le _)
rw [← card_zero]
exact cof_le_card 0
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_zero | null |
cof_eq_zero {o} : cof o = 0 ↔ o = 0 :=
⟨inductionOn o fun _ r _ z =>
let ⟨_, hl, e⟩ := cof_eq r
type_eq_zero_iff_isEmpty.2 <|
⟨fun a =>
let ⟨_, h, _⟩ := hl a
(mk_eq_zero_iff.1 (e.trans z)).elim' ⟨_, h⟩⟩,
fun e => by simp [e]⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_eq_zero | null |
cof_ne_zero {o} : cof o ≠ 0 ↔ o ≠ 0 :=
cof_eq_zero.not
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_ne_zero | null |
cof_succ (o) : cof (succ o) = 1 := by
apply le_antisymm
· refine inductionOn o fun α r _ => ?_
change cof (type _) ≤ _
rw [← (_ : #_ = 1)]
· apply cof_type_le
refine fun a => ⟨Sum.inr PUnit.unit, Set.mem_singleton _, ?_⟩
rcases a with (a | ⟨⟨⟨⟩⟩⟩) <;> simp [EmptyRelation]
· simp
· rw [← Cardinal.succ_zero, succ_le_iff]
simpa [lt_iff_le_and_ne, Cardinal.zero_le] using fun h =>
succ_ne_zero o (cof_eq_zero.1 (Eq.symm h))
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_succ | null |
cof_eq_one_iff_is_succ {o} : cof.{u} o = 1 ↔ ∃ a, o = succ a :=
⟨inductionOn o fun α r _ z => by
rcases cof_eq r with ⟨S, hl, e⟩; rw [z] at e
obtain ⟨a⟩ := mk_ne_zero_iff.1 (by rw [e]; exact one_ne_zero)
refine
⟨typein r a,
Eq.symm <|
Quotient.sound
⟨RelIso.ofSurjective (RelEmbedding.ofMonotone ?_ fun x y => ?_) fun x => ?_⟩⟩
· apply Sum.rec <;> [exact Subtype.val; exact fun _ => a]
· rcases x with (x | ⟨⟨⟨⟩⟩⟩) <;> rcases y with (y | ⟨⟨⟨⟩⟩⟩) <;>
simp [Subrel, Order.Preimage, EmptyRelation]
exact x.2
· suffices r x a ∨ ∃ _ : PUnit.{u}, ↑a = x by
convert this
dsimp [RelEmbedding.ofMonotone]; simp
rcases trichotomous_of r x a with (h | h | h)
· exact Or.inl h
· exact Or.inr ⟨PUnit.unit, h.symm⟩
· rcases hl x with ⟨a', aS, hn⟩
refine absurd h ?_
convert hn
change (a : α) = ↑(⟨a', aS⟩ : S)
have := le_one_iff_subsingleton.1 (le_of_eq e)
congr!,
fun ⟨a, e⟩ => by simp [e]⟩
/-! ### Fundamental sequences -/ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_eq_one_iff_is_succ | null |
IsFundamentalSequence (a o : Ordinal.{u}) (f : ∀ b < o, Ordinal.{u}) : Prop :=
o ≤ a.cof.ord ∧ (∀ {i j} (hi hj), i < j → f i hi < f j hj) ∧ blsub.{u, u} o f = a | def | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | IsFundamentalSequence | A fundamental sequence for `a` is an increasing sequence of length `o = cof a` that converges at
`a`. We provide `o` explicitly in order to avoid type rewrites. |
protected cof_eq (hf : IsFundamentalSequence a o f) : a.cof.ord = o :=
hf.1.antisymm' <| by
rw [← hf.2.2]
exact (ord_le_ord.2 (cof_blsub_le f)).trans (ord_card_le o) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_eq | null |
protected strict_mono (hf : IsFundamentalSequence a o f) {i j} :
∀ hi hj, i < j → f i hi < f j hj :=
hf.2.1 | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | strict_mono | null |
blsub_eq (hf : IsFundamentalSequence a o f) : blsub.{u, u} o f = a :=
hf.2.2 | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | blsub_eq | null |
ord_cof (hf : IsFundamentalSequence a o f) :
IsFundamentalSequence a a.cof.ord fun i hi => f i (hi.trans_le (by rw [hf.cof_eq])) := by
have H := hf.cof_eq
subst H
exact hf | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | ord_cof | null |
id_of_le_cof (h : o ≤ o.cof.ord) : IsFundamentalSequence o o fun a _ => a :=
⟨h, @fun _ _ _ _ => id, blsub_id o⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | id_of_le_cof | null |
protected zero {f : ∀ b < (0 : Ordinal), Ordinal} : IsFundamentalSequence 0 0 f :=
⟨by rw [cof_zero, ord_zero], @fun i _ hi => (Ordinal.not_lt_zero i hi).elim, blsub_zero f⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | zero | null |
protected succ : IsFundamentalSequence (succ o) 1 fun _ _ => o := by
refine ⟨?_, @fun i j hi hj h => ?_, blsub_const Ordinal.one_ne_zero o⟩
· rw [cof_succ, ord_one]
· rw [lt_one_iff_zero] at hi hj
rw [hi, hj] at h
exact h.false.elim | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | succ | null |
protected monotone (hf : IsFundamentalSequence a o f) {i j : Ordinal} (hi : i < o)
(hj : j < o) (hij : i ≤ j) : f i hi ≤ f j hj := by
rcases lt_or_eq_of_le hij with (hij | rfl)
· exact (hf.2.1 hi hj hij).le
· rfl | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | monotone | null |
trans {a o o' : Ordinal.{u}} {f : ∀ b < o, Ordinal.{u}} (hf : IsFundamentalSequence a o f)
{g : ∀ b < o', Ordinal.{u}} (hg : IsFundamentalSequence o o' g) :
IsFundamentalSequence a o' fun i hi =>
f (g i hi) (by rw [← hg.2.2]; apply lt_blsub) := by
refine ⟨?_, @fun i j _ _ h => hf.2.1 _ _ (hg.2.1 _ _ h), ?_⟩
· rw [hf.cof_eq]
exact hg.1.trans (ord_cof_le o)
· rw [@blsub_comp.{u, u, u} o _ f (@IsFundamentalSequence.monotone _ _ f hf)]
· exact hf.2.2
· exact hg.2.2 | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | trans | null |
protected lt {a o : Ordinal} {s : Π p < o, Ordinal}
(h : IsFundamentalSequence a o s) {p : Ordinal} (hp : p < o) : s p hp < a :=
h.blsub_eq ▸ lt_blsub s p hp | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | lt | null |
exists_fundamental_sequence (a : Ordinal.{u}) :
∃ f, IsFundamentalSequence a a.cof.ord f := by
suffices h : ∃ o f, IsFundamentalSequence a o f by
rcases h with ⟨o, f, hf⟩
exact ⟨_, hf.ord_cof⟩
rcases exists_lsub_cof a with ⟨ι, f, hf, hι⟩
rcases ord_eq ι with ⟨r, wo, hr⟩
let r' := Subrel r fun i ↦ ∀ j, r j i → f j < f i
let hrr' : r' ↪r r := Subrel.relEmbedding _ _
haveI := hrr'.isWellOrder
refine
⟨_, _, hrr'.ordinal_type_le.trans ?_, @fun i j _ h _ => (enum r' ⟨j, h⟩).prop _ ?_,
le_antisymm (blsub_le fun i hi => lsub_le_iff.1 hf.le _) ?_⟩
· rw [← hι, hr]
· change r (hrr'.1 _) (hrr'.1 _)
rwa [hrr'.2, @enum_lt_enum _ r']
· rw [← hf, lsub_le_iff]
intro i
suffices h : ∃ i' hi', f i ≤ bfamilyOfFamily' r' (fun i => f i) i' hi' by
rcases h with ⟨i', hi', hfg⟩
exact hfg.trans_lt (lt_blsub _ _ _)
by_cases h : ∀ j, r j i → f j < f i
· refine ⟨typein r' ⟨i, h⟩, typein_lt_type _ _, ?_⟩
rw [bfamilyOfFamily'_typein]
· push_neg at h
obtain ⟨hji, hij⟩ := wo.wf.min_mem _ h
refine ⟨typein r' ⟨_, fun k hkj => lt_of_lt_of_le ?_ hij⟩, typein_lt_type _ _, ?_⟩
· by_contra! H
exact (wo.wf.not_lt_min _ h ⟨IsTrans.trans _ _ _ hkj hji, H⟩) hkj
· rwa [bfamilyOfFamily'_typein]
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | exists_fundamental_sequence | Every ordinal has a fundamental sequence. |
cof_cof (a : Ordinal.{u}) : cof (cof a).ord = cof a := by
obtain ⟨f, hf⟩ := exists_fundamental_sequence a
obtain ⟨g, hg⟩ := exists_fundamental_sequence a.cof.ord
exact ord_injective (hf.trans hg).cof_eq.symm | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_cof | null |
protected IsNormal.isFundamentalSequence {f : Ordinal.{u} → Ordinal.{u}} (hf : IsNormal f)
{a o} (ha : IsSuccLimit a) {g} (hg : IsFundamentalSequence a o g) :
IsFundamentalSequence (f a) o fun b hb => f (g b hb) := by
refine ⟨?_, @fun i j _ _ h => hf.strictMono (hg.2.1 _ _ h), ?_⟩
· rcases exists_lsub_cof (f a) with ⟨ι, f', hf', hι⟩
rw [← hg.cof_eq, ord_le_ord, ← hι]
suffices (lsub.{u, u} fun i => sInf { b : Ordinal | f' i ≤ f b }) = a by
rw [← this]
apply cof_lsub_le
have H : ∀ i, ∃ b < a, f' i ≤ f b := fun i => by
have := lt_lsub.{u, u} f' i
rw [hf', ← IsNormal.blsub_eq.{u, u} hf ha, lt_blsub_iff] at this
simpa using this
refine (lsub_le fun i => ?_).antisymm (le_of_forall_lt fun b hb => ?_)
· rcases H i with ⟨b, hb, hb'⟩
exact lt_of_le_of_lt (csInf_le' hb') hb
· have := hf.strictMono hb
rw [← hf', lt_lsub_iff] at this
obtain ⟨i, hi⟩ := this
rcases H i with ⟨b, _, hb⟩
exact
((le_csInf_iff'' ⟨b, by exact hb⟩).2 fun c hc =>
hf.strictMono.le_iff_le.1 (hi.trans hc)).trans_lt (lt_lsub _ i)
· rw [@blsub_comp.{u, u, u} a _ (fun b _ => f b) (@fun i j _ _ h => hf.strictMono.monotone h) g
hg.2.2]
exact IsNormal.blsub_eq.{u, u} hf ha | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | IsNormal.isFundamentalSequence | null |
IsNormal.cof_eq {f} (hf : IsNormal f) {a} (ha : IsSuccLimit a) : cof (f a) = cof a :=
let ⟨_, hg⟩ := exists_fundamental_sequence a
ord_injective (hf.isFundamentalSequence ha hg).cof_eq | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | IsNormal.cof_eq | null |
IsNormal.cof_le {f} (hf : IsNormal f) (a) : cof a ≤ cof (f a) := by
rcases zero_or_succ_or_isSuccLimit a with (rfl | ⟨b, rfl⟩ | ha)
· rw [cof_zero]
exact zero_le _
· rw [cof_succ, Cardinal.one_le_iff_ne_zero, cof_ne_zero, ← Ordinal.pos_iff_ne_zero]
exact (Ordinal.zero_le (f b)).trans_lt (hf.strictMono (lt_succ b))
· rw [hf.cof_eq ha]
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | IsNormal.cof_le | null |
cof_add (a b : Ordinal) : b ≠ 0 → cof (a + b) = cof b := fun h => by
rcases zero_or_succ_or_isSuccLimit b with (rfl | ⟨c, rfl⟩ | hb)
· contradiction
· rw [add_succ, cof_succ, cof_succ]
· exact (isNormal_add_right a).cof_eq hb | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_add | null |
aleph0_le_cof {o} : ℵ₀ ≤ cof o ↔ IsSuccLimit o := by
rcases zero_or_succ_or_isSuccLimit o with (rfl | ⟨o, rfl⟩ | l)
· simp [Cardinal.aleph0_ne_zero]
· simp [Cardinal.one_lt_aleph0]
· simp only [l, iff_true]
refine le_of_not_gt fun h => ?_
obtain ⟨n, e⟩ := Cardinal.lt_aleph0.1 h
have := cof_cof o
rw [e, ord_nat] at this
cases n
· apply l.ne_bot
simpa using e
· rw [natCast_succ, cof_succ] at this
rw [← this, cof_eq_one_iff_is_succ] at e
rcases e with ⟨a, rfl⟩
exact not_isSuccLimit_succ _ l
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | aleph0_le_cof | null |
cof_preOmega {o : Ordinal} (ho : IsSuccPrelimit o) : (preOmega o).cof = o.cof := by
by_cases h : IsMin o
· simp [h.eq_bot]
· exact isNormal_preOmega.cof_eq ⟨h, ho⟩
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_preOmega | null |
cof_omega {o : Ordinal} (ho : IsSuccLimit o) : (ω_ o).cof = o.cof :=
isNormal_omega.cof_eq ho
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_omega | null |
cof_omega0 : cof ω = ℵ₀ :=
(aleph0_le_cof.2 isSuccLimit_omega0).antisymm' <| by
rw [← card_omega0]
apply cof_le_card | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_omega0 | null |
cof_eq' (r : α → α → Prop) [IsWellOrder α r] (h : IsSuccLimit (type r)) :
∃ S : Set α, (∀ a, ∃ b ∈ S, r a b) ∧ #S = cof (type r) :=
let ⟨S, H, e⟩ := cof_eq r
⟨S, fun a =>
let a' := enum r ⟨_, h.succ_lt (typein_lt_type r a)⟩
let ⟨b, h, ab⟩ := H a'
⟨b, h,
(IsOrderConnected.conn a b a' <|
(typein_lt_typein r).1
(by
rw [typein_enum]
exact lt_succ (typein _ _))).resolve_right
ab⟩,
e⟩
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_eq' | null |
cof_univ : cof univ.{u, v} = Cardinal.univ.{u, v} :=
le_antisymm (cof_le_card _)
(by
refine le_of_forall_lt fun c h => ?_
rcases lt_univ'.1 h with ⟨c, rfl⟩
rcases @cof_eq Ordinal.{u} (· < ·) _ with ⟨S, H, Se⟩
rw [univ, ← lift_cof, ← Cardinal.lift_lift.{u+1, v, u}, Cardinal.lift_lt, ← Se]
refine lt_of_not_ge fun h => ?_
obtain ⟨a, e⟩ := Cardinal.mem_range_lift_of_le h
refine Quotient.inductionOn a (fun α e => ?_) e
obtain ⟨f⟩ := Quotient.exact e
have f := Equiv.ulift.symm.trans f
let g a := (f a).1
let o := succ (iSup g)
rcases H o with ⟨b, h, l⟩
refine l (lt_succ_iff.2 ?_)
rw [← show g (f.symm ⟨b, h⟩) = b by simp [g]]
apply Ordinal.le_iSup) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | cof_univ | null |
mk_bounded_subset {α : Type*} (h : ∀ x < #α, 2 ^ x < #α) {r : α → α → Prop}
[IsWellOrder α r] (hr : (#α).ord = type r) : #{ s : Set α // Bounded r s } = #α := by
rcases eq_or_ne #α 0 with (ha | ha)
· rw [ha]
haveI := mk_eq_zero_iff.1 ha
rw [mk_eq_zero_iff]
constructor
rintro ⟨s, hs⟩
exact (not_unbounded_iff s).2 hs (unbounded_of_isEmpty s)
have h' : IsStrongLimit #α := ⟨ha, @h⟩
have ha := h'.aleph0_le
apply le_antisymm
· have : { s : Set α | Bounded r s } = ⋃ i, 𝒫{ j | r j i } := setOf_exists _
rw [← coe_setOf, this]
refine mk_iUnion_le_sum_mk.trans ((sum_le_iSup (fun i => #(𝒫{ j | r j i }))).trans
((mul_le_max_of_aleph0_le_left ha).trans ?_))
rw [max_eq_left]
apply ciSup_le' _
intro i
rw [mk_powerset]
apply (h'.two_power_lt _).le
rw [coe_setOf, card_typein, ← lt_ord, hr]
apply typein_lt_type
· refine @mk_le_of_injective α _ (fun x => Subtype.mk {x} ?_) ?_
· apply bounded_singleton
rw [← hr]
apply isSuccLimit_ord ha
· intro a b hab
simpa [singleton_eq_singleton_iff] using hab | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | mk_bounded_subset | null |
mk_subset_mk_lt_cof {α : Type*} (h : ∀ x < #α, 2 ^ x < #α) :
#{ s : Set α // #s < cof (#α).ord } = #α := by
rcases eq_or_ne #α 0 with (ha | ha)
· simp [ha]
have h' : IsStrongLimit #α := ⟨ha, @h⟩
rcases ord_eq α with ⟨r, wo, hr⟩
apply le_antisymm
· conv_rhs => rw [← mk_bounded_subset h hr]
apply mk_le_mk_of_subset
intro s hs
rw [hr] at hs
exact lt_cof_type hs
· refine @mk_le_of_injective α _ (fun x => Subtype.mk {x} ?_) ?_
· rw [mk_singleton]
exact one_lt_aleph0.trans_le (aleph0_le_cof.2 (isSuccLimit_ord h'.aleph0_le))
· intro a b hab
simpa [singleton_eq_singleton_iff] using hab | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | mk_subset_mk_lt_cof | null |
unbounded_of_unbounded_sUnion (r : α → α → Prop) [wo : IsWellOrder α r] {s : Set (Set α)}
(h₁ : Unbounded r <| ⋃₀ s) (h₂ : #s < Order.cof (swap rᶜ)) : ∃ x ∈ s, Unbounded r x := by
by_contra! h
simp_rw [not_unbounded_iff] at h
let f : s → α := fun x : s => wo.wf.sup x (h x.1 x.2)
refine h₂.not_ge (le_trans (csInf_le' ⟨range f, fun x => ?_, rfl⟩) mk_range_le)
rcases h₁ x with ⟨y, ⟨c, hc, hy⟩, hxy⟩
exact ⟨f ⟨c, hc⟩, mem_range_self _, fun hxz => hxy (Trans.trans (wo.wf.lt_sup _ hy) hxz)⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | unbounded_of_unbounded_sUnion | If the union of s is unbounded and s is smaller than the cofinality,
then s has an unbounded member |
unbounded_of_unbounded_iUnion {α β : Type u} (r : α → α → Prop) [wo : IsWellOrder α r]
(s : β → Set α) (h₁ : Unbounded r <| ⋃ x, s x) (h₂ : #β < Order.cof (swap rᶜ)) :
∃ x : β, Unbounded r (s x) := by
rw [← sUnion_range] at h₁
rcases unbounded_of_unbounded_sUnion r h₁ (mk_range_le.trans_lt h₂) with ⟨_, ⟨x, rfl⟩, u⟩
exact ⟨x, u⟩
/-! ### Consequences of König's lemma -/ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | unbounded_of_unbounded_iUnion | If the union of s is unbounded and s is smaller than the cofinality,
then s has an unbounded member |
lt_power_cof {c : Cardinal.{u}} : ℵ₀ ≤ c → c < c ^ c.ord.cof :=
Cardinal.inductionOn c fun α h => by
rcases ord_eq α with ⟨r, wo, re⟩
have := isSuccLimit_ord h
rw [re] at this ⊢
rcases cof_eq' r this with ⟨S, H, Se⟩
have := sum_lt_prod (fun a : S => #{ x // r x a }) (fun _ => #α) fun i => ?_
· simp only [Cardinal.prod_const, Cardinal.lift_id, ← Se, ← mk_sigma, power_def] at this ⊢
refine lt_of_le_of_lt ?_ this
refine ⟨Embedding.ofSurjective ?_ ?_⟩
· exact fun x => x.2.1
· exact fun a =>
let ⟨b, h, ab⟩ := H a
⟨⟨⟨_, h⟩, _, ab⟩, rfl⟩
· have := typein_lt_type r i
rwa [← re, lt_ord] at this | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | lt_power_cof | null |
lt_cof_power {a b : Cardinal} (ha : ℵ₀ ≤ a) (b1 : 1 < b) : a < (b ^ a).ord.cof := by
have b0 : b ≠ 0 := (zero_lt_one.trans b1).ne'
apply lt_imp_lt_of_le_imp_le (power_le_power_left <| power_ne_zero a b0)
rw [← power_mul, mul_eq_self ha]
exact lt_power_cof (ha.trans <| (cantor' _ b1).le) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Cardinal/Cofinality.lean | lt_cof_power | null |
continuum : Cardinal.{u} :=
2 ^ ℵ₀
@[inherit_doc] scoped notation "𝔠" => Cardinal.continuum
@[simp] | def | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | continuum | Cardinality of the continuum. |
two_power_aleph0 : 2 ^ ℵ₀ = 𝔠 :=
rfl
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | two_power_aleph0 | null |
lift_continuum : lift.{v} 𝔠 = 𝔠 := by
rw [← two_power_aleph0, lift_two_power, lift_aleph0, two_power_aleph0]
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | lift_continuum | null |
continuum_le_lift {c : Cardinal.{u}} : 𝔠 ≤ lift.{v} c ↔ 𝔠 ≤ c := by
rw [← lift_continuum.{v, u}, lift_le]
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | continuum_le_lift | null |
lift_le_continuum {c : Cardinal.{u}} : lift.{v} c ≤ 𝔠 ↔ c ≤ 𝔠 := by
rw [← lift_continuum.{v, u}, lift_le]
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | lift_le_continuum | null |
continuum_lt_lift {c : Cardinal.{u}} : 𝔠 < lift.{v} c ↔ 𝔠 < c := by
rw [← lift_continuum.{v, u}, lift_lt]
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | continuum_lt_lift | null |
lift_lt_continuum {c : Cardinal.{u}} : lift.{v} c < 𝔠 ↔ c < 𝔠 := by
rw [← lift_continuum.{v, u}, lift_lt]
/-! | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | lift_lt_continuum | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.