File: Mathlib/SetTheory/Cardinal/Basic.lean

full_name: Cardinal.isEquivalent
code: /-- The equivalence relation on types given by equivalence (bijective correspondence) of types.
  Quotienting by this equivalence relation gives the cardinal numbers.
-/
instance Cardinal.isEquivalent : Setoid (Type u) 
goal: Setoid (Type u)

full_name: Cardinal
code: /-- `Cardinal.{u}` is the type of cardinal numbers in `Type u`,
  defined as the quotient of `Type u` by existence of an equivalence
  (a bijection with explicit inverse). -/
@[pp_with_univ]
def Cardinal : Type (u + 1) 
goal: Type (u + 1)

full_name: Cardinal.mk
code: /-- The cardinal number of a type -/
def mk : Type u → Cardinal 
goal: Type u → Cardinal.{u}

full_name: Cardinal._aux_Mathlib_SetTheory_Cardinal_Basic___unexpand_Cardinal_mk_1
code: @[inherit_doc]
scoped prefix:max "#" => Cardinal.mk
goal: Lean.PrettyPrinter.Unexpander

full_name: Cardinal.«_aux_Mathlib_SetTheory_Cardinal_Basic___macroRules_Cardinal_term#__1»
code: @[inherit_doc]
scoped prefix:max "#" => Cardinal.mk
goal: Lean.Macro

full_name: Cardinal.canLiftCardinalType
code: instance canLiftCardinalType : CanLift Cardinal.{u} (Type u) mk fun _ => True 
goal: CanLift Cardinal.{u} (Type u) Cardinal.mk fun x => True

full_name: Cardinal.inductionOn
code: @[elab_as_elim]
theorem inductionOn {p : Cardinal → Prop} (c : Cardinal) (h : ∀ α, p #α) : p c 
goal: p c

full_name: Cardinal.inductionOn₂
code: @[elab_as_elim]
theorem inductionOn₂ {p : Cardinal → Cardinal → Prop} (c₁ : Cardinal) (c₂ : Cardinal)
    (h : ∀ α β, p #α #β) : p c₁ c₂ 
goal: p c₁ c₂

full_name: Cardinal.inductionOn₃
code: @[elab_as_elim]
theorem inductionOn₃ {p : Cardinal → Cardinal → Cardinal → Prop} (c₁ : Cardinal) (c₂ : Cardinal)
    (c₃ : Cardinal) (h : ∀ α β γ, p #α #β #γ) : p c₁ c₂ c₃ 
goal: p c₁ c₂ c₃

full_name: Cardinal.eq
code: protected theorem eq : #α = #β ↔ Nonempty (α ≃ β) 
goal: Cardinal.mk α = Cardinal.mk β ↔ Nonempty (α ≃ β)

full_name: Cardinal.mk'_def
code: @[simp]
theorem mk'_def (α : Type u) : @Eq Cardinal ⟦α⟧ #α 
goal: ⟦α⟧ = Cardinal.mk α

full_name: Cardinal.mk_out
code: @[simp]
theorem mk_out (c : Cardinal) : #c.out = c 
goal: Cardinal.mk (Quotient.out c) = c

full_name: Cardinal.outMkEquiv
code: /-- The representative of the cardinal of a type is equivalent to the original type. -/
def outMkEquiv {α : Type v} : (#α).out ≃ α 
goal: Quotient.out (Cardinal.mk α) ≃ α

full_name: Cardinal.mk_congr
code: theorem mk_congr (e : α ≃ β) : #α = #β 
goal: Cardinal.mk α = Cardinal.mk β

full_name: Cardinal.map
code: /-- Lift a function between `Type*`s to a function between `Cardinal`s. -/
def map (f : Type u → Type v) (hf : ∀ α β, α ≃ β → f α ≃ f β) : Cardinal.{u} → Cardinal.{v} 
goal: Cardinal.{u} → Cardinal.{v}

full_name: Cardinal.map_mk
code: @[simp]
theorem map_mk (f : Type u → Type v) (hf : ∀ α β, α ≃ β → f α ≃ f β) (α : Type u) :
    map f hf #α = #(f α) 
goal: Cardinal.map f hf (Cardinal.mk α) = Cardinal.mk (f α)

full_name: Cardinal.map₂
code: /-- Lift a binary operation `Type* → Type* → Type*` to a binary operation on `Cardinal`s. -/
def map₂ (f : Type u → Type v → Type w) (hf : ∀ α β γ δ, α ≃ β → γ ≃ δ → f α γ ≃ f β δ) :
    Cardinal.{u} → Cardinal.{v} → Cardinal.{w} 
goal: Cardinal.{u} → Cardinal.{v} → Cardinal.{w}

full_name: Cardinal.lift
code: /-- The universe lift operation on cardinals. You can specify the universes explicitly with
  `lift.{u v} : Cardinal.{v} → Cardinal.{max v u}` -/
@[pp_with_univ]
def lift (c : Cardinal.{v}) : Cardinal.{max v u} 
goal: Cardinal.{max v u}

full_name: Cardinal.mk_uLift
code: @[simp]
theorem mk_uLift (α) : #(ULift.{v, u} α) = lift.{v} #α 
goal: Cardinal.mk (ULift.{v, u} α) = Cardinal.lift.{v, u} (Cardinal.mk α)

full_name: Cardinal.lift_umax
code: /-- `lift.{max u v, u}` equals `lift.{v, u}`. -/
@[simp, nolint simpNF]
theorem lift_umax : lift.{max u v, u} = lift.{v, u} 
goal: Cardinal.lift.{max u v, u} = Cardinal.lift.{v, u}

full_name: Cardinal.lift_umax'
code: /-- `lift.{max v u, u}` equals `lift.{v, u}`. -/
@[simp, nolint simpNF]
theorem lift_umax' : lift.{max v u, u} = lift.{v, u} 
goal: Cardinal.lift.{max v u, u} = Cardinal.lift.{v, u}

full_name: Cardinal.lift_id'
code: /-- A cardinal lifted to a lower or equal universe equals itself. -/
@[simp, nolint simpNF]
theorem lift_id' (a : Cardinal.{max u v}) : lift.{u} a = a 
goal: Cardinal.lift.{u, max u v} a = a

full_name: Cardinal.lift_id
code: /-- A cardinal lifted to the same universe equals itself. -/
@[simp]
theorem lift_id (a : Cardinal) : lift.{u, u} a = a 
goal: Cardinal.lift.{u, u} a = a

full_name: Cardinal.lift_uzero
code: /-- A cardinal lifted to the zero universe equals itself. -/
-- porting note (#10618): simp can prove this
-- @[simp]
theorem lift_uzero (a : Cardinal.{u}) : lift.{0} a = a 
goal: Cardinal.lift.{0, u} a = a

full_name: Cardinal.lift_lift
code: @[simp]
theorem lift_lift.{u_1} (a : Cardinal.{u_1}) : lift.{w} (lift.{v} a) = lift.{max v w} a 
goal: Cardinal.lift.{w, max v u_1} (Cardinal.lift.{v, u_1} a) = Cardinal.lift.{max v w, u_1} a

full_name: Cardinal.instLE
code: /-- We define the order on cardinal numbers by `#α ≤ #β` if and only if
  there exists an embedding (injective function) from α to β. -/
instance : LE Cardinal.{u} 
goal: LE Cardinal.{u}

full_name: Cardinal.partialOrder
code: instance partialOrder : PartialOrder Cardinal.{u} 
goal: PartialOrder Cardinal.{u}

full_name: Cardinal.linearOrder
code: instance linearOrder : LinearOrder Cardinal.{u} 
goal: LinearOrder Cardinal.{u}

full_name: Cardinal.le_def
code: theorem le_def (α β : Type u) : #α ≤ #β ↔ Nonempty (α ↪ β) 
goal: Cardinal.mk α ≤ Cardinal.mk β ↔ Nonempty (α ↪ β)

full_name: Cardinal.mk_le_of_injective
code: theorem mk_le_of_injective {α β : Type u} {f : α → β} (hf : Injective f) : #α ≤ #β 
goal: Cardinal.mk α ≤ Cardinal.mk β

full_name: Function.Embedding.cardinal_le
code: theorem _root_.Function.Embedding.cardinal_le {α β : Type u} (f : α ↪ β) : #α ≤ #β 
goal: Cardinal.mk α ≤ Cardinal.mk β

full_name: Cardinal.mk_le_of_surjective
code: theorem mk_le_of_surjective {α β : Type u} {f : α → β} (hf : Surjective f) : #β ≤ #α 
goal: Cardinal.mk β ≤ Cardinal.mk α

full_name: Cardinal.le_mk_iff_exists_set
code: theorem le_mk_iff_exists_set {c : Cardinal} {α : Type u} : c ≤ #α ↔ ∃ p : Set α, #p = c 
goal: c ≤ Cardinal.mk α ↔ ∃ p, Cardinal.mk ↑p = c

full_name: Cardinal.mk_subtype_le
code: theorem mk_subtype_le {α : Type u} (p : α → Prop) : #(Subtype p) ≤ #α 
goal: Cardinal.mk (Subtype p) ≤ Cardinal.mk α

full_name: Cardinal.mk_set_le
code: theorem mk_set_le (s : Set α) : #s ≤ #α 
goal: Cardinal.mk ↑s ≤ Cardinal.mk α

full_name: Cardinal.mk_preimage_down
code: @[simp]
lemma mk_preimage_down {s : Set α} : #(ULift.down.{v} ⁻¹' s) = lift.{v} (#s) 
goal: Cardinal.mk ↑(ULift.down ⁻¹' s) = Cardinal.lift.{v, u} (Cardinal.mk ↑s)

full_name: Cardinal.out_embedding
code: theorem out_embedding {c c' : Cardinal} : c ≤ c' ↔ Nonempty (c.out ↪ c'.out) 
goal: c ≤ c' ↔ Nonempty (Quotient.out c ↪ Quotient.out c')

full_name: Cardinal.lift_mk_le
code: theorem lift_mk_le {α : Type v} {β : Type w} :
    lift.{max u w} #α ≤ lift.{max u v} #β ↔ Nonempty (α ↪ β) 
goal: Cardinal.lift.{max u w, v} (Cardinal.mk α) ≤ Cardinal.lift.{max u v, w} (Cardinal.mk β) ↔ Nonempty (α ↪ β)

full_name: Cardinal.lift_mk_le'
code: /-- A variant of `Cardinal.lift_mk_le` with specialized universes.
Because Lean often can not realize it should use this specialization itself,
we provide this statement separately so you don't have to solve the specialization problem either.
-/
theorem lift_mk_le' {α : Type u} {β : Type v} : lift.{v} #α ≤ lift.{u} #β ↔ Nonempty (α ↪ β) 
goal: Cardinal.lift.{v, u} (Cardinal.mk α) ≤ Cardinal.lift.{u, v} (Cardinal.mk β) ↔ Nonempty (α ↪ β)

full_name: Cardinal.lift_mk_eq
code: theorem lift_mk_eq {α : Type u} {β : Type v} :
    lift.{max v w} #α = lift.{max u w} #β ↔ Nonempty (α ≃ β) 
goal: Cardinal.lift.{max v w, u} (Cardinal.mk α) = Cardinal.lift.{max u w, v} (Cardinal.mk β) ↔ Nonempty (α ≃ β)

full_name: Cardinal.lift_mk_eq'
code: /-- A variant of `Cardinal.lift_mk_eq` with specialized universes.
Because Lean often can not realize it should use this specialization itself,
we provide this statement separately so you don't have to solve the specialization problem either.
-/
theorem lift_mk_eq' {α : Type u} {β : Type v} : lift.{v} #α = lift.{u} #β ↔ Nonempty (α ≃ β) 
goal: Cardinal.lift.{v, u} (Cardinal.mk α) = Cardinal.lift.{u, v} (Cardinal.mk β) ↔ Nonempty (α ≃ β)

full_name: Cardinal.lift_le
code: @[simp]
theorem lift_le {a b : Cardinal.{v}} : lift.{u, v} a ≤ lift.{u, v} b ↔ a ≤ b 
goal: Cardinal.lift.{u, v} a ≤ Cardinal.lift.{u, v} b ↔ a ≤ b

full_name: Cardinal.liftOrderEmbedding_apply
code: /-- `Cardinal.lift` as an `OrderEmbedding`. -/
@[simps! (config := .asFn)]
def liftOrderEmbedding : Cardinal.{v} ↪o Cardinal.{max v u} 
goal: ⇑Cardinal.liftOrderEmbedding = Cardinal.lift.{u, v}

full_name: Cardinal.liftOrderEmbedding
code: /-- `Cardinal.lift` as an `OrderEmbedding`. -/
@[simps! (config := .asFn)]
def liftOrderEmbedding : Cardinal.{v} ↪o Cardinal.{max v u} 
goal: Cardinal.{v} ↪o Cardinal.{max v u}

full_name: Cardinal.lift_injective
code: theorem lift_injective : Injective lift.{u, v} 
goal: Function.Injective Cardinal.lift.{u, v}

full_name: Cardinal.lift_inj
code: @[simp]
theorem lift_inj {a b : Cardinal.{u}} : lift.{v, u} a = lift.{v, u} b ↔ a = b 
goal: Cardinal.lift.{v, u} a = Cardinal.lift.{v, u} b ↔ a = b

full_name: Cardinal.lift_lt
code: @[simp]
theorem lift_lt {a b : Cardinal.{u}} : lift.{v, u} a < lift.{v, u} b ↔ a < b 
goal: Cardinal.lift.{v, u} a < Cardinal.lift.{v, u} b ↔ a < b

full_name: Cardinal.lift_strictMono
code: theorem lift_strictMono : StrictMono lift 
goal: StrictMono Cardinal.lift.{u_2, u_1}

full_name: Cardinal.lift_monotone
code: theorem lift_monotone : Monotone lift 
goal: Monotone Cardinal.lift.{u_2, u_1}

full_name: Cardinal.instZero
code: instance : Zero Cardinal.{u} 
goal: Zero Cardinal.{u}

full_name: Cardinal.instInhabited
code: instance : Inhabited Cardinal.{u} 
goal: Inhabited Cardinal.{u}

full_name: Cardinal.mk_eq_zero
code: @[simp]
theorem mk_eq_zero (α : Type u) [IsEmpty α] : #α = 0 
goal: Cardinal.mk α = 0

full_name: Cardinal.lift_zero
code: @[simp]
theorem lift_zero : lift 0 = 0 
goal: Cardinal.lift.{u_2, u_1} 0 = 0

full_name: Cardinal.lift_eq_zero
code: @[simp]
theorem lift_eq_zero {a : Cardinal.{v}} : lift.{u} a = 0 ↔ a = 0 
goal: Cardinal.lift.{u, v} a = 0 ↔ a = 0

full_name: Cardinal.mk_eq_zero_iff
code: theorem mk_eq_zero_iff {α : Type u} : #α = 0 ↔ IsEmpty α 
goal: Cardinal.mk α = 0 ↔ IsEmpty α

full_name: Cardinal.mk_ne_zero_iff
code: theorem mk_ne_zero_iff {α : Type u} : #α ≠ 0 ↔ Nonempty α 
goal: Cardinal.mk α ≠ 0 ↔ Nonempty α

full_name: Cardinal.mk_ne_zero
code: @[simp]
theorem mk_ne_zero (α : Type u) [Nonempty α] : #α ≠ 0 
goal: Cardinal.mk α ≠ 0

full_name: Cardinal.instOne
code: instance : One Cardinal.{u} 
goal: One Cardinal.{u}

full_name: Cardinal.instNontrivial
code: instance : Nontrivial Cardinal.{u} 
goal: Nontrivial Cardinal.{u}

full_name: Cardinal.mk_eq_one
code: theorem mk_eq_one (α : Type u) [Unique α] : #α = 1 
goal: Cardinal.mk α = 1

full_name: Cardinal.le_one_iff_subsingleton
code: theorem le_one_iff_subsingleton {α : Type u} : #α ≤ 1 ↔ Subsingleton α 
goal: Cardinal.mk α ≤ 1 ↔ Subsingleton α

full_name: Cardinal.mk_le_one_iff_set_subsingleton
code: @[simp]
theorem mk_le_one_iff_set_subsingleton {s : Set α} : #s ≤ 1 ↔ s.Subsingleton 
goal: Cardinal.mk ↑s ≤ 1 ↔ s.Subsingleton

full_name: Cardinal.instAdd
code: instance : Add Cardinal.{u} 
goal: Add Cardinal.{u}

full_name: Cardinal.add_def
code: theorem add_def (α β : Type u) : #α + #β = #(α ⊕ β) 
goal: Cardinal.mk α + Cardinal.mk β = Cardinal.mk (α ⊕ β)

full_name: Cardinal.instNatCast
code: instance : NatCast Cardinal.{u} 
goal: NatCast Cardinal.{u}

full_name: Cardinal.mk_sum
code: @[simp]
theorem mk_sum (α : Type u) (β : Type v) : #(α ⊕ β) = lift.{v, u} #α + lift.{u, v} #β 
goal: Cardinal.mk (α ⊕ β) = Cardinal.lift.{v, u} (Cardinal.mk α) + Cardinal.lift.{u, v} (Cardinal.mk β)

full_name: Cardinal.mk_option
code: @[simp]
theorem mk_option {α : Type u} : #(Option α) = #α + 1 
goal: Cardinal.mk (Option α) = Cardinal.mk α + 1

full_name: Cardinal.mk_psum
code: @[simp]
theorem mk_psum (α : Type u) (β : Type v) : #(α ⊕' β) = lift.{v} #α + lift.{u} #β 
goal: Cardinal.mk (α ⊕' β) = Cardinal.lift.{v, u} (Cardinal.mk α) + Cardinal.lift.{u, v} (Cardinal.mk β)

full_name: Cardinal.mk_fintype
code: @[simp]
theorem mk_fintype (α : Type u) [h : Fintype α] : #α = Fintype.card α 
goal: Cardinal.mk α = ↑(Fintype.card α)

full_name: Cardinal.cast_succ
code: protected theorem cast_succ (n : ℕ) : ((n + 1 : ℕ) : Cardinal.{u}) = n + 1 
goal: ↑(n + 1) = ↑n + 1

full_name: Cardinal.instMul
code: instance : Mul Cardinal.{u} 
goal: Mul Cardinal.{u}

full_name: Cardinal.mul_def
code: theorem mul_def (α β : Type u) : #α * #β = #(α × β) 
goal: Cardinal.mk α * Cardinal.mk β = Cardinal.mk (α × β)

full_name: Cardinal.mk_prod
code: @[simp]
theorem mk_prod (α : Type u) (β : Type v) : #(α × β) = lift.{v, u} #α * lift.{u, v} #β 
goal: Cardinal.mk (α × β) = Cardinal.lift.{v, u} (Cardinal.mk α) * Cardinal.lift.{u, v} (Cardinal.mk β)

full_name: _private.Mathlib.SetTheory.Cardinal.Basic.0.Cardinal.mul_comm'
code: private theorem mul_comm' (a b : Cardinal.{u}) : a * b = b * a 
goal: a * b = b * a

full_name: Cardinal.instPowCardinal
code: /-- The cardinal exponential. `#α ^ #β` is the cardinal of `β → α`. -/
instance instPowCardinal : Pow Cardinal.{u} Cardinal.{u} 
goal: Pow Cardinal.{u} Cardinal.{u}

full_name: Cardinal.power_def
code: theorem power_def (α β : Type u) : #α ^ #β = #(β → α) 
goal: Cardinal.mk α ^ Cardinal.mk β = Cardinal.mk (β → α)

full_name: Cardinal.mk_arrow
code: theorem mk_arrow (α : Type u) (β : Type v) : #(α → β) = (lift.{u} #β^lift.{v} #α) 
goal: Cardinal.mk (α → β) = Cardinal.lift.{u, v} (Cardinal.mk β) ^ Cardinal.lift.{v, u} (Cardinal.mk α)

full_name: Cardinal.lift_power
code: @[simp]
theorem lift_power (a b : Cardinal.{u}) : lift.{v} (a ^ b) = lift.{v} a ^ lift.{v} b 
goal: Cardinal.lift.{v, u} (a ^ b) = Cardinal.lift.{v, u} a ^ Cardinal.lift.{v, u} b

full_name: Cardinal.power_zero
code: @[simp]
theorem power_zero {a : Cardinal} : a ^ (0 : Cardinal) = 1 
goal: a ^ 0 = 1

full_name: Cardinal.power_one
code: @[simp]
theorem power_one {a : Cardinal.{u}} : a ^ (1 : Cardinal) = a 
goal: a ^ 1 = a

full_name: Cardinal.power_add
code: theorem power_add {a b c : Cardinal} : a ^ (b + c) = a ^ b * a ^ c 
goal: a ^ (b + c) = a ^ b * a ^ c

full_name: Cardinal.commSemiring
code: instance commSemiring : CommSemiring Cardinal.{u} 
goal: CommSemiring Cardinal.{u}

full_name: Cardinal.one_power
code: @[simp]
theorem one_power {a : Cardinal} : (1 : Cardinal) ^ a = 1 
goal: 1 ^ a = 1

full_name: Cardinal.mk_bool
code: theorem mk_bool : #Bool = 2 
goal: Cardinal.mk Bool = 2

full_name: Cardinal.mk_Prop
code: theorem mk_Prop : #Prop = 2 
goal: Cardinal.mk Prop = 2

full_name: Cardinal.zero_power
code: @[simp]
theorem zero_power {a : Cardinal} : a ≠ 0 → (0 : Cardinal) ^ a = 0 
goal: a ≠ 0 → 0 ^ a = 0

full_name: Cardinal.power_ne_zero
code: theorem power_ne_zero {a : Cardinal} (b : Cardinal) : a ≠ 0 → a ^ b ≠ 0 
goal: a ≠ 0 → a ^ b ≠ 0

full_name: Cardinal.mul_power
code: theorem mul_power {a b c : Cardinal} : (a * b) ^ c = a ^ c * b ^ c 
goal: (a * b) ^ c = a ^ c * b ^ c

full_name: Cardinal.power_mul
code: theorem power_mul {a b c : Cardinal} : a ^ (b * c) = (a ^ b) ^ c 
goal: a ^ (b * c) = (a ^ b) ^ c

full_name: Cardinal.pow_cast_right
code: @[simp]
theorem pow_cast_right (a : Cardinal.{u}) (n : ℕ) : a ^ (↑n : Cardinal.{u}) = a ^ n 
goal: a ^ ↑n = a ^ n

full_name: Cardinal.lift_one
code: @[simp]
theorem lift_one : lift 1 = 1 
goal: Cardinal.lift.{u_2, u_1} 1 = 1

full_name: Cardinal.lift_eq_one
code: @[simp]
theorem lift_eq_one {a : Cardinal.{v}} : lift.{u} a = 1 ↔ a = 1 
goal: Cardinal.lift.{u, v} a = 1 ↔ a = 1

full_name: Cardinal.lift_add
code: @[simp]
theorem lift_add (a b : Cardinal.{u}) : lift.{v} (a + b) = lift.{v} a + lift.{v} b 
goal: Cardinal.lift.{v, u} (a + b) = Cardinal.lift.{v, u} a + Cardinal.lift.{v, u} b

full_name: Cardinal.lift_mul
code: @[simp]
theorem lift_mul (a b : Cardinal.{u}) : lift.{v} (a * b) = lift.{v} a * lift.{v} b 
goal: Cardinal.lift.{v, u} (a * b) = Cardinal.lift.{v, u} a * Cardinal.lift.{v, u} b

full_name: Cardinal.lift_two
code: theorem lift_two : lift.{u, v} 2 = 2 
goal: Cardinal.lift.{u, v} 2 = 2

full_name: Cardinal.mk_set
code: @[simp]
theorem mk_set {α : Type u} : #(Set α) = 2 ^ #α 
goal: Cardinal.mk (Set α) = 2 ^ Cardinal.mk α

full_name: Cardinal.mk_powerset
code: /-- A variant of `Cardinal.mk_set` expressed in terms of a `Set` instead of a `Type`. -/
@[simp]
theorem mk_powerset {α : Type u} (s : Set α) : #(↥(𝒫 s)) = 2 ^ #(↥s) 
goal: Cardinal.mk ↑(𝒫 s) = 2 ^ Cardinal.mk ↑s

full_name: Cardinal.lift_two_power
code: theorem lift_two_power (a : Cardinal) : lift.{v} (2 ^ a) = 2 ^ lift.{v} a 
goal: Cardinal.lift.{v, u_1} (2 ^ a) = 2 ^ Cardinal.lift.{v, u_1} a

full_name: Cardinal.zero_le
code: protected theorem zero_le : ∀ a : Cardinal, 0 ≤ a 
goal: 0 ≤ a

full_name: _private.Mathlib.SetTheory.Cardinal.Basic.0.Cardinal.add_le_add'
code: private theorem add_le_add' : ∀ {a b c d : Cardinal}, a ≤ b → c ≤ d → a + c ≤ b + d 
goal: a ≤ b → c ≤ d → a + c ≤ b + d

full_name: Cardinal.add_covariantClass
code: instance add_covariantClass : CovariantClass Cardinal Cardinal (· + ·) (· ≤ ·) 
goal: CovariantClass Cardinal.{u_1} Cardinal.{u_1} (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: Cardinal.add_swap_covariantClass
code: instance add_swap_covariantClass : CovariantClass Cardinal Cardinal (swap (· + ·)) (· ≤ ·) 
goal: CovariantClass Cardinal.{u_1} Cardinal.{u_1} (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: Cardinal.canonicallyOrderedCommSemiring
code: instance canonicallyOrderedCommSemiring : CanonicallyOrderedCommSemiring Cardinal.{u} 
goal: CanonicallyOrderedCommSemiring Cardinal.{u}

full_name: Cardinal.instCanonicallyLinearOrderedAddCommMonoid
code: instance : CanonicallyLinearOrderedAddCommMonoid Cardinal.{u} 
goal: CanonicallyLinearOrderedAddCommMonoid Cardinal.{u}

full_name: Cardinal.instCanonicallyOrderedAddCommMonoid
code: instance : CanonicallyOrderedAddCommMonoid Cardinal.{u} 
goal: CanonicallyOrderedAddCommMonoid Cardinal.{u}

full_name: Cardinal.instLinearOrderedCommMonoidWithZero
code: instance : LinearOrderedCommMonoidWithZero Cardinal.{u} 
goal: LinearOrderedCommMonoidWithZero Cardinal.{u}

full_name: Cardinal.instCommMonoidWithZero
code: instance : CommMonoidWithZero Cardinal.{u} 
goal: CommMonoidWithZero Cardinal.{u}

full_name: Cardinal.instCommMonoid
code: instance : CommMonoid Cardinal.{u} 
goal: CommMonoid Cardinal.{u}

full_name: Cardinal.zero_power_le
code: theorem zero_power_le (c : Cardinal.{u}) : (0 : Cardinal.{u}) ^ c ≤ 1 
goal: 0 ^ c ≤ 1

full_name: Cardinal.power_le_power_left
code: theorem power_le_power_left : ∀ {a b c : Cardinal}, a ≠ 0 → b ≤ c → a ^ b ≤ a ^ c 
goal: a ≠ 0 → b ≤ c → a ^ b ≤ a ^ c

full_name: Cardinal.self_le_power
code: theorem self_le_power (a : Cardinal) {b : Cardinal} (hb : 1 ≤ b) : a ≤ a ^ b 
goal: a ≤ a ^ b

full_name: Cardinal.cantor
code: /-- **Cantor's theorem** -/
theorem cantor (a : Cardinal.{u}) : a < 2 ^ a 
goal: a < 2 ^ a

full_name: Cardinal.instNoMaxOrder
code: instance : NoMaxOrder Cardinal.{u} 
goal: NoMaxOrder Cardinal.{u}

full_name: Cardinal.instDistribLattice
code: instance : DistribLattice Cardinal.{u} 
goal: DistribLattice Cardinal.{u}

full_name: Cardinal.one_lt_iff_nontrivial
code: theorem one_lt_iff_nontrivial {α : Type u} : 1 < #α ↔ Nontrivial α 
goal: 1 < Cardinal.mk α ↔ Nontrivial α

full_name: Cardinal.power_le_max_power_one
code: theorem power_le_max_power_one {a b c : Cardinal} (h : b ≤ c) : a ^ b ≤ max (a ^ c) 1 
goal: a ^ b ≤ max (a ^ c) 1

full_name: Cardinal.power_le_power_right
code: theorem power_le_power_right {a b c : Cardinal} : a ≤ b → a ^ c ≤ b ^ c 
goal: a ≤ b → a ^ c ≤ b ^ c

full_name: Cardinal.power_pos
code: theorem power_pos {a : Cardinal} (b : Cardinal) (ha : 0 < a) : 0 < a ^ b 
goal: 0 < a ^ b

full_name: Cardinal.lt_wf
code: protected theorem lt_wf : @WellFounded Cardinal.{u} (· < ·) 
goal: WellFounded fun x x_1 => x < x_1

full_name: Cardinal.instWellFoundedRelation
code: instance : WellFoundedRelation Cardinal.{u} 
goal: WellFoundedRelation Cardinal.{u}

full_name: Cardinal.instWellFoundedLT
code: instance : WellFoundedLT Cardinal.{u} 
goal: WellFoundedLT Cardinal.{u}

full_name: Cardinal.wo
code: instance wo : @IsWellOrder Cardinal.{u} (· < ·) 
goal: IsWellOrder Cardinal.{u} fun x x_1 => x < x_1

full_name: Cardinal.instConditionallyCompleteLinearOrderBot
code: instance : ConditionallyCompleteLinearOrderBot Cardinal 
goal: ConditionallyCompleteLinearOrderBot Cardinal.{u_1}

full_name: Cardinal.sInf_empty
code: @[simp]
theorem sInf_empty : sInf (∅ : Set Cardinal.{u}) = 0 
goal: sInf ∅ = 0

full_name: Cardinal.sInf_eq_zero_iff
code: lemma sInf_eq_zero_iff {s : Set Cardinal} : sInf s = 0 ↔ s = ∅ ∨ ∃ a ∈ s, a = 0 
goal: sInf s = 0 ↔ s = ∅ ∨ ∃ a ∈ s, a = 0

full_name: Cardinal.iInf_eq_zero_iff
code: lemma iInf_eq_zero_iff {ι : Sort*} {f : ι → Cardinal} :
    (⨅ i, f i) = 0 ↔ IsEmpty ι ∨ ∃ i, f i = 0 
goal: ⨅ i, f i = 0 ↔ IsEmpty ι ∨ ∃ i, f i = 0

full_name: Cardinal.instSuccOrder
code: /-- Note that the successor of `c` is not the same as `c + 1` except in the case of finite `c`. -/
instance : SuccOrder Cardinal 
goal: SuccOrder Cardinal.{u_1}

full_name: Cardinal.succ_def
code: theorem succ_def (c : Cardinal) : succ c = sInf { c' | c < c' } 
goal: Order.succ c = sInf {c' | c < c'}

full_name: Cardinal.succ_pos
code: theorem succ_pos : ∀ c : Cardinal, 0 < succ c 
goal: 0 < Order.succ c

full_name: Cardinal.succ_ne_zero
code: theorem succ_ne_zero (c : Cardinal) : succ c ≠ 0 
goal: Order.succ c ≠ 0

full_name: Cardinal.add_one_le_succ
code: theorem add_one_le_succ (c : Cardinal.{u}) : c + 1 ≤ succ c 
goal: c + 1 ≤ Order.succ c

full_name: Cardinal.IsLimit
code: /-- A cardinal is a limit if it is not zero or a successor cardinal. Note that `ℵ₀` is a limit
  cardinal by this definition, but `0` isn't.

  Use `IsSuccLimit` if you want to include the `c = 0` case. -/
def IsLimit (c : Cardinal) : Prop 
goal: Prop

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

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

full_name: Cardinal.IsLimit.succ_lt
code: theorem IsLimit.succ_lt {x c} (h : IsLimit c) : x < c → succ x < c 
goal: x < c → Order.succ x < c

full_name: Cardinal.isSuccLimit_zero
code: theorem isSuccLimit_zero : IsSuccLimit (0 : Cardinal) 
goal: Order.IsSuccLimit 0

full_name: Cardinal.sum
code: /-- The indexed sum of cardinals is the cardinality of the
  indexed disjoint union, i.e. sigma type. -/
def sum {ι} (f : ι → Cardinal) : Cardinal 
goal: Cardinal.{max u_2 u_1}

full_name: Cardinal.le_sum
code: theorem le_sum {ι} (f : ι → Cardinal) (i) : f i ≤ sum f 
goal: f i ≤ Cardinal.sum f

full_name: Cardinal.mk_sigma
code: @[simp]
theorem mk_sigma {ι} (f : ι → Type*) : #(Σ i, f i) = sum fun i => #(f i) 
goal: Cardinal.mk ((i : ι) × f i) = Cardinal.sum fun i => Cardinal.mk (f i)

full_name: Cardinal.sum_const
code: @[simp]
theorem sum_const (ι : Type u) (a : Cardinal.{v}) :
    (sum fun _ : ι => a) = lift.{v} #ι * lift.{u} a 
goal: (Cardinal.sum fun x => a) = Cardinal.lift.{v, u} (Cardinal.mk ι) * Cardinal.lift.{u, v} a

full_name: Cardinal.sum_const'
code: theorem sum_const' (ι : Type u) (a : Cardinal.{u}) : (sum fun _ : ι => a) = #ι * a 
goal: (Cardinal.sum fun x => a) = Cardinal.mk ι * a

full_name: Cardinal.sum_add_distrib
code: @[simp]
theorem sum_add_distrib {ι} (f g : ι → Cardinal) : sum (f + g) = sum f + sum g 
goal: Cardinal.sum (f + g) = Cardinal.sum f + Cardinal.sum g

full_name: Cardinal.sum_add_distrib'
code: @[simp]
theorem sum_add_distrib' {ι} (f g : ι → Cardinal) :
    (Cardinal.sum fun i => f i + g i) = sum f + sum g 
goal: (Cardinal.sum fun i => f i + g i) = Cardinal.sum f + Cardinal.sum g

full_name: Cardinal.lift_sum
code: @[simp]
theorem lift_sum {ι : Type u} (f : ι → Cardinal.{v}) :
    Cardinal.lift.{w} (Cardinal.sum f) = Cardinal.sum fun i => Cardinal.lift.{w} (f i) 
goal: Cardinal.lift.{w, max v u} (Cardinal.sum f) = Cardinal.sum fun i => Cardinal.lift.{w, v} (f i)

full_name: Cardinal.sum_le_sum
code: theorem sum_le_sum {ι} (f g : ι → Cardinal) (H : ∀ i, f i ≤ g i) : sum f ≤ sum g 
goal: Cardinal.sum f ≤ Cardinal.sum g

full_name: Cardinal.mk_le_mk_mul_of_mk_preimage_le
code: theorem mk_le_mk_mul_of_mk_preimage_le {c : Cardinal} (f : α → β) (hf : ∀ b : β, #(f ⁻¹' {b}) ≤ c) :
    #α ≤ #β * c 
goal: Cardinal.mk α ≤ Cardinal.mk β * c

full_name: Cardinal.lift_mk_le_lift_mk_mul_of_lift_mk_preimage_le
code: theorem lift_mk_le_lift_mk_mul_of_lift_mk_preimage_le {α : Type u} {β : Type v} {c : Cardinal}
    (f : α → β) (hf : ∀ b : β, lift.{v} #(f ⁻¹' {b}) ≤ c) : lift.{v} #α ≤ lift.{u} #β * c 
goal: Cardinal.lift.{v, u} (Cardinal.mk α) ≤ Cardinal.lift.{u, v} (Cardinal.mk β) * c

full_name: Cardinal.bddAbove_range
code: /-- The range of an indexed cardinal function, whose outputs live in a higher universe than the
    inputs, is always bounded above. -/
theorem bddAbove_range {ι : Type u} (f : ι → Cardinal.{max u v}) : BddAbove (Set.range f) 
goal: BddAbove (Set.range f)

full_name: Cardinal.instSmallElemIic
code: instance (a : Cardinal.{u}) : Small.{u} (Set.Iic a) 
goal: Small.{u, u + 1} ↑(Set.Iic a)

full_name: Cardinal.instSmallElemIio
code: instance (a : Cardinal.{u}) : Small.{u} (Set.Iio a) 
goal: Small.{u, u + 1} ↑(Set.Iio a)

full_name: Cardinal.bddAbove_iff_small
code: /-- A set of cardinals is bounded above iff it's small, i.e. it corresponds to a usual ZFC set. -/
theorem bddAbove_iff_small {s : Set Cardinal.{u}} : BddAbove s ↔ Small.{u} s 
goal: BddAbove s ↔ Small.{u, u + 1} ↑s

full_name: Cardinal.bddAbove_of_small
code: theorem bddAbove_of_small (s : Set Cardinal.{u}) [h : Small.{u} s] : BddAbove s 
goal: BddAbove s

full_name: Cardinal.bddAbove_image
code: theorem bddAbove_image (f : Cardinal.{u} → Cardinal.{max u v}) {s : Set Cardinal.{u}}
    (hs : BddAbove s) : BddAbove (f '' s) 
goal: BddAbove (f '' s)

full_name: Cardinal.bddAbove_range_comp
code: theorem bddAbove_range_comp {ι : Type u} {f : ι → Cardinal.{v}} (hf : BddAbove (range f))
    (g : Cardinal.{v} → Cardinal.{max v w}) : BddAbove (range (g ∘ f)) 
goal: BddAbove (Set.range (g ∘ f))

full_name: Cardinal.iSup_le_sum
code: theorem iSup_le_sum {ι} (f : ι → Cardinal) : iSup f ≤ sum f 
goal: iSup f ≤ Cardinal.sum f

full_name: Cardinal.sum_le_iSup_lift
code: theorem sum_le_iSup_lift {ι : Type u}
    (f : ι → Cardinal.{max u v}) : sum f ≤ Cardinal.lift #ι * iSup f 
goal: Cardinal.sum f ≤ Cardinal.lift.{v, u} (Cardinal.mk ι) * iSup f

full_name: Cardinal.sum_le_iSup
code: theorem sum_le_iSup {ι : Type u} (f : ι → Cardinal.{u}) : sum f ≤ #ι * iSup f 
goal: Cardinal.sum f ≤ Cardinal.mk ι * iSup f

full_name: Cardinal.sum_nat_eq_add_sum_succ
code: theorem sum_nat_eq_add_sum_succ (f : ℕ → Cardinal.{u}) :
    Cardinal.sum f = f 0 + Cardinal.sum fun i => f (i + 1) 
goal: Cardinal.sum f = f 0 + Cardinal.sum fun i => f (i + 1)

full_name: Cardinal.iSup_of_empty
code: /-- A variant of `ciSup_of_empty` but with `0` on the RHS for convenience -/
protected theorem iSup_of_empty {ι} (f : ι → Cardinal) [IsEmpty ι] : iSup f = 0 
goal: iSup f = 0

full_name: Cardinal.exists_eq_of_iSup_eq_of_not_isSuccLimit
code: lemma exists_eq_of_iSup_eq_of_not_isSuccLimit
    {ι : Type u} (f : ι → Cardinal.{v}) (ω : Cardinal.{v})
    (hω : ¬ Order.IsSuccLimit ω)
    (h : ⨆ i : ι, f i = ω) : ∃ i, f i = ω 
goal: ∃ i, f i = ω

full_name: Cardinal.exists_eq_of_iSup_eq_of_not_isLimit
code: lemma exists_eq_of_iSup_eq_of_not_isLimit
    {ι : Type u} [hι : Nonempty ι] (f : ι → Cardinal.{v}) (hf : BddAbove (range f))
    (ω : Cardinal.{v}) (hω : ¬ ω.IsLimit)
    (h : ⨆ i : ι, f i = ω) : ∃ i, f i = ω 
goal: ∃ i, f i = ω

full_name: Cardinal.lift_mk_shrink
code: @[simp, nolint simpNF]
theorem lift_mk_shrink (α : Type u) [Small.{v} α] :
    Cardinal.lift.{max u w} #(Shrink.{v} α) = Cardinal.lift.{max v w} #α 
goal: Cardinal.lift.{max u w, v} (Cardinal.mk (Shrink.{v, u} α)) = Cardinal.lift.{max v w, u} (Cardinal.mk α)

full_name: Cardinal.lift_mk_shrink'
code: @[simp]
theorem lift_mk_shrink' (α : Type u) [Small.{v} α] :
    Cardinal.lift.{u} #(Shrink.{v} α) = Cardinal.lift.{v} #α 
goal: Cardinal.lift.{u, v} (Cardinal.mk (Shrink.{v, u} α)) = Cardinal.lift.{v, u} (Cardinal.mk α)

full_name: Cardinal.lift_mk_shrink''
code: @[simp]
theorem lift_mk_shrink'' (α : Type max u v) [Small.{v} α] :
    Cardinal.lift.{u} #(Shrink.{v} α) = #α 
goal: Cardinal.lift.{u, v} (Cardinal.mk (Shrink.{v, max u v} α)) = Cardinal.mk α

full_name: Cardinal.prod
code: /-- The indexed product of cardinals is the cardinality of the Pi type
  (dependent product). -/
def prod {ι : Type u} (f : ι → Cardinal) : Cardinal 
goal: Cardinal.{max u u_1}

full_name: Cardinal.mk_pi
code: @[simp]
theorem mk_pi {ι : Type u} (α : ι → Type v) : #(∀ i, α i) = prod fun i => #(α i) 
goal: Cardinal.mk ((i : ι) → α i) = Cardinal.prod fun i => Cardinal.mk (α i)

full_name: Cardinal.prod_const
code: @[simp]
theorem prod_const (ι : Type u) (a : Cardinal.{v}) :
    (prod fun _ : ι => a) = lift.{u} a ^ lift.{v} #ι 
goal: (Cardinal.prod fun x => a) = Cardinal.lift.{u, v} a ^ Cardinal.lift.{v, u} (Cardinal.mk ι)

full_name: Cardinal.prod_const'
code: theorem prod_const' (ι : Type u) (a : Cardinal.{u}) : (prod fun _ : ι => a) = a ^ #ι 
goal: (Cardinal.prod fun x => a) = a ^ Cardinal.mk ι

full_name: Cardinal.prod_le_prod
code: theorem prod_le_prod {ι} (f g : ι → Cardinal) (H : ∀ i, f i ≤ g i) : prod f ≤ prod g 
goal: Cardinal.prod f ≤ Cardinal.prod g

full_name: Cardinal.prod_eq_zero
code: @[simp]
theorem prod_eq_zero {ι} (f : ι → Cardinal.{u}) : prod f = 0 ↔ ∃ i, f i = 0 
goal: Cardinal.prod f = 0 ↔ ∃ i, f i = 0

full_name: Cardinal.prod_ne_zero
code: theorem prod_ne_zero {ι} (f : ι → Cardinal) : prod f ≠ 0 ↔ ∀ i, f i ≠ 0 
goal: Cardinal.prod f ≠ 0 ↔ ∀ (i : ι), f i ≠ 0

full_name: Cardinal.lift_prod
code: @[simp]
theorem lift_prod {ι : Type u} (c : ι → Cardinal.{v}) :
    lift.{w} (prod c) = prod fun i => lift.{w} (c i) 
goal: Cardinal.lift.{w, max v u} (Cardinal.prod c) = Cardinal.prod fun i => Cardinal.lift.{w, v} (c i)

full_name: Cardinal.prod_eq_of_fintype
code: theorem prod_eq_of_fintype {α : Type u} [h : Fintype α] (f : α → Cardinal.{v}) :
    prod f = Cardinal.lift.{u} (∏ i, f i) 
goal: Cardinal.prod f = Cardinal.lift.{u, v} (∏ i : α, f i)

full_name: Cardinal.lift_sInf
code: @[simp]
theorem lift_sInf (s : Set Cardinal) : lift.{u, v} (sInf s) = sInf (lift.{u, v} '' s) 
goal: Cardinal.lift.{u, v} (sInf s) = sInf (Cardinal.lift.{u, v} '' s)

full_name: Cardinal.lift_iInf
code: @[simp]
theorem lift_iInf {ι} (f : ι → Cardinal) : lift.{u, v} (iInf f) = ⨅ i, lift.{u, v} (f i) 
goal: Cardinal.lift.{u, v} (iInf f) = ⨅ i, Cardinal.lift.{u, v} (f i)

full_name: Cardinal.lift_down
code: theorem lift_down {a : Cardinal.{u}} {b : Cardinal.{max u v}} :
    b ≤ lift.{v,u} a → ∃ a', lift.{v,u} a' = b 
goal: b ≤ Cardinal.lift.{v, u} a → ∃ a', Cardinal.lift.{v, u} a' = b

full_name: Cardinal.le_lift_iff
code: theorem le_lift_iff {a : Cardinal.{u}} {b : Cardinal.{max u v}} :
    b ≤ lift.{v, u} a ↔ ∃ a', lift.{v, u} a' = b ∧ a' ≤ a 
goal: b ≤ Cardinal.lift.{v, u} a ↔ ∃ a', Cardinal.lift.{v, u} a' = b ∧ a' ≤ a

full_name: Cardinal.lt_lift_iff
code: theorem lt_lift_iff {a : Cardinal.{u}} {b : Cardinal.{max u v}} :
    b < lift.{v, u} a ↔ ∃ a', lift.{v, u} a' = b ∧ a' < a 
goal: b < Cardinal.lift.{v, u} a ↔ ∃ a', Cardinal.lift.{v, u} a' = b ∧ a' < a

full_name: Cardinal.lift_succ
code: @[simp]
theorem lift_succ (a) : lift.{v, u} (succ a) = succ (lift.{v, u} a) 
goal: Cardinal.lift.{v, u} (Order.succ a) = Order.succ (Cardinal.lift.{v, u} a)

full_name: Cardinal.lift_umax_eq
code: @[simp, nolint simpNF]
theorem lift_umax_eq {a : Cardinal.{u}} {b : Cardinal.{v}} :
    lift.{max v w} a = lift.{max u w} b ↔ lift.{v} a = lift.{u} b 
goal: Cardinal.lift.{max v w, u} a = Cardinal.lift.{max u w, v} b ↔ Cardinal.lift.{v, u} a = Cardinal.lift.{u, v} b

full_name: Cardinal.lift_min
code: @[simp]
theorem lift_min {a b : Cardinal} : lift.{u, v} (min a b) = min (lift.{u, v} a) (lift.{u, v} b) 
goal: Cardinal.lift.{u, v} (min a b) = min (Cardinal.lift.{u, v} a) (Cardinal.lift.{u, v} b)

full_name: Cardinal.lift_max
code: @[simp]
theorem lift_max {a b : Cardinal} : lift.{u, v} (max a b) = max (lift.{u, v} a) (lift.{u, v} b) 
goal: Cardinal.lift.{u, v} (max a b) = max (Cardinal.lift.{u, v} a) (Cardinal.lift.{u, v} b)

full_name: Cardinal.lift_sSup
code: /-- The lift of a supremum is the supremum of the lifts. -/
theorem lift_sSup {s : Set Cardinal} (hs : BddAbove s) :
    lift.{u} (sSup s) = sSup (lift.{u} '' s) 
goal: Cardinal.lift.{u, u_1} (sSup s) = sSup (Cardinal.lift.{u, u_1} '' s)

full_name: Cardinal.lift_iSup
code: /-- The lift of a supremum is the supremum of the lifts. -/
theorem lift_iSup {ι : Type v} {f : ι → Cardinal.{w}} (hf : BddAbove (range f)) :
    lift.{u} (iSup f) = ⨆ i, lift.{u} (f i) 
goal: Cardinal.lift.{u, w} (iSup f) = ⨆ i, Cardinal.lift.{u, w} (f i)

full_name: Cardinal.lift_iSup_le
code: /-- To prove that the lift of a supremum is bounded by some cardinal `t`,
it suffices to show that the lift of each cardinal is bounded by `t`. -/
theorem lift_iSup_le {ι : Type v} {f : ι → Cardinal.{w}} {t : Cardinal} (hf : BddAbove (range f))
    (w : ∀ i, lift.{u} (f i) ≤ t) : lift.{u} (iSup f) ≤ t 
goal: Cardinal.lift.{u, w} (iSup f) ≤ t

full_name: Cardinal.lift_iSup_le_iff
code: @[simp]
theorem lift_iSup_le_iff {ι : Type v} {f : ι → Cardinal.{w}} (hf : BddAbove (range f))
    {t : Cardinal} : lift.{u} (iSup f) ≤ t ↔ ∀ i, lift.{u} (f i) ≤ t 
goal: Cardinal.lift.{u, w} (iSup f) ≤ t ↔ ∀ (i : ι), Cardinal.lift.{u, w} (f i) ≤ t

full_name: Cardinal.lift_iSup_le_lift_iSup
code: /-- To prove an inequality between the lifts to a common universe of two different supremums,
it suffices to show that the lift of each cardinal from the smaller supremum
if bounded by the lift of some cardinal from the larger supremum.
-/
theorem lift_iSup_le_lift_iSup {ι : Type v} {ι' : Type v'} {f : ι → Cardinal.{w}}
    {f' : ι' → Cardinal.{w'}} (hf : BddAbove (range f)) (hf' : BddAbove (range f')) {g : ι → ι'}
    (h : ∀ i, lift.{w'} (f i) ≤ lift.{w} (f' (g i))) : lift.{w'} (iSup f) ≤ lift.{w} (iSup f') 
goal: Cardinal.lift.{w', w} (iSup f) ≤ Cardinal.lift.{w, w'} (iSup f')

full_name: Cardinal.lift_iSup_le_lift_iSup'
code: /-- A variant of `lift_iSup_le_lift_iSup` with universes specialized via `w = v` and `w' = v'`.
This is sometimes necessary to avoid universe unification issues. -/
theorem lift_iSup_le_lift_iSup' {ι : Type v} {ι' : Type v'} {f : ι → Cardinal.{v}}
    {f' : ι' → Cardinal.{v'}} (hf : BddAbove (range f)) (hf' : BddAbove (range f')) (g : ι → ι')
    (h : ∀ i, lift.{v'} (f i) ≤ lift.{v} (f' (g i))) : lift.{v'} (iSup f) ≤ lift.{v} (iSup f') 
goal: Cardinal.lift.{v', v} (iSup f) ≤ Cardinal.lift.{v, v'} (iSup f')

full_name: Cardinal.aleph0
code: /-- `ℵ₀` is the smallest infinite cardinal. -/
def aleph0 : Cardinal.{u} 
goal: Cardinal.{u}

full_name: Cardinal._aux_Mathlib_SetTheory_Cardinal_Basic___macroRules_Cardinal_termℵ₀_1
code: @[inherit_doc]
scoped notation "ℵ₀" => Cardinal.aleph0
goal: Lean.Macro

full_name: Cardinal._aux_Mathlib_SetTheory_Cardinal_Basic___unexpand_Cardinal_aleph0_1
code: @[inherit_doc]
scoped notation "ℵ₀" => Cardinal.aleph0
goal: Lean.PrettyPrinter.Unexpander

full_name: Cardinal.mk_nat
code: theorem mk_nat : #ℕ = ℵ₀ 
goal: Cardinal.mk ℕ = Cardinal.aleph0

full_name: Cardinal.aleph0_ne_zero
code: theorem aleph0_ne_zero : ℵ₀ ≠ 0 
goal: Cardinal.aleph0 ≠ 0

full_name: Cardinal.aleph0_pos
code: theorem aleph0_pos : 0 < ℵ₀ 
goal: 0 < Cardinal.aleph0

full_name: Cardinal.lift_aleph0
code: @[simp]
theorem lift_aleph0 : lift ℵ₀ = ℵ₀ 
goal: Cardinal.lift.{u_1, u_2} Cardinal.aleph0 = Cardinal.aleph0

full_name: Cardinal.aleph0_le_lift
code: @[simp]
theorem aleph0_le_lift {c : Cardinal.{u}} : ℵ₀ ≤ lift.{v} c ↔ ℵ₀ ≤ c 
goal: Cardinal.aleph0 ≤ Cardinal.lift.{v, u} c ↔ Cardinal.aleph0 ≤ c

full_name: Cardinal.lift_le_aleph0
code: @[simp]
theorem lift_le_aleph0 {c : Cardinal.{u}} : lift.{v} c ≤ ℵ₀ ↔ c ≤ ℵ₀ 
goal: Cardinal.lift.{v, u} c ≤ Cardinal.aleph0 ↔ c ≤ Cardinal.aleph0

full_name: Cardinal.aleph0_lt_lift
code: @[simp]
theorem aleph0_lt_lift {c : Cardinal.{u}} : ℵ₀ < lift.{v} c ↔ ℵ₀ < c 
goal: Cardinal.aleph0 < Cardinal.lift.{v, u} c ↔ Cardinal.aleph0 < c

full_name: Cardinal.lift_lt_aleph0
code: @[simp]
theorem lift_lt_aleph0 {c : Cardinal.{u}} : lift.{v} c < ℵ₀ ↔ c < ℵ₀ 
goal: Cardinal.lift.{v, u} c < Cardinal.aleph0 ↔ c < Cardinal.aleph0

full_name: Cardinal.mk_fin
code: theorem mk_fin (n : ℕ) : #(Fin n) = n 
goal: Cardinal.mk (Fin n) = ↑n

full_name: Cardinal.lift_natCast
code: @[simp]
theorem lift_natCast (n : ℕ) : lift.{u} (n : Cardinal.{v}) = n 
goal: Cardinal.lift.{u, v} ↑n = ↑n

full_name: Cardinal.lift_ofNat
code: @[simp]
theorem lift_ofNat (n : ℕ) [n.AtLeastTwo] :
    lift.{u} (no_index (OfNat.ofNat n : Cardinal.{v})) = OfNat.ofNat n 
goal: Cardinal.lift.{u, v} (OfNat.ofNat n) = OfNat.ofNat n

full_name: Cardinal.lift_eq_nat_iff
code: @[simp]
theorem lift_eq_nat_iff {a : Cardinal.{u}} {n : ℕ} : lift.{v} a = n ↔ a = n 
goal: Cardinal.lift.{v, u} a = ↑n ↔ a = ↑n

full_name: Cardinal.lift_eq_ofNat_iff
code: @[simp]
theorem lift_eq_ofNat_iff {a : Cardinal.{u}} {n : ℕ} [n.AtLeastTwo] :
    lift.{v} a = (no_index (OfNat.ofNat n)) ↔ a = OfNat.ofNat n 
goal: Cardinal.lift.{v, u} a = OfNat.ofNat n ↔ a = OfNat.ofNat n

full_name: Cardinal.nat_eq_lift_iff
code: @[simp]
theorem nat_eq_lift_iff {n : ℕ} {a : Cardinal.{u}} :
    (n : Cardinal) = lift.{v} a ↔ (n : Cardinal) = a 
goal: ↑n = Cardinal.lift.{v, u} a ↔ ↑n = a

full_name: Cardinal.zero_eq_lift_iff
code: @[simp]
theorem zero_eq_lift_iff {a : Cardinal.{u}} :
    (0 : Cardinal) = lift.{v} a ↔ 0 = a 
goal: 0 = Cardinal.lift.{v, u} a ↔ 0 = a

full_name: Cardinal.one_eq_lift_iff
code: @[simp]
theorem one_eq_lift_iff {a : Cardinal.{u}} :
    (1 : Cardinal) = lift.{v} a ↔ 1 = a 
goal: 1 = Cardinal.lift.{v, u} a ↔ 1 = a

full_name: Cardinal.ofNat_eq_lift_iff
code: @[simp]
theorem ofNat_eq_lift_iff {a : Cardinal.{u}} {n : ℕ} [n.AtLeastTwo] :
    (no_index (OfNat.ofNat n : Cardinal)) = lift.{v} a ↔ (OfNat.ofNat n : Cardinal) = a 
goal: OfNat.ofNat n = Cardinal.lift.{v, u} a ↔ OfNat.ofNat n = a

full_name: Cardinal.lift_le_nat_iff
code: @[simp]
theorem lift_le_nat_iff {a : Cardinal.{u}} {n : ℕ} : lift.{v} a ≤ n ↔ a ≤ n 
goal: Cardinal.lift.{v, u} a ≤ ↑n ↔ a ≤ ↑n

full_name: Cardinal.lift_le_one_iff
code: @[simp]
theorem lift_le_one_iff {a : Cardinal.{u}} :
    lift.{v} a ≤ 1 ↔ a ≤ 1 
goal: Cardinal.lift.{v, u} a ≤ 1 ↔ a ≤ 1

full_name: Cardinal.lift_le_ofNat_iff
code: @[simp]
theorem lift_le_ofNat_iff {a : Cardinal.{u}} {n : ℕ} [n.AtLeastTwo] :
    lift.{v} a ≤ (no_index (OfNat.ofNat n)) ↔ a ≤ OfNat.ofNat n 
goal: Cardinal.lift.{v, u} a ≤ OfNat.ofNat n ↔ a ≤ OfNat.ofNat n

full_name: Cardinal.nat_le_lift_iff
code: @[simp]
theorem nat_le_lift_iff {n : ℕ} {a : Cardinal.{u}} : n ≤ lift.{v} a ↔ n ≤ a 
goal: ↑n ≤ Cardinal.lift.{v, u} a ↔ ↑n ≤ a

full_name: Cardinal.one_le_lift_iff
code: @[simp]
theorem one_le_lift_iff {a : Cardinal.{u}} :
    (1 : Cardinal) ≤ lift.{v} a ↔ 1 ≤ a 
goal: 1 ≤ Cardinal.lift.{v, u} a ↔ 1 ≤ a

full_name: Cardinal.ofNat_le_lift_iff
code: @[simp]
theorem ofNat_le_lift_iff {a : Cardinal.{u}} {n : ℕ} [n.AtLeastTwo] :
    (no_index (OfNat.ofNat n : Cardinal)) ≤ lift.{v} a ↔ (OfNat.ofNat n : Cardinal) ≤ a 
goal: OfNat.ofNat n ≤ Cardinal.lift.{v, u} a ↔ OfNat.ofNat n ≤ a

full_name: Cardinal.lift_lt_nat_iff
code: @[simp]
theorem lift_lt_nat_iff {a : Cardinal.{u}} {n : ℕ} : lift.{v} a < n ↔ a < n 
goal: Cardinal.lift.{v, u} a < ↑n ↔ a < ↑n

full_name: Cardinal.lift_lt_ofNat_iff
code: @[simp]
theorem lift_lt_ofNat_iff {a : Cardinal.{u}} {n : ℕ} [n.AtLeastTwo] :
    lift.{v} a < (no_index (OfNat.ofNat n)) ↔ a < OfNat.ofNat n 
goal: Cardinal.lift.{v, u} a < OfNat.ofNat n ↔ a < OfNat.ofNat n

full_name: Cardinal.nat_lt_lift_iff
code: @[simp]
theorem nat_lt_lift_iff {n : ℕ} {a : Cardinal.{u}} : n < lift.{v} a ↔ n < a 
goal: ↑n < Cardinal.lift.{v, u} a ↔ ↑n < a

full_name: Cardinal.zero_lt_lift_iff
code: @[simp]
theorem zero_lt_lift_iff {a : Cardinal.{u}} :
    (0 : Cardinal) < lift.{v} a ↔ 0 < a 
goal: 0 < Cardinal.lift.{v, u} a ↔ 0 < a

full_name: Cardinal.one_lt_lift_iff
code: @[simp]
theorem one_lt_lift_iff {a : Cardinal.{u}} :
    (1 : Cardinal) < lift.{v} a ↔ 1 < a 
goal: 1 < Cardinal.lift.{v, u} a ↔ 1 < a

full_name: Cardinal.ofNat_lt_lift_iff
code: @[simp]
theorem ofNat_lt_lift_iff {a : Cardinal.{u}} {n : ℕ} [n.AtLeastTwo] :
    (no_index (OfNat.ofNat n : Cardinal)) < lift.{v} a ↔ (OfNat.ofNat n : Cardinal) < a 
goal: OfNat.ofNat n < Cardinal.lift.{v, u} a ↔ OfNat.ofNat n < a

full_name: Cardinal.lift_mk_fin
code: theorem lift_mk_fin (n : ℕ) : lift #(Fin n) = n 
goal: Cardinal.lift.{u_1, 0} (Cardinal.mk (Fin n)) = ↑n

full_name: Cardinal.mk_coe_finset
code: theorem mk_coe_finset {α : Type u} {s : Finset α} : #s = ↑(Finset.card s) 
goal: Cardinal.mk { x // x ∈ s } = ↑s.card

full_name: Cardinal.mk_finset_of_fintype
code: theorem mk_finset_of_fintype [Fintype α] : #(Finset α) = 2 ^ Fintype.card α 
goal: Cardinal.mk (Finset α) = 2 ^ Fintype.card α

full_name: Cardinal.mk_finsupp_lift_of_fintype
code: @[simp]
theorem mk_finsupp_lift_of_fintype (α : Type u) (β : Type v) [Fintype α] [Zero β] :
    #(α →₀ β) = lift.{u} #β ^ Fintype.card α 
goal: Cardinal.mk (α →₀ β) = Cardinal.lift.{u, v} (Cardinal.mk β) ^ Fintype.card α

full_name: Cardinal.mk_finsupp_of_fintype
code: theorem mk_finsupp_of_fintype (α β : Type u) [Fintype α] [Zero β] :
    #(α →₀ β) = #β ^ Fintype.card α 
goal: Cardinal.mk (α →₀ β) = Cardinal.mk β ^ Fintype.card α

full_name: Cardinal.card_le_of_finset
code: theorem card_le_of_finset {α} (s : Finset α) : (s.card : Cardinal) ≤ #α 
goal: ↑s.card ≤ Cardinal.mk α

full_name: Cardinal.natCast_pow
code: @[norm_cast]
theorem natCast_pow {m n : ℕ} : (↑(m ^ n) : Cardinal) = (↑m : Cardinal) ^ (↑n : Cardinal) 
goal: ↑(m ^ n) = ↑m ^ ↑n

full_name: Cardinal.natCast_le
code: @[norm_cast]
theorem natCast_le {m n : ℕ} : (m : Cardinal) ≤ n ↔ m ≤ n 
goal: ↑m ≤ ↑n ↔ m ≤ n

full_name: Cardinal.natCast_lt
code: @[norm_cast]
theorem natCast_lt {m n : ℕ} : (m : Cardinal) < n ↔ m < n 
goal: ↑m < ↑n ↔ m < n

full_name: Cardinal.instCharZero
code: instance : CharZero Cardinal 
goal: CharZero Cardinal.{u_1}

full_name: Cardinal.natCast_inj
code: theorem natCast_inj {m n : ℕ} : (m : Cardinal) = n ↔ m = n 
goal: ↑m = ↑n ↔ m = n

full_name: Cardinal.natCast_injective
code: theorem natCast_injective : Injective ((↑) : ℕ → Cardinal) 
goal: Function.Injective Nat.cast

full_name: Cardinal.nat_succ
code: @[norm_cast]
theorem nat_succ (n : ℕ) : (n.succ : Cardinal) = succ ↑n 
goal: ↑n.succ = Order.succ ↑n

full_name: Cardinal.succ_natCast
code: lemma succ_natCast (n : ℕ) : Order.succ (n : Cardinal) = n + 1 
goal: Order.succ ↑n = ↑n + 1

full_name: Cardinal.natCast_add_one_le_iff
code: lemma natCast_add_one_le_iff {n : ℕ} {c : Cardinal} : n + 1 ≤ c ↔ n < c 
goal: ↑n + 1 ≤ c ↔ ↑n < c

full_name: Cardinal.two_le_iff_one_lt
code: lemma two_le_iff_one_lt {c : Cardinal} : 2 ≤ c ↔ 1 < c 
goal: 2 ≤ c ↔ 1 < c

full_name: Cardinal.succ_zero
code: @[simp]
theorem succ_zero : succ (0 : Cardinal) = 1 
goal: Order.succ 0 = 1

full_name: Cardinal.exists_finset_le_card
code: theorem exists_finset_le_card (α : Type*) (n : ℕ) (h : n ≤ #α) :
    ∃ s : Finset α, n ≤ s.card 
goal: ∃ s, n ≤ s.card

full_name: Cardinal.card_le_of
code: theorem card_le_of {α : Type u} {n : ℕ} (H : ∀ s : Finset α, s.card ≤ n) : #α ≤ n 
goal: Cardinal.mk α ≤ ↑n

full_name: Cardinal.cantor'
code: theorem cantor' (a) {b : Cardinal} (hb : 1 < b) : a < b ^ a 
goal: a < b ^ a

full_name: Cardinal.one_le_iff_pos
code: theorem one_le_iff_pos {c : Cardinal} : 1 ≤ c ↔ 0 < c 
goal: 1 ≤ c ↔ 0 < c

full_name: Cardinal.one_le_iff_ne_zero
code: theorem one_le_iff_ne_zero {c : Cardinal} : 1 ≤ c ↔ c ≠ 0 
goal: 1 ≤ c ↔ c ≠ 0

full_name: Cardinal.lt_one_iff_zero
code: @[simp]
theorem lt_one_iff_zero {c : Cardinal} : c < 1 ↔ c = 0 
goal: c < 1 ↔ c = 0

full_name: Cardinal.nat_lt_aleph0
code: theorem nat_lt_aleph0 (n : ℕ) : (n : Cardinal.{u}) < ℵ₀ 
goal: ↑n < Cardinal.aleph0

full_name: Cardinal.one_lt_aleph0
code: @[simp]
theorem one_lt_aleph0 : 1 < ℵ₀ 
goal: 1 < Cardinal.aleph0

full_name: Cardinal.one_le_aleph0
code: theorem one_le_aleph0 : 1 ≤ ℵ₀ 
goal: 1 ≤ Cardinal.aleph0

full_name: Cardinal.lt_aleph0
code: theorem lt_aleph0 {c : Cardinal} : c < ℵ₀ ↔ ∃ n : ℕ, c = n 
goal: c < Cardinal.aleph0 ↔ ∃ n, c = ↑n

full_name: Cardinal.succ_eq_of_lt_aleph0
code: lemma succ_eq_of_lt_aleph0 {c : Cardinal} (h : c < ℵ₀) : Order.succ c = c + 1 
goal: Order.succ c = c + 1

full_name: Cardinal.aleph0_le
code: theorem aleph0_le {c : Cardinal} : ℵ₀ ≤ c ↔ ∀ n : ℕ, ↑n ≤ c 
goal: Cardinal.aleph0 ≤ c ↔ ∀ (n : ℕ), ↑n ≤ c

full_name: Cardinal.isSuccLimit_aleph0
code: theorem isSuccLimit_aleph0 : IsSuccLimit ℵ₀ 
goal: Order.IsSuccLimit Cardinal.aleph0

full_name: Cardinal.isLimit_aleph0
code: theorem isLimit_aleph0 : IsLimit ℵ₀ 
goal: Cardinal.aleph0.IsLimit

full_name: Cardinal.not_isLimit_natCast
code: lemma not_isLimit_natCast : (n : ℕ) → ¬ IsLimit (n : Cardinal.{u})
  
goal: ¬(↑n).IsLimit

full_name: Cardinal.IsLimit.aleph0_le
code: theorem IsLimit.aleph0_le {c : Cardinal} (h : IsLimit c) : ℵ₀ ≤ c 
goal: Cardinal.aleph0 ≤ c

full_name: Cardinal.exists_eq_natCast_of_iSup_eq
code: lemma exists_eq_natCast_of_iSup_eq {ι : Type u} [Nonempty ι] (f : ι → Cardinal.{v})
    (hf : BddAbove (range f)) (n : ℕ) (h : ⨆ i, f i = n) : ∃ i, f i = n 
goal: ∃ i, f i = ↑n

full_name: Cardinal.range_natCast
code: @[simp]
theorem range_natCast : range ((↑) : ℕ → Cardinal) = Iio ℵ₀ 
goal: Set.range Nat.cast = Set.Iio Cardinal.aleph0

full_name: Cardinal.mk_eq_nat_iff
code: theorem mk_eq_nat_iff {α : Type u} {n : ℕ} : #α = n ↔ Nonempty (α ≃ Fin n) 
goal: Cardinal.mk α = ↑n ↔ Nonempty (α ≃ Fin n)

full_name: Cardinal.lt_aleph0_iff_finite
code: theorem lt_aleph0_iff_finite {α : Type u} : #α < ℵ₀ ↔ Finite α 
goal: Cardinal.mk α < Cardinal.aleph0 ↔ Finite α

full_name: Cardinal.lt_aleph0_iff_fintype
code: theorem lt_aleph0_iff_fintype {α : Type u} : #α < ℵ₀ ↔ Nonempty (Fintype α) 
goal: Cardinal.mk α < Cardinal.aleph0 ↔ Nonempty (Fintype α)

full_name: Cardinal.lt_aleph0_of_finite
code: theorem lt_aleph0_of_finite (α : Type u) [Finite α] : #α < ℵ₀ 
goal: Cardinal.mk α < Cardinal.aleph0

full_name: Cardinal.lt_aleph0_iff_set_finite
code: theorem lt_aleph0_iff_set_finite {S : Set α} : #S < ℵ₀ ↔ S.Finite 
goal: Cardinal.mk ↑S < Cardinal.aleph0 ↔ S.Finite

full_name: Cardinal.lt_aleph0_iff_subtype_finite
code: @[simp]
theorem lt_aleph0_iff_subtype_finite {p : α → Prop} : #{ x // p x } < ℵ₀ ↔ { x | p x }.Finite 
goal: Cardinal.mk { x // p x } < Cardinal.aleph0 ↔ {x | p x}.Finite

full_name: Cardinal.mk_le_aleph0_iff
code: theorem mk_le_aleph0_iff : #α ≤ ℵ₀ ↔ Countable α 
goal: Cardinal.mk α ≤ Cardinal.aleph0 ↔ Countable α

full_name: Cardinal.mk_le_aleph0
code: @[simp]
theorem mk_le_aleph0 [Countable α] : #α ≤ ℵ₀ 
goal: Cardinal.mk α ≤ Cardinal.aleph0

full_name: Cardinal.le_aleph0_iff_set_countable
code: theorem le_aleph0_iff_set_countable {s : Set α} : #s ≤ ℵ₀ ↔ s.Countable 
goal: Cardinal.mk ↑s ≤ Cardinal.aleph0 ↔ s.Countable

full_name: Cardinal.le_aleph0_iff_subtype_countable
code: @[simp]
theorem le_aleph0_iff_subtype_countable {p : α → Prop} :
    #{ x // p x } ≤ ℵ₀ ↔ { x | p x }.Countable 
goal: Cardinal.mk { x // p x } ≤ Cardinal.aleph0 ↔ {x | p x}.Countable

full_name: Cardinal.canLiftCardinalNat
code: instance canLiftCardinalNat : CanLift Cardinal ℕ (↑) fun x => x < ℵ₀ 
goal: CanLift Cardinal.{u_1} ℕ Nat.cast fun x => x < Cardinal.aleph0

full_name: Cardinal.add_lt_aleph0
code: theorem add_lt_aleph0 {a b : Cardinal} (ha : a < ℵ₀) (hb : b < ℵ₀) : a + b < ℵ₀ 
goal: a + b < Cardinal.aleph0

full_name: Cardinal.add_lt_aleph0_iff
code: theorem add_lt_aleph0_iff {a b : Cardinal} : a + b < ℵ₀ ↔ a < ℵ₀ ∧ b < ℵ₀ 
goal: a + b < Cardinal.aleph0 ↔ a < Cardinal.aleph0 ∧ b < Cardinal.aleph0

full_name: Cardinal.aleph0_le_add_iff
code: theorem aleph0_le_add_iff {a b : Cardinal} : ℵ₀ ≤ a + b ↔ ℵ₀ ≤ a ∨ ℵ₀ ≤ b 
goal: Cardinal.aleph0 ≤ a + b ↔ Cardinal.aleph0 ≤ a ∨ Cardinal.aleph0 ≤ b

full_name: Cardinal.nsmul_lt_aleph0_iff
code: /-- See also `Cardinal.nsmul_lt_aleph0_iff_of_ne_zero` if you already have `n ≠ 0`. -/
theorem nsmul_lt_aleph0_iff {n : ℕ} {a : Cardinal} : n • a < ℵ₀ ↔ n = 0 ∨ a < ℵ₀ 
goal: n • a < Cardinal.aleph0 ↔ n = 0 ∨ a < Cardinal.aleph0

full_name: Cardinal.nsmul_lt_aleph0_iff_of_ne_zero
code: /-- See also `Cardinal.nsmul_lt_aleph0_iff` for a hypothesis-free version. -/
theorem nsmul_lt_aleph0_iff_of_ne_zero {n : ℕ} {a : Cardinal} (h : n ≠ 0) : n • a < ℵ₀ ↔ a < ℵ₀ 
goal: n • a < Cardinal.aleph0 ↔ a < Cardinal.aleph0

full_name: Cardinal.mul_lt_aleph0
code: theorem mul_lt_aleph0 {a b : Cardinal} (ha : a < ℵ₀) (hb : b < ℵ₀) : a * b < ℵ₀ 
goal: a * b < Cardinal.aleph0

full_name: Cardinal.mul_lt_aleph0_iff
code: theorem mul_lt_aleph0_iff {a b : Cardinal} : a * b < ℵ₀ ↔ a = 0 ∨ b = 0 ∨ a < ℵ₀ ∧ b < ℵ₀ 
goal: a * b < Cardinal.aleph0 ↔ a = 0 ∨ b = 0 ∨ a < Cardinal.aleph0 ∧ b < Cardinal.aleph0

full_name: Cardinal.aleph0_le_mul_iff
code: /-- See also `Cardinal.aleph0_le_mul_iff`. -/
theorem aleph0_le_mul_iff {a b : Cardinal} : ℵ₀ ≤ a * b ↔ a ≠ 0 ∧ b ≠ 0 ∧ (ℵ₀ ≤ a ∨ ℵ₀ ≤ b) 
goal: Cardinal.aleph0 ≤ a * b ↔ a ≠ 0 ∧ b ≠ 0 ∧ (Cardinal.aleph0 ≤ a ∨ Cardinal.aleph0 ≤ b)

full_name: Cardinal.aleph0_le_mul_iff'
code: /-- See also `Cardinal.aleph0_le_mul_iff'`. -/
theorem aleph0_le_mul_iff' {a b : Cardinal.{u}} : ℵ₀ ≤ a * b ↔ a ≠ 0 ∧ ℵ₀ ≤ b ∨ ℵ₀ ≤ a ∧ b ≠ 0 
goal: Cardinal.aleph0 ≤ a * b ↔ a ≠ 0 ∧ Cardinal.aleph0 ≤ b ∨ Cardinal.aleph0 ≤ a ∧ b ≠ 0

full_name: Cardinal.mul_lt_aleph0_iff_of_ne_zero
code: theorem mul_lt_aleph0_iff_of_ne_zero {a b : Cardinal} (ha : a ≠ 0) (hb : b ≠ 0) :
    a * b < ℵ₀ ↔ a < ℵ₀ ∧ b < ℵ₀ 
goal: a * b < Cardinal.aleph0 ↔ a < Cardinal.aleph0 ∧ b < Cardinal.aleph0

full_name: Cardinal.power_lt_aleph0
code: theorem power_lt_aleph0 {a b : Cardinal} (ha : a < ℵ₀) (hb : b < ℵ₀) : a ^ b < ℵ₀ 
goal: a ^ b < Cardinal.aleph0

full_name: Cardinal.eq_one_iff_unique
code: theorem eq_one_iff_unique {α : Type*} : #α = 1 ↔ Subsingleton α ∧ Nonempty α 
goal: Cardinal.mk α = 1 ↔ Subsingleton α ∧ Nonempty α

full_name: Cardinal.infinite_iff
code: theorem infinite_iff {α : Type u} : Infinite α ↔ ℵ₀ ≤ #α 
goal: Infinite α ↔ Cardinal.aleph0 ≤ Cardinal.mk α

full_name: Cardinal.aleph0_le_mk_iff
code: lemma aleph0_le_mk_iff : ℵ₀ ≤ #α ↔ Infinite α 
goal: Cardinal.aleph0 ≤ Cardinal.mk α ↔ Infinite α

full_name: Cardinal.mk_lt_aleph0_iff
code: lemma mk_lt_aleph0_iff : #α < ℵ₀ ↔ Finite α 
goal: Cardinal.mk α < Cardinal.aleph0 ↔ Finite α

full_name: Cardinal.aleph0_le_mk
code: @[simp]
theorem aleph0_le_mk (α : Type u) [Infinite α] : ℵ₀ ≤ #α 
goal: Cardinal.aleph0 ≤ Cardinal.mk α

full_name: Cardinal.mk_eq_aleph0
code: @[simp]
theorem mk_eq_aleph0 (α : Type*) [Countable α] [Infinite α] : #α = ℵ₀ 
goal: Cardinal.mk α = Cardinal.aleph0

full_name: Cardinal.denumerable_iff
code: theorem denumerable_iff {α : Type u} : Nonempty (Denumerable α) ↔ #α = ℵ₀ 
goal: Nonempty (Denumerable α) ↔ Cardinal.mk α = Cardinal.aleph0

full_name: Cardinal.mk_denumerable
code: theorem mk_denumerable (α : Type u) [Denumerable α] : #α = ℵ₀ 
goal: Cardinal.mk α = Cardinal.aleph0

full_name: Set.countable_infinite_iff_nonempty_denumerable
code: theorem _root_.Set.countable_infinite_iff_nonempty_denumerable {α : Type*} {s : Set α} :
    s.Countable ∧ s.Infinite ↔ Nonempty (Denumerable s) 
goal: s.Countable ∧ s.Infinite ↔ Nonempty (Denumerable ↑s)

full_name: Cardinal.aleph0_add_aleph0
code: @[simp]
theorem aleph0_add_aleph0 : ℵ₀ + ℵ₀ = ℵ₀ 
goal: Cardinal.aleph0 + Cardinal.aleph0 = Cardinal.aleph0

full_name: Cardinal.aleph0_mul_aleph0
code: theorem aleph0_mul_aleph0 : ℵ₀ * ℵ₀ = ℵ₀ 
goal: Cardinal.aleph0 * Cardinal.aleph0 = Cardinal.aleph0

full_name: Cardinal.nat_mul_aleph0
code: @[simp]
theorem nat_mul_aleph0 {n : ℕ} (hn : n ≠ 0) : ↑n * ℵ₀ = ℵ₀ 
goal: ↑n * Cardinal.aleph0 = Cardinal.aleph0

full_name: Cardinal.aleph0_mul_nat
code: @[simp]
theorem aleph0_mul_nat {n : ℕ} (hn : n ≠ 0) : ℵ₀ * n = ℵ₀ 
goal: Cardinal.aleph0 * ↑n = Cardinal.aleph0

full_name: Cardinal.ofNat_mul_aleph0
code: @[simp]
theorem ofNat_mul_aleph0 {n : ℕ} [Nat.AtLeastTwo n] : no_index (OfNat.ofNat n) * ℵ₀ = ℵ₀ 
goal: OfNat.ofNat n * Cardinal.aleph0 = Cardinal.aleph0

full_name: Cardinal.aleph0_mul_ofNat
code: @[simp]
theorem aleph0_mul_ofNat {n : ℕ} [Nat.AtLeastTwo n] : ℵ₀ * no_index (OfNat.ofNat n) = ℵ₀ 
goal: Cardinal.aleph0 * OfNat.ofNat n = Cardinal.aleph0

full_name: Cardinal.add_le_aleph0
code: @[simp]
theorem add_le_aleph0 {c₁ c₂ : Cardinal} : c₁ + c₂ ≤ ℵ₀ ↔ c₁ ≤ ℵ₀ ∧ c₂ ≤ ℵ₀ 
goal: c₁ + c₂ ≤ Cardinal.aleph0 ↔ c₁ ≤ Cardinal.aleph0 ∧ c₂ ≤ Cardinal.aleph0

full_name: Cardinal.aleph0_add_nat
code: @[simp]
theorem aleph0_add_nat (n : ℕ) : ℵ₀ + n = ℵ₀ 
goal: Cardinal.aleph0 + ↑n = Cardinal.aleph0

full_name: Cardinal.nat_add_aleph0
code: @[simp]
theorem nat_add_aleph0 (n : ℕ) : ↑n + ℵ₀ = ℵ₀ 
goal: ↑n + Cardinal.aleph0 = Cardinal.aleph0

full_name: Cardinal.ofNat_add_aleph0
code: @[simp]
theorem ofNat_add_aleph0 {n : ℕ} [Nat.AtLeastTwo n] : no_index (OfNat.ofNat n) + ℵ₀ = ℵ₀ 
goal: OfNat.ofNat n + Cardinal.aleph0 = Cardinal.aleph0

full_name: Cardinal.aleph0_add_ofNat
code: @[simp]
theorem aleph0_add_ofNat {n : ℕ} [Nat.AtLeastTwo n] : ℵ₀ + no_index (OfNat.ofNat n) = ℵ₀ 
goal: Cardinal.aleph0 + OfNat.ofNat n = Cardinal.aleph0

full_name: Cardinal.exists_nat_eq_of_le_nat
code: theorem exists_nat_eq_of_le_nat {c : Cardinal} {n : ℕ} (h : c ≤ n) : ∃ m, m ≤ n ∧ c = m 
goal: ∃ m ≤ n, c = ↑m

full_name: Cardinal.mk_int
code: theorem mk_int : #ℤ = ℵ₀ 
goal: Cardinal.mk ℤ = Cardinal.aleph0

full_name: Cardinal.mk_pNat
code: theorem mk_pNat : #ℕ+ = ℵ₀ 
goal: Cardinal.mk ℕ+ = Cardinal.aleph0

full_name: Cardinal.sum_lt_prod
code: /-- **König's theorem** -/
theorem sum_lt_prod {ι} (f g : ι → Cardinal) (H : ∀ i, f i < g i) : sum f < prod g 
goal: Cardinal.sum f < Cardinal.prod g

full_name: Cardinal.mk_empty
code: theorem mk_empty : #Empty = 0 
goal: Cardinal.mk Empty = 0

full_name: Cardinal.mk_pempty
code: theorem mk_pempty : #PEmpty = 0 
goal: Cardinal.mk PEmpty.{u_1 + 1} = 0

full_name: Cardinal.mk_punit
code: theorem mk_punit : #PUnit = 1 
goal: Cardinal.mk PUnit.{u_1 + 1} = 1

full_name: Cardinal.mk_unit
code: theorem mk_unit : #Unit = 1 
goal: Cardinal.mk Unit = 1

full_name: Cardinal.mk_singleton
code: theorem mk_singleton {α : Type u} (x : α) : #({x} : Set α) = 1 
goal: Cardinal.mk ↑{x} = 1

full_name: Cardinal.mk_plift_true
code: theorem mk_plift_true : #(PLift True) = 1 
goal: Cardinal.mk (PLift True) = 1

full_name: Cardinal.mk_plift_false
code: theorem mk_plift_false : #(PLift False) = 0 
goal: Cardinal.mk (PLift False) = 0

full_name: Cardinal.mk_vector
code: @[simp]
theorem mk_vector (α : Type u) (n : ℕ) : #(Vector α n) = #α ^ n 
goal: Cardinal.mk (Mathlib.Vector α n) = Cardinal.mk α ^ n

full_name: Cardinal.mk_list_eq_sum_pow
code: theorem mk_list_eq_sum_pow (α : Type u) : #(List α) = sum fun n : ℕ => #α ^ n 
goal: Cardinal.mk (List α) = Cardinal.sum fun n => Cardinal.mk α ^ n

full_name: Cardinal.mk_quot_le
code: theorem mk_quot_le {α : Type u} {r : α → α → Prop} : #(Quot r) ≤ #α 
goal: Cardinal.mk (Quot r) ≤ Cardinal.mk α

full_name: Cardinal.mk_quotient_le
code: theorem mk_quotient_le {α : Type u} {s : Setoid α} : #(Quotient s) ≤ #α 
goal: Cardinal.mk (Quotient s) ≤ Cardinal.mk α

full_name: Cardinal.mk_subtype_le_of_subset
code: theorem mk_subtype_le_of_subset {α : Type u} {p q : α → Prop} (h : ∀ ⦃x⦄, p x → q x) :
    #(Subtype p) ≤ #(Subtype q) 
goal: Cardinal.mk (Subtype p) ≤ Cardinal.mk (Subtype q)

full_name: Cardinal.mk_emptyCollection
code: theorem mk_emptyCollection (α : Type u) : #(∅ : Set α) = 0 
goal: Cardinal.mk ↑∅ = 0

full_name: Cardinal.mk_emptyCollection_iff
code: theorem mk_emptyCollection_iff {α : Type u} {s : Set α} : #s = 0 ↔ s = ∅ 
goal: Cardinal.mk ↑s = 0 ↔ s = ∅

full_name: Cardinal.mk_univ
code: @[simp]
theorem mk_univ {α : Type u} : #(@univ α) = #α 
goal: Cardinal.mk ↑Set.univ = Cardinal.mk α

full_name: Cardinal.mk_image_le
code: theorem mk_image_le {α β : Type u} {f : α → β} {s : Set α} : #(f '' s) ≤ #s 
goal: Cardinal.mk ↑(f '' s) ≤ Cardinal.mk ↑s

full_name: Cardinal.mk_image_le_lift
code: theorem mk_image_le_lift {α : Type u} {β : Type v} {f : α → β} {s : Set α} :
    lift.{u} #(f '' s) ≤ lift.{v} #s 
goal: Cardinal.lift.{u, v} (Cardinal.mk ↑(f '' s)) ≤ Cardinal.lift.{v, u} (Cardinal.mk ↑s)

full_name: Cardinal.mk_range_le
code: theorem mk_range_le {α β : Type u} {f : α → β} : #(range f) ≤ #α 
goal: Cardinal.mk ↑(Set.range f) ≤ Cardinal.mk α

full_name: Cardinal.mk_range_le_lift
code: theorem mk_range_le_lift {α : Type u} {β : Type v} {f : α → β} :
    lift.{u} #(range f) ≤ lift.{v} #α 
goal: Cardinal.lift.{u, v} (Cardinal.mk ↑(Set.range f)) ≤ Cardinal.lift.{v, u} (Cardinal.mk α)

full_name: Cardinal.mk_range_eq
code: theorem mk_range_eq (f : α → β) (h : Injective f) : #(range f) = #α 
goal: Cardinal.mk ↑(Set.range f) = Cardinal.mk α

full_name: Cardinal.mk_range_eq_lift
code: theorem mk_range_eq_lift {α : Type u} {β : Type v} {f : α → β} (hf : Injective f) :
    lift.{max u w} #(range f) = lift.{max v w} #α 
goal: Cardinal.lift.{max u w, v} (Cardinal.mk ↑(Set.range f)) = Cardinal.lift.{max v w, u} (Cardinal.mk α)

full_name: Cardinal.mk_range_eq_of_injective
code: theorem mk_range_eq_of_injective {α : Type u} {β : Type v} {f : α → β} (hf : Injective f) :
    lift.{u} #(range f) = lift.{v} #α 
goal: Cardinal.lift.{u, v} (Cardinal.mk ↑(Set.range f)) = Cardinal.lift.{v, u} (Cardinal.mk α)

full_name: Cardinal.lift_mk_le_lift_mk_of_injective
code: lemma lift_mk_le_lift_mk_of_injective {α : Type u} {β : Type v} {f : α → β} (hf : Injective f) :
    Cardinal.lift.{v} (#α) ≤ Cardinal.lift.{u} (#β) 
goal: Cardinal.lift.{v, u} (Cardinal.mk α) ≤ Cardinal.lift.{u, v} (Cardinal.mk β)

full_name: Cardinal.lift_mk_le_lift_mk_of_surjective
code: lemma lift_mk_le_lift_mk_of_surjective {α : Type u} {β : Type v} {f : α → β} (hf : Surjective f) :
    Cardinal.lift.{u} (#β) ≤ Cardinal.lift.{v} (#α) 
goal: Cardinal.lift.{u, v} (Cardinal.mk β) ≤ Cardinal.lift.{v, u} (Cardinal.mk α)

full_name: Cardinal.mk_image_eq_of_injOn
code: theorem mk_image_eq_of_injOn {α β : Type u} (f : α → β) (s : Set α) (h : InjOn f s) :
    #(f '' s) = #s 
goal: Cardinal.mk ↑(f '' s) = Cardinal.mk ↑s

full_name: Cardinal.mk_image_eq_of_injOn_lift
code: theorem mk_image_eq_of_injOn_lift {α : Type u} {β : Type v} (f : α → β) (s : Set α)
    (h : InjOn f s) : lift.{u} #(f '' s) = lift.{v} #s 
goal: Cardinal.lift.{u, v} (Cardinal.mk ↑(f '' s)) = Cardinal.lift.{v, u} (Cardinal.mk ↑s)

full_name: Cardinal.mk_image_eq
code: theorem mk_image_eq {α β : Type u} {f : α → β} {s : Set α} (hf : Injective f) : #(f '' s) = #s 
goal: Cardinal.mk ↑(f '' s) = Cardinal.mk ↑s

full_name: Cardinal.mk_image_eq_lift
code: theorem mk_image_eq_lift {α : Type u} {β : Type v} (f : α → β) (s : Set α) (h : Injective f) :
    lift.{u} #(f '' s) = lift.{v} #s 
goal: Cardinal.lift.{u, v} (Cardinal.mk ↑(f '' s)) = Cardinal.lift.{v, u} (Cardinal.mk ↑s)

full_name: Cardinal.mk_iUnion_le_sum_mk
code: theorem mk_iUnion_le_sum_mk {α ι : Type u} {f : ι → Set α} : #(⋃ i, f i) ≤ sum fun i => #(f i) 
goal: Cardinal.mk ↑(⋃ i, f i) ≤ Cardinal.sum fun i => Cardinal.mk ↑(f i)

full_name: Cardinal.mk_iUnion_le_sum_mk_lift
code: theorem mk_iUnion_le_sum_mk_lift {α : Type u} {ι : Type v} {f : ι → Set α} :
    lift.{v} #(⋃ i, f i) ≤ sum fun i => #(f i) 
goal: Cardinal.lift.{v, u} (Cardinal.mk ↑(⋃ i, f i)) ≤ Cardinal.sum fun i => Cardinal.mk ↑(f i)

full_name: Cardinal.mk_iUnion_eq_sum_mk
code: theorem mk_iUnion_eq_sum_mk {α ι : Type u} {f : ι → Set α}
    (h : Pairwise fun i j => Disjoint (f i) (f j)) : #(⋃ i, f i) = sum fun i => #(f i) 
goal: Cardinal.mk ↑(⋃ i, f i) = Cardinal.sum fun i => Cardinal.mk ↑(f i)

full_name: Cardinal.mk_iUnion_eq_sum_mk_lift
code: theorem mk_iUnion_eq_sum_mk_lift {α : Type u} {ι : Type v} {f : ι → Set α}
    (h : Pairwise fun i j => Disjoint (f i) (f j)) :
    lift.{v} #(⋃ i, f i) = sum fun i => #(f i) 
goal: Cardinal.lift.{v, u} (Cardinal.mk ↑(⋃ i, f i)) = Cardinal.sum fun i => Cardinal.mk ↑(f i)

full_name: Cardinal.mk_iUnion_le
code: theorem mk_iUnion_le {α ι : Type u} (f : ι → Set α) : #(⋃ i, f i) ≤ #ι * ⨆ i, #(f i) 
goal: Cardinal.mk ↑(⋃ i, f i) ≤ Cardinal.mk ι * ⨆ i, Cardinal.mk ↑(f i)

full_name: Cardinal.mk_iUnion_le_lift
code: theorem mk_iUnion_le_lift {α : Type u} {ι : Type v} (f : ι → Set α) :
    lift.{v} #(⋃ i, f i) ≤ lift.{u} #ι * ⨆ i, lift.{v} #(f i) 
goal: Cardinal.lift.{v, u} (Cardinal.mk ↑(⋃ i, f i)) ≤
  Cardinal.lift.{u, v} (Cardinal.mk ι) * ⨆ i, Cardinal.lift.{v, u} (Cardinal.mk ↑(f i))

full_name: Cardinal.mk_sUnion_le
code: theorem mk_sUnion_le {α : Type u} (A : Set (Set α)) : #(⋃₀ A) ≤ #A * ⨆ s : A, #s 
goal: Cardinal.mk ↑(⋃₀ A) ≤ Cardinal.mk ↑A * ⨆ s, Cardinal.mk ↑↑s

full_name: Cardinal.mk_biUnion_le
code: theorem mk_biUnion_le {ι α : Type u} (A : ι → Set α) (s : Set ι) :
    #(⋃ x ∈ s, A x) ≤ #s * ⨆ x : s, #(A x.1) 
goal: Cardinal.mk ↑(⋃ x ∈ s, A x) ≤ Cardinal.mk ↑s * ⨆ x, Cardinal.mk ↑(A ↑x)

full_name: Cardinal.mk_biUnion_le_lift
code: theorem mk_biUnion_le_lift {α : Type u} {ι : Type v} (A : ι → Set α) (s : Set ι) :
    lift.{v} #(⋃ x ∈ s, A x) ≤ lift.{u} #s * ⨆ x : s, lift.{v} #(A x.1) 
goal: Cardinal.lift.{v, u} (Cardinal.mk ↑(⋃ x ∈ s, A x)) ≤
  Cardinal.lift.{u, v} (Cardinal.mk ↑s) * ⨆ x, Cardinal.lift.{v, u} (Cardinal.mk ↑(A ↑x))

full_name: Cardinal.finset_card_lt_aleph0
code: theorem finset_card_lt_aleph0 (s : Finset α) : #(↑s : Set α) < ℵ₀ 
goal: Cardinal.mk ↑↑s < Cardinal.aleph0

full_name: Cardinal.mk_set_eq_nat_iff_finset
code: theorem mk_set_eq_nat_iff_finset {α} {s : Set α} {n : ℕ} :
    #s = n ↔ ∃ t : Finset α, (t : Set α) = s ∧ t.card = n 
goal: Cardinal.mk ↑s = ↑n ↔ ∃ t, ↑t = s ∧ t.card = n

full_name: Cardinal.mk_eq_nat_iff_finset
code: theorem mk_eq_nat_iff_finset {n : ℕ} :
    #α = n ↔ ∃ t : Finset α, (t : Set α) = univ ∧ t.card = n 
goal: Cardinal.mk α = ↑n ↔ ∃ t, ↑t = Set.univ ∧ t.card = n

full_name: Cardinal.mk_eq_nat_iff_fintype
code: theorem mk_eq_nat_iff_fintype {n : ℕ} : #α = n ↔ ∃ h : Fintype α, @Fintype.card α h = n 
goal: Cardinal.mk α = ↑n ↔ ∃ h, Fintype.card α = n

full_name: Cardinal.mk_union_add_mk_inter
code: theorem mk_union_add_mk_inter {α : Type u} {S T : Set α} :
    #(S ∪ T : Set α) + #(S ∩ T : Set α) = #S + #T 
goal: Cardinal.mk ↑(S ∪ T) + Cardinal.mk ↑(S ∩ T) = Cardinal.mk ↑S + Cardinal.mk ↑T

full_name: Cardinal.mk_union_le
code: /-- The cardinality of a union is at most the sum of the cardinalities
of the two sets. -/
theorem mk_union_le {α : Type u} (S T : Set α) : #(S ∪ T : Set α) ≤ #S + #T 
goal: Cardinal.mk ↑(S ∪ T) ≤ Cardinal.mk ↑S + Cardinal.mk ↑T

full_name: Cardinal.mk_union_of_disjoint
code: theorem mk_union_of_disjoint {α : Type u} {S T : Set α} (H : Disjoint S T) :
    #(S ∪ T : Set α) = #S + #T 
goal: Cardinal.mk ↑(S ∪ T) = Cardinal.mk ↑S + Cardinal.mk ↑T

full_name: Cardinal.mk_insert
code: theorem mk_insert {α : Type u} {s : Set α} {a : α} (h : a ∉ s) :
    #(insert a s : Set α) = #s + 1 
goal: Cardinal.mk ↑(insert a s) = Cardinal.mk ↑s + 1

full_name: Cardinal.mk_insert_le
code: theorem mk_insert_le {α : Type u} {s : Set α} {a : α} : #(insert a s : Set α) ≤ #s + 1 
goal: Cardinal.mk ↑(insert a s) ≤ Cardinal.mk ↑s + 1

full_name: Cardinal.mk_sum_compl
code: theorem mk_sum_compl {α} (s : Set α) : #s + #(sᶜ : Set α) = #α 
goal: Cardinal.mk ↑s + Cardinal.mk ↑sᶜ = Cardinal.mk α

full_name: Cardinal.mk_le_mk_of_subset
code: theorem mk_le_mk_of_subset {α} {s t : Set α} (h : s ⊆ t) : #s ≤ #t 
goal: Cardinal.mk ↑s ≤ Cardinal.mk ↑t

full_name: Cardinal.mk_le_iff_forall_finset_subset_card_le
code: theorem mk_le_iff_forall_finset_subset_card_le {α : Type u} {n : ℕ} {t : Set α} :
    #t ≤ n ↔ ∀ s : Finset α, (s : Set α) ⊆ t → s.card ≤ n 
goal: Cardinal.mk ↑t ≤ ↑n ↔ ∀ (s : Finset α), ↑s ⊆ t → s.card ≤ n

full_name: Cardinal.mk_subtype_mono
code: theorem mk_subtype_mono {p q : α → Prop} (h : ∀ x, p x → q x) :
    #{ x // p x } ≤ #{ x // q x } 
goal: Cardinal.mk { x // p x } ≤ Cardinal.mk { x // q x }

full_name: Cardinal.le_mk_diff_add_mk
code: theorem le_mk_diff_add_mk (S T : Set α) : #S ≤ #(S \ T : Set α) + #T 
goal: Cardinal.mk ↑S ≤ Cardinal.mk ↑(S \ T) + Cardinal.mk ↑T

full_name: Cardinal.mk_diff_add_mk
code: theorem mk_diff_add_mk {S T : Set α} (h : T ⊆ S) : #(S \ T : Set α) + #T = #S 
goal: Cardinal.mk ↑(S \ T) + Cardinal.mk ↑T = Cardinal.mk ↑S

full_name: Cardinal.mk_union_le_aleph0
code: theorem mk_union_le_aleph0 {α} {P Q : Set α} :
    #(P ∪ Q : Set α) ≤ ℵ₀ ↔ #P ≤ ℵ₀ ∧ #Q ≤ ℵ₀ 
goal: Cardinal.mk ↑(P ∪ Q) ≤ Cardinal.aleph0 ↔ Cardinal.mk ↑P ≤ Cardinal.aleph0 ∧ Cardinal.mk ↑Q ≤ Cardinal.aleph0

full_name: Cardinal.mk_subtype_of_equiv
code: theorem mk_subtype_of_equiv {α β : Type u} (p : β → Prop) (e : α ≃ β) :
    #{ a : α // p (e a) } = #{ b : β // p b } 
goal: Cardinal.mk { a // p (e a) } = Cardinal.mk { b // p b }

full_name: Cardinal.mk_sep
code: theorem mk_sep (s : Set α) (t : α → Prop) : #({ x ∈ s | t x } : Set α) = #{ x : s | t x.1 } 
goal: Cardinal.mk ↑{x | x ∈ s ∧ t x} = Cardinal.mk ↑{x | t ↑x}

full_name: Cardinal.mk_preimage_of_injective_lift
code: theorem mk_preimage_of_injective_lift {α : Type u} {β : Type v} (f : α → β) (s : Set β)
    (h : Injective f) : lift.{v} #(f ⁻¹' s) ≤ lift.{u} #s 
goal: Cardinal.lift.{v, u} (Cardinal.mk ↑(f ⁻¹' s)) ≤ Cardinal.lift.{u, v} (Cardinal.mk ↑s)

full_name: Cardinal.mk_preimage_of_subset_range_lift
code: theorem mk_preimage_of_subset_range_lift {α : Type u} {β : Type v} (f : α → β) (s : Set β)
    (h : s ⊆ range f) : lift.{u} #s ≤ lift.{v} #(f ⁻¹' s) 
goal: Cardinal.lift.{u, v} (Cardinal.mk ↑s) ≤ Cardinal.lift.{v, u} (Cardinal.mk ↑(f ⁻¹' s))

full_name: Cardinal.mk_preimage_of_injective_of_subset_range_lift
code: theorem mk_preimage_of_injective_of_subset_range_lift {β : Type v} (f : α → β) (s : Set β)
    (h : Injective f) (h2 : s ⊆ range f) : lift.{v} #(f ⁻¹' s) = lift.{u} #s 
goal: Cardinal.lift.{v, u} (Cardinal.mk ↑(f ⁻¹' s)) = Cardinal.lift.{u, v} (Cardinal.mk ↑s)

full_name: Cardinal.mk_preimage_of_injective_of_subset_range
code: theorem mk_preimage_of_injective_of_subset_range (f : α → β) (s : Set β) (h : Injective f)
    (h2 : s ⊆ range f) : #(f ⁻¹' s) = #s 
goal: Cardinal.mk ↑(f ⁻¹' s) = Cardinal.mk ↑s

full_name: Cardinal.mk_preimage_of_injective
code: theorem mk_preimage_of_injective (f : α → β) (s : Set β) (h : Injective f) :
    #(f ⁻¹' s) ≤ #s 
goal: Cardinal.mk ↑(f ⁻¹' s) ≤ Cardinal.mk ↑s

full_name: Cardinal.mk_preimage_of_subset_range
code: theorem mk_preimage_of_subset_range (f : α → β) (s : Set β) (h : s ⊆ range f) :
    #s ≤ #(f ⁻¹' s) 
goal: Cardinal.mk ↑s ≤ Cardinal.mk ↑(f ⁻¹' s)

full_name: Cardinal.mk_subset_ge_of_subset_image_lift
code: theorem mk_subset_ge_of_subset_image_lift {α : Type u} {β : Type v} (f : α → β) {s : Set α}
    {t : Set β} (h : t ⊆ f '' s) : lift.{u} #t ≤ lift.{v} #({ x ∈ s | f x ∈ t } : Set α) 
goal: Cardinal.lift.{u, v} (Cardinal.mk ↑t) ≤ Cardinal.lift.{v, u} (Cardinal.mk ↑{x | x ∈ s ∧ f x ∈ t})

full_name: Cardinal.mk_subset_ge_of_subset_image
code: theorem mk_subset_ge_of_subset_image (f : α → β) {s : Set α} {t : Set β} (h : t ⊆ f '' s) :
    #t ≤ #({ x ∈ s | f x ∈ t } : Set α) 
goal: Cardinal.mk ↑t ≤ Cardinal.mk ↑{x | x ∈ s ∧ f x ∈ t}

full_name: Cardinal.le_mk_iff_exists_subset
code: theorem le_mk_iff_exists_subset {c : Cardinal} {α : Type u} {s : Set α} :
    c ≤ #s ↔ ∃ p : Set α, p ⊆ s ∧ #p = c 
goal: c ≤ Cardinal.mk ↑s ↔ ∃ p ⊆ s, Cardinal.mk ↑p = c

full_name: Cardinal.two_le_iff
code: theorem two_le_iff : (2 : Cardinal) ≤ #α ↔ ∃ x y : α, x ≠ y 
goal: 2 ≤ Cardinal.mk α ↔ ∃ x y, x ≠ y

full_name: Cardinal.two_le_iff'
code: theorem two_le_iff' (x : α) : (2 : Cardinal) ≤ #α ↔ ∃ y : α, y ≠ x 
goal: 2 ≤ Cardinal.mk α ↔ ∃ y, y ≠ x

full_name: Cardinal.mk_eq_two_iff
code: theorem mk_eq_two_iff : #α = 2 ↔ ∃ x y : α, x ≠ y ∧ ({x, y} : Set α) = univ 
goal: Cardinal.mk α = 2 ↔ ∃ x y, x ≠ y ∧ {x, y} = Set.univ

full_name: Cardinal.mk_eq_two_iff'
code: theorem mk_eq_two_iff' (x : α) : #α = 2 ↔ ∃! y, y ≠ x 
goal: Cardinal.mk α = 2 ↔ ∃! y, y ≠ x

full_name: Cardinal.exists_not_mem_of_length_lt
code: theorem exists_not_mem_of_length_lt {α : Type*} (l : List α) (h : ↑l.length < #α) :
    ∃ z : α, z ∉ l 
goal: ∃ z, z ∉ l

full_name: Cardinal.three_le
code: theorem three_le {α : Type*} (h : 3 ≤ #α) (x : α) (y : α) : ∃ z : α, z ≠ x ∧ z ≠ y 
goal: ∃ z, z ≠ x ∧ z ≠ y

full_name: Cardinal.powerlt
code: /-- The function `a ^< b`, defined as the supremum of `a ^ c` for `c < b`. -/
def powerlt (a b : Cardinal.{u}) : Cardinal.{u} 
goal: Cardinal.{u}

full_name: Cardinal.«_aux_Mathlib_SetTheory_Cardinal_Basic___macroRules_Cardinal_term_^<__1»
code: @[inherit_doc]
infixl:80 " ^< " => powerlt
goal: Lean.Macro

full_name: Cardinal._aux_Mathlib_SetTheory_Cardinal_Basic___unexpand_Cardinal_powerlt_1
code: @[inherit_doc]
infixl:80 " ^< " => powerlt
goal: Lean.PrettyPrinter.Unexpander

full_name: Cardinal.le_powerlt
code: theorem le_powerlt {b c : Cardinal.{u}} (a) (h : c < b) : (a^c) ≤ a ^< b 
goal: a ^ c ≤ a ^< b

full_name: Cardinal.powerlt_le
code: theorem powerlt_le {a b c : Cardinal.{u}} : a ^< b ≤ c ↔ ∀ x < b, a ^ x ≤ c 
goal: a ^< b ≤ c ↔ ∀ x < b, a ^ x ≤ c

full_name: Cardinal.powerlt_le_powerlt_left
code: theorem powerlt_le_powerlt_left {a b c : Cardinal} (h : b ≤ c) : a ^< b ≤ a ^< c 
goal: a ^< b ≤ a ^< c

full_name: Cardinal.powerlt_mono_left
code: theorem powerlt_mono_left (a) : Monotone fun c => a ^< c 
goal: Monotone fun c => a ^< c

full_name: Cardinal.powerlt_succ
code: theorem powerlt_succ {a b : Cardinal} (h : a ≠ 0) : a ^< succ b = a ^ b 
goal: a ^< Order.succ b = a ^ b

full_name: Cardinal.powerlt_min
code: theorem powerlt_min {a b c : Cardinal} : a ^< min b c = min (a ^< b) (a ^< c) 
goal: a ^< min b c = min (a ^< b) (a ^< c)

full_name: Cardinal.powerlt_max
code: theorem powerlt_max {a b c : Cardinal} : a ^< max b c = max (a ^< b) (a ^< c) 
goal: a ^< max b c = max (a ^< b) (a ^< c)

full_name: Cardinal.zero_powerlt
code: theorem zero_powerlt {a : Cardinal} (h : a ≠ 0) : 0 ^< a = 1 
goal: 0 ^< a = 1

full_name: Cardinal.powerlt_zero
code: @[simp]
theorem powerlt_zero {a : Cardinal} : a ^< 0 = 0 
goal: a ^< 0 = 0