File: Mathlib/SetTheory/Cardinal/Ordinal.lean

full_name: Cardinal.ord_isLimit
code: theorem ord_isLimit {c} (co : ℵ₀ ≤ c) : (ord c).IsLimit 
goal: c.ord.IsLimit

full_name: Cardinal.noMaxOrder
code: theorem noMaxOrder {c} (h : ℵ₀ ≤ c) : NoMaxOrder c.ord.out.α 
goal: NoMaxOrder (Quotient.out c.ord).α

full_name: Cardinal.alephIdx.initialSeg
code: /-- The `aleph'` index function, which gives the ordinal index of a cardinal.
  (The `aleph'` part is because unlike `aleph` this counts also the
  finite stages. So `alephIdx n = n`, `alephIdx ω = ω`,
  `alephIdx ℵ₁ = ω + 1` and so on.)
  In this definition, we register additionally that this function is an initial segment,
  i.e., it is order preserving and its range is an initial segment of the ordinals.
  For the basic function version, see `alephIdx`.
  For an upgraded version stating that the range is everything, see `AlephIdx.rel_iso`. -/
def alephIdx.initialSeg : @InitialSeg Cardinal Ordinal (· < ·) (· < ·) 
goal: (fun x x_1 => x < x_1) ≼i fun x x_1 => x < x_1

full_name: Cardinal.alephIdx
code: /-- The `aleph'` index function, which gives the ordinal index of a cardinal.
  (The `aleph'` part is because unlike `aleph` this counts also the
  finite stages. So `alephIdx n = n`, `alephIdx ω = ω`,
  `alephIdx ℵ₁ = ω + 1` and so on.)
  For an upgraded version stating that the range is everything, see `AlephIdx.rel_iso`. -/
def alephIdx : Cardinal → Ordinal 
goal: Cardinal.{u_1} → Ordinal.{u_1}

full_name: Cardinal.alephIdx.initialSeg_coe
code: @[simp]
theorem alephIdx.initialSeg_coe : (alephIdx.initialSeg : Cardinal → Ordinal) = alephIdx 
goal: ⇑Cardinal.alephIdx.initialSeg = Cardinal.alephIdx

full_name: Cardinal.alephIdx_lt
code: @[simp]
theorem alephIdx_lt {a b} : alephIdx a < alephIdx b ↔ a < b 
goal: a.alephIdx < b.alephIdx ↔ a < b

full_name: Cardinal.alephIdx_le
code: @[simp]
theorem alephIdx_le {a b} : alephIdx a ≤ alephIdx b ↔ a ≤ b 
goal: a.alephIdx ≤ b.alephIdx ↔ a ≤ b

full_name: Cardinal.alephIdx.init
code: theorem alephIdx.init {a b} : b < alephIdx a → ∃ c, alephIdx c = b 
goal: b < a.alephIdx → ∃ c, c.alephIdx = b

full_name: Cardinal.alephIdx.relIso
code: /-- The `aleph'` index function, which gives the ordinal index of a cardinal.
  (The `aleph'` part is because unlike `aleph` this counts also the
  finite stages. So `alephIdx n = n`, `alephIdx ℵ₀ = ω`,
  `alephIdx ℵ₁ = ω + 1` and so on.)
  In this version, we register additionally that this function is an order isomorphism
  between cardinals and ordinals.
  For the basic function version, see `alephIdx`. -/
def alephIdx.relIso : @RelIso Cardinal.{u} Ordinal.{u} (· < ·) (· < ·) 
goal: (fun x x_1 => x < x_1) ≃r fun x x_1 => x < x_1

full_name: Cardinal.alephIdx.relIso_coe
code: @[simp]
theorem alephIdx.relIso_coe : (alephIdx.relIso : Cardinal → Ordinal) = alephIdx 
goal: ⇑Cardinal.alephIdx.relIso = Cardinal.alephIdx

full_name: Cardinal.type_cardinal
code: @[simp]
theorem type_cardinal : @type Cardinal (· < ·) _ = Ordinal.univ.{u, u + 1} 
goal: (Ordinal.type fun x x_1 => x < x_1) = Ordinal.univ.{u, u + 1}

full_name: Cardinal.mk_cardinal
code: @[simp]
theorem mk_cardinal : #Cardinal = univ.{u, u + 1} 
goal: #Cardinal.{u} = Cardinal.univ.{u, u + 1}

full_name: Cardinal.Aleph'.relIso
code: /-- The `aleph'` function gives the cardinals listed by their ordinal
  index, and is the inverse of `aleph_idx`.
  `aleph' n = n`, `aleph' ω = ω`, `aleph' (ω + 1) = succ ℵ₀`, etc.
  In this version, we register additionally that this function is an order isomorphism
  between ordinals and cardinals.
  For the basic function version, see `aleph'`. -/
def Aleph'.relIso 
goal: (fun x x_1 => x < x_1) ≃r fun x x_1 => x < x_1

full_name: Cardinal.aleph'
code: /-- The `aleph'` function gives the cardinals listed by their ordinal
  index, and is the inverse of `aleph_idx`.
  `aleph' n = n`, `aleph' ω = ω`, `aleph' (ω + 1) = succ ℵ₀`, etc. -/
def aleph' : Ordinal → Cardinal 
goal: Ordinal.{u_1} → Cardinal.{u_1}

full_name: Cardinal.aleph'.relIso_coe
code: @[simp]
theorem aleph'.relIso_coe : (Aleph'.relIso : Ordinal → Cardinal) = aleph' 
goal: ⇑Cardinal.Aleph'.relIso = Cardinal.aleph'

full_name: Cardinal.aleph'_lt
code: @[simp]
theorem aleph'_lt {o₁ o₂ : Ordinal} : aleph' o₁ < aleph' o₂ ↔ o₁ < o₂ 
goal: Cardinal.aleph' o₁ < Cardinal.aleph' o₂ ↔ o₁ < o₂

full_name: Cardinal.aleph'_le
code: @[simp]
theorem aleph'_le {o₁ o₂ : Ordinal} : aleph' o₁ ≤ aleph' o₂ ↔ o₁ ≤ o₂ 
goal: Cardinal.aleph' o₁ ≤ Cardinal.aleph' o₂ ↔ o₁ ≤ o₂

full_name: Cardinal.aleph'_alephIdx
code: @[simp]
theorem aleph'_alephIdx (c : Cardinal) : aleph' c.alephIdx = c 
goal: Cardinal.aleph' c.alephIdx = c

full_name: Cardinal.alephIdx_aleph'
code: @[simp]
theorem alephIdx_aleph' (o : Ordinal) : (aleph' o).alephIdx = o 
goal: (Cardinal.aleph' o).alephIdx = o

full_name: Cardinal.aleph'_zero
code: @[simp]
theorem aleph'_zero : aleph' 0 = 0 
goal: Cardinal.aleph' 0 = 0

full_name: Cardinal.aleph'_succ
code: @[simp]
theorem aleph'_succ {o : Ordinal} : aleph' (succ o) = succ (aleph' o) 
goal: Cardinal.aleph' (Order.succ o) = Order.succ (Cardinal.aleph' o)

full_name: Cardinal.aleph'_nat
code: @[simp]
theorem aleph'_nat : ∀ n : ℕ, aleph' n = n
  
goal: Cardinal.aleph' ↑n = ↑n

full_name: Cardinal.aleph'_le_of_limit
code: theorem aleph'_le_of_limit {o : Ordinal} (l : o.IsLimit) {c} :
    aleph' o ≤ c ↔ ∀ o' < o, aleph' o' ≤ c 
goal: Cardinal.aleph' o ≤ c ↔ ∀ o' < o, Cardinal.aleph' o' ≤ c

full_name: Cardinal.aleph'_limit
code: theorem aleph'_limit {o : Ordinal} (ho : o.IsLimit) : aleph' o = ⨆ a : Iio o, aleph' a 
goal: Cardinal.aleph' o = ⨆ a, Cardinal.aleph' ↑a

full_name: Cardinal.aleph'_omega
code: @[simp]
theorem aleph'_omega : aleph' ω = ℵ₀ 
goal: Cardinal.aleph' ω = ℵ₀

full_name: Cardinal.aleph'Equiv
code: /-- `aleph'` and `aleph_idx` form an equivalence between `Ordinal` and `Cardinal` -/
@[simp]
def aleph'Equiv : Ordinal ≃ Cardinal 
goal: Ordinal.{u_1} ≃ Cardinal.{u_1}

full_name: Cardinal.aleph
code: /-- The `aleph` function gives the infinite cardinals listed by their
  ordinal index. `aleph 0 = ℵ₀`, `aleph 1 = succ ℵ₀` is the first
  uncountable cardinal, and so on. -/
def aleph (o : Ordinal) : Cardinal 
goal: Cardinal.{u_1}

full_name: Cardinal.aleph_lt
code: @[simp]
theorem aleph_lt {o₁ o₂ : Ordinal} : aleph o₁ < aleph o₂ ↔ o₁ < o₂ 
goal: Cardinal.aleph o₁ < Cardinal.aleph o₂ ↔ o₁ < o₂

full_name: Cardinal.aleph_le
code: @[simp]
theorem aleph_le {o₁ o₂ : Ordinal} : aleph o₁ ≤ aleph o₂ ↔ o₁ ≤ o₂ 
goal: Cardinal.aleph o₁ ≤ Cardinal.aleph o₂ ↔ o₁ ≤ o₂

full_name: Cardinal.max_aleph_eq
code: @[simp]
theorem max_aleph_eq (o₁ o₂ : Ordinal) : max (aleph o₁) (aleph o₂) = aleph (max o₁ o₂) 
goal: max (Cardinal.aleph o₁) (Cardinal.aleph o₂) = Cardinal.aleph (max o₁ o₂)

full_name: Cardinal.aleph_succ
code: @[simp]
theorem aleph_succ {o : Ordinal} : aleph (succ o) = succ (aleph o) 
goal: Cardinal.aleph (Order.succ o) = Order.succ (Cardinal.aleph o)

full_name: Cardinal.aleph_zero
code: @[simp]
theorem aleph_zero : aleph 0 = ℵ₀ 
goal: Cardinal.aleph 0 = ℵ₀

full_name: Cardinal.aleph_limit
code: theorem aleph_limit {o : Ordinal} (ho : o.IsLimit) : aleph o = ⨆ a : Iio o, aleph a 
goal: Cardinal.aleph o = ⨆ a, Cardinal.aleph ↑a

full_name: Cardinal.aleph0_le_aleph'
code: theorem aleph0_le_aleph' {o : Ordinal} : ℵ₀ ≤ aleph' o ↔ ω ≤ o 
goal: ℵ₀ ≤ Cardinal.aleph' o ↔ ω ≤ o

full_name: Cardinal.aleph0_le_aleph
code: theorem aleph0_le_aleph (o : Ordinal) : ℵ₀ ≤ aleph o 
goal: ℵ₀ ≤ Cardinal.aleph o

full_name: Cardinal.aleph'_pos
code: theorem aleph'_pos {o : Ordinal} (ho : 0 < o) : 0 < aleph' o 
goal: 0 < Cardinal.aleph' o

full_name: Cardinal.aleph_pos
code: theorem aleph_pos (o : Ordinal) : 0 < aleph o 
goal: 0 < Cardinal.aleph o

full_name: Cardinal.aleph_toNat
code: @[simp]
theorem aleph_toNat (o : Ordinal) : toNat (aleph o) = 0 
goal: Cardinal.toNat (Cardinal.aleph o) = 0

full_name: Cardinal.aleph_toPartENat
code: @[simp]
theorem aleph_toPartENat (o : Ordinal) : toPartENat (aleph o) = ⊤ 
goal: Cardinal.toPartENat (Cardinal.aleph o) = ⊤

full_name: Cardinal.nonempty_out_aleph
code: instance nonempty_out_aleph (o : Ordinal) : Nonempty (aleph o).ord.out.α 
goal: Nonempty (Quotient.out (Cardinal.aleph o).ord).α

full_name: Cardinal.ord_aleph_isLimit
code: theorem ord_aleph_isLimit (o : Ordinal) : (aleph o).ord.IsLimit 
goal: (Cardinal.aleph o).ord.IsLimit

full_name: Cardinal.instNoMaxOrderαOutWellOrderOrdAleph
code: instance (o : Ordinal) : NoMaxOrder (aleph o).ord.out.α 
goal: NoMaxOrder (Quotient.out (Cardinal.aleph o).ord).α

full_name: Cardinal.exists_aleph
code: theorem exists_aleph {c : Cardinal} : ℵ₀ ≤ c ↔ ∃ o, c = aleph o 
goal: ℵ₀ ≤ c ↔ ∃ o, c = Cardinal.aleph o

full_name: Cardinal.aleph'_isNormal
code: theorem aleph'_isNormal : IsNormal (ord ∘ aleph') 
goal: Ordinal.IsNormal (Cardinal.ord ∘ Cardinal.aleph')

full_name: Cardinal.aleph_isNormal
code: theorem aleph_isNormal : IsNormal (ord ∘ aleph) 
goal: Ordinal.IsNormal (Cardinal.ord ∘ Cardinal.aleph)

full_name: Cardinal.succ_aleph0
code: theorem succ_aleph0 : succ ℵ₀ = aleph 1 
goal: Order.succ ℵ₀ = Cardinal.aleph 1

full_name: Cardinal.aleph0_lt_aleph_one
code: theorem aleph0_lt_aleph_one : ℵ₀ < aleph 1 
goal: ℵ₀ < Cardinal.aleph 1

full_name: Cardinal.countable_iff_lt_aleph_one
code: theorem countable_iff_lt_aleph_one {α : Type*} (s : Set α) : s.Countable ↔ #s < aleph 1 
goal: s.Countable ↔ #↑s < Cardinal.aleph 1

full_name: Cardinal.ord_card_unbounded
code: /-- Ordinals that are cardinals are unbounded. -/
theorem ord_card_unbounded : Unbounded (· < ·) { b : Ordinal | b.card.ord = b } 
goal: Set.Unbounded (fun x x_1 => x < x_1) {b | b.card.ord = b}

full_name: Cardinal.eq_aleph'_of_eq_card_ord
code: theorem eq_aleph'_of_eq_card_ord {o : Ordinal} (ho : o.card.ord = o) : ∃ a, (aleph' a).ord = o 
goal: ∃ a, (Cardinal.aleph' a).ord = o

full_name: Cardinal.ord_aleph'_eq_enum_card
code: /-- `ord ∘ aleph'` enumerates the ordinals that are cardinals. -/
theorem ord_aleph'_eq_enum_card : ord ∘ aleph' = enumOrd { b : Ordinal | b.card.ord = b } 
goal: Cardinal.ord ∘ Cardinal.aleph' = Ordinal.enumOrd {b | b.card.ord = b}

full_name: Cardinal.ord_card_unbounded'
code: /-- Infinite ordinals that are cardinals are unbounded. -/
theorem ord_card_unbounded' : Unbounded (· < ·) { b : Ordinal | b.card.ord = b ∧ ω ≤ b } 
goal: Set.Unbounded (fun x x_1 => x < x_1) {b | b.card.ord = b ∧ ω ≤ b}

full_name: Cardinal.eq_aleph_of_eq_card_ord
code: theorem eq_aleph_of_eq_card_ord {o : Ordinal} (ho : o.card.ord = o) (ho' : ω ≤ o) :
    ∃ a, (aleph a).ord = o 
goal: ∃ a, (Cardinal.aleph a).ord = o

full_name: Cardinal.ord_aleph_eq_enum_card
code: /-- `ord ∘ aleph` enumerates the infinite ordinals that are cardinals. -/
theorem ord_aleph_eq_enum_card :
    ord ∘ aleph = enumOrd { b : Ordinal | b.card.ord = b ∧ ω ≤ b } 
goal: Cardinal.ord ∘ Cardinal.aleph = Ordinal.enumOrd {b | b.card.ord = b ∧ ω ≤ b}

full_name: Cardinal.beth
code: /-- Beth numbers are defined so that `beth 0 = ℵ₀`, `beth (succ o) = 2 ^ (beth o)`, and when `o` is
a limit ordinal, `beth o` is the supremum of `beth o'` for `o' < o`.

Assuming the generalized continuum hypothesis, which is undecidable in ZFC, `beth o = aleph o` for
every `o`. -/
def beth (o : Ordinal.{u}) : Cardinal.{u} 
goal: Cardinal.{u}

full_name: Cardinal.beth_zero
code: @[simp]
theorem beth_zero : beth 0 = aleph0 
goal: Cardinal.beth 0 = ℵ₀

full_name: Cardinal.beth_succ
code: @[simp]
theorem beth_succ (o : Ordinal) : beth (succ o) = 2 ^ beth o 
goal: Cardinal.beth (Order.succ o) = 2 ^ Cardinal.beth o

full_name: Cardinal.beth_limit
code: theorem beth_limit {o : Ordinal} : o.IsLimit → beth o = ⨆ a : Iio o, beth a 
goal: o.IsLimit → Cardinal.beth o = ⨆ a, Cardinal.beth ↑a

full_name: Cardinal.beth_strictMono
code: theorem beth_strictMono : StrictMono beth 
goal: StrictMono Cardinal.beth

full_name: Cardinal.beth_mono
code: theorem beth_mono : Monotone beth 
goal: Monotone Cardinal.beth

full_name: Cardinal.beth_lt
code: @[simp]
theorem beth_lt {o₁ o₂ : Ordinal} : beth o₁ < beth o₂ ↔ o₁ < o₂ 
goal: Cardinal.beth o₁ < Cardinal.beth o₂ ↔ o₁ < o₂

full_name: Cardinal.beth_le
code: @[simp]
theorem beth_le {o₁ o₂ : Ordinal} : beth o₁ ≤ beth o₂ ↔ o₁ ≤ o₂ 
goal: Cardinal.beth o₁ ≤ Cardinal.beth o₂ ↔ o₁ ≤ o₂

full_name: Cardinal.aleph_le_beth
code: theorem aleph_le_beth (o : Ordinal) : aleph o ≤ beth o 
goal: Cardinal.aleph o ≤ Cardinal.beth o

full_name: Cardinal.aleph0_le_beth
code: theorem aleph0_le_beth (o : Ordinal) : ℵ₀ ≤ beth o 
goal: ℵ₀ ≤ Cardinal.beth o

full_name: Cardinal.beth_pos
code: theorem beth_pos (o : Ordinal) : 0 < beth o 
goal: 0 < Cardinal.beth o

full_name: Cardinal.beth_ne_zero
code: theorem beth_ne_zero (o : Ordinal) : beth o ≠ 0 
goal: Cardinal.beth o ≠ 0

full_name: Cardinal.beth_normal
code: theorem beth_normal : IsNormal.{u} fun o => (beth o).ord 
goal: Ordinal.IsNormal fun o => (Cardinal.beth o).ord

full_name: Cardinal.mul_eq_self
code: /-- If `α` is an infinite type, then `α × α` and `α` have the same cardinality. -/
theorem mul_eq_self {c : Cardinal} (h : ℵ₀ ≤ c) : c * c = c 
goal: c * c = c

full_name: Cardinal.mul_eq_max
code: /-- If `α` and `β` are infinite types, then the cardinality of `α × β` is the maximum
of the cardinalities of `α` and `β`. -/
theorem mul_eq_max {a b : Cardinal} (ha : ℵ₀ ≤ a) (hb : ℵ₀ ≤ b) : a * b = max a b 
goal: a * b = max a b

full_name: Cardinal.mul_mk_eq_max
code: @[simp]
theorem mul_mk_eq_max {α β : Type u} [Infinite α] [Infinite β] : #α * #β = max #α #β 
goal: #α * #β = max #α #β

full_name: Cardinal.aleph_mul_aleph
code: @[simp]
theorem aleph_mul_aleph (o₁ o₂ : Ordinal) : aleph o₁ * aleph o₂ = aleph (max o₁ o₂) 
goal: Cardinal.aleph o₁ * Cardinal.aleph o₂ = Cardinal.aleph (max o₁ o₂)

full_name: Cardinal.aleph0_mul_eq
code: @[simp]
theorem aleph0_mul_eq {a : Cardinal} (ha : ℵ₀ ≤ a) : ℵ₀ * a = a 
goal: ℵ₀ * a = a

full_name: Cardinal.mul_aleph0_eq
code: @[simp]
theorem mul_aleph0_eq {a : Cardinal} (ha : ℵ₀ ≤ a) : a * ℵ₀ = a 
goal: a * ℵ₀ = a

full_name: Cardinal.aleph0_mul_mk_eq
code: theorem aleph0_mul_mk_eq {α : Type*} [Infinite α] : ℵ₀ * #α = #α 
goal: ℵ₀ * #α = #α

full_name: Cardinal.mk_mul_aleph0_eq
code: theorem mk_mul_aleph0_eq {α : Type*} [Infinite α] : #α * ℵ₀ = #α 
goal: #α * ℵ₀ = #α

full_name: Cardinal.aleph0_mul_aleph
code: @[simp]
theorem aleph0_mul_aleph (o : Ordinal) : ℵ₀ * aleph o = aleph o 
goal: ℵ₀ * Cardinal.aleph o = Cardinal.aleph o

full_name: Cardinal.aleph_mul_aleph0
code: @[simp]
theorem aleph_mul_aleph0 (o : Ordinal) : aleph o * ℵ₀ = aleph o 
goal: Cardinal.aleph o * ℵ₀ = Cardinal.aleph o

full_name: Cardinal.mul_lt_of_lt
code: theorem mul_lt_of_lt {a b c : Cardinal} (hc : ℵ₀ ≤ c) (h1 : a < c) (h2 : b < c) : a * b < c 
goal: a * b < c

full_name: Cardinal.mul_le_max_of_aleph0_le_left
code: theorem mul_le_max_of_aleph0_le_left {a b : Cardinal} (h : ℵ₀ ≤ a) : a * b ≤ max a b 
goal: a * b ≤ max a b

full_name: Cardinal.mul_eq_max_of_aleph0_le_left
code: theorem mul_eq_max_of_aleph0_le_left {a b : Cardinal} (h : ℵ₀ ≤ a) (h' : b ≠ 0) :
    a * b = max a b 
goal: a * b = max a b

full_name: Cardinal.mul_le_max_of_aleph0_le_right
code: theorem mul_le_max_of_aleph0_le_right {a b : Cardinal} (h : ℵ₀ ≤ b) : a * b ≤ max a b 
goal: a * b ≤ max a b

full_name: Cardinal.mul_eq_max_of_aleph0_le_right
code: theorem mul_eq_max_of_aleph0_le_right {a b : Cardinal} (h' : a ≠ 0) (h : ℵ₀ ≤ b) :
    a * b = max a b 
goal: a * b = max a b

full_name: Cardinal.mul_eq_max'
code: theorem mul_eq_max' {a b : Cardinal} (h : ℵ₀ ≤ a * b) : a * b = max a b 
goal: a * b = max a b

full_name: Cardinal.mul_le_max
code: theorem mul_le_max (a b : Cardinal) : a * b ≤ max (max a b) ℵ₀ 
goal: a * b ≤ max (max a b) ℵ₀

full_name: Cardinal.mul_eq_left
code: theorem mul_eq_left {a b : Cardinal} (ha : ℵ₀ ≤ a) (hb : b ≤ a) (hb' : b ≠ 0) : a * b = a 
goal: a * b = a

full_name: Cardinal.mul_eq_right
code: theorem mul_eq_right {a b : Cardinal} (hb : ℵ₀ ≤ b) (ha : a ≤ b) (ha' : a ≠ 0) : a * b = b 
goal: a * b = b

full_name: Cardinal.le_mul_left
code: theorem le_mul_left {a b : Cardinal} (h : b ≠ 0) : a ≤ b * a 
goal: a ≤ b * a

full_name: Cardinal.le_mul_right
code: theorem le_mul_right {a b : Cardinal} (h : b ≠ 0) : a ≤ a * b 
goal: a ≤ a * b

full_name: Cardinal.mul_eq_left_iff
code: theorem mul_eq_left_iff {a b : Cardinal} : a * b = a ↔ max ℵ₀ b ≤ a ∧ b ≠ 0 ∨ b = 1 ∨ a = 0 
goal: a * b = a ↔ max ℵ₀ b ≤ a ∧ b ≠ 0 ∨ b = 1 ∨ a = 0

full_name: Cardinal.add_eq_self
code: /-- If `α` is an infinite type, then `α ⊕ α` and `α` have the same cardinality. -/
theorem add_eq_self {c : Cardinal} (h : ℵ₀ ≤ c) : c + c = c 
goal: c + c = c

full_name: Cardinal.add_eq_max
code: /-- If `α` is an infinite type, then the cardinality of `α ⊕ β` is the maximum
of the cardinalities of `α` and `β`. -/
theorem add_eq_max {a b : Cardinal} (ha : ℵ₀ ≤ a) : a + b = max a b 
goal: a + b = max a b

full_name: Cardinal.add_eq_max'
code: theorem add_eq_max' {a b : Cardinal} (ha : ℵ₀ ≤ b) : a + b = max a b 
goal: a + b = max a b

full_name: Cardinal.add_mk_eq_max
code: @[simp]
theorem add_mk_eq_max {α β : Type u} [Infinite α] : #α + #β = max #α #β 
goal: #α + #β = max #α #β

full_name: Cardinal.add_mk_eq_max'
code: @[simp]
theorem add_mk_eq_max' {α β : Type u} [Infinite β] : #α + #β = max #α #β 
goal: #α + #β = max #α #β

full_name: Cardinal.add_le_max
code: theorem add_le_max (a b : Cardinal) : a + b ≤ max (max a b) ℵ₀ 
goal: a + b ≤ max (max a b) ℵ₀

full_name: Cardinal.add_le_of_le
code: theorem add_le_of_le {a b c : Cardinal} (hc : ℵ₀ ≤ c) (h1 : a ≤ c) (h2 : b ≤ c) : a + b ≤ c 
goal: a + b ≤ c

full_name: Cardinal.add_lt_of_lt
code: theorem add_lt_of_lt {a b c : Cardinal} (hc : ℵ₀ ≤ c) (h1 : a < c) (h2 : b < c) : a + b < c 
goal: a + b < c

full_name: Cardinal.eq_of_add_eq_of_aleph0_le
code: theorem eq_of_add_eq_of_aleph0_le {a b c : Cardinal} (h : a + b = c) (ha : a < c) (hc : ℵ₀ ≤ c) :
    b = c 
goal: b = c

full_name: Cardinal.add_eq_left
code: theorem add_eq_left {a b : Cardinal} (ha : ℵ₀ ≤ a) (hb : b ≤ a) : a + b = a 
goal: a + b = a

full_name: Cardinal.add_eq_right
code: theorem add_eq_right {a b : Cardinal} (hb : ℵ₀ ≤ b) (ha : a ≤ b) : a + b = b 
goal: a + b = b

full_name: Cardinal.add_eq_left_iff
code: theorem add_eq_left_iff {a b : Cardinal} : a + b = a ↔ max ℵ₀ b ≤ a ∨ b = 0 
goal: a + b = a ↔ max ℵ₀ b ≤ a ∨ b = 0

full_name: Cardinal.add_eq_right_iff
code: theorem add_eq_right_iff {a b : Cardinal} : a + b = b ↔ max ℵ₀ a ≤ b ∨ a = 0 
goal: a + b = b ↔ max ℵ₀ a ≤ b ∨ a = 0

full_name: Cardinal.add_nat_eq
code: theorem add_nat_eq {a : Cardinal} (n : ℕ) (ha : ℵ₀ ≤ a) : a + n = a 
goal: a + ↑n = a

full_name: Cardinal.nat_add_eq
code: theorem nat_add_eq {a : Cardinal} (n : ℕ) (ha : ℵ₀ ≤ a) : n + a = a 
goal: ↑n + a = a

full_name: Cardinal.add_one_eq
code: theorem add_one_eq {a : Cardinal} (ha : ℵ₀ ≤ a) : a + 1 = a 
goal: a + 1 = a

full_name: Cardinal.mk_add_one_eq
code: theorem mk_add_one_eq {α : Type*} [Infinite α] : #α + 1 = #α 
goal: #α + 1 = #α

full_name: Cardinal.eq_of_add_eq_add_left
code: protected theorem eq_of_add_eq_add_left {a b c : Cardinal} (h : a + b = a + c) (ha : a < ℵ₀) :
    b = c 
goal: b = c

full_name: Cardinal.eq_of_add_eq_add_right
code: protected theorem eq_of_add_eq_add_right {a b c : Cardinal} (h : a + b = c + b) (hb : b < ℵ₀) :
    a = c 
goal: a = c

full_name: Cardinal.ciSup_add
code: protected theorem ciSup_add (c : Cardinal.{v}) : (⨆ i, f i) + c = ⨆ i, f i + c 
goal: (⨆ i, f i) + c = ⨆ i, f i + c

full_name: Cardinal.add_ciSup
code: protected theorem add_ciSup (c : Cardinal.{v}) : c + (⨆ i, f i) = ⨆ i, c + f i 
goal: c + ⨆ i, f i = ⨆ i, c + f i

full_name: Cardinal.ciSup_add_ciSup
code: protected theorem ciSup_add_ciSup (g : ι' → Cardinal.{v}) (hg : BddAbove (range g)) :
    (⨆ i, f i) + (⨆ j, g j) = ⨆ (i) (j), f i + g j 
goal: (⨆ i, f i) + ⨆ j, g j = ⨆ i, ⨆ j, f i + g j

full_name: Cardinal.ciSup_mul
code: protected theorem ciSup_mul (c : Cardinal.{v}) : (⨆ i, f i) * c = ⨆ i, f i * c 
goal: (⨆ i, f i) * c = ⨆ i, f i * c

full_name: Cardinal.mul_ciSup
code: protected theorem mul_ciSup (c : Cardinal.{v}) : c * (⨆ i, f i) = ⨆ i, c * f i 
goal: c * ⨆ i, f i = ⨆ i, c * f i

full_name: Cardinal.ciSup_mul_ciSup
code: protected theorem ciSup_mul_ciSup (g : ι' → Cardinal.{v}) :
    (⨆ i, f i) * (⨆ j, g j) = ⨆ (i) (j), f i * g j 
goal: (⨆ i, f i) * ⨆ j, g j = ⨆ i, ⨆ j, f i * g j

full_name: Cardinal.aleph_add_aleph
code: @[simp]
theorem aleph_add_aleph (o₁ o₂ : Ordinal) : aleph o₁ + aleph o₂ = aleph (max o₁ o₂) 
goal: Cardinal.aleph o₁ + Cardinal.aleph o₂ = Cardinal.aleph (max o₁ o₂)

full_name: Cardinal.principal_add_ord
code: theorem principal_add_ord {c : Cardinal} (hc : ℵ₀ ≤ c) : Ordinal.Principal (· + ·) c.ord 
goal: Ordinal.Principal (fun x x_1 => x + x_1) c.ord

full_name: Cardinal.principal_add_aleph
code: theorem principal_add_aleph (o : Ordinal) : Ordinal.Principal (· + ·) (aleph o).ord 
goal: Ordinal.Principal (fun x x_1 => x + x_1) (Cardinal.aleph o).ord

full_name: Cardinal.add_right_inj_of_lt_aleph0
code: theorem add_right_inj_of_lt_aleph0 {α β γ : Cardinal} (γ₀ : γ < aleph0) : α + γ = β + γ ↔ α = β 
goal: α + γ = β + γ ↔ α = β

full_name: Cardinal.add_nat_inj
code: @[simp]
theorem add_nat_inj {α β : Cardinal} (n : ℕ) : α + n = β + n ↔ α = β 
goal: α + ↑n = β + ↑n ↔ α = β

full_name: Cardinal.add_one_inj
code: @[simp]
theorem add_one_inj {α β : Cardinal} : α + 1 = β + 1 ↔ α = β 
goal: α + 1 = β + 1 ↔ α = β

full_name: Cardinal.add_le_add_iff_of_lt_aleph0
code: theorem add_le_add_iff_of_lt_aleph0 {α β γ : Cardinal} (γ₀ : γ < Cardinal.aleph0) :
    α + γ ≤ β + γ ↔ α ≤ β 
goal: α + γ ≤ β + γ ↔ α ≤ β

full_name: Cardinal.add_nat_le_add_nat_iff
code: @[simp]
theorem add_nat_le_add_nat_iff {α β : Cardinal} (n : ℕ) : α + n ≤ β + n ↔ α ≤ β 
goal: α + ↑n ≤ β + ↑n ↔ α ≤ β

full_name: Cardinal.add_one_le_add_one_iff
code: @[simp]
theorem add_one_le_add_one_iff {α β : Cardinal} : α + 1 ≤ β + 1 ↔ α ≤ β 
goal: α + 1 ≤ β + 1 ↔ α ≤ β

full_name: Cardinal.pow_le
code: theorem pow_le {κ μ : Cardinal.{u}} (H1 : ℵ₀ ≤ κ) (H2 : μ < ℵ₀) : κ ^ μ ≤ κ 
goal: κ ^ μ ≤ κ

full_name: Cardinal.pow_eq
code: theorem pow_eq {κ μ : Cardinal.{u}} (H1 : ℵ₀ ≤ κ) (H2 : 1 ≤ μ) (H3 : μ < ℵ₀) : κ ^ μ = κ 
goal: κ ^ μ = κ

full_name: Cardinal.power_self_eq
code: theorem power_self_eq {c : Cardinal} (h : ℵ₀ ≤ c) : c ^ c = 2 ^ c 
goal: c ^ c = 2 ^ c

full_name: Cardinal.prod_eq_two_power
code: theorem prod_eq_two_power {ι : Type u} [Infinite ι] {c : ι → Cardinal.{v}} (h₁ : ∀ i, 2 ≤ c i)
    (h₂ : ∀ i, lift.{u} (c i) ≤ lift.{v} #ι) : prod c = 2 ^ lift.{v} #ι 
goal: Cardinal.prod c = 2 ^ Cardinal.lift.{v, u} #ι

full_name: Cardinal.power_eq_two_power
code: theorem power_eq_two_power {c₁ c₂ : Cardinal} (h₁ : ℵ₀ ≤ c₁) (h₂ : 2 ≤ c₂) (h₂' : c₂ ≤ c₁) :
    c₂ ^ c₁ = 2 ^ c₁ 
goal: c₂ ^ c₁ = 2 ^ c₁

full_name: Cardinal.nat_power_eq
code: theorem nat_power_eq {c : Cardinal.{u}} (h : ℵ₀ ≤ c) {n : ℕ} (hn : 2 ≤ n) :
    (n : Cardinal.{u}) ^ c = 2 ^ c 
goal: ↑n ^ c = 2 ^ c

full_name: Cardinal.power_nat_le
code: theorem power_nat_le {c : Cardinal.{u}} {n : ℕ} (h : ℵ₀ ≤ c) : c ^ n ≤ c 
goal: c ^ n ≤ c

full_name: Cardinal.power_nat_eq
code: theorem power_nat_eq {c : Cardinal.{u}} {n : ℕ} (h1 : ℵ₀ ≤ c) (h2 : 1 ≤ n) : c ^ n = c 
goal: c ^ n = c

full_name: Cardinal.power_nat_le_max
code: theorem power_nat_le_max {c : Cardinal.{u}} {n : ℕ} : c ^ (n : Cardinal.{u}) ≤ max c ℵ₀ 
goal: c ^ ↑n ≤ max c ℵ₀

full_name: Cardinal.powerlt_aleph0
code: theorem powerlt_aleph0 {c : Cardinal} (h : ℵ₀ ≤ c) : c ^< ℵ₀ = c 
goal: c ^< ℵ₀ = c

full_name: Cardinal.powerlt_aleph0_le
code: theorem powerlt_aleph0_le (c : Cardinal) : c ^< ℵ₀ ≤ max c ℵ₀ 
goal: c ^< ℵ₀ ≤ max c ℵ₀

full_name: Cardinal.mk_equiv_eq_zero_iff_lift_ne
code: theorem mk_equiv_eq_zero_iff_lift_ne : #(α ≃ β') = 0 ↔ lift.{v} #α ≠ lift.{u} #β' 
goal: #(α ≃ β') = 0 ↔ Cardinal.lift.{v, u} #α ≠ Cardinal.lift.{u, v} #β'

full_name: Cardinal.mk_equiv_eq_zero_iff_ne
code: theorem mk_equiv_eq_zero_iff_ne : #(α ≃ β) = 0 ↔ #α ≠ #β 
goal: #(α ≃ β) = 0 ↔ #α ≠ #β

full_name: Cardinal.mk_equiv_comm
code: /-- This lemma makes lemmas assuming `Infinite α` applicable to the situation where we have
  `Infinite β` instead. -/
theorem mk_equiv_comm : #(α ≃ β') = #(β' ≃ α) 
goal: #(α ≃ β') = #(β' ≃ α)

full_name: Cardinal.mk_embedding_eq_zero_iff_lift_lt
code: theorem mk_embedding_eq_zero_iff_lift_lt : #(α ↪ β') = 0 ↔ lift.{u} #β' < lift.{v} #α 
goal: #(α ↪ β') = 0 ↔ Cardinal.lift.{u, v} #β' < Cardinal.lift.{v, u} #α

full_name: Cardinal.mk_embedding_eq_zero_iff_lt
code: theorem mk_embedding_eq_zero_iff_lt : #(α ↪ β) = 0 ↔ #β < #α 
goal: #(α ↪ β) = 0 ↔ #β < #α

full_name: Cardinal.mk_arrow_eq_zero_iff
code: theorem mk_arrow_eq_zero_iff : #(α → β') = 0 ↔ #α ≠ 0 ∧ #β' = 0 
goal: #(α → β') = 0 ↔ #α ≠ 0 ∧ #β' = 0

full_name: Cardinal.mk_surjective_eq_zero_iff_lift
code: theorem mk_surjective_eq_zero_iff_lift :
    #{f : α → β' | Surjective f} = 0 ↔ lift.{v} #α < lift.{u} #β' ∨ (#α ≠ 0 ∧ #β' = 0) 
goal: #↑{f | Function.Surjective f} = 0 ↔ Cardinal.lift.{v, u} #α < Cardinal.lift.{u, v} #β' ∨ #α ≠ 0 ∧ #β' = 0

full_name: Cardinal.mk_surjective_eq_zero_iff
code: theorem mk_surjective_eq_zero_iff :
    #{f : α → β | Surjective f} = 0 ↔ #α < #β ∨ (#α ≠ 0 ∧ #β = 0) 
goal: #↑{f | Function.Surjective f} = 0 ↔ #α < #β ∨ #α ≠ 0 ∧ #β = 0

full_name: Cardinal.mk_equiv_le_embedding
code: theorem mk_equiv_le_embedding : #(α ≃ β') ≤ #(α ↪ β') 
goal: #(α ≃ β') ≤ #(α ↪ β')

full_name: Cardinal.mk_embedding_le_arrow
code: theorem mk_embedding_le_arrow : #(α ↪ β') ≤ #(α → β') 
goal: #(α ↪ β') ≤ #(α → β')

full_name: Cardinal.mk_perm_eq_self_power
code: theorem mk_perm_eq_self_power : #(Equiv.Perm α) = #α ^ #α 
goal: #(Equiv.Perm α) = #α ^ #α

full_name: Cardinal.mk_perm_eq_two_power
code: theorem mk_perm_eq_two_power : #(Equiv.Perm α) = 2 ^ #α 
goal: #(Equiv.Perm α) = 2 ^ #α

full_name: Cardinal.mk_equiv_eq_arrow_of_lift_eq
code: theorem mk_equiv_eq_arrow_of_lift_eq (leq : lift.{v} #α = lift.{u} #β') :
    #(α ≃ β') = #(α → β') 
goal: #(α ≃ β') = #(α → β')

full_name: Cardinal.mk_equiv_eq_arrow_of_eq
code: theorem mk_equiv_eq_arrow_of_eq (eq : #α = #β) : #(α ≃ β) = #(α → β) 
goal: #(α ≃ β) = #(α → β)

full_name: Cardinal.mk_equiv_of_lift_eq
code: theorem mk_equiv_of_lift_eq (leq : lift.{v} #α = lift.{u} #β') : #(α ≃ β') = 2 ^ lift.{v} #α 
goal: #(α ≃ β') = 2 ^ Cardinal.lift.{v, u} #α

full_name: Cardinal.mk_equiv_of_eq
code: theorem mk_equiv_of_eq (eq : #α = #β) : #(α ≃ β) = 2 ^ #α 
goal: #(α ≃ β) = 2 ^ #α

full_name: Cardinal.mk_embedding_eq_arrow_of_lift_le
code: theorem mk_embedding_eq_arrow_of_lift_le (lle : lift.{u} #β' ≤ lift.{v} #α) :
    #(β' ↪ α) = #(β' → α) 
goal: #(β' ↪ α) = #(β' → α)

full_name: Cardinal.mk_embedding_eq_arrow_of_le
code: theorem mk_embedding_eq_arrow_of_le (le : #β ≤ #α) : #(β ↪ α) = #(β → α) 
goal: #(β ↪ α) = #(β → α)

full_name: Cardinal.mk_surjective_eq_arrow_of_lift_le
code: theorem mk_surjective_eq_arrow_of_lift_le (lle : lift.{u} #β' ≤ lift.{v} #α) :
    #{f : α → β' | Surjective f} = #(α → β') 
goal: #↑{f | Function.Surjective f} = #(α → β')

full_name: Cardinal.mk_surjective_eq_arrow_of_le
code: theorem mk_surjective_eq_arrow_of_le (le : #β ≤ #α) : #{f : α → β | Surjective f} = #(α → β) 
goal: #↑{f | Function.Surjective f} = #(α → β)

full_name: Cardinal.mk_list_eq_mk
code: @[simp]
theorem mk_list_eq_mk (α : Type u) [Infinite α] : #(List α) = #α 
goal: #(List α) = #α

full_name: Cardinal.mk_list_eq_aleph0
code: theorem mk_list_eq_aleph0 (α : Type u) [Countable α] [Nonempty α] : #(List α) = ℵ₀ 
goal: #(List α) = ℵ₀

full_name: Cardinal.mk_list_eq_max_mk_aleph0
code: theorem mk_list_eq_max_mk_aleph0 (α : Type u) [Nonempty α] : #(List α) = max #α ℵ₀ 
goal: #(List α) = max #α ℵ₀

full_name: Cardinal.mk_list_le_max
code: theorem mk_list_le_max (α : Type u) : #(List α) ≤ max ℵ₀ #α 
goal: #(List α) ≤ max ℵ₀ #α

full_name: Cardinal.mk_finset_of_infinite
code: @[simp]
theorem mk_finset_of_infinite (α : Type u) [Infinite α] : #(Finset α) = #α 
goal: #(Finset α) = #α

full_name: Cardinal.mk_finsupp_lift_of_infinite
code: @[simp]
theorem mk_finsupp_lift_of_infinite (α : Type u) (β : Type v) [Infinite α] [Zero β] [Nontrivial β] :
    #(α →₀ β) = max (lift.{v} #α) (lift.{u} #β) 
goal: #(α →₀ β) = max (Cardinal.lift.{v, u} #α) (Cardinal.lift.{u, v} #β)

full_name: Cardinal.mk_finsupp_of_infinite
code: theorem mk_finsupp_of_infinite (α β : Type u) [Infinite α] [Zero β] [Nontrivial β] :
    #(α →₀ β) = max #α #β 
goal: #(α →₀ β) = max #α #β

full_name: Cardinal.mk_finsupp_lift_of_infinite'
code: @[simp]
theorem mk_finsupp_lift_of_infinite' (α : Type u) (β : Type v) [Nonempty α] [Zero β] [Infinite β] :
    #(α →₀ β) = max (lift.{v} #α) (lift.{u} #β) 
goal: #(α →₀ β) = max (Cardinal.lift.{v, u} #α) (Cardinal.lift.{u, v} #β)

full_name: Cardinal.mk_finsupp_of_infinite'
code: theorem mk_finsupp_of_infinite' (α β : Type u) [Nonempty α] [Zero β] [Infinite β] :
    #(α →₀ β) = max #α #β 
goal: #(α →₀ β) = max #α #β

full_name: Cardinal.mk_finsupp_nat
code: theorem mk_finsupp_nat (α : Type u) [Nonempty α] : #(α →₀ ℕ) = max #α ℵ₀ 
goal: #(α →₀ ℕ) = max #α ℵ₀

full_name: Cardinal.mk_multiset_of_nonempty
code: @[simp]
theorem mk_multiset_of_nonempty (α : Type u) [Nonempty α] : #(Multiset α) = max #α ℵ₀ 
goal: #(Multiset α) = max #α ℵ₀

full_name: Cardinal.mk_multiset_of_infinite
code: theorem mk_multiset_of_infinite (α : Type u) [Infinite α] : #(Multiset α) = #α 
goal: #(Multiset α) = #α

full_name: Cardinal.mk_multiset_of_isEmpty
code: theorem mk_multiset_of_isEmpty (α : Type u) [IsEmpty α] : #(Multiset α) = 1 
goal: #(Multiset α) = 1

full_name: Cardinal.mk_multiset_of_countable
code: theorem mk_multiset_of_countable (α : Type u) [Countable α] [Nonempty α] : #(Multiset α) = ℵ₀ 
goal: #(Multiset α) = ℵ₀

full_name: Cardinal.mk_bounded_set_le_of_infinite
code: theorem mk_bounded_set_le_of_infinite (α : Type u) [Infinite α] (c : Cardinal) :
    #{ t : Set α // #t ≤ c } ≤ #α ^ c 
goal: #{ t // #↑t ≤ c } ≤ #α ^ c

full_name: Cardinal.mk_bounded_set_le
code: theorem mk_bounded_set_le (α : Type u) (c : Cardinal) :
    #{ t : Set α // #t ≤ c } ≤ max #α ℵ₀ ^ c 
goal: #{ t // #↑t ≤ c } ≤ max #α ℵ₀ ^ c

full_name: Cardinal.mk_bounded_subset_le
code: theorem mk_bounded_subset_le {α : Type u} (s : Set α) (c : Cardinal.{u}) :
    #{ t : Set α // t ⊆ s ∧ #t ≤ c } ≤ max #s ℵ₀ ^ c 
goal: #{ t // t ⊆ s ∧ #↑t ≤ c } ≤ max #↑s ℵ₀ ^ c

full_name: Cardinal.mk_compl_of_infinite
code: theorem mk_compl_of_infinite {α : Type*} [Infinite α] (s : Set α) (h2 : #s < #α) :
    #(sᶜ : Set α) = #α 
goal: #↑sᶜ = #α

full_name: Cardinal.mk_compl_finset_of_infinite
code: theorem mk_compl_finset_of_infinite {α : Type*} [Infinite α] (s : Finset α) :
    #((↑s)ᶜ : Set α) = #α 
goal: #↑(↑s)ᶜ = #α

full_name: Cardinal.mk_compl_eq_mk_compl_infinite
code: theorem mk_compl_eq_mk_compl_infinite {α : Type*} [Infinite α] {s t : Set α} (hs : #s < #α)
    (ht : #t < #α) : #(sᶜ : Set α) = #(tᶜ : Set α) 
goal: #↑sᶜ = #↑tᶜ

full_name: Cardinal.mk_compl_eq_mk_compl_finite_lift
code: theorem mk_compl_eq_mk_compl_finite_lift {α : Type u} {β : Type v} [Finite α] {s : Set α}
    {t : Set β} (h1 : (lift.{max v w, u} #α) = (lift.{max u w, v} #β))
    (h2 : lift.{max v w, u} #s = lift.{max u w, v} #t) :
    lift.{max v w} #(sᶜ : Set α) = lift.{max u w} #(tᶜ : Set β) 
goal: Cardinal.lift.{max v w, u} #↑sᶜ = Cardinal.lift.{max u w, v} #↑tᶜ

full_name: Cardinal.mk_compl_eq_mk_compl_finite
code: theorem mk_compl_eq_mk_compl_finite {α β : Type u} [Finite α] {s : Set α} {t : Set β}
    (h1 : #α = #β) (h : #s = #t) : #(sᶜ : Set α) = #(tᶜ : Set β) 
goal: #↑sᶜ = #↑tᶜ

full_name: Cardinal.mk_compl_eq_mk_compl_finite_same
code: theorem mk_compl_eq_mk_compl_finite_same {α : Type u} [Finite α] {s t : Set α} (h : #s = #t) :
    #(sᶜ : Set α) = #(tᶜ : Set α) 
goal: #↑sᶜ = #↑tᶜ

full_name: Cardinal.extend_function
code: theorem extend_function {α β : Type*} {s : Set α} (f : s ↪ β)
    (h : Nonempty ((sᶜ : Set α) ≃ ((range f)ᶜ : Set β))) : ∃ g : α ≃ β, ∀ x : s, g x = f x 
goal: ∃ g, ∀ (x : ↑s), g ↑x = f x

full_name: Cardinal.extend_function_finite
code: theorem extend_function_finite {α : Type u} {β : Type v} [Finite α] {s : Set α} (f : s ↪ β)
    (h : Nonempty (α ≃ β)) : ∃ g : α ≃ β, ∀ x : s, g x = f x 
goal: ∃ g, ∀ (x : ↑s), g ↑x = f x

full_name: Cardinal.extend_function_of_lt
code: theorem extend_function_of_lt {α β : Type*} {s : Set α} (f : s ↪ β) (hs : #s < #α)
    (h : Nonempty (α ≃ β)) : ∃ g : α ≃ β, ∀ x : s, g x = f x 
goal: ∃ g, ∀ (x : ↑s), g ↑x = f x

full_name: Ordinal._aux_Mathlib_SetTheory_Cardinal_Ordinal___macroRules_Ordinal_termω___1
code: /--
`ω_ o` is a notation for the *initial ordinal* of cardinality
`aleph o`. Thus, for example `ω_ 0 = ω`.
-/
scoped notation "ω_" o => ord <| aleph o
goal: Lean.Macro

full_name: Ordinal._aux_Mathlib_SetTheory_Cardinal_Ordinal___macroRules_Ordinal_termω₁_1
code: /--
`ω₁` is the first uncountable ordinal.
-/
scoped notation "ω₁" => ord <| aleph 1
goal: Lean.Macro

full_name: Ordinal.omega_lt_omega1
code: lemma omega_lt_omega1 : ω < ω₁ 
goal: ω < (Cardinal.aleph 1).ord

full_name: Ordinal.Cardinal.mk_iUnion_Ordinal_le_of_le
code: /--
Bounding the cardinal of an ordinal-indexed union of sets.
-/
lemma mk_iUnion_Ordinal_le_of_le {β : Type*} {o : Ordinal} {c : Cardinal}
    (ho : o.card ≤ c) (hc : ℵ₀ ≤ c) (A : Ordinal → Set β)
    (hA : ∀ j < o, #(A j) ≤ c) :
    #(⋃ j < o, A j) ≤ c 
goal: #↑(⋃ j, ⋃ (_ : j < o), A j) ≤ c