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 ⌀ |
|---|---|---|---|---|---|---|
card_image_equiv (e : α ≃ β) : Nat.card (e '' s) = Nat.card s :=
Nat.card_congr (e.image s).symm | lemma | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_image_equiv | null |
card_preimage_of_injOn {f : α → β} {s : Set β} (hf : (f ⁻¹' s).InjOn f) (hsf : s ⊆ range f) :
Nat.card (f ⁻¹' s) = Nat.card s := by
rw [← Nat.card_image_of_injOn hf, image_preimage_eq_iff.2 hsf] | lemma | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_preimage_of_injOn | null |
card_preimage_of_injective {f : α → β} {s : Set β} (hf : Injective f) (hsf : s ⊆ range f) :
Nat.card (f ⁻¹' s) = Nat.card s := card_preimage_of_injOn hf.injOn hsf | lemma | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_preimage_of_injective | null |
card_univ : Nat.card (univ : Set α) = Nat.card α :=
card_congr (Equiv.Set.univ α) | lemma | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_univ | null |
card_range_of_injective {f : α → β} (hf : Injective f) :
Nat.card (range f) = Nat.card α := by
rw [← Nat.card_preimage_of_injective hf le_rfl]
simp [Nat.card_univ] | lemma | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_range_of_injective | null |
equivFinOfCardPos {α : Type*} (h : Nat.card α ≠ 0) : α ≃ Fin (Nat.card α) := by
cases fintypeOrInfinite α
· simpa only [card_eq_fintype_card] using Fintype.equivFin α
· simp only [card_eq_zero_of_infinite, ne_eq, not_true_eq_false] at h | def | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | equivFinOfCardPos | If the cardinality is positive, that means it is a finite type, so there is
an equivalence between `α` and `Fin (Nat.card α)`. See also `Finite.equivFin`. |
card_of_subsingleton (a : α) [Subsingleton α] : Nat.card α = 1 := by
letI := Fintype.ofSubsingleton a
rw [card_eq_fintype_card, Fintype.card_ofSubsingleton a] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_of_subsingleton | null |
card_eq_one_iff_unique : Nat.card α = 1 ↔ Subsingleton α ∧ Nonempty α :=
Cardinal.toNat_eq_one_iff_unique
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_eq_one_iff_unique | null |
card_unique [Nonempty α] [Subsingleton α] : Nat.card α = 1 := by
simp [card_eq_one_iff_unique, *] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_unique | null |
card_eq_one_iff_exists : Nat.card α = 1 ↔ ∃ x : α, ∀ y : α, y = x := by
rw [card_eq_one_iff_unique]
exact ⟨fun ⟨s, ⟨a⟩⟩ ↦ ⟨a, fun x ↦ s.elim x a⟩, fun ⟨x, h⟩ ↦ ⟨subsingleton_of_forall_eq x h, ⟨x⟩⟩⟩ | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_eq_one_iff_exists | null |
card_eq_two_iff : Nat.card α = 2 ↔ ∃ x y : α, x ≠ y ∧ {x, y} = @Set.univ α :=
toNat_eq_ofNat.trans mk_eq_two_iff | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_eq_two_iff | null |
card_eq_two_iff' (x : α) : Nat.card α = 2 ↔ ∃! y, y ≠ x :=
toNat_eq_ofNat.trans (mk_eq_two_iff' x)
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_eq_two_iff' | null |
card_subtype_true : Nat.card {_a : α // True} = Nat.card α :=
card_congr <| Equiv.subtypeUnivEquiv fun _ => trivial
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_subtype_true | null |
card_sum [Finite α] [Finite β] : Nat.card (α ⊕ β) = Nat.card α + Nat.card β := by
have := Fintype.ofFinite α
have := Fintype.ofFinite β
simp_rw [Nat.card_eq_fintype_card, Fintype.card_sum]
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_sum | null |
card_prod (α β : Type*) : Nat.card (α × β) = Nat.card α * Nat.card β := by
simp only [Nat.card, mk_prod, toNat_mul, toNat_lift]
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_prod | null |
card_ulift (α : Type*) : Nat.card (ULift α) = Nat.card α :=
card_congr Equiv.ulift
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_ulift | null |
card_plift (α : Type*) : Nat.card (PLift α) = Nat.card α :=
card_congr Equiv.plift | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_plift | null |
card_sigma {β : α → Type*} [Fintype α] [∀ a, Finite (β a)] :
Nat.card (Sigma β) = ∑ a, Nat.card (β a) := by
letI _ (a : α) : Fintype (β a) := Fintype.ofFinite (β a)
simp_rw [Nat.card_eq_fintype_card, Fintype.card_sigma] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_sigma | null |
card_pi {β : α → Type*} [Fintype α] : Nat.card (∀ a, β a) = ∏ a, Nat.card (β a) := by
simp_rw [Nat.card, mk_pi, prod_eq_of_fintype, toNat_lift, map_prod] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_pi | null |
card_fun [Finite α] : Nat.card (α → β) = Nat.card β ^ Nat.card α := by
haveI := Fintype.ofFinite α
rw [Nat.card_pi, Finset.prod_const, Finset.card_univ, ← Nat.card_eq_fintype_card]
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_fun | null |
card_zmod (n : ℕ) : Nat.card (ZMod n) = n := by
cases n
· exact @Nat.card_eq_zero_of_infinite _ Int.infinite
· rw [Nat.card_eq_fintype_card, ZMod.card] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_zmod | null |
card_singleton_prod (a : α) (t : Set β) : Nat.card ({a} ×ˢ t) = Nat.card t := by
rw [singleton_prod, Nat.card_image_of_injective (Prod.mk_right_injective a)] | lemma | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_singleton_prod | null |
card_prod_singleton (s : Set α) (b : β) : Nat.card (s ×ˢ {b}) = Nat.card s := by
rw [prod_singleton, Nat.card_image_of_injective (Prod.mk_left_injective b)] | lemma | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_prod_singleton | null |
natCard_pos (hs : s.Finite) : 0 < Nat.card s ↔ s.Nonempty := by
simp [pos_iff_ne_zero, Nat.card_eq_zero, hs.to_subtype, nonempty_iff_ne_empty]
protected alias ⟨_, Nonempty.natCard_pos⟩ := natCard_pos | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | natCard_pos | null |
natCard_graphOn (s : Set α) (f : α → β) : Nat.card (s.graphOn f) = Nat.card s := by
rw [← Nat.card_image_of_injOn fst_injOn_graph, image_fst_graphOn] | lemma | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | natCard_graphOn | null |
card (α : Type*) : ℕ∞ :=
toENat (mk α)
@[simp] | def | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card | `ENat.card α` is the cardinality of `α` as an extended natural number.
If `α` is infinite, `ENat.card α = ⊤`. |
card_eq_coe_fintype_card [Fintype α] : card α = Fintype.card α := by
simp [card]
@[simp high] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_eq_coe_fintype_card | null |
card_eq_top_of_infinite [Infinite α] : card α = ⊤ := by
simp only [card, toENat_eq_top, aleph0_le_mk]
@[simp] lemma card_eq_top : card α = ⊤ ↔ Infinite α := by simp [card, aleph0_le_mk_iff]
@[simp] theorem card_lt_top_of_finite [Finite α] : card α < ⊤ := by simp [card]
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_eq_top_of_infinite | null |
card_sum (α β : Type*) :
card (α ⊕ β) = card α + card β := by
simp only [card, mk_sum, map_add, toENat_lift] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_sum | null |
card_congr {α β : Type*} (f : α ≃ β) : card α = card β :=
Cardinal.toENat_congr f
@[simp] lemma card_ulift (α : Type*) : card (ULift α) = card α := card_congr Equiv.ulift
@[simp] lemma card_plift (α : Type*) : card (PLift α) = card α := card_congr Equiv.plift | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_congr | null |
card_image_of_injOn {α β : Type*} {f : α → β} {s : Set α} (h : Set.InjOn f s) :
card (f '' s) = card s :=
card_congr (Equiv.Set.imageOfInjOn f s h).symm | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_image_of_injOn | null |
card_image_of_injective {α β : Type*} (f : α → β) (s : Set α)
(h : Function.Injective f) : card (f '' s) = card s := card_image_of_injOn h.injOn | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_image_of_injective | null |
card_le_card_of_injective {α β : Type*} {f : α → β} (hf : Injective f) : card α ≤ card β := by
rw [← card_ulift α, ← card_ulift β]
exact Cardinal.gciENat.gc.monotone_u <| Cardinal.lift_mk_le_lift_mk_of_injective hf
@[simp] | lemma | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_le_card_of_injective | null |
_root_.Cardinal.natCast_le_toENat_iff {n : ℕ} {c : Cardinal} :
↑n ≤ toENat c ↔ ↑n ≤ c := by
rw [← toENat_nat n, toENat_le_iff_of_le_aleph0 (le_of_lt (nat_lt_aleph0 n))] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | _root_.Cardinal.natCast_le_toENat_iff | null |
_root_.Cardinal.toENat_le_natCast_iff {c : Cardinal} {n : ℕ} :
toENat c ≤ n ↔ c ≤ n := by simp
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | _root_.Cardinal.toENat_le_natCast_iff | null |
_root_.Cardinal.natCast_eq_toENat_iff {n : ℕ} {c : Cardinal} :
↑n = toENat c ↔ ↑n = c := by
rw [le_antisymm_iff, le_antisymm_iff, Cardinal.toENat_le_natCast_iff,
Cardinal.natCast_le_toENat_iff] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | _root_.Cardinal.natCast_eq_toENat_iff | null |
_root_.Cardinal.toENat_eq_natCast_iff {c : Cardinal} {n : ℕ} :
Cardinal.toENat c = n ↔ c = n := by simp
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | _root_.Cardinal.toENat_eq_natCast_iff | null |
_root_.Cardinal.natCast_lt_toENat_iff {n : ℕ} {c : Cardinal} :
↑n < toENat c ↔ ↑n < c := by
simp only [← not_le, Cardinal.toENat_le_natCast_iff]
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | _root_.Cardinal.natCast_lt_toENat_iff | null |
_root_.Cardinal.toENat_lt_natCast_iff {n : ℕ} {c : Cardinal} :
toENat c < ↑n ↔ c < ↑n := by
simp only [← not_le, Cardinal.natCast_le_toENat_iff] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | _root_.Cardinal.toENat_lt_natCast_iff | null |
card_eq_zero_iff_empty (α : Type*) : card α = 0 ↔ IsEmpty α := by
rw [← Cardinal.mk_eq_zero_iff]
simp [card] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_eq_zero_iff_empty | null |
card_ne_zero_iff_nonempty (α : Type*) : card α ≠ 0 ↔ Nonempty α := by
simp [card_eq_zero_iff_empty]
@[simp] lemma card_pos [Nonempty α] : 0 < card α := by
simpa [pos_iff_ne_zero, card_ne_zero_iff_nonempty] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_ne_zero_iff_nonempty | null |
card_le_one_iff_subsingleton (α : Type*) : card α ≤ 1 ↔ Subsingleton α := by
rw [← le_one_iff_subsingleton]
simp [card]
@[simp] lemma card_le_one [Subsingleton α] : card α ≤ 1 := by simpa [card_le_one_iff_subsingleton] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_le_one_iff_subsingleton | null |
one_lt_card_iff_nontrivial (α : Type*) : 1 < card α ↔ Nontrivial α := by
rw [← Cardinal.one_lt_iff_nontrivial]
conv_rhs => rw [← Nat.cast_one]
rw [← natCast_lt_toENat_iff]
simp only [ENat.card, Nat.cast_one]
@[simp] lemma one_lt_card [Nontrivial α] : 1 < card α := by simpa [one_lt_card_iff_nontrivial]
@[simp] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | one_lt_card_iff_nontrivial | null |
card_prod (α β : Type*) : ENat.card (α × β) = .card α * .card β := by
simp [ENat.card] | theorem | SetTheory | [
"Mathlib.Data.ULift",
"Mathlib.Data.ZMod.Defs",
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat"
] | Mathlib/SetTheory/Cardinal/Finite.lean | card_prod | null |
@[simp]
mk_finsupp_lift_of_fintype (α : Type u) (β : Type v) [Fintype α] [Zero β] :
#(α →₀ β) = lift.{u} #β ^ Fintype.card α := by
simpa using (@Finsupp.equivFunOnFinite α β _ _).cardinal_eq | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.Data.Finsupp.Basic",
"Mathlib.Data.Finsupp.Multiset"
] | Mathlib/SetTheory/Cardinal/Finsupp.lean | mk_finsupp_lift_of_fintype | null |
mk_finsupp_of_fintype (α β : Type u) [Fintype α] [Zero β] :
#(α →₀ β) = #β ^ Fintype.card α := by simp
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.Data.Finsupp.Basic",
"Mathlib.Data.Finsupp.Multiset"
] | Mathlib/SetTheory/Cardinal/Finsupp.lean | mk_finsupp_of_fintype | null |
mk_finsupp_lift_of_infinite (α : Type u) (β : Type v) [Infinite α] [Zero β] [Nontrivial β] :
#(α →₀ β) = max (lift.{v} #α) (lift.{u} #β) := by
apply le_antisymm
· calc
#(α →₀ β) ≤ #(Finset (α × β)) := mk_le_of_injective (Finsupp.graph_injective α β)
_ = #(α × β) := mk_finset_of_infinite _
_ = max (lift.{v} #α) (lift.{u} #β) := by
rw [mk_prod, mul_eq_max_of_aleph0_le_left] <;> simp
· apply max_le <;> rw [← lift_id #(α →₀ β), ← lift_umax]
· obtain ⟨b, hb⟩ := exists_ne (0 : β)
exact lift_mk_le.{v}.2 ⟨⟨_, Finsupp.single_left_injective hb⟩⟩
· inhabit α
exact lift_mk_le.{u}.2 ⟨⟨_, Finsupp.single_injective default⟩⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.Data.Finsupp.Basic",
"Mathlib.Data.Finsupp.Multiset"
] | Mathlib/SetTheory/Cardinal/Finsupp.lean | mk_finsupp_lift_of_infinite | null |
mk_finsupp_of_infinite (α β : Type u) [Infinite α] [Zero β] [Nontrivial β] :
#(α →₀ β) = max #α #β := by simp
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.Data.Finsupp.Basic",
"Mathlib.Data.Finsupp.Multiset"
] | Mathlib/SetTheory/Cardinal/Finsupp.lean | mk_finsupp_of_infinite | null |
mk_finsupp_lift_of_infinite' (α : Type u) (β : Type v) [Nonempty α] [Zero β] [Infinite β] :
#(α →₀ β) = max (lift.{v} #α) (lift.{u} #β) := by
cases fintypeOrInfinite α
· rw [mk_finsupp_lift_of_fintype]
have : ℵ₀ ≤ (#β).lift := aleph0_le_lift.2 (aleph0_le_mk β)
rw [max_eq_right (le_trans _ this), power_nat_eq this]
exacts [Fintype.card_pos, lift_le_aleph0.2 (lt_aleph0_of_finite _).le]
· apply mk_finsupp_lift_of_infinite | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.Data.Finsupp.Basic",
"Mathlib.Data.Finsupp.Multiset"
] | Mathlib/SetTheory/Cardinal/Finsupp.lean | mk_finsupp_lift_of_infinite' | null |
mk_finsupp_of_infinite' (α β : Type u) [Nonempty α] [Zero β] [Infinite β] :
#(α →₀ β) = max #α #β := by simp | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.Data.Finsupp.Basic",
"Mathlib.Data.Finsupp.Multiset"
] | Mathlib/SetTheory/Cardinal/Finsupp.lean | mk_finsupp_of_infinite' | null |
mk_finsupp_nat (α : Type u) [Nonempty α] : #(α →₀ ℕ) = max #α ℵ₀ := by simp | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.Data.Finsupp.Basic",
"Mathlib.Data.Finsupp.Multiset"
] | Mathlib/SetTheory/Cardinal/Finsupp.lean | mk_finsupp_nat | null |
mk_multiset_of_isEmpty (α : Type u) [IsEmpty α] : #(Multiset α) = 1 :=
Multiset.toFinsupp.toEquiv.cardinal_eq.trans (by simp)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.Data.Finsupp.Basic",
"Mathlib.Data.Finsupp.Multiset"
] | Mathlib/SetTheory/Cardinal/Finsupp.lean | mk_multiset_of_isEmpty | null |
mk_multiset_of_nonempty (α : Type u) [Nonempty α] : #(Multiset α) = max #α ℵ₀ := by
classical
exact Multiset.toFinsupp.toEquiv.cardinal_eq.trans (mk_finsupp_nat α) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.Data.Finsupp.Basic",
"Mathlib.Data.Finsupp.Multiset"
] | Mathlib/SetTheory/Cardinal/Finsupp.lean | mk_multiset_of_nonempty | null |
mk_multiset_of_infinite (α : Type u) [Infinite α] : #(Multiset α) = #α := by simp | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.Data.Finsupp.Basic",
"Mathlib.Data.Finsupp.Multiset"
] | Mathlib/SetTheory/Cardinal/Finsupp.lean | mk_multiset_of_infinite | null |
mk_multiset_of_countable (α : Type u) [Countable α] [Nonempty α] : #(Multiset α) = ℵ₀ := by
classical
exact Multiset.toFinsupp.toEquiv.cardinal_eq.trans (by simp) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.Data.Finsupp.Basic",
"Mathlib.Data.Finsupp.Multiset"
] | Mathlib/SetTheory/Cardinal/Finsupp.lean | mk_multiset_of_countable | null |
mk_abelianization_le (G : Type u) [Group G] :
#(Abelianization G) ≤ #G := Cardinal.mk_le_of_surjective Quotient.mk_surjective
@[to_additive (attr := simp)] | theorem | SetTheory | [
"Mathlib.Algebra.FreeAbelianGroup.Finsupp",
"Mathlib.Algebra.Ring.TransferInstance",
"Mathlib.Data.Finsupp.Fintype",
"Mathlib.Data.ZMod.Defs",
"Mathlib.GroupTheory.FreeGroup.Reduce",
"Mathlib.RingTheory.FreeCommRing",
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Cardinal.Finsupp"
] | Mathlib/SetTheory/Cardinal/Free.lean | mk_abelianization_le | null |
mk_freeMonoid [Nonempty α] : #(FreeMonoid α) = max #α ℵ₀ :=
Cardinal.mk_list_eq_max_mk_aleph0 _
@[to_additive (attr := simp)] | theorem | SetTheory | [
"Mathlib.Algebra.FreeAbelianGroup.Finsupp",
"Mathlib.Algebra.Ring.TransferInstance",
"Mathlib.Data.Finsupp.Fintype",
"Mathlib.Data.ZMod.Defs",
"Mathlib.GroupTheory.FreeGroup.Reduce",
"Mathlib.RingTheory.FreeCommRing",
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Cardinal.Finsupp"
] | Mathlib/SetTheory/Cardinal/Free.lean | mk_freeMonoid | null |
mk_freeGroup [Nonempty α] : #(FreeGroup α) = max #α ℵ₀ := by
classical
apply le_antisymm
· apply (mk_le_of_injective (FreeGroup.toWord_injective (α := α))).trans_eq
simp [Cardinal.mk_list_eq_max_mk_aleph0]
obtain hα | hα := lt_or_ge #α ℵ₀
· simp only [hα.le, max_eq_right, max_eq_right_iff]
exact (mul_lt_aleph0 hα (nat_lt_aleph0 2)).le
· rw [max_eq_left hα, max_eq_left (hα.trans <| Cardinal.le_mul_right two_ne_zero),
Cardinal.mul_eq_left hα _ (by simp)]
exact (nat_lt_aleph0 2).le.trans hα
· apply max_le
· exact mk_le_of_injective FreeGroup.of_injective
· simp
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.FreeAbelianGroup.Finsupp",
"Mathlib.Algebra.Ring.TransferInstance",
"Mathlib.Data.Finsupp.Fintype",
"Mathlib.Data.ZMod.Defs",
"Mathlib.GroupTheory.FreeGroup.Reduce",
"Mathlib.RingTheory.FreeCommRing",
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Cardinal.Finsupp"
] | Mathlib/SetTheory/Cardinal/Free.lean | mk_freeGroup | null |
mk_freeAbelianGroup [Nonempty α] : #(FreeAbelianGroup α) = max #α ℵ₀ := by
rw [Cardinal.mk_congr (FreeAbelianGroup.equivFinsupp α).toEquiv]
simp
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.FreeAbelianGroup.Finsupp",
"Mathlib.Algebra.Ring.TransferInstance",
"Mathlib.Data.Finsupp.Fintype",
"Mathlib.Data.ZMod.Defs",
"Mathlib.GroupTheory.FreeGroup.Reduce",
"Mathlib.RingTheory.FreeCommRing",
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Cardinal.Finsupp"
] | Mathlib/SetTheory/Cardinal/Free.lean | mk_freeAbelianGroup | null |
mk_freeRing : #(FreeRing α) = max #α ℵ₀ := by
cases isEmpty_or_nonempty α <;> simp [FreeRing]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.FreeAbelianGroup.Finsupp",
"Mathlib.Algebra.Ring.TransferInstance",
"Mathlib.Data.Finsupp.Fintype",
"Mathlib.Data.ZMod.Defs",
"Mathlib.GroupTheory.FreeGroup.Reduce",
"Mathlib.RingTheory.FreeCommRing",
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Cardinal.Finsupp"
] | Mathlib/SetTheory/Cardinal/Free.lean | mk_freeRing | null |
mk_freeCommRing : #(FreeCommRing α) = max #α ℵ₀ := by
cases isEmpty_or_nonempty α <;> simp [FreeCommRing] | theorem | SetTheory | [
"Mathlib.Algebra.FreeAbelianGroup.Finsupp",
"Mathlib.Algebra.Ring.TransferInstance",
"Mathlib.Data.Finsupp.Fintype",
"Mathlib.Data.ZMod.Defs",
"Mathlib.GroupTheory.FreeGroup.Reduce",
"Mathlib.RingTheory.FreeCommRing",
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Cardinal.Finsupp"
] | Mathlib/SetTheory/Cardinal/Free.lean | mk_freeCommRing | null |
nonempty_commRing [Nonempty α] : Nonempty (CommRing α) := by
obtain hR | hR := finite_or_infinite α
· obtain ⟨x⟩ := nonempty_fintype α
have : NeZero (Fintype.card α) := ⟨by simp⟩
classical
obtain ⟨e⟩ := Fintype.truncEquivFin α
exact ⟨open scoped Fin.CommRing in e.commRing⟩
· have ⟨e⟩ : Nonempty (α ≃ FreeCommRing α) := by simp [← Cardinal.eq]
exact ⟨e.commRing⟩
@[simp] | instance | SetTheory | [
"Mathlib.Algebra.FreeAbelianGroup.Finsupp",
"Mathlib.Algebra.Ring.TransferInstance",
"Mathlib.Data.Finsupp.Fintype",
"Mathlib.Data.ZMod.Defs",
"Mathlib.GroupTheory.FreeGroup.Reduce",
"Mathlib.RingTheory.FreeCommRing",
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Cardinal.Finsupp"
] | Mathlib/SetTheory/Cardinal/Free.lean | nonempty_commRing | A commutative ring can be constructed on any non-empty type.
See also `Infinite.nonempty_field`. |
nonempty_commRing_iff : Nonempty (CommRing α) ↔ Nonempty α :=
⟨Nonempty.map (·.zero), fun _ => nonempty_commRing _⟩
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.FreeAbelianGroup.Finsupp",
"Mathlib.Algebra.Ring.TransferInstance",
"Mathlib.Data.Finsupp.Fintype",
"Mathlib.Data.ZMod.Defs",
"Mathlib.GroupTheory.FreeGroup.Reduce",
"Mathlib.RingTheory.FreeCommRing",
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Cardinal.Finsupp"
] | Mathlib/SetTheory/Cardinal/Free.lean | nonempty_commRing_iff | null |
nonempty_ring_iff : Nonempty (Ring α) ↔ Nonempty α :=
⟨Nonempty.map (·.zero), fun _ => (nonempty_commRing _).map (·.toRing)⟩
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.FreeAbelianGroup.Finsupp",
"Mathlib.Algebra.Ring.TransferInstance",
"Mathlib.Data.Finsupp.Fintype",
"Mathlib.Data.ZMod.Defs",
"Mathlib.GroupTheory.FreeGroup.Reduce",
"Mathlib.RingTheory.FreeCommRing",
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Cardinal.Finsupp"
] | Mathlib/SetTheory/Cardinal/Free.lean | nonempty_ring_iff | null |
nonempty_commSemiring_iff : Nonempty (CommSemiring α) ↔ Nonempty α :=
⟨Nonempty.map (·.zero), fun _ => (nonempty_commRing _).map (·.toCommSemiring)⟩
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.FreeAbelianGroup.Finsupp",
"Mathlib.Algebra.Ring.TransferInstance",
"Mathlib.Data.Finsupp.Fintype",
"Mathlib.Data.ZMod.Defs",
"Mathlib.GroupTheory.FreeGroup.Reduce",
"Mathlib.RingTheory.FreeCommRing",
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Cardinal.Finsupp"
] | Mathlib/SetTheory/Cardinal/Free.lean | nonempty_commSemiring_iff | null |
nonempty_semiring_iff : Nonempty (Semiring α) ↔ Nonempty α :=
⟨Nonempty.map (·.zero), fun _ => (nonempty_commRing _).map (·.toSemiring)⟩ | theorem | SetTheory | [
"Mathlib.Algebra.FreeAbelianGroup.Finsupp",
"Mathlib.Algebra.Ring.TransferInstance",
"Mathlib.Data.Finsupp.Fintype",
"Mathlib.Data.ZMod.Defs",
"Mathlib.GroupTheory.FreeGroup.Reduce",
"Mathlib.RingTheory.FreeCommRing",
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Cardinal.Finsupp"
] | Mathlib/SetTheory/Cardinal/Free.lean | nonempty_semiring_iff | null |
HasCardinalLT (X : Type u) (κ : Cardinal.{v}) : Prop :=
Cardinal.lift.{v} (Cardinal.mk X) < Cardinal.lift κ | def | SetTheory | [
"Mathlib.SetTheory.Cardinal.Regular"
] | Mathlib/SetTheory/Cardinal/HasCardinalLT.lean | HasCardinalLT | The property that the cardinal of a type `X : Type u` is less than `κ : Cardinal.{v}`. |
hasCardinalLT_iff_cardinal_mk_lt (X : Type u) (κ : Cardinal.{u}) :
HasCardinalLT X κ ↔ Cardinal.mk X < κ := by
simp [HasCardinalLT] | lemma | SetTheory | [
"Mathlib.SetTheory.Cardinal.Regular"
] | Mathlib/SetTheory/Cardinal/HasCardinalLT.lean | hasCardinalLT_iff_cardinal_mk_lt | null |
small : Small.{v} X := by
dsimp [HasCardinalLT] at h
rw [← Cardinal.lift_lt.{_, v + 1}, Cardinal.lift_lift, Cardinal.lift_lift] at h
simpa only [Cardinal.small_iff_lift_mk_lt_univ] using h.trans (Cardinal.lift_lt_univ' κ) | lemma | SetTheory | [
"Mathlib.SetTheory.Cardinal.Regular"
] | Mathlib/SetTheory/Cardinal/HasCardinalLT.lean | small | null |
of_le {κ' : Cardinal.{v}} (hκ' : κ ≤ κ') :
HasCardinalLT X κ' :=
lt_of_lt_of_le h (by simpa only [Cardinal.lift_le] using hκ')
variable {Y : Type u'} | lemma | SetTheory | [
"Mathlib.SetTheory.Cardinal.Regular"
] | Mathlib/SetTheory/Cardinal/HasCardinalLT.lean | of_le | null |
of_injective (f : Y → X) (hf : Function.Injective f) :
HasCardinalLT Y κ := by
dsimp [HasCardinalLT] at h ⊢
rw [← Cardinal.lift_lt.{_, u}, Cardinal.lift_lift, Cardinal.lift_lift]
rw [← Cardinal.lift_lt.{_, u'}, Cardinal.lift_lift, Cardinal.lift_lift] at h
exact lt_of_le_of_lt (Cardinal.mk_le_of_injective
(Function.Injective.comp ULift.up_injective
(Function.Injective.comp hf ULift.down_injective))) h | lemma | SetTheory | [
"Mathlib.SetTheory.Cardinal.Regular"
] | Mathlib/SetTheory/Cardinal/HasCardinalLT.lean | of_injective | null |
of_surjective (f : X → Y) (hf : Function.Surjective f) :
HasCardinalLT Y κ := by
dsimp [HasCardinalLT] at h ⊢
rw [← Cardinal.lift_lt.{_, u}, Cardinal.lift_lift, Cardinal.lift_lift]
rw [← Cardinal.lift_lt.{_, u'}, Cardinal.lift_lift, Cardinal.lift_lift] at h
exact lt_of_le_of_lt (Cardinal.mk_le_of_surjective
(Function.Surjective.comp ULift.up_surjective (Function.Surjective.comp hf
ULift.down_surjective))) h | lemma | SetTheory | [
"Mathlib.SetTheory.Cardinal.Regular"
] | Mathlib/SetTheory/Cardinal/HasCardinalLT.lean | of_surjective | null |
hasCardinalLT_iff_of_equiv {X : Type u} {Y : Type u'} (e : X ≃ Y) (κ : Cardinal.{v}) :
HasCardinalLT X κ ↔ HasCardinalLT Y κ :=
⟨fun h ↦ h.of_injective _ e.symm.injective,
fun h ↦ h.of_injective _ e.injective⟩
@[simp] | lemma | SetTheory | [
"Mathlib.SetTheory.Cardinal.Regular"
] | Mathlib/SetTheory/Cardinal/HasCardinalLT.lean | hasCardinalLT_iff_of_equiv | null |
hasCardinalLT_aleph0_iff (X : Type u) :
HasCardinalLT X Cardinal.aleph0.{v} ↔ Finite X := by
simpa [HasCardinalLT] using Cardinal.mk_lt_aleph0_iff | lemma | SetTheory | [
"Mathlib.SetTheory.Cardinal.Regular"
] | Mathlib/SetTheory/Cardinal/HasCardinalLT.lean | hasCardinalLT_aleph0_iff | null |
hasCardinalLT_sum_iff (X : Type u) (Y : Type u') (κ : Cardinal.{w})
(hκ : Cardinal.aleph0 ≤ κ) :
HasCardinalLT (X ⊕ Y) κ ↔ HasCardinalLT X κ ∧ HasCardinalLT Y κ := by
constructor
· intro h
exact ⟨h.of_injective _ Sum.inl_injective,
h.of_injective _ Sum.inr_injective⟩
· rintro ⟨hX, hY⟩
dsimp [HasCardinalLT] at hX hY ⊢
rw [← Cardinal.lift_lt.{_, u'}, Cardinal.lift_lift, Cardinal.lift_lift] at hX
rw [← Cardinal.lift_lt.{_, u}, Cardinal.lift_lift, Cardinal.lift_lift] at hY
simp only [Cardinal.mk_sum, Cardinal.lift_add, Cardinal.lift_lift]
exact Cardinal.add_lt_of_lt (by simpa using hκ) hX hY | lemma | SetTheory | [
"Mathlib.SetTheory.Cardinal.Regular"
] | Mathlib/SetTheory/Cardinal/HasCardinalLT.lean | hasCardinalLT_sum_iff | null |
hasCardinalLT_option_iff (X : Type u) (κ : Cardinal.{w})
(hκ : Cardinal.aleph0 ≤ κ) :
HasCardinalLT (Option X) κ ↔ HasCardinalLT X κ := by
rw [hasCardinalLT_iff_of_equiv (Equiv.optionEquivSumPUnit.{0} X),
hasCardinalLT_sum_iff _ _ _ hκ, and_iff_left_iff_imp]
refine fun _ ↦ HasCardinalLT.of_le ?_ hκ
rw [hasCardinalLT_aleph0_iff]
infer_instance | lemma | SetTheory | [
"Mathlib.SetTheory.Cardinal.Regular"
] | Mathlib/SetTheory/Cardinal/HasCardinalLT.lean | hasCardinalLT_option_iff | null |
exists_regular_cardinal (X : Type u) [Small.{w} X] :
∃ (κ : Cardinal.{w}), κ.IsRegular ∧ HasCardinalLT X κ :=
⟨Order.succ (max (Cardinal.mk (Shrink.{w} X)) .aleph0),
Cardinal.isRegular_succ (le_max_right _ _), by
simp [hasCardinalLT_iff_of_equiv (equivShrink.{w} X),
hasCardinalLT_iff_cardinal_mk_lt]⟩ | lemma | SetTheory | [
"Mathlib.SetTheory.Cardinal.Regular"
] | Mathlib/SetTheory/Cardinal/HasCardinalLT.lean | exists_regular_cardinal | For any `w`-small type `X`, there exists a regular cardinal `κ : Cardinal.{w}`
such that `HasCardinalLT X κ`. |
exists_regular_cardinal_forall {ι : Type v} (X : ι → Type u) [Small.{w} ι]
[∀ i, Small.{w} (X i)] :
∃ (κ : Cardinal.{w}), κ.IsRegular ∧ ∀ (i : ι), HasCardinalLT (X i) κ := by
obtain ⟨κ, hκ, h⟩ := exists_regular_cardinal.{w} (Sigma X)
exact ⟨κ, hκ, fun i ↦ h.of_injective _ sigma_mk_injective⟩ | lemma | SetTheory | [
"Mathlib.SetTheory.Cardinal.Regular"
] | Mathlib/SetTheory/Cardinal/HasCardinalLT.lean | exists_regular_cardinal_forall | For any `w`-small family `X : ι → Type u` of `w`-small types, there exists
a regular cardinal `κ : Cardinal.{w}` such that `HasCardinalLT (X i) κ` for all `i : ι`. |
count_le_cardinal : (count p n : Cardinal) ≤ Cardinal.mk { k | p k } := by
rw [count_eq_card_fintype, ← Cardinal.mk_fintype]
exact Cardinal.mk_subtype_mono fun x hx ↦ hx.2 | theorem | SetTheory | [
"Mathlib.Data.Nat.Count",
"Mathlib.Data.Set.Card"
] | Mathlib/SetTheory/Cardinal/NatCount.lean | count_le_cardinal | null |
count_le_setENCard : count p n ≤ Set.encard { k | p k } := by
simp only [Set.encard, ENat.card, Set.coe_setOf, Cardinal.natCast_le_toENat_iff]
exact Nat.count_le_cardinal n | theorem | SetTheory | [
"Mathlib.Data.Nat.Count",
"Mathlib.Data.Set.Card"
] | Mathlib/SetTheory/Cardinal/NatCount.lean | count_le_setENCard | null |
count_le_setNCard (h : { k | p k }.Finite) : count p n ≤ Set.ncard { k | p k } := by
rw [Set.ncard_def, ← ENat.coe_le_coe, ENat.coe_toNat (by simpa)]
exact count_le_setENCard n | theorem | SetTheory | [
"Mathlib.Data.Nat.Count",
"Mathlib.Data.Set.Card"
] | Mathlib/SetTheory/Cardinal/NatCount.lean | count_le_setNCard | null |
lift_mk_le' {α : Type u} {β : Type v} : lift.{v} #α ≤ lift.{u} #β ↔ Nonempty (α ↪ β) :=
lift_mk_le.{0}
/-! ### `lift` sends `Cardinal.{u}` to an initial segment of `Cardinal.{max u v}`. -/ | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_mk_le' | We define the order on cardinal numbers by `#α ≤ #β` if and only if
there exists an embedding (injective function) from α to β. -/
instance : LE Cardinal.{u} :=
⟨fun q₁ q₂ =>
Quotient.liftOn₂ q₁ q₂ (fun α β => Nonempty <| α ↪ β) fun _ _ _ _ ⟨e₁⟩ ⟨e₂⟩ =>
propext ⟨fun ⟨e⟩ => ⟨e.congr e₁ e₂⟩, fun ⟨e⟩ => ⟨e.congr e₁.symm e₂.symm⟩⟩⟩
instance partialOrder : PartialOrder Cardinal.{u} where
le := (· ≤ ·)
le_refl := by
rintro ⟨α⟩
exact ⟨Embedding.refl _⟩
le_trans := by
rintro ⟨α⟩ ⟨β⟩ ⟨γ⟩ ⟨e₁⟩ ⟨e₂⟩
exact ⟨e₁.trans e₂⟩
le_antisymm := by
rintro ⟨α⟩ ⟨β⟩ ⟨e₁⟩ ⟨e₂⟩
exact Quotient.sound (e₁.antisymm e₂)
instance linearOrder : LinearOrder Cardinal.{u} :=
{ Cardinal.partialOrder with
le_total := by
rintro ⟨α⟩ ⟨β⟩
apply Embedding.total
toDecidableLE := Classical.decRel _ }
theorem le_def (α β : Type u) : #α ≤ #β ↔ Nonempty (α ↪ β) :=
Iff.rfl
theorem mk_le_of_injective {α β : Type u} {f : α → β} (hf : Injective f) : #α ≤ #β :=
⟨⟨f, hf⟩⟩
theorem _root_.Function.Embedding.cardinal_le {α β : Type u} (f : α ↪ β) : #α ≤ #β :=
⟨f⟩
theorem mk_le_of_surjective {α β : Type u} {f : α → β} (hf : Surjective f) : #β ≤ #α :=
⟨Embedding.ofSurjective f hf⟩
theorem le_mk_iff_exists_set {c : Cardinal} {α : Type u} : c ≤ #α ↔ ∃ p : Set α, #p = c :=
⟨inductionOn c fun _ ⟨⟨f, hf⟩⟩ => ⟨Set.range f, (Equiv.ofInjective f hf).cardinal_eq.symm⟩,
fun ⟨_, e⟩ => e ▸ ⟨⟨Subtype.val, fun _ _ => Subtype.eq⟩⟩⟩
theorem mk_subtype_le {α : Type u} (p : α → Prop) : #(Subtype p) ≤ #α :=
⟨Embedding.subtype p⟩
theorem mk_set_le (s : Set α) : #s ≤ #α :=
mk_subtype_le s
theorem out_embedding {c c' : Cardinal} : c ≤ c' ↔ Nonempty (c.out ↪ c'.out) := by
conv_lhs => rw [← Cardinal.mk_out c, ← Cardinal.mk_out c', le_def]
theorem lift_mk_le {α : Type v} {β : Type w} :
lift.{max u w} #α ≤ lift.{max u v} #β ↔ Nonempty (α ↪ β) :=
⟨fun ⟨f⟩ => ⟨Embedding.congr Equiv.ulift Equiv.ulift f⟩, fun ⟨f⟩ =>
⟨Embedding.congr Equiv.ulift.symm Equiv.ulift.symm f⟩⟩
/-- A variant of `Cardinal.lift_mk_le` 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. |
@[simps!]
liftInitialSeg : Cardinal.{u} ≤i Cardinal.{max u v} := by
refine ⟨(OrderEmbedding.ofMapLEIff lift ?_).ltEmbedding, ?_⟩ <;> intro a b
· refine inductionOn₂ a b fun _ _ ↦ ?_
rw [← lift_umax, lift_mk_le.{v, u, u}, le_def]
· refine inductionOn₂ a b fun α β h ↦ ?_
obtain ⟨e⟩ := h.le
replace e := e.congr (Equiv.refl β) Equiv.ulift
refine ⟨#(range e), mk_congr (Equiv.ulift.trans <| Equiv.symm ?_)⟩
apply (e.codRestrict _ mem_range_self).equivOfSurjective
rintro ⟨a, ⟨b, rfl⟩⟩
exact ⟨b, rfl⟩ | def | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | liftInitialSeg | `Cardinal.lift` as an `InitialSeg`. |
mem_range_lift_of_le {a : Cardinal.{u}} {b : Cardinal.{max u v}} :
b ≤ lift.{v, u} a → b ∈ Set.range lift.{v, u} :=
liftInitialSeg.mem_range_of_le | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | mem_range_lift_of_le | null |
lift_injective : Injective lift.{u, v} :=
liftInitialSeg.injective
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_injective | null |
lift_inj {a b : Cardinal.{u}} : lift.{v, u} a = lift.{v, u} b ↔ a = b :=
lift_injective.eq_iff
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_inj | null |
lift_le {a b : Cardinal.{v}} : lift.{u} a ≤ lift.{u} b ↔ a ≤ b :=
liftInitialSeg.le_iff_le
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_le | null |
lift_lt {a b : Cardinal.{u}} : lift.{v, u} a < lift.{v, u} b ↔ a < b :=
liftInitialSeg.lt_iff_lt | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_lt | null |
lift_strictMono : StrictMono lift := fun _ _ => lift_lt.2 | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_strictMono | null |
lift_monotone : Monotone lift :=
lift_strictMono.monotone
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_monotone | null |
lift_min {a b : Cardinal} : lift.{u, v} (min a b) = min (lift.{u, v} a) (lift.{u, v} b) :=
lift_monotone.map_min
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_min | null |
lift_max {a b : Cardinal} : lift.{u, v} (max a b) = max (lift.{u, v} a) (lift.{u, v} b) :=
lift_monotone.map_max | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_max | null |
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 := by
rw [← lift_lift.{v, w, u}, ← lift_lift.{u, w, v}, lift_inj] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_umax_eq | null |
le_lift_iff {a : Cardinal.{u}} {b : Cardinal.{max u v}} :
b ≤ lift.{v, u} a ↔ ∃ a' ≤ a, lift.{v, u} a' = b :=
liftInitialSeg.le_apply_iff | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | le_lift_iff | null |
lt_lift_iff {a : Cardinal.{u}} {b : Cardinal.{max u v}} :
b < lift.{v, u} a ↔ ∃ a' < a, lift.{v, u} a' = b :=
liftInitialSeg.lt_apply_iff
/-! ### Basic cardinals -/
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lt_lift_iff | null |
lift_eq_zero {a : Cardinal.{v}} : lift.{u} a = 0 ↔ a = 0 :=
lift_injective.eq_iff' lift_zero
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_eq_zero | null |
mk_fintype (α : Type u) [h : Fintype α] : #α = Fintype.card α :=
mk_congr (Fintype.equivOfCardEq (by simp)) | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | mk_fintype | null |
private cast_succ (n : ℕ) : ((n + 1 : ℕ) : Cardinal.{u}) = n + 1 := by
change #(ULift.{u} _) = #(ULift.{u} _) + 1
rw [← mk_option]
simp | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | cast_succ | null |
commSemiring : CommSemiring Cardinal.{u} where
zero := 0
one := 1
add := (· + ·)
mul := (· * ·)
zero_add a := inductionOn a fun α => mk_congr <| Equiv.emptySum _ α
add_zero a := inductionOn a fun α => mk_congr <| Equiv.sumEmpty α _
add_assoc a b c := inductionOn₃ a b c fun α β γ => mk_congr <| Equiv.sumAssoc α β γ
add_comm a b := inductionOn₂ a b fun α β => mk_congr <| Equiv.sumComm α β
zero_mul a := inductionOn a fun _ => mk_eq_zero _
mul_zero a := inductionOn a fun _ => mk_eq_zero _
one_mul a := inductionOn a fun α => mk_congr <| Equiv.uniqueProd α _
mul_one a := inductionOn a fun α => mk_congr <| Equiv.prodUnique α _
mul_assoc a b c := inductionOn₃ a b c fun α β γ => mk_congr <| Equiv.prodAssoc α β γ
mul_comm a b := inductionOn₂ a b fun α β => mk_congr <| Equiv.prodComm α β
left_distrib a b c := inductionOn₃ a b c fun α β γ => mk_congr <| Equiv.prodSumDistrib α β γ
right_distrib a b c := inductionOn₃ a b c fun α β γ => mk_congr <| Equiv.sumProdDistrib α β γ
nsmul := nsmulRec
npow n c := c ^ (n : Cardinal)
npow_zero := power_zero
npow_succ n c := by rw [cast_succ, power_add, power_one]
natCast n := lift #(Fin n)
natCast_zero := rfl
natCast_succ n := cast_succ n | instance | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | commSemiring | null |
mk_bool : #Bool = 2 := by simp | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | mk_bool | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.