File: Mathlib/SetTheory/Cardinal/Cofinality.lean

full_name: Order.cof
code: /-- Cofinality of a reflexive order `≼`. This is the smallest cardinality
  of a subset `S : Set α` such that `∀ a, ∃ b ∈ S, a ≼ b`. -/
def cof (r : α → α → Prop) : Cardinal 
goal: Cardinal.{u_1}

full_name: Order.cof_nonempty
code: /-- The set in the definition of `Order.cof` is nonempty. -/
theorem cof_nonempty (r : α → α → Prop) [IsRefl α r] :
    { c | ∃ S : Set α, (∀ a, ∃ b ∈ S, r a b) ∧ #S = c }.Nonempty 
goal: {c | ∃ S, (∀ (a : α), ∃ b ∈ S, r a b) ∧ #↑S = c}.Nonempty

full_name: Order.cof_le
code: theorem cof_le (r : α → α → Prop) {S : Set α} (h : ∀ a, ∃ b ∈ S, r a b) : cof r ≤ #S 
goal: Order.cof r ≤ #↑S

full_name: Order.le_cof
code: theorem le_cof {r : α → α → Prop} [IsRefl α r] (c : Cardinal) :
    c ≤ cof r ↔ ∀ {S : Set α}, (∀ a, ∃ b ∈ S, r a b) → c ≤ #S 
goal: c ≤ Order.cof r ↔ ∀ {S : Set α}, (∀ (a : α), ∃ b ∈ S, r a b) → c ≤ #↑S

full_name: RelIso.cof_le_lift
code: theorem RelIso.cof_le_lift {α : Type u} {β : Type v} {r : α → α → Prop} {s} [IsRefl β s]
    (f : r ≃r s) : Cardinal.lift.{max u v} (Order.cof r) ≤
    Cardinal.lift.{max u v} (Order.cof s) 
goal: Cardinal.lift.{max u v, u} (Order.cof r) ≤ Cardinal.lift.{max u v, v} (Order.cof s)

full_name: RelIso.cof_eq_lift
code: theorem RelIso.cof_eq_lift {α : Type u} {β : Type v} {r s} [IsRefl α r] [IsRefl β s] (f : r ≃r s) :
    Cardinal.lift.{max u v} (Order.cof r) = Cardinal.lift.{max u v} (Order.cof s) 
goal: Cardinal.lift.{max u v, u} (Order.cof r) = Cardinal.lift.{max u v, v} (Order.cof s)

full_name: RelIso.cof_le
code: theorem RelIso.cof_le {α β : Type u} {r : α → α → Prop} {s} [IsRefl β s] (f : r ≃r s) :
    Order.cof r ≤ Order.cof s 
goal: Order.cof r ≤ Order.cof s

full_name: RelIso.cof_eq
code: theorem RelIso.cof_eq {α β : Type u} {r s} [IsRefl α r] [IsRefl β s] (f : r ≃r s) :
    Order.cof r = Order.cof s 
goal: Order.cof r = Order.cof s

full_name: StrictOrder.cof
code: /-- Cofinality of a strict order `≺`. This is the smallest cardinality of a set `S : Set α` such
that `∀ a, ∃ b ∈ S, ¬ b ≺ a`. -/
def StrictOrder.cof (r : α → α → Prop) : Cardinal 
goal: Cardinal.{u_1}

full_name: StrictOrder.cof_nonempty
code: /-- The set in the definition of `Order.StrictOrder.cof` is nonempty. -/
theorem StrictOrder.cof_nonempty (r : α → α → Prop) [IsIrrefl α r] :
    { c | ∃ S : Set α, Unbounded r S ∧ #S = c }.Nonempty 
goal: {c | ∃ S, Set.Unbounded r S ∧ #↑S = c}.Nonempty

full_name: Ordinal.cof
code: /-- 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`. It is defined for all ordinals, but
  `cof 0 = 0` and `cof (succ o) = 1`, so it is only really
  interesting on limit ordinals (when it is an infinite cardinal). -/
def cof (o : Ordinal.{u}) : Cardinal.{u} 
goal: Cardinal.{u}

full_name: Ordinal.cof_type
code: theorem cof_type (r : α → α → Prop) [IsWellOrder α r] : (type r).cof = StrictOrder.cof r 
goal: (Ordinal.type r).cof = StrictOrder.cof r

full_name: Ordinal.le_cof_type
code: theorem le_cof_type [IsWellOrder α r] {c} : c ≤ cof (type r) ↔ ∀ S, Unbounded r S → c ≤ #S 
goal: c ≤ (Ordinal.type r).cof ↔ ∀ (S : Set α), Set.Unbounded r S → c ≤ #↑S

full_name: Ordinal.cof_type_le
code: theorem cof_type_le [IsWellOrder α r] {S : Set α} (h : Unbounded r S) : cof (type r) ≤ #S 
goal: (Ordinal.type r).cof ≤ #↑S

full_name: Ordinal.lt_cof_type
code: theorem lt_cof_type [IsWellOrder α r] {S : Set α} : #S < cof (type r) → Bounded r S 
goal: #↑S < (Ordinal.type r).cof → Set.Bounded r S

full_name: Ordinal.cof_eq
code: theorem cof_eq (r : α → α → Prop) [IsWellOrder α r] : ∃ S, Unbounded r S ∧ #S = cof (type r) 
goal: ∃ S, Set.Unbounded r S ∧ #↑S = (Ordinal.type r).cof

full_name: Ordinal.ord_cof_eq
code: theorem ord_cof_eq (r : α → α → Prop) [IsWellOrder α r] :
    ∃ S, Unbounded r S ∧ type (Subrel r S) = (cof (type r)).ord 
goal: ∃ S, Set.Unbounded r S ∧ Ordinal.type (Subrel r S) = (Ordinal.type r).cof.ord

full_name: _private.Mathlib.SetTheory.Cardinal.Cofinality.0.Ordinal.card_mem_cof
code: private theorem card_mem_cof {o} : ∃ (ι : _) (f : ι → Ordinal), lsub.{u, u} f = o ∧ #ι = o.card 
goal: ∃ ι f, Ordinal.lsub f = o ∧ #ι = o.card

full_name: Ordinal.cof_lsub_def_nonempty
code: /-- The set in the `lsub` characterization of `cof` is nonempty. -/
theorem cof_lsub_def_nonempty (o) :
    { a : Cardinal | ∃ (ι : _) (f : ι → Ordinal), lsub.{u, u} f = o ∧ #ι = a }.Nonempty 
goal: {a | ∃ ι f, Ordinal.lsub f = o ∧ #ι = a}.Nonempty

full_name: Ordinal.cof_eq_sInf_lsub
code: theorem cof_eq_sInf_lsub (o : Ordinal.{u}) : cof o =
    sInf { a : Cardinal | ∃ (ι : Type u) (f : ι → Ordinal), lsub.{u, u} f = o ∧ #ι = a } 
goal: o.cof = sInf {a | ∃ ι f, Ordinal.lsub f = o ∧ #ι = a}

full_name: Ordinal.lift_cof
code: @[simp]
theorem lift_cof (o) : Cardinal.lift.{u, v} (cof o) = cof (Ordinal.lift.{u, v} o) 
goal: Cardinal.lift.{u, v} o.cof = (Ordinal.lift.{u, v} o).cof

full_name: Ordinal.cof_le_card
code: theorem cof_le_card (o) : cof o ≤ card o 
goal: o.cof ≤ o.card

full_name: Ordinal.cof_ord_le
code: theorem cof_ord_le (c : Cardinal) : c.ord.cof ≤ c 
goal: c.ord.cof ≤ c

full_name: Ordinal.ord_cof_le
code: theorem ord_cof_le (o : Ordinal.{u}) : o.cof.ord ≤ o 
goal: o.cof.ord ≤ o

full_name: Ordinal.exists_lsub_cof
code: theorem exists_lsub_cof (o : Ordinal) :
    ∃ (ι : _) (f : ι → Ordinal), lsub.{u, u} f = o ∧ #ι = cof o 
goal: ∃ ι f, Ordinal.lsub f = o ∧ #ι = o.cof

full_name: Ordinal.cof_lsub_le
code: theorem cof_lsub_le {ι} (f : ι → Ordinal) : cof (lsub.{u, u} f) ≤ #ι 
goal: (Ordinal.lsub f).cof ≤ #ι

full_name: Ordinal.cof_lsub_le_lift
code: theorem cof_lsub_le_lift {ι} (f : ι → Ordinal) :
    cof (lsub.{u, v} f) ≤ Cardinal.lift.{v, u} #ι 
goal: (Ordinal.lsub f).cof ≤ Cardinal.lift.{v, u} #ι

full_name: Ordinal.le_cof_iff_lsub
code: theorem le_cof_iff_lsub {o : Ordinal} {a : Cardinal} :
    a ≤ cof o ↔ ∀ {ι} (f : ι → Ordinal), lsub.{u, u} f = o → a ≤ #ι 
goal: a ≤ o.cof ↔ ∀ {ι : Type u} (f : ι → Ordinal.{u}), Ordinal.lsub f = o → a ≤ #ι

full_name: Ordinal.lsub_lt_ord_lift
code: theorem 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 
goal: Ordinal.lsub f < c

full_name: Ordinal.lsub_lt_ord
code: theorem lsub_lt_ord {ι} {f : ι → Ordinal} {c : Ordinal} (hι : #ι < c.cof) :
    (∀ i, f i < c) → lsub.{u, u} f < c 
goal: (∀ (i : ι), f i < c) → Ordinal.lsub f < c

full_name: Ordinal.cof_sup_le_lift
code: theorem cof_sup_le_lift {ι} {f : ι → Ordinal} (H : ∀ i, f i < sup.{u, v} f) :
    cof (sup.{u, v} f) ≤ Cardinal.lift.{v, u} #ι 
goal: (Ordinal.sup f).cof ≤ Cardinal.lift.{v, u} #ι

full_name: Ordinal.cof_sup_le
code: theorem cof_sup_le {ι} {f : ι → Ordinal} (H : ∀ i, f i < sup.{u, u} f) :
    cof (sup.{u, u} f) ≤ #ι 
goal: (Ordinal.sup f).cof ≤ #ι

full_name: Ordinal.sup_lt_ord_lift
code: theorem sup_lt_ord_lift {ι} {f : ι → Ordinal} {c : Ordinal} (hι : Cardinal.lift.{v, u} #ι < c.cof)
    (hf : ∀ i, f i < c) : sup.{u, v} f < c 
goal: Ordinal.sup f < c

full_name: Ordinal.sup_lt_ord
code: theorem sup_lt_ord {ι} {f : ι → Ordinal} {c : Ordinal} (hι : #ι < c.cof) :
    (∀ i, f i < c) → sup.{u, u} f < c 
goal: (∀ (i : ι), f i < c) → Ordinal.sup f < c

full_name: Ordinal.iSup_lt_lift
code: theorem iSup_lt_lift {ι} {f : ι → Cardinal} {c : Cardinal}
    (hι : Cardinal.lift.{v, u} #ι < c.ord.cof)
    (hf : ∀ i, f i < c) : iSup.{max u v + 1, u + 1} f < c 
goal: iSup f < c

full_name: Ordinal.iSup_lt
code: theorem iSup_lt {ι} {f : ι → Cardinal} {c : Cardinal} (hι : #ι < c.ord.cof) :
    (∀ i, f i < c) → iSup f < c 
goal: (∀ (i : ι), f i < c) → iSup f < c

full_name: Ordinal.nfpFamily_lt_ord_lift
code: theorem 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.{u, v} f a < c 
goal: Ordinal.nfpFamily f a < c

full_name: Ordinal.nfpFamily_lt_ord
code: theorem 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 
goal: a < c → Ordinal.nfpFamily f a < c

full_name: Ordinal.nfpBFamily_lt_ord_lift
code: theorem nfpBFamily_lt_ord_lift {o : Ordinal} {f : ∀ a < o, Ordinal → Ordinal} {c} (hc : ℵ₀ < cof c)
    (hc' : Cardinal.lift.{v, u} o.card < cof c) (hf : ∀ (i hi), ∀ b < c, f i hi b < c) {a} :
    a < c → nfpBFamily.{u, v} o f a < c 
goal: a < c → o.nfpBFamily f a < c

full_name: Ordinal.nfpBFamily_lt_ord
code: theorem nfpBFamily_lt_ord {o : Ordinal} {f : ∀ a < o, Ordinal → Ordinal} {c} (hc : ℵ₀ < cof c)
    (hc' : o.card < cof c) (hf : ∀ (i hi), ∀ b < c, f i hi b < c) {a} :
    a < c → nfpBFamily.{u, u} o f a < c 
goal: a < c → o.nfpBFamily f a < c

full_name: Ordinal.nfp_lt_ord
code: theorem nfp_lt_ord {f : Ordinal → Ordinal} {c} (hc : ℵ₀ < cof c) (hf : ∀ i < c, f i < c) {a} :
    a < c → nfp f a < c 
goal: a < c → Ordinal.nfp f a < c

full_name: Ordinal.exists_blsub_cof
code: theorem exists_blsub_cof (o : Ordinal) :
    ∃ f : ∀ a < (cof o).ord, Ordinal, blsub.{u, u} _ f = o 
goal: ∃ f, o.cof.ord.blsub f = o

full_name: Ordinal.le_cof_iff_blsub
code: theorem 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 
goal: a ≤ b.cof ↔ ∀ {o : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), o.blsub f = b → a ≤ o.card

full_name: Ordinal.cof_blsub_le_lift
code: theorem cof_blsub_le_lift {o} (f : ∀ a < o, Ordinal) :
    cof (blsub.{u, v} o f) ≤ Cardinal.lift.{v, u} o.card 
goal: (o.blsub f).cof ≤ Cardinal.lift.{v, u} o.card

full_name: Ordinal.cof_blsub_le
code: theorem cof_blsub_le {o} (f : ∀ a < o, Ordinal) : cof (blsub.{u, u} o f) ≤ o.card 
goal: (o.blsub f).cof ≤ o.card

full_name: Ordinal.blsub_lt_ord_lift
code: theorem 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 
goal: o.blsub f < c

full_name: Ordinal.blsub_lt_ord
code: theorem 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 
goal: o.blsub f < c

full_name: Ordinal.cof_bsup_le_lift
code: theorem 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 
goal: (o.bsup f).cof ≤ Cardinal.lift.{v, u} o.card

full_name: Ordinal.cof_bsup_le
code: theorem 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 
goal: (∀ (i : Ordinal.{u}) (h : i < o), f i h < o.bsup f) → (o.bsup f).cof ≤ o.card

full_name: Ordinal.bsup_lt_ord_lift
code: theorem 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 
goal: o.bsup f < c

full_name: Ordinal.bsup_lt_ord
code: theorem 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 
goal: (∀ (i : Ordinal.{u}) (hi : i < o), f i hi < c) → o.bsup f < c

full_name: Ordinal.cof_zero
code: @[simp]
theorem cof_zero : cof 0 = 0 
goal: Ordinal.cof 0 = 0

full_name: Ordinal.cof_eq_zero
code: @[simp]
theorem cof_eq_zero {o} : cof o = 0 ↔ o = 0 
goal: o.cof = 0 ↔ o = 0

full_name: Ordinal.cof_ne_zero
code: theorem cof_ne_zero {o} : cof o ≠ 0 ↔ o ≠ 0 
goal: o.cof ≠ 0 ↔ o ≠ 0

full_name: Ordinal.cof_succ
code: @[simp]
theorem cof_succ (o) : cof (succ o) = 1 
goal: (Order.succ o).cof = 1

full_name: Ordinal.cof_eq_one_iff_is_succ
code: @[simp]
theorem cof_eq_one_iff_is_succ {o} : cof.{u} o = 1 ↔ ∃ a, o = succ a 
goal: o.cof = 1 ↔ ∃ a, o = Order.succ a

full_name: Ordinal.IsFundamentalSequence
code: /-- 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. -/
def IsFundamentalSequence (a o : Ordinal.{u}) (f : ∀ b < o, Ordinal.{u}) : Prop 
goal: Prop

full_name: Ordinal.IsFundamentalSequence.cof_eq
code: protected theorem cof_eq (hf : IsFundamentalSequence a o f) : a.cof.ord = o 
goal: a.cof.ord = o

full_name: Ordinal.IsFundamentalSequence.strict_mono
code: protected theorem strict_mono (hf : IsFundamentalSequence a o f) {i j} :
    ∀ hi hj, i < j → f i hi < f j hj 
goal: i < j → f i hi < f j hj

full_name: Ordinal.IsFundamentalSequence.blsub_eq
code: theorem blsub_eq (hf : IsFundamentalSequence a o f) : blsub.{u, u} o f = a 
goal: o.blsub f = a

full_name: Ordinal.IsFundamentalSequence.ord_cof
code: theorem 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])) 
goal: a.IsFundamentalSequence a.cof.ord fun i hi => f i ⋯

full_name: Ordinal.IsFundamentalSequence.id_of_le_cof
code: theorem id_of_le_cof (h : o ≤ o.cof.ord) : IsFundamentalSequence o o fun a _ => a 
goal: o.IsFundamentalSequence o fun a x => a

full_name: Ordinal.IsFundamentalSequence.zero
code: protected theorem zero {f : ∀ b < (0 : Ordinal), Ordinal} : IsFundamentalSequence 0 0 f 
goal: Ordinal.IsFundamentalSequence 0 0 f

full_name: Ordinal.IsFundamentalSequence.succ
code: protected theorem succ : IsFundamentalSequence (succ o) 1 fun _ _ => o 
goal: (Order.succ o).IsFundamentalSequence 1 fun x x => o

full_name: Ordinal.IsFundamentalSequence.monotone
code: protected theorem monotone (hf : IsFundamentalSequence a o f) {i j : Ordinal} (hi : i < o)
    (hj : j < o) (hij : i ≤ j) : f i hi ≤ f j hj 
goal: f i hi ≤ f j hj

full_name: Ordinal.IsFundamentalSequence.trans
code: theorem 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) 
goal: a.IsFundamentalSequence o' fun i hi => f (g i hi) ⋯

full_name: Ordinal.exists_fundamental_sequence
code: /-- Every ordinal has a fundamental sequence. -/
theorem exists_fundamental_sequence (a : Ordinal.{u}) :
    ∃ f, IsFundamentalSequence a a.cof.ord f 
goal: ∃ f, a.IsFundamentalSequence a.cof.ord f

full_name: Ordinal.cof_cof
code: @[simp]
theorem cof_cof (a : Ordinal.{u}) : cof (cof a).ord = cof a 
goal: a.cof.ord.cof = a.cof

full_name: Ordinal.IsNormal.isFundamentalSequence
code: protected theorem IsNormal.isFundamentalSequence {f : Ordinal.{u} → Ordinal.{u}} (hf : IsNormal f)
    {a o} (ha : IsLimit a) {g} (hg : IsFundamentalSequence a o g) :
    IsFundamentalSequence (f a) o fun b hb => f (g b hb) 
goal: (f a).IsFundamentalSequence o fun b hb => f (g b hb)

full_name: Ordinal.IsNormal.cof_eq
code: theorem IsNormal.cof_eq {f} (hf : IsNormal f) {a} (ha : IsLimit a) : cof (f a) = cof a 
goal: (f a).cof = a.cof

full_name: Ordinal.IsNormal.cof_le
code: theorem IsNormal.cof_le {f} (hf : IsNormal f) (a) : cof a ≤ cof (f a) 
goal: a.cof ≤ (f a).cof

full_name: Ordinal.cof_add
code: @[simp]
theorem cof_add (a b : Ordinal) : b ≠ 0 → cof (a + b) = cof b 
goal: b ≠ 0 → (a + b).cof = b.cof

full_name: Ordinal.aleph0_le_cof
code: theorem aleph0_le_cof {o} : ℵ₀ ≤ cof o ↔ IsLimit o 
goal: ℵ₀ ≤ o.cof ↔ o.IsLimit

full_name: Ordinal.aleph'_cof
code: @[simp]
theorem aleph'_cof {o : Ordinal} (ho : o.IsLimit) : (aleph' o).ord.cof = o.cof 
goal: (Cardinal.aleph' o).ord.cof = o.cof

full_name: Ordinal.aleph_cof
code: @[simp]
theorem aleph_cof {o : Ordinal} (ho : o.IsLimit) : (aleph o).ord.cof = o.cof 
goal: (Cardinal.aleph o).ord.cof = o.cof

full_name: Ordinal.cof_omega
code: @[simp]
theorem cof_omega : cof ω = ℵ₀ 
goal: ω.cof = ℵ₀

full_name: Ordinal.cof_eq'
code: theorem cof_eq' (r : α → α → Prop) [IsWellOrder α r] (h : IsLimit (type r)) :
    ∃ S : Set α, (∀ a, ∃ b ∈ S, r a b) ∧ #S = cof (type r) 
goal: ∃ S, (∀ (a : α), ∃ b ∈ S, r a b) ∧ #↑S = (Ordinal.type r).cof

full_name: Ordinal.cof_univ
code: @[simp]
theorem cof_univ : cof univ.{u, v} = Cardinal.univ.{u, v} 
goal: Ordinal.univ.{u, v}.cof = Cardinal.univ.{u, v}

full_name: Ordinal.unbounded_of_unbounded_sUnion
code: /-- If the union of s is unbounded and s is smaller than the cofinality,
  then s has an unbounded member -/
theorem unbounded_of_unbounded_sUnion (r : α → α → Prop) [wo : IsWellOrder α r] {s : Set (Set α)}
    (h₁ : Unbounded r <| ⋃₀ s) (h₂ : #s < StrictOrder.cof r) : ∃ x ∈ s, Unbounded r x 
goal: ∃ x ∈ s, Set.Unbounded r x

full_name: Ordinal.unbounded_of_unbounded_iUnion
code: /-- If the union of s is unbounded and s is smaller than the cofinality,
  then s has an unbounded member -/
theorem unbounded_of_unbounded_iUnion {α β : Type u} (r : α → α → Prop) [wo : IsWellOrder α r]
    (s : β → Set α) (h₁ : Unbounded r <| ⋃ x, s x) (h₂ : #β < StrictOrder.cof r) :
    ∃ x : β, Unbounded r (s x) 
goal: ∃ x, Set.Unbounded r (s x)

full_name: Ordinal.infinite_pigeonhole
code: /-- The infinite pigeonhole principle -/
theorem infinite_pigeonhole {β α : Type u} (f : β → α) (h₁ : ℵ₀ ≤ #β) (h₂ : #α < (#β).ord.cof) :
    ∃ a : α, #(f ⁻¹' {a}) = #β 
goal: ∃ a, #↑(f ⁻¹' {a}) = #β

full_name: Ordinal.infinite_pigeonhole_card
code: /-- Pigeonhole principle for a cardinality below the cardinality of the domain -/
theorem infinite_pigeonhole_card {β α : Type u} (f : β → α) (θ : Cardinal) (hθ : θ ≤ #β)
    (h₁ : ℵ₀ ≤ θ) (h₂ : #α < θ.ord.cof) : ∃ a : α, θ ≤ #(f ⁻¹' {a}) 
goal: ∃ a, θ ≤ #↑(f ⁻¹' {a})

full_name: Ordinal.infinite_pigeonhole_set
code: theorem infinite_pigeonhole_set {β α : Type u} {s : Set β} (f : s → α) (θ : Cardinal)
    (hθ : θ ≤ #s) (h₁ : ℵ₀ ≤ θ) (h₂ : #α < θ.ord.cof) :
    ∃ (a : α) (t : Set β) (h : t ⊆ s), θ ≤ #t ∧ ∀ ⦃x⦄ (hx : x ∈ t), f ⟨x, h hx⟩ = a 
goal: ∃ a t, ∃ (h : t ⊆ s), θ ≤ #↑t ∧ ∀ ⦃x : β⦄ (hx : x ∈ t), f ⟨x, ⋯⟩ = a

full_name: Cardinal.IsStrongLimit
code: /-- A cardinal is a strong limit if it is not zero and it is
  closed under powersets. Note that `ℵ₀` is a strong limit by this definition. -/
def IsStrongLimit (c : Cardinal) : Prop 
goal: Prop

full_name: Cardinal.IsStrongLimit.ne_zero
code: theorem IsStrongLimit.ne_zero {c} (h : IsStrongLimit c) : c ≠ 0 
goal: c ≠ 0

full_name: Cardinal.IsStrongLimit.two_power_lt
code: theorem IsStrongLimit.two_power_lt {x c} (h : IsStrongLimit c) : x < c → (2^x) < c 
goal: x < c → 2 ^ x < c

full_name: Cardinal.isStrongLimit_aleph0
code: theorem isStrongLimit_aleph0 : IsStrongLimit ℵ₀ 
goal: ℵ₀.IsStrongLimit

full_name: Cardinal.IsStrongLimit.isSuccLimit
code: protected theorem IsStrongLimit.isSuccLimit {c} (H : IsStrongLimit c) : IsSuccLimit c 
goal: Order.IsSuccLimit c

full_name: Cardinal.IsStrongLimit.isLimit
code: theorem IsStrongLimit.isLimit {c} (H : IsStrongLimit c) : IsLimit c 
goal: c.IsLimit

full_name: Cardinal.isStrongLimit_beth
code: theorem isStrongLimit_beth {o : Ordinal} (H : IsSuccLimit o) : IsStrongLimit (beth o) 
goal: (Cardinal.beth o).IsStrongLimit

full_name: Cardinal.mk_bounded_subset
code: theorem mk_bounded_subset {α : Type*} (h : ∀ x < #α, (2^x) < #α) {r : α → α → Prop}
    [IsWellOrder α r] (hr : (#α).ord = type r) : #{ s : Set α // Bounded r s } = #α 
goal: #{ s // Set.Bounded r s } = #α

full_name: Cardinal.mk_subset_mk_lt_cof
code: theorem mk_subset_mk_lt_cof {α : Type*} (h : ∀ x < #α, (2^x) < #α) :
    #{ s : Set α // #s < cof (#α).ord } = #α 
goal: #{ s // #↑s < (#α).ord.cof } = #α

full_name: Cardinal.IsRegular
code: /-- A cardinal is regular if it is infinite and it equals its own cofinality. -/
def IsRegular (c : Cardinal) : Prop 
goal: Prop

full_name: Cardinal.IsRegular.aleph0_le
code: theorem IsRegular.aleph0_le {c : Cardinal} (H : c.IsRegular) : ℵ₀ ≤ c 
goal: ℵ₀ ≤ c

full_name: Cardinal.IsRegular.cof_eq
code: theorem IsRegular.cof_eq {c : Cardinal} (H : c.IsRegular) : c.ord.cof = c 
goal: c.ord.cof = c

full_name: Cardinal.IsRegular.pos
code: theorem IsRegular.pos {c : Cardinal} (H : c.IsRegular) : 0 < c 
goal: 0 < c

full_name: Cardinal.IsRegular.nat_lt
code: theorem IsRegular.nat_lt {c : Cardinal} (H : c.IsRegular) (n : ℕ) : n < c 
goal: ↑n < c

full_name: Cardinal.IsRegular.ord_pos
code: theorem IsRegular.ord_pos {c : Cardinal} (H : c.IsRegular) : 0 < c.ord 
goal: 0 < c.ord

full_name: Cardinal.isRegular_cof
code: theorem isRegular_cof {o : Ordinal} (h : o.IsLimit) : IsRegular o.cof 
goal: o.cof.IsRegular

full_name: Cardinal.isRegular_aleph0
code: theorem isRegular_aleph0 : IsRegular ℵ₀ 
goal: ℵ₀.IsRegular

full_name: Cardinal.isRegular_succ
code: theorem isRegular_succ {c : Cardinal.{u}} (h : ℵ₀ ≤ c) : IsRegular (succ c) 
goal: (Order.succ c).IsRegular

full_name: Cardinal.isRegular_aleph_one
code: theorem isRegular_aleph_one : IsRegular (aleph 1) 
goal: (Cardinal.aleph 1).IsRegular

full_name: Cardinal.isRegular_aleph'_succ
code: theorem isRegular_aleph'_succ {o : Ordinal} (h : ω ≤ o) : IsRegular (aleph' (succ o)) 
goal: (Cardinal.aleph' (Order.succ o)).IsRegular

full_name: Cardinal.isRegular_aleph_succ
code: theorem isRegular_aleph_succ (o : Ordinal) : IsRegular (aleph (succ o)) 
goal: (Cardinal.aleph (Order.succ o)).IsRegular

full_name: Cardinal.infinite_pigeonhole_card_lt
code: /-- A function whose codomain's cardinality is infinite but strictly smaller than its domain's
has a fiber with cardinality strictly great than the codomain.
-/
theorem infinite_pigeonhole_card_lt {β α : Type u} (f : β → α) (w : #α < #β) (w' : ℵ₀ ≤ #α) :
    ∃ a : α, #α < #(f ⁻¹' {a}) 
goal: ∃ a, #α < #↑(f ⁻¹' {a})

full_name: Cardinal.exists_infinite_fiber
code: /-- A function whose codomain's cardinality is infinite but strictly smaller than its domain's
has an infinite fiber.
-/
theorem exists_infinite_fiber {β α : Type u} (f : β → α) (w : #α < #β) (w' : Infinite α) :
    ∃ a : α, Infinite (f ⁻¹' {a}) 
goal: ∃ a, Infinite ↑(f ⁻¹' {a})

full_name: Cardinal.le_range_of_union_finset_eq_top
code: /-- If an infinite type `β` can be expressed as a union of finite sets,
then the cardinality of the collection of those finite sets
must be at least the cardinality of `β`.
-/
theorem le_range_of_union_finset_eq_top {α β : Type*} [Infinite β] (f : α → Finset β)
    (w : ⋃ a, (f a : Set β) = ⊤) : #β ≤ #(range f) 
goal: #β ≤ #↑(Set.range f)

full_name: Cardinal.lsub_lt_ord_lift_of_isRegular
code: theorem lsub_lt_ord_lift_of_isRegular {ι} {f : ι → Ordinal} {c} (hc : IsRegular c)
    (hι : Cardinal.lift.{v, u} #ι < c) : (∀ i, f i < c.ord) → Ordinal.lsub.{u, v} f < c.ord 
goal: (∀ (i : ι), f i < c.ord) → Ordinal.lsub f < c.ord

full_name: Cardinal.lsub_lt_ord_of_isRegular
code: theorem lsub_lt_ord_of_isRegular {ι} {f : ι → Ordinal} {c} (hc : IsRegular c) (hι : #ι < c) :
    (∀ i, f i < c.ord) → Ordinal.lsub f < c.ord 
goal: (∀ (i : ι), f i < c.ord) → Ordinal.lsub f < c.ord

full_name: Cardinal.sup_lt_ord_lift_of_isRegular
code: theorem sup_lt_ord_lift_of_isRegular {ι} {f : ι → Ordinal} {c} (hc : IsRegular c)
    (hι : Cardinal.lift.{v, u} #ι < c) : (∀ i, f i < c.ord) → Ordinal.sup.{u, v} f < c.ord 
goal: (∀ (i : ι), f i < c.ord) → Ordinal.sup f < c.ord

full_name: Cardinal.sup_lt_ord_of_isRegular
code: theorem sup_lt_ord_of_isRegular {ι} {f : ι → Ordinal} {c} (hc : IsRegular c) (hι : #ι < c) :
    (∀ i, f i < c.ord) → Ordinal.sup f < c.ord 
goal: (∀ (i : ι), f i < c.ord) → Ordinal.sup f < c.ord

full_name: Cardinal.blsub_lt_ord_lift_of_isRegular
code: theorem blsub_lt_ord_lift_of_isRegular {o : Ordinal} {f : ∀ a < o, Ordinal} {c} (hc : IsRegular c)
    (ho : Cardinal.lift.{v, u} o.card < c) :
    (∀ i hi, f i hi < c.ord) → Ordinal.blsub.{u, v} o f < c.ord 
goal: (∀ (i : Ordinal.{u}) (hi : i < o), f i hi < c.ord) → o.blsub f < c.ord

full_name: Cardinal.blsub_lt_ord_of_isRegular
code: theorem blsub_lt_ord_of_isRegular {o : Ordinal} {f : ∀ a < o, Ordinal} {c} (hc : IsRegular c)
    (ho : o.card < c) : (∀ i hi, f i hi < c.ord) → Ordinal.blsub o f < c.ord 
goal: (∀ (i : Ordinal.{max u_2 u_3}) (hi : i < o), f i hi < c.ord) → o.blsub f < c.ord

full_name: Cardinal.bsup_lt_ord_lift_of_isRegular
code: theorem bsup_lt_ord_lift_of_isRegular {o : Ordinal} {f : ∀ a < o, Ordinal} {c} (hc : IsRegular c)
    (hι : Cardinal.lift.{v, u} o.card < c) :
    (∀ i hi, f i hi < c.ord) → Ordinal.bsup.{u, v} o f < c.ord 
goal: (∀ (i : Ordinal.{u}) (hi : i < o), f i hi < c.ord) → o.bsup f < c.ord

full_name: Cardinal.bsup_lt_ord_of_isRegular
code: theorem bsup_lt_ord_of_isRegular {o : Ordinal} {f : ∀ a < o, Ordinal} {c} (hc : IsRegular c)
    (hι : o.card < c) : (∀ i hi, f i hi < c.ord) → Ordinal.bsup o f < c.ord 
goal: (∀ (i : Ordinal.{max u_2 u_3}) (hi : i < o), f i hi < c.ord) → o.bsup f < c.ord

full_name: Cardinal.iSup_lt_lift_of_isRegular
code: theorem iSup_lt_lift_of_isRegular {ι} {f : ι → Cardinal} {c} (hc : IsRegular c)
    (hι : Cardinal.lift.{v, u} #ι < c) : (∀ i, f i < c) → iSup.{max u v + 1, u + 1} f < c 
goal: (∀ (i : ι), f i < c) → iSup f < c

full_name: Cardinal.iSup_lt_of_isRegular
code: theorem iSup_lt_of_isRegular {ι} {f : ι → Cardinal} {c} (hc : IsRegular c) (hι : #ι < c) :
    (∀ i, f i < c) → iSup f < c 
goal: (∀ (i : ι), f i < c) → iSup f < c

full_name: Cardinal.sum_lt_lift_of_isRegular
code: theorem sum_lt_lift_of_isRegular {ι : Type u} {f : ι → Cardinal} {c : Cardinal} (hc : IsRegular c)
    (hι : Cardinal.lift.{v, u} #ι < c) (hf : ∀ i, f i < c) : sum f < c 
goal: Cardinal.sum f < c

full_name: Cardinal.sum_lt_of_isRegular
code: theorem sum_lt_of_isRegular {ι : Type u} {f : ι → Cardinal} {c : Cardinal} (hc : IsRegular c)
    (hι : #ι < c) : (∀ i, f i < c) → sum f < c 
goal: (∀ (i : ι), f i < c) → Cardinal.sum f < c

full_name: Cardinal.card_lt_of_card_iUnion_lt
code: @[simp]
theorem card_lt_of_card_iUnion_lt {ι : Type u} {α : Type u} {t : ι → Set α} {c : Cardinal}
    (h : #(⋃ i, t i) < c) (i : ι) : #(t i) < c 
goal: #↑(t i) < c

full_name: Cardinal.card_iUnion_lt_iff_forall_of_isRegular
code: @[simp]
theorem card_iUnion_lt_iff_forall_of_isRegular {ι : Type u} {α : Type u} {t : ι → Set α}
    {c : Cardinal} (hc : c.IsRegular) (hι : #ι < c) : #(⋃ i, t i) < c ↔ ∀ i, #(t i) < c 
goal: #↑(⋃ i, t i) < c ↔ ∀ (i : ι), #↑(t i) < c

full_name: Cardinal.card_lt_of_card_biUnion_lt
code: theorem card_lt_of_card_biUnion_lt {α β : Type u} {s : Set α} {t : ∀ a ∈ s, Set β} {c : Cardinal}
    (h : #(⋃ a ∈ s, t a ‹_›) < c) (a : α) (ha : a ∈ s) : # (t a ha) < c 
goal: #↑(t a ha) < c

full_name: Cardinal.card_biUnion_lt_iff_forall_of_isRegular
code: theorem card_biUnion_lt_iff_forall_of_isRegular {α β : Type u} {s : Set α} {t : ∀ a ∈ s, Set β}
    {c : Cardinal} (hc : c.IsRegular) (hs : #s < c) :
    #(⋃ a ∈ s, t a ‹_›) < c ↔ ∀ a (ha : a ∈ s), # (t a ha) < c 
goal: #↑(⋃ a, ⋃ (h : a ∈ s), t a h) < c ↔ ∀ (a : α) (ha : a ∈ s), #↑(t a ha) < c

full_name: Cardinal.nfpFamily_lt_ord_lift_of_isRegular
code: theorem nfpFamily_lt_ord_lift_of_isRegular {ι} {f : ι → Ordinal → Ordinal} {c} (hc : IsRegular c)
    (hι : Cardinal.lift.{v, u} #ι < c) (hc' : c ≠ ℵ₀) (hf : ∀ (i), ∀ b < c.ord, f i b < c.ord) {a}
    (ha : a < c.ord) : nfpFamily.{u, v} f a < c.ord 
goal: Ordinal.nfpFamily f a < c.ord

full_name: Cardinal.nfpFamily_lt_ord_of_isRegular
code: theorem nfpFamily_lt_ord_of_isRegular {ι} {f : ι → Ordinal → Ordinal} {c} (hc : IsRegular c)
    (hι : #ι < c) (hc' : c ≠ ℵ₀) {a} (hf : ∀ (i), ∀ b < c.ord, f i b < c.ord) :
    a < c.ord → nfpFamily.{u, u} f a < c.ord 
goal: a < c.ord → Ordinal.nfpFamily f a < c.ord

full_name: Cardinal.nfpBFamily_lt_ord_lift_of_isRegular
code: theorem nfpBFamily_lt_ord_lift_of_isRegular {o : Ordinal} {f : ∀ a < o, Ordinal → Ordinal} {c}
    (hc : IsRegular c) (ho : Cardinal.lift.{v, u} o.card < c) (hc' : c ≠ ℵ₀)
    (hf : ∀ (i hi), ∀ b < c.ord, f i hi b < c.ord) {a} :
    a < c.ord → nfpBFamily.{u, v} o f a < c.ord 
goal: a < c.ord → o.nfpBFamily f a < c.ord

full_name: Cardinal.nfpBFamily_lt_ord_of_isRegular
code: theorem nfpBFamily_lt_ord_of_isRegular {o : Ordinal} {f : ∀ a < o, Ordinal → Ordinal} {c}
    (hc : IsRegular c) (ho : o.card < c) (hc' : c ≠ ℵ₀)
    (hf : ∀ (i hi), ∀ b < c.ord, f i hi b < c.ord) {a} :
    a < c.ord → nfpBFamily.{u, u} o f a < c.ord 
goal: a < c.ord → o.nfpBFamily f a < c.ord

full_name: Cardinal.nfp_lt_ord_of_isRegular
code: theorem nfp_lt_ord_of_isRegular {f : Ordinal → Ordinal} {c} (hc : IsRegular c) (hc' : c ≠ ℵ₀)
    (hf : ∀ i < c.ord, f i < c.ord) {a} : a < c.ord → nfp f a < c.ord 
goal: a < c.ord → Ordinal.nfp f a < c.ord

full_name: Cardinal.derivFamily_lt_ord_lift
code: theorem derivFamily_lt_ord_lift {ι} {f : ι → Ordinal → Ordinal} {c} (hc : IsRegular c)
    (hι : Cardinal.lift.{v, u} #ι < c) (hc' : c ≠ ℵ₀)
    (hf : ∀ (i), ∀ b < c.ord, f i b < c.ord) {a} :
    a < c.ord → derivFamily.{u, v} f a < c.ord 
goal: a < c.ord → Ordinal.derivFamily f a < c.ord

full_name: Cardinal.derivFamily_lt_ord
code: theorem derivFamily_lt_ord {ι} {f : ι → Ordinal → Ordinal} {c} (hc : IsRegular c) (hι : #ι < c)
    (hc' : c ≠ ℵ₀) (hf : ∀ (i), ∀ b < c.ord, f i b < c.ord) {a} :
    a < c.ord → derivFamily.{u, u} f a < c.ord 
goal: a < c.ord → Ordinal.derivFamily f a < c.ord

full_name: Cardinal.derivBFamily_lt_ord_lift
code: theorem derivBFamily_lt_ord_lift {o : Ordinal} {f : ∀ a < o, Ordinal → Ordinal} {c}
    (hc : IsRegular c) (hι : Cardinal.lift.{v, u} o.card < c) (hc' : c ≠ ℵ₀)
    (hf : ∀ (i hi), ∀ b < c.ord, f i hi b < c.ord) {a} :
    a < c.ord → derivBFamily.{u, v} o f a < c.ord 
goal: a < c.ord → o.derivBFamily f a < c.ord

full_name: Cardinal.derivBFamily_lt_ord
code: theorem derivBFamily_lt_ord {o : Ordinal} {f : ∀ a < o, Ordinal → Ordinal} {c} (hc : IsRegular c)
    (hι : o.card < c) (hc' : c ≠ ℵ₀) (hf : ∀ (i hi), ∀ b < c.ord, f i hi b < c.ord) {a} :
    a < c.ord → derivBFamily.{u, u} o f a < c.ord 
goal: a < c.ord → o.derivBFamily f a < c.ord

full_name: Cardinal.deriv_lt_ord
code: theorem deriv_lt_ord {f : Ordinal.{u} → Ordinal} {c} (hc : IsRegular c) (hc' : c ≠ ℵ₀)
    (hf : ∀ i < c.ord, f i < c.ord) {a} : a < c.ord → deriv f a < c.ord 
goal: a < c.ord → Ordinal.deriv f a < c.ord

full_name: Cardinal.IsInaccessible
code: /-- A cardinal is inaccessible if it is an uncountable regular strong limit cardinal. -/
def IsInaccessible (c : Cardinal) 
goal: Prop

full_name: Cardinal.IsInaccessible.mk
code: theorem IsInaccessible.mk {c} (h₁ : ℵ₀ < c) (h₂ : c ≤ c.ord.cof) (h₃ : ∀ x < c, (2^x) < c) :
    IsInaccessible c 
goal: c.IsInaccessible

full_name: Cardinal.univ_inaccessible
code: theorem univ_inaccessible : IsInaccessible univ.{u, v} 
goal: Cardinal.univ.{u, v}.IsInaccessible

full_name: Cardinal.lt_power_cof
code: theorem lt_power_cof {c : Cardinal.{u}} : ℵ₀ ≤ c → c < (c^cof c.ord) 
goal: ℵ₀ ≤ c → c < c ^ c.ord.cof

full_name: Cardinal.lt_cof_power
code: theorem lt_cof_power {a b : Cardinal} (ha : ℵ₀ ≤ a) (b1 : 1 < b) : a < cof (b^a).ord 
goal: a < (b ^ a).ord.cof

full_name: Ordinal.sup_sequence_lt_omega1
code: lemma sup_sequence_lt_omega1 {α} [Countable α] (o : α → Ordinal) (ho : ∀ n, o n < ω₁) :
    sup o < ω₁ 
goal: Ordinal.sup o < (Cardinal.aleph 1).ord