fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
aleph0_lt_continuum : ℵ₀ < 𝔠 :=
cantor ℵ₀ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | aleph0_lt_continuum | null |
aleph0_le_continuum : ℵ₀ ≤ 𝔠 :=
aleph0_lt_continuum.le
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | aleph0_le_continuum | null |
beth_one : ℶ_ 1 = 𝔠 := by simpa using beth_succ 0 | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | beth_one | null |
nat_lt_continuum (n : ℕ) : ↑n < 𝔠 :=
(nat_lt_aleph0 n).trans aleph0_lt_continuum | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | nat_lt_continuum | null |
mk_set_nat : #(Set ℕ) = 𝔠 := by simp | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | mk_set_nat | null |
continuum_pos : 0 < 𝔠 :=
nat_lt_continuum 0 | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | continuum_pos | null |
continuum_ne_zero : 𝔠 ≠ 0 :=
continuum_pos.ne' | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | continuum_ne_zero | null |
aleph_one_le_continuum : ℵ₁ ≤ 𝔠 := by
rw [← succ_aleph0]
exact Order.succ_le_of_lt aleph0_lt_continuum
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | aleph_one_le_continuum | null |
continuum_toNat : toNat continuum = 0 :=
toNat_apply_of_aleph0_le aleph0_le_continuum
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | continuum_toNat | null |
continuum_toENat : toENat continuum = ⊤ :=
(toENat_eq_top.2 aleph0_le_continuum)
/-! | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | continuum_toENat | null |
@[simp]
aleph0_add_continuum : ℵ₀ + 𝔠 = 𝔠 :=
add_eq_right aleph0_le_continuum aleph0_le_continuum
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | aleph0_add_continuum | null |
continuum_add_aleph0 : 𝔠 + ℵ₀ = 𝔠 :=
(add_comm _ _).trans aleph0_add_continuum
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | continuum_add_aleph0 | null |
continuum_add_self : 𝔠 + 𝔠 = 𝔠 :=
add_eq_self aleph0_le_continuum
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | continuum_add_self | null |
nat_add_continuum (n : ℕ) : ↑n + 𝔠 = 𝔠 :=
nat_add_eq n aleph0_le_continuum
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | nat_add_continuum | null |
continuum_add_nat (n : ℕ) : 𝔠 + n = 𝔠 :=
(add_comm _ _).trans (nat_add_continuum n)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | continuum_add_nat | null |
ofNat_add_continuum {n : ℕ} [Nat.AtLeastTwo n] : ofNat(n) + 𝔠 = 𝔠 :=
nat_add_continuum n
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | ofNat_add_continuum | null |
continuum_add_ofNat {n : ℕ} [Nat.AtLeastTwo n] : 𝔠 + ofNat(n) = 𝔠 :=
continuum_add_nat n
/-! | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | continuum_add_ofNat | null |
@[simp]
continuum_mul_self : 𝔠 * 𝔠 = 𝔠 :=
mul_eq_left aleph0_le_continuum le_rfl continuum_ne_zero
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | continuum_mul_self | null |
continuum_mul_aleph0 : 𝔠 * ℵ₀ = 𝔠 :=
mul_eq_left aleph0_le_continuum aleph0_le_continuum aleph0_ne_zero
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | continuum_mul_aleph0 | null |
aleph0_mul_continuum : ℵ₀ * 𝔠 = 𝔠 :=
(mul_comm _ _).trans continuum_mul_aleph0
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | aleph0_mul_continuum | null |
nat_mul_continuum {n : ℕ} (hn : n ≠ 0) : ↑n * 𝔠 = 𝔠 :=
mul_eq_right aleph0_le_continuum (nat_lt_continuum n).le (Nat.cast_ne_zero.2 hn)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | nat_mul_continuum | null |
continuum_mul_nat {n : ℕ} (hn : n ≠ 0) : 𝔠 * n = 𝔠 :=
(mul_comm _ _).trans (nat_mul_continuum hn)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | continuum_mul_nat | null |
ofNat_mul_continuum {n : ℕ} [Nat.AtLeastTwo n] : ofNat(n) * 𝔠 = 𝔠 :=
nat_mul_continuum (OfNat.ofNat_ne_zero n)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | ofNat_mul_continuum | null |
continuum_mul_ofNat {n : ℕ} [Nat.AtLeastTwo n] : 𝔠 * ofNat(n) = 𝔠 :=
continuum_mul_nat (OfNat.ofNat_ne_zero n)
/-! | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | continuum_mul_ofNat | null |
@[simp]
aleph0_power_aleph0 : ℵ₀ ^ ℵ₀ = 𝔠 :=
power_self_eq le_rfl
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | aleph0_power_aleph0 | null |
nat_power_aleph0 {n : ℕ} (hn : 2 ≤ n) : n ^ ℵ₀ = 𝔠 :=
nat_power_eq le_rfl hn
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | nat_power_aleph0 | null |
continuum_power_aleph0 : 𝔠 ^ ℵ₀ = 𝔠 := by
rw [← two_power_aleph0, ← power_mul, mul_eq_left le_rfl le_rfl aleph0_ne_zero] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | continuum_power_aleph0 | null |
power_aleph0_of_le_continuum {x : Cardinal} (h₁ : 2 ≤ x) (h₂ : x ≤ 𝔠) : x ^ ℵ₀ = 𝔠 := by
apply le_antisymm
· rw [← continuum_power_aleph0]
exact power_le_power_right h₂
· rw [← two_power_aleph0]
exact power_le_power_right h₁ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic"
] | Mathlib/SetTheory/Cardinal/Continuum.lean | power_aleph0_of_le_continuum | null |
mk_subtype_le_of_countable_eventually_mem_aux {α ι : Type u} {a : Cardinal}
[Countable ι] {f : ι → Set α} {l : Filter ι} [NeBot l]
{t : Set α} (ht : ∀ x ∈ t, ∀ᶠ i in l, x ∈ f i)
(h'f : ∀ i, #(f i) ≤ a) : #t ≤ a := by
rcases lt_or_ge a ℵ₀ with ha|ha
/- case `a` finite. In this case, it suffices to show that any finite subset `s` of `t` has
cardinality at most `a`. For this, we pick `i` such that `f i` contains all the points in `s`,
and apply the assumption that the cardinality of `f i` is at most `a`. -/
· obtain ⟨n, rfl⟩ : ∃ (n : ℕ), a = n := lt_aleph0.1 ha
apply mk_le_iff_forall_finset_subset_card_le.2 (fun s hs ↦ ?_)
have A : ∀ x ∈ s, ∀ᶠ i in l, x ∈ f i := fun x hx ↦ ht x (hs hx)
have B : ∀ᶠ i in l, ∀ x ∈ s, x ∈ f i := (s.eventually_all).2 A
rcases B.exists with ⟨i, hi⟩
have : ∀ i, Fintype (f i) := fun i ↦ (lt_aleph0_iff_fintype.1 ((h'f i).trans_lt ha)).some
let u : Finset α := (f i).toFinset
have I1 : s.card ≤ u.card := by
have : s ⊆ u := fun x hx ↦ by simpa only [u, Set.mem_toFinset] using hi x hx
exact Finset.card_le_card this
have I2 : (u.card : Cardinal) ≤ n := by
convert h'f i; simp only [u, Set.toFinset_card, mk_fintype]
exact I1.trans (Nat.cast_le.1 I2)
· have : t ⊆ ⋃ i, f i := by
intro x hx
obtain ⟨i, hi⟩ : ∃ i, x ∈ f i := (ht x hx).exists
exact mem_iUnion_of_mem i hi
calc #t ≤ #(⋃ i, f i) := mk_le_mk_of_subset this
_ ≤ sum (fun i ↦ #(f i)) := mk_iUnion_le_sum_mk
_ ≤ sum (fun _ ↦ a) := sum_le_sum _ _ h'f
_ = #ι * a := by simp
_ ≤ ℵ₀ * a := mul_le_mul_right' mk_le_aleph0 a
_ = a := aleph0_mul_eq ha | lemma | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.Order.Filter.Finite",
"Mathlib.Order.Filter.Map"
] | Mathlib/SetTheory/Cardinal/CountableCover.lean | mk_subtype_le_of_countable_eventually_mem_aux | If a set `t` is eventually covered by a countable family of sets, all with cardinality at
most `a`, then the cardinality of `t` is also bounded by `a`.
Superseded by `mk_le_of_countable_eventually_mem` which does not assume
that the indexing set lives in the same universe. |
mk_subtype_le_of_countable_eventually_mem {α : Type u} {ι : Type v} {a : Cardinal}
[Countable ι] {f : ι → Set α} {l : Filter ι} [NeBot l]
{t : Set α} (ht : ∀ x ∈ t, ∀ᶠ i in l, x ∈ f i)
(h'f : ∀ i, #(f i) ≤ a) : #t ≤ a := by
let g : ULift.{u, v} ι → Set (ULift.{v, u} α) := (ULift.down ⁻¹' ·) ∘ f ∘ ULift.down
suffices #(ULift.down.{v} ⁻¹' t) ≤ Cardinal.lift.{v, u} a by simpa
let l' : Filter (ULift.{u} ι) := Filter.map ULift.up l
have : NeBot l' := map_neBot
apply mk_subtype_le_of_countable_eventually_mem_aux (ι := ULift.{u} ι) (l := l') (f := g)
· intro x hx
simpa only [Function.comp_apply, mem_preimage, eventually_map] using ht _ hx
· intro i
simpa [g] using h'f i.down | lemma | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.Order.Filter.Finite",
"Mathlib.Order.Filter.Map"
] | Mathlib/SetTheory/Cardinal/CountableCover.lean | mk_subtype_le_of_countable_eventually_mem | If a set `t` is eventually covered by a countable family of sets, all with cardinality at
most `a`, then the cardinality of `t` is also bounded by `a`. |
mk_le_of_countable_eventually_mem {α : Type u} {ι : Type v} {a : Cardinal}
[Countable ι] {f : ι → Set α} {l : Filter ι} [NeBot l] (ht : ∀ x, ∀ᶠ i in l, x ∈ f i)
(h'f : ∀ i, #(f i) ≤ a) : #α ≤ a := by
rw [← mk_univ]
exact mk_subtype_le_of_countable_eventually_mem (l := l) (fun x _ ↦ ht x) h'f | lemma | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.Order.Filter.Finite",
"Mathlib.Order.Filter.Map"
] | Mathlib/SetTheory/Cardinal/CountableCover.lean | mk_le_of_countable_eventually_mem | If a space is eventually covered by a countable family of sets, all with cardinality at
most `a`, then the cardinality of the space is also bounded by `a`. |
mk_of_countable_eventually_mem {α : Type u} {ι : Type v} {a : Cardinal}
[Countable ι] {f : ι → Set α} {l : Filter ι} [NeBot l] (ht : ∀ x, ∀ᶠ i in l, x ∈ f i)
(h'f : ∀ i, #(f i) = a) : #α = a := by
apply le_antisymm
· apply mk_le_of_countable_eventually_mem ht (fun i ↦ (h'f i).le)
· obtain ⟨i⟩ : Nonempty ι := nonempty_of_neBot l
rw [← (h'f i)]
exact mk_set_le (f i) | lemma | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.Order.Filter.Finite",
"Mathlib.Order.Filter.Map"
] | Mathlib/SetTheory/Cardinal/CountableCover.lean | mk_of_countable_eventually_mem | If a space is eventually covered by a countable family of sets, all with cardinality `a`,
then the cardinality of the space is also `a`. |
Cardinal.isEquivalent : Setoid (Type u) where
r α β := Nonempty (α ≃ β)
iseqv := ⟨
fun α => ⟨Equiv.refl α⟩,
fun ⟨e⟩ => ⟨e.symm⟩,
fun ⟨e₁⟩ ⟨e₂⟩ => ⟨e₁.trans e₂⟩⟩ | instance | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | Cardinal.isEquivalent | The equivalence relation on types given by equivalence (bijective correspondence) of types.
Quotienting by this equivalence relation gives the cardinal numbers. |
@[pp_with_univ]
Cardinal : Type (u + 1) :=
Quotient Cardinal.isEquivalent | def | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | Cardinal | `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). |
mk : Type u → Cardinal :=
Quotient.mk'
@[inherit_doc]
scoped prefix:max "#" => Cardinal.mk | def | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk | The cardinal number of a type |
canLiftCardinalType : CanLift Cardinal.{u} (Type u) mk fun _ => True :=
⟨fun c _ => Quot.inductionOn c fun α => ⟨α, rfl⟩⟩
@[elab_as_elim] | instance | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | canLiftCardinalType | null |
inductionOn {p : Cardinal → Prop} (c : Cardinal) (h : ∀ α, p #α) : p c :=
Quotient.inductionOn c h
@[elab_as_elim] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | inductionOn | null |
inductionOn₂ {p : Cardinal → Cardinal → Prop} (c₁ : Cardinal) (c₂ : Cardinal)
(h : ∀ α β, p #α #β) : p c₁ c₂ :=
Quotient.inductionOn₂ c₁ c₂ h
@[elab_as_elim] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | inductionOn₂ | null |
inductionOn₃ {p : Cardinal → Cardinal → Cardinal → Prop} (c₁ : Cardinal) (c₂ : Cardinal)
(c₃ : Cardinal) (h : ∀ α β γ, p #α #β #γ) : p c₁ c₂ c₃ :=
Quotient.inductionOn₃ c₁ c₂ c₃ h | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | inductionOn₃ | null |
induction_on_pi {ι : Type u} {p : (ι → Cardinal.{v}) → Prop}
(f : ι → Cardinal.{v}) (h : ∀ f : ι → Type v, p fun i ↦ #(f i)) : p f :=
Quotient.induction_on_pi f h | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | induction_on_pi | null |
protected eq : #α = #β ↔ Nonempty (α ≃ β) :=
Quotient.eq'
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | eq | null |
mk_out (c : Cardinal) : #c.out = c :=
Quotient.out_eq _ | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_out | null |
outMkEquiv {α : Type v} : (#α).out ≃ α :=
Nonempty.some <| Cardinal.eq.mp (by simp) | def | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | outMkEquiv | The representative of the cardinal of a type is equivalent to the original type. |
mk_congr (e : α ≃ β) : #α = #β :=
Quot.sound ⟨e⟩
alias _root_.Equiv.cardinal_eq := mk_congr | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_congr | null |
map (f : Type u → Type v) (hf : ∀ α β, α ≃ β → f α ≃ f β) : Cardinal.{u} → Cardinal.{v} :=
Quotient.map f fun α β ⟨e⟩ => ⟨hf α β e⟩
@[simp] | def | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | map | Lift a function between `Type*`s to a function between `Cardinal`s. |
map_mk (f : Type u → Type v) (hf : ∀ α β, α ≃ β → f α ≃ f β) (α : Type u) :
map f hf #α = #(f α) :=
rfl | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | map_mk | null |
map₂ (f : Type u → Type v → Type w) (hf : ∀ α β γ δ, α ≃ β → γ ≃ δ → f α γ ≃ f β δ) :
Cardinal.{u} → Cardinal.{v} → Cardinal.{w} :=
Quotient.map₂ f fun α β ⟨e₁⟩ γ δ ⟨e₂⟩ => ⟨hf α β γ δ e₁ e₂⟩
/-! ### Lifting cardinals to a higher universe -/ | def | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | map₂ | Lift a binary operation `Type* → Type* → Type*` to a binary operation on `Cardinal`s. |
@[pp_with_univ]
lift (c : Cardinal.{v}) : Cardinal.{max v u} :=
map ULift.{u, v} (fun _ _ e => Equiv.ulift.trans <| e.trans Equiv.ulift.symm) c
@[simp] | def | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | lift | The universe lift operation on cardinals. You can specify the universes explicitly with
`lift.{u v} : Cardinal.{v} → Cardinal.{max v u}` |
mk_uLift (α) : #(ULift.{v, u} α) = lift.{v} #α :=
rfl | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_uLift | null |
lift_umax : lift.{max u v, u} = lift.{v, u} :=
funext fun a => inductionOn a fun _ => (Equiv.ulift.trans Equiv.ulift.symm).cardinal_eq | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | lift_umax | `lift.{max u v, u}` equals `lift.{v, u}`.
Unfortunately, the simp lemma doesn't work. |
lift_id' (a : Cardinal.{max u v}) : lift.{u} a = a :=
inductionOn a fun _ => mk_congr Equiv.ulift | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | lift_id' | A cardinal lifted to a lower or equal universe equals itself.
Unfortunately, the simp lemma doesn't work. |
@[simp]
lift_id (a : Cardinal) : lift.{u, u} a = a :=
lift_id'.{u, u} a | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | lift_id | A cardinal lifted to the same universe equals itself. |
@[simp]
lift_uzero (a : Cardinal.{u}) : lift.{0} a = a :=
lift_id'.{0, u} a
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | lift_uzero | A cardinal lifted to the zero universe equals itself. |
lift_lift.{u_1} (a : Cardinal.{u_1}) : lift.{w} (lift.{v} a) = lift.{max v w} a :=
inductionOn a fun _ => (Equiv.ulift.trans <| Equiv.ulift.trans Equiv.ulift.symm).cardinal_eq | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | lift_lift. | null |
out_lift_equiv (a : Cardinal.{u}) : Nonempty ((lift.{v} a).out ≃ a.out) := by
rw [← mk_out a, ← mk_uLift, mk_out]
exact ⟨outMkEquiv.trans Equiv.ulift⟩ | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | out_lift_equiv | null |
lift_mk_eq {α : Type u} {β : Type v} :
lift.{max v w} #α = lift.{max u w} #β ↔ Nonempty (α ≃ β) :=
Quotient.eq'.trans
⟨fun ⟨f⟩ => ⟨Equiv.ulift.symm.trans <| f.trans Equiv.ulift⟩, fun ⟨f⟩ =>
⟨Equiv.ulift.trans <| f.trans Equiv.ulift.symm⟩⟩ | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | lift_mk_eq | null |
lift_mk_eq' {α : Type u} {β : Type v} : lift.{v} #α = lift.{u} #β ↔ Nonempty (α ≃ β) :=
lift_mk_eq.{u, v, 0} | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | lift_mk_eq' | A variant of `Cardinal.lift_mk_eq` with specialized universes.
Because Lean often cannot realize it should use this specialization itself,
we provide this statement separately so you don't have to solve the specialization problem either. |
mk_congr_lift {α : Type u} {β : Type v} (e : α ≃ β) : lift.{v} #α = lift.{u} #β :=
lift_mk_eq'.2 ⟨e⟩
alias _root_.Equiv.lift_cardinal_eq := mk_congr_lift
/-! ### Basic cardinals -/ | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_congr_lift | null |
@[simp]
mk_eq_zero (α : Type u) [IsEmpty α] : #α = 0 :=
(Equiv.equivOfIsEmpty α (ULift (Fin 0))).cardinal_eq
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_eq_zero | null |
lift_zero : lift 0 = 0 := mk_eq_zero _ | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | lift_zero | null |
mk_eq_zero_iff {α : Type u} : #α = 0 ↔ IsEmpty α :=
⟨fun e =>
let ⟨h⟩ := Quotient.exact e
h.isEmpty,
@mk_eq_zero α⟩ | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_eq_zero_iff | null |
mk_ne_zero_iff {α : Type u} : #α ≠ 0 ↔ Nonempty α :=
(not_iff_not.2 mk_eq_zero_iff).trans not_isEmpty_iff
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_ne_zero_iff | null |
mk_ne_zero (α : Type u) [Nonempty α] : #α ≠ 0 :=
mk_ne_zero_iff.2 ‹_› | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_ne_zero | null |
mk_eq_one (α : Type u) [Subsingleton α] [Nonempty α] : #α = 1 :=
let ⟨_⟩ := nonempty_unique α; (Equiv.ofUnique α (ULift (Fin 1))).cardinal_eq | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_eq_one | null |
add_def (α β : Type u) : #α + #β = #(α ⊕ β) :=
rfl | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | add_def | null |
@[simp]
mk_sum (α : Type u) (β : Type v) : #(α ⊕ β) = lift.{v, u} #α + lift.{u, v} #β :=
mk_congr (Equiv.ulift.symm.sumCongr Equiv.ulift.symm)
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_sum | null |
mk_option {α : Type u} : #(Option α) = #α + 1 := by
rw [(Equiv.optionEquivSumPUnit.{u, u} α).cardinal_eq, mk_sum, mk_eq_one PUnit, lift_id, lift_id]
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_option | null |
mk_psum (α : Type u) (β : Type v) : #(α ⊕' β) = lift.{v} #α + lift.{u} #β :=
(mk_congr (Equiv.psumEquivSum α β)).trans (mk_sum α β) | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_psum | null |
mul_def (α β : Type u) : #α * #β = #(α × β) :=
rfl
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mul_def | null |
mk_prod (α : Type u) (β : Type v) : #(α × β) = lift.{v, u} #α * lift.{u, v} #β :=
mk_congr (Equiv.ulift.symm.prodCongr Equiv.ulift.symm) | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_prod | null |
instPowCardinal : Pow Cardinal.{u} Cardinal.{u} :=
⟨map₂ (fun α β => β → α) fun _ _ _ _ e₁ e₂ => e₂.arrowCongr e₁⟩ | instance | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | instPowCardinal | The cardinal exponential. `#α ^ #β` is the cardinal of `β → α`. |
power_def (α β : Type u) : #α ^ #β = #(β → α) :=
rfl | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | power_def | null |
mk_arrow (α : Type u) (β : Type v) : #(α → β) = (lift.{u} #β^lift.{v} #α) :=
mk_congr (Equiv.ulift.symm.arrowCongr Equiv.ulift.symm)
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_arrow | null |
lift_power (a b : Cardinal.{u}) : lift.{v} (a ^ b) = lift.{v} a ^ lift.{v} b :=
inductionOn₂ a b fun _ _ =>
mk_congr <| Equiv.ulift.trans (Equiv.ulift.arrowCongr Equiv.ulift).symm
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | lift_power | null |
power_zero (a : Cardinal) : a ^ (0 : Cardinal) = 1 :=
inductionOn a fun _ => mk_eq_one _
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | power_zero | null |
power_one (a : Cardinal.{u}) : a ^ (1 : Cardinal) = a :=
inductionOn a fun α => mk_congr (Equiv.funUnique (ULift.{u} (Fin 1)) α) | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | power_one | null |
power_add (a b c : Cardinal) : a ^ (b + c) = a ^ b * a ^ c :=
inductionOn₃ a b c fun α β γ => mk_congr <| Equiv.sumArrowEquivProdArrow β γ α
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | power_add | null |
one_power {a : Cardinal} : (1 : Cardinal) ^ a = 1 :=
inductionOn a fun _ => mk_eq_one _
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | one_power | null |
zero_power {a : Cardinal} : a ≠ 0 → (0 : Cardinal) ^ a = 0 :=
inductionOn a fun _ heq =>
mk_eq_zero_iff.2 <|
isEmpty_pi.2 <|
let ⟨a⟩ := mk_ne_zero_iff.1 heq
⟨a, inferInstance⟩ | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | zero_power | null |
power_ne_zero {a : Cardinal} (b : Cardinal) : a ≠ 0 → a ^ b ≠ 0 :=
inductionOn₂ a b fun _ _ h =>
let ⟨a⟩ := mk_ne_zero_iff.1 h
mk_ne_zero_iff.2 ⟨fun _ => a⟩ | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | power_ne_zero | null |
mul_power {a b c : Cardinal} : (a * b) ^ c = a ^ c * b ^ c :=
inductionOn₃ a b c fun _ _ γ => mk_congr <| Equiv.arrowProdEquivProdArrow γ _ _
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mul_power | null |
lift_one : lift 1 = 1 := mk_eq_one _
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | lift_one | null |
lift_add (a b : Cardinal.{u}) : lift.{v} (a + b) = lift.{v} a + lift.{v} b :=
inductionOn₂ a b fun _ _ =>
mk_congr <| Equiv.ulift.trans (Equiv.sumCongr Equiv.ulift Equiv.ulift).symm
/-! ### Indexed cardinal `sum` -/ | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | lift_add | null |
sum {ι} (f : ι → Cardinal) : Cardinal :=
mk (Σ i, (f i).out)
@[simp] | def | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | sum | The indexed sum of cardinals is the cardinality of the
indexed disjoint union, i.e. sigma type. |
mk_sigma {ι} (f : ι → Type*) : #(Σ i, f i) = sum fun i => #(f i) :=
mk_congr <| Equiv.sigmaCongrRight fun _ => outMkEquiv.symm | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_sigma | null |
mk_sigma_congr_lift {ι : Type v} {ι' : Type v'} {f : ι → Type w} {g : ι' → Type w'}
(e : ι ≃ ι') (h : ∀ i, lift.{w'} #(f i) = lift.{w} #(g (e i))) :
lift.{max v' w'} #(Σ i, f i) = lift.{max v w} #(Σ i, g i) :=
Cardinal.lift_mk_eq'.2 ⟨.sigmaCongr e fun i ↦ Classical.choice <| Cardinal.lift_mk_eq'.1 (h i)⟩ | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_sigma_congr_lift | null |
mk_sigma_congr {ι ι' : Type u} {f : ι → Type v} {g : ι' → Type v} (e : ι ≃ ι')
(h : ∀ i, #(f i) = #(g (e i))) : #(Σ i, f i) = #(Σ i, g i) :=
mk_congr <| Equiv.sigmaCongr e fun i ↦ Classical.choice <| Cardinal.eq.mp (h i) | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_sigma_congr | null |
mk_sigma_congr' {ι : Type u} {ι' : Type v} {f : ι → Type max w (max u v)}
{g : ι' → Type max w (max u v)} (e : ι ≃ ι')
(h : ∀ i, #(f i) = #(g (e i))) : #(Σ i, f i) = #(Σ i, g i) :=
mk_congr <| Equiv.sigmaCongr e fun i ↦ Classical.choice <| Cardinal.eq.mp (h i) | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_sigma_congr' | Similar to `mk_sigma_congr` with indexing types in different universes. This is not a strict
generalization. |
mk_sigma_congrRight {ι : Type u} {f g : ι → Type v} (h : ∀ i, #(f i) = #(g i)) :
#(Σ i, f i) = #(Σ i, g i) :=
mk_sigma_congr (Equiv.refl ι) h | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_sigma_congrRight | null |
mk_psigma_congrRight {ι : Type u} {f g : ι → Type v} (h : ∀ i, #(f i) = #(g i)) :
#(Σ' i, f i) = #(Σ' i, g i) :=
mk_congr <| .psigmaCongrRight fun i => Classical.choice <| Cardinal.eq.mp (h i) | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_psigma_congrRight | null |
mk_psigma_congrRight_prop {ι : Prop} {f g : ι → Type v} (h : ∀ i, #(f i) = #(g i)) :
#(Σ' i, f i) = #(Σ' i, g i) :=
mk_congr <| .psigmaCongrRight fun i => Classical.choice <| Cardinal.eq.mp (h i) | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_psigma_congrRight_prop | null |
mk_sigma_arrow {ι} (α : Type*) (f : ι → Type*) :
#(Sigma f → α) = #(Π i, f i → α) := mk_congr <| Equiv.piCurry fun _ _ ↦ α
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_sigma_arrow | null |
sum_const (ι : Type u) (a : Cardinal.{v}) :
(sum fun _ : ι => a) = lift.{v} #ι * lift.{u} a :=
inductionOn a fun α =>
mk_congr <|
calc
(Σ _ : ι, Quotient.out #α) ≃ ι × Quotient.out #α := Equiv.sigmaEquivProd _ _
_ ≃ ULift ι × ULift α := Equiv.ulift.symm.prodCongr (outMkEquiv.trans Equiv.ulift.symm) | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | sum_const | null |
sum_const' (ι : Type u) (a : Cardinal.{u}) : (sum fun _ : ι => a) = #ι * a := by simp
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | sum_const' | null |
lift_sum {ι : Type u} (f : ι → Cardinal.{v}) :
Cardinal.lift.{w} (Cardinal.sum f) = Cardinal.sum fun i => Cardinal.lift.{w} (f i) :=
Equiv.cardinal_eq <|
Equiv.ulift.trans <|
Equiv.sigmaCongrRight fun a =>
Nonempty.some <| by rw [← lift_mk_eq.{_,_,v}, mk_out, mk_out, lift_lift] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | lift_sum | null |
sum_nat_eq_add_sum_succ (f : ℕ → Cardinal.{u}) :
Cardinal.sum f = f 0 + Cardinal.sum fun i => f (i + 1) := by
refine (Equiv.sigmaNatSucc fun i => Quotient.out (f i)).cardinal_eq.trans ?_
simp only [mk_sum, mk_out, lift_id, mk_sigma]
/-! ### Indexed cardinal `prod` -/ | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | sum_nat_eq_add_sum_succ | null |
prod {ι : Type u} (f : ι → Cardinal) : Cardinal :=
#(Π i, (f i).out)
@[simp] | def | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | prod | The indexed product of cardinals is the cardinality of the Pi type
(dependent product). |
mk_pi {ι : Type u} (α : ι → Type v) : #(Π i, α i) = prod fun i => #(α i) :=
mk_congr <| Equiv.piCongrRight fun _ => outMkEquiv.symm | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_pi | null |
mk_pi_congr_lift {ι : Type v} {ι' : Type v'} {f : ι → Type w} {g : ι' → Type w'}
(e : ι ≃ ι') (h : ∀ i, lift.{w'} #(f i) = lift.{w} #(g (e i))) :
lift.{max v' w'} #(Π i, f i) = lift.{max v w} #(Π i, g i) :=
Cardinal.lift_mk_eq'.2 ⟨.piCongr e fun i ↦ Classical.choice <| Cardinal.lift_mk_eq'.1 (h i)⟩ | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_pi_congr_lift | null |
mk_pi_congr {ι ι' : Type u} {f : ι → Type v} {g : ι' → Type v} (e : ι ≃ ι')
(h : ∀ i, #(f i) = #(g (e i))) : #(Π i, f i) = #(Π i, g i) :=
mk_congr <| Equiv.piCongr e fun i ↦ Classical.choice <| Cardinal.eq.mp (h i) | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Util.Delaborators",
"Mathlib.Util.AssertExists"
] | Mathlib/SetTheory/Cardinal/Defs.lean | mk_pi_congr | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.