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 ⌀ |
|---|---|---|---|---|---|---|
mk_surjective_eq_arrow_of_le (le : #β ≤ #α) : #{f : α → β | Surjective f} = #(α → β) :=
mk_surjective_eq_arrow_of_lift_le (lift_le.mpr le) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_surjective_eq_arrow_of_le | null |
@[simp]
mk_list_eq_mk (α : Type u) [Infinite α] : #(List α) = #α :=
have H1 : ℵ₀ ≤ #α := aleph0_le_mk α
Eq.symm <|
le_antisymm ((le_def _ _).2 ⟨⟨fun a => [a], fun _ => by simp⟩⟩) <|
calc
#(List α) = sum fun n : ℕ => #α ^ (n : Cardinal.{u}) := mk_list_eq_sum_pow α
_ ≤ sum fun _ : ℕ => #α := sum_le_sum _ _ fun n => pow_le H1 <| nat_lt_aleph0 n
_ = #α := by simp [H1] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_list_eq_mk | null |
mk_list_eq_aleph0 (α : Type u) [Countable α] [Nonempty α] : #(List α) = ℵ₀ :=
mk_le_aleph0.antisymm (aleph0_le_mk _) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_list_eq_aleph0 | null |
mk_list_eq_max_mk_aleph0 (α : Type u) [Nonempty α] : #(List α) = max #α ℵ₀ := by
cases finite_or_infinite α
· rw [mk_list_eq_aleph0, eq_comm, max_eq_right]
exact mk_le_aleph0
· rw [mk_list_eq_mk, eq_comm, max_eq_left]
exact aleph0_le_mk α | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_list_eq_max_mk_aleph0 | null |
mk_list_le_max (α : Type u) : #(List α) ≤ max ℵ₀ #α := by
cases finite_or_infinite α
· exact mk_le_aleph0.trans (le_max_left _ _)
· rw [mk_list_eq_mk]
apply le_max_right
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_list_le_max | null |
mk_finset_of_infinite (α : Type u) [Infinite α] : #(Finset α) = #α := by
classical
exact Eq.symm <|
le_antisymm (mk_le_of_injective fun _ _ => Finset.singleton_inj.1) <|
calc
#(Finset α) ≤ #(List α) := mk_le_of_surjective List.toFinset_surjective
_ = #α := mk_list_eq_mk α | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_finset_of_infinite | null |
mk_bounded_set_le_of_infinite (α : Type u) [Infinite α] (c : Cardinal) :
#{ t : Set α // #t ≤ c } ≤ #α ^ c := by
rw [← add_one_eq (aleph0_le_mk α)]
induction c using Cardinal.inductionOn with | _ β
fapply mk_le_of_surjective
· intro f
use Sum.inl ⁻¹' range f
refine le_trans (mk_preimage_of_injective _ _ fun x y => Sum.inl.inj) ?_
apply mk_range_le
rintro ⟨s, ⟨g⟩⟩
classical
use fun y => if h : ∃ x : s, g x = y then Sum.inl (Classical.choose h).val
else Sum.inr (ULift.up 0)
apply Subtype.eq; ext x
constructor
· rintro ⟨y, h⟩
dsimp only at h
by_cases h' : ∃ z : s, g z = y
· rw [dif_pos h'] at h
cases Sum.inl.inj h
exact (Classical.choose h').2
· rw [dif_neg h'] at h
cases h
· intro h
have : ∃ z : s, g z = g ⟨x, h⟩ := ⟨⟨x, h⟩, rfl⟩
use g ⟨x, h⟩
dsimp only
rw [dif_pos this]
congr
suffices Classical.choose this = ⟨x, h⟩ from congr_arg Subtype.val this
apply g.2
exact Classical.choose_spec this | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_bounded_set_le_of_infinite | null |
mk_bounded_set_le (α : Type u) (c : Cardinal) :
#{ t : Set α // #t ≤ c } ≤ max #α ℵ₀ ^ c := by
trans #{ t : Set ((ULift.{u} ℕ) ⊕ α) // #t ≤ c }
· refine ⟨Embedding.subtypeMap ?_ ?_⟩
· apply Embedding.image
use Sum.inr
apply Sum.inr.inj
intro s hs
exact mk_image_le.trans hs
apply (mk_bounded_set_le_of_infinite ((ULift.{u} ℕ) ⊕ α) c).trans
rw [max_comm, ← add_eq_max] <;> rfl | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_bounded_set_le | null |
mk_bounded_subset_le {α : Type u} (s : Set α) (c : Cardinal.{u}) :
#{ t : Set α // t ⊆ s ∧ #t ≤ c } ≤ max #s ℵ₀ ^ c := by
refine le_trans ?_ (mk_bounded_set_le s c)
refine ⟨Embedding.codRestrict _ ?_ ?_⟩
· use fun t => (↑) ⁻¹' t.1
rintro ⟨t, ht1, ht2⟩ ⟨t', h1t', h2t'⟩ h
apply Subtype.eq
dsimp only at h ⊢
refine (preimage_eq_preimage' ?_ ?_).1 h <;> rw [Subtype.range_coe] <;> assumption
rintro ⟨t, _, h2t⟩; exact (mk_preimage_of_injective _ _ Subtype.val_injective).trans h2t | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_bounded_subset_le | null |
mk_compl_of_infinite {α : Type*} [Infinite α] (s : Set α) (h2 : #s < #α) :
#(sᶜ : Set α) = #α := by
refine eq_of_add_eq_of_aleph0_le ?_ h2 (aleph0_le_mk α)
exact mk_sum_compl s | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_compl_of_infinite | null |
mk_compl_finset_of_infinite {α : Type*} [Infinite α] (s : Finset α) :
#((↑s)ᶜ : Set α) = #α := by
apply mk_compl_of_infinite
exact (finset_card_lt_aleph0 s).trans_le (aleph0_le_mk α) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_compl_finset_of_infinite | null |
mk_compl_eq_mk_compl_infinite {α : Type*} [Infinite α] {s t : Set α} (hs : #s < #α)
(ht : #t < #α) : #(sᶜ : Set α) = #(tᶜ : Set α) := by
rw [mk_compl_of_infinite s hs, mk_compl_of_infinite t ht] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_compl_eq_mk_compl_infinite | null |
mk_compl_eq_mk_compl_finite_lift {α : Type u} {β : Type v} [Finite α] {s : Set α}
{t : Set β} (h1 : (lift.{max v w, u} #α) = (lift.{max u w, v} #β))
(h2 : lift.{max v w, u} #s = lift.{max u w, v} #t) :
lift.{max v w} #(sᶜ : Set α) = lift.{max u w} #(tᶜ : Set β) := by
cases nonempty_fintype α
rcases lift_mk_eq.{u, v, w}.1 h1 with ⟨e⟩; letI : Fintype β := Fintype.ofEquiv α e
replace h1 : Fintype.card α = Fintype.card β := (Fintype.ofEquiv_card _).symm
classical
lift s to Finset α using s.toFinite
lift t to Finset β using t.toFinite
simp only [Finset.coe_sort_coe, mk_fintype, Fintype.card_coe, lift_natCast, Nat.cast_inj] at h2
simp only [← Finset.coe_compl, Finset.coe_sort_coe, mk_coe_finset, Finset.card_compl,
lift_natCast, h1, h2] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_compl_eq_mk_compl_finite_lift | null |
mk_compl_eq_mk_compl_finite {α β : Type u} [Finite α] {s : Set α} {t : Set β}
(h1 : #α = #β) (h : #s = #t) : #(sᶜ : Set α) = #(tᶜ : Set β) := by
rw [← lift_inj.{u, u}]
apply mk_compl_eq_mk_compl_finite_lift.{u, u, u}
<;> rwa [lift_inj] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_compl_eq_mk_compl_finite | null |
mk_compl_eq_mk_compl_finite_same {α : Type u} [Finite α] {s t : Set α} (h : #s = #t) :
#(sᶜ : Set α) = #(tᶜ : Set α) :=
mk_compl_eq_mk_compl_finite.{u} rfl h | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_compl_eq_mk_compl_finite_same | null |
extend_function {α β : Type*} {s : Set α} (f : s ↪ β)
(h : Nonempty ((sᶜ : Set α) ≃ ((range f)ᶜ : Set β))) : ∃ g : α ≃ β, ∀ x : s, g x = f x := by
classical
have := h; obtain ⟨g⟩ := this
let h : α ≃ β :=
(Set.sumCompl (s : Set α)).symm.trans
((sumCongr (Equiv.ofInjective f f.2) g).trans (Set.sumCompl (range f)))
refine ⟨h, ?_⟩; rintro ⟨x, hx⟩; simp [h, Set.sumCompl_symm_apply_of_mem, hx] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | extend_function | null |
extend_function_finite {α : Type u} {β : Type v} [Finite α] {s : Set α} (f : s ↪ β)
(h : Nonempty (α ≃ β)) : ∃ g : α ≃ β, ∀ x : s, g x = f x := by
apply extend_function.{u, v} f
obtain ⟨g⟩ := id h
rw [← lift_mk_eq.{u, v, max u v}] at h
rw [← lift_mk_eq.{u, v, max u v}, mk_compl_eq_mk_compl_finite_lift.{u, v, max u v} h]
rw [mk_range_eq_lift.{u, v, max u v}]; exact f.2 | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | extend_function_finite | null |
extend_function_of_lt {α β : Type*} {s : Set α} (f : s ↪ β) (hs : #s < #α)
(h : Nonempty (α ≃ β)) : ∃ g : α ≃ β, ∀ x : s, g x = f x := by
cases fintypeOrInfinite α
· exact extend_function_finite f h
· apply extend_function f
obtain ⟨g⟩ := id h
haveI := Infinite.of_injective _ g.injective
rw [← lift_mk_eq'] at h ⊢
rwa [mk_compl_of_infinite s hs, mk_compl_of_infinite]
rwa [← lift_lt, mk_range_eq_of_injective f.injective, ← h, lift_lt] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | extend_function_of_lt | null |
@[simp]
mk_preimage_down {s : Set α} : #(ULift.down.{v} ⁻¹' s) = lift.{v} (#s) := by
rw [← mk_uLift, Cardinal.eq]
constructor
let f : ULift.down ⁻¹' s → ULift s := fun x ↦ ULift.up (restrictPreimage s ULift.down x)
have : Function.Bijective f :=
ULift.up_bijective.comp (restrictPreimage_bijective _ (ULift.down_bijective))
exact Equiv.ofBijective f this | lemma | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | mk_preimage_down | null |
lift_mk_shrink (α : Type u) [Small.{v} α] :
Cardinal.lift.{max u w} #(Shrink.{v} α) = Cardinal.lift.{max v w} #α :=
lift_mk_eq.2 ⟨(equivShrink α).symm⟩
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | lift_mk_shrink | null |
lift_mk_shrink' (α : Type u) [Small.{v} α] :
Cardinal.lift.{u} #(Shrink.{v} α) = Cardinal.lift.{v} #α :=
lift_mk_shrink.{u, v, 0} α
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | lift_mk_shrink' | null |
lift_mk_shrink'' (α : Type max u v) [Small.{v} α] :
Cardinal.lift.{u} #(Shrink.{v} α) = #α := by
rw [← lift_umax, lift_mk_shrink.{max u v, v, 0} α, ← lift_umax, lift_id] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | lift_mk_shrink'' | null |
prod_eq_of_fintype {α : Type u} [h : Fintype α] (f : α → Cardinal.{v}) :
prod f = Cardinal.lift.{u} (∏ i, f i) := by
revert f
refine Fintype.induction_empty_option ?_ ?_ ?_ α (h_fintype := h)
· intro α β hβ e h f
letI := Fintype.ofEquiv β e.symm
rw [← e.prod_comp f, ← h]
exact mk_congr (e.piCongrLeft _).symm
· intro f
rw [Fintype.univ_pempty, Finset.prod_empty, lift_one, Cardinal.prod, mk_eq_one]
· intro α hα h f
rw [Cardinal.prod, mk_congr Equiv.piOptionEquivProd, mk_prod, lift_umax.{v, u}, mk_out, ←
Cardinal.prod, lift_prod, Fintype.prod_option, lift_mul, ← h fun a => f (some a)]
simp only [lift_id]
/-! ### Basic cardinals -/ | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | prod_eq_of_fintype | null |
le_one_iff_subsingleton {α : Type u} : #α ≤ 1 ↔ Subsingleton α :=
⟨fun ⟨f⟩ => ⟨fun _ _ => f.injective (Subsingleton.elim _ _)⟩, fun ⟨h⟩ =>
⟨fun _ => ULift.up 0, fun _ _ _ => h _ _⟩⟩
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | le_one_iff_subsingleton | null |
mk_le_one_iff_set_subsingleton {s : Set α} : #s ≤ 1 ↔ s.Subsingleton :=
le_one_iff_subsingleton.trans s.subsingleton_coe
alias ⟨_, _root_.Set.Subsingleton.cardinalMk_le_one⟩ := mk_le_one_iff_set_subsingleton | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | mk_le_one_iff_set_subsingleton | null |
private cast_succ (n : ℕ) : ((n + 1 : ℕ) : Cardinal.{u}) = n + 1 := by
change #(ULift.{u} _) = #(ULift.{u} _) + 1
rw [← mk_option]
simp
/-! ### Order properties -/ | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | cast_succ | null |
one_lt_iff_nontrivial {α : Type u} : 1 < #α ↔ Nontrivial α := by
rw [← not_le, le_one_iff_subsingleton, ← not_nontrivial_iff_subsingleton, Classical.not_not] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | one_lt_iff_nontrivial | null |
sInf_eq_zero_iff {s : Set Cardinal} : sInf s = 0 ↔ s = ∅ ∨ ∃ a ∈ s, a = 0 := by
refine ⟨fun h ↦ ?_, fun h ↦ ?_⟩
· rcases s.eq_empty_or_nonempty with rfl | hne
· exact Or.inl rfl
· exact Or.inr ⟨sInf s, csInf_mem hne, h⟩
· rcases h with rfl | ⟨a, ha, rfl⟩
· exact Cardinal.sInf_empty
· exact eq_bot_iff.2 (csInf_le' ha) | lemma | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | sInf_eq_zero_iff | null |
iInf_eq_zero_iff {ι : Sort*} {f : ι → Cardinal} :
(⨅ i, f i) = 0 ↔ IsEmpty ι ∨ ∃ i, f i = 0 := by
simp [iInf, sInf_eq_zero_iff] | lemma | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | iInf_eq_zero_iff | null |
protected iSup_of_empty {ι} (f : ι → Cardinal) [IsEmpty ι] : iSup f = 0 :=
ciSup_of_empty f
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | iSup_of_empty | A variant of `ciSup_of_empty` but with `0` on the RHS for convenience |
lift_sInf (s : Set Cardinal) : lift.{u, v} (sInf s) = sInf (lift.{u, v} '' s) := by
rcases eq_empty_or_nonempty s with (rfl | hs)
· simp
· exact lift_monotone.map_csInf hs
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | lift_sInf | null |
lift_iInf {ι} (f : ι → Cardinal) : lift.{u, v} (iInf f) = ⨅ i, lift.{u, v} (f i) := by
unfold iInf
convert lift_sInf (range f)
simp_rw [← comp_apply (f := lift), range_comp] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | lift_iInf | null |
small_Iic (a : Cardinal.{u}) : Small.{u} (Iic a) := by
rw [← mk_out a]
apply @small_of_surjective (Set a.out) (Iic #a.out) _ fun x => ⟨#x, mk_set_le x⟩
rintro ⟨x, hx⟩
simpa using le_mk_iff_exists_set.1 hx | instance | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | small_Iic | null |
small_Iio (a : Cardinal.{u}) : Small.{u} (Iio a) := small_subset Iio_subset_Iic_self | instance | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | small_Iio | null |
small_Icc (a b : Cardinal.{u}) : Small.{u} (Icc a b) := small_subset Icc_subset_Iic_self | instance | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | small_Icc | null |
small_Ico (a b : Cardinal.{u}) : Small.{u} (Ico a b) := small_subset Ico_subset_Iio_self | instance | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | small_Ico | null |
small_Ioc (a b : Cardinal.{u}) : Small.{u} (Ioc a b) := small_subset Ioc_subset_Iic_self | instance | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | small_Ioc | null |
small_Ioo (a b : Cardinal.{u}) : Small.{u} (Ioo a b) := small_subset Ioo_subset_Iio_self | instance | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | small_Ioo | null |
bddAbove_iff_small {s : Set Cardinal.{u}} : BddAbove s ↔ Small.{u} s :=
⟨fun ⟨a, ha⟩ => @small_subset _ (Iic a) s (fun _ h => ha h) _, by
rintro ⟨ι, ⟨e⟩⟩
use sum.{u, u} fun x ↦ e.symm x
intro a ha
simpa using le_sum (fun x ↦ e.symm x) (e ⟨a, ha⟩)⟩ | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | bddAbove_iff_small | A set of cardinals is bounded above iff it's small, i.e. it corresponds to a usual ZFC set. |
bddAbove_of_small (s : Set Cardinal.{u}) [h : Small.{u} s] : BddAbove s :=
bddAbove_iff_small.2 h | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | bddAbove_of_small | null |
bddAbove_range {ι : Type*} [Small.{u} ι] (f : ι → Cardinal.{u}) : BddAbove (Set.range f) :=
bddAbove_of_small _ | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | bddAbove_range | null |
bddAbove_image (f : Cardinal.{u} → Cardinal.{max u v}) {s : Set Cardinal.{u}}
(hs : BddAbove s) : BddAbove (f '' s) := by
rw [bddAbove_iff_small] at hs ⊢
exact small_lift _ | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | bddAbove_image | null |
bddAbove_range_comp {ι : Type u} {f : ι → Cardinal.{v}} (hf : BddAbove (range f))
(g : Cardinal.{v} → Cardinal.{max v w}) : BddAbove (range (g ∘ f)) := by
rw [range_comp]
exact bddAbove_image g hf | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | bddAbove_range_comp | null |
_root_.not_small_cardinal : ¬ Small.{u} Cardinal.{max u v} := by
intro h
have := small_lift.{_, v} Cardinal.{max u v}
rw [← small_univ_iff, ← bddAbove_iff_small] at this
exact not_bddAbove_univ this | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | _root_.not_small_cardinal | The type of cardinals in universe `u` is not `Small.{u}`. This is a version of the Burali-Forti
paradox. |
uncountable : Uncountable Cardinal.{u} :=
Uncountable.of_not_small not_small_cardinal.{u}
/-! ### Bounds on suprema -/ | instance | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | uncountable | null |
sum_le_iSup_lift {ι : Type u}
(f : ι → Cardinal.{max u v}) : sum f ≤ Cardinal.lift #ι * iSup f := by
rw [← (iSup f).lift_id, ← lift_umax, lift_umax.{max u v, u}, ← sum_const]
exact sum_le_sum _ _ (le_ciSup <| bddAbove_of_small _) | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | sum_le_iSup_lift | null |
sum_le_iSup {ι : Type u} (f : ι → Cardinal.{u}) : sum f ≤ #ι * iSup f := by
rw [← lift_id #ι]
exact sum_le_iSup_lift f | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | sum_le_iSup | null |
lift_sSup {s : Set Cardinal} (hs : BddAbove s) :
lift.{u} (sSup s) = sSup (lift.{u} '' s) := by
apply ((le_csSup_iff' (bddAbove_image.{_,u} _ hs)).2 fun c hc => _).antisymm (csSup_le' _)
· intro c hc
by_contra h
obtain ⟨d, rfl⟩ := Cardinal.mem_range_lift_of_le (not_le.1 h).le
simp_rw [lift_le] at h hc
rw [csSup_le_iff' hs] at h
exact h fun a ha => lift_le.1 <| hc (mem_image_of_mem _ ha)
· rintro i ⟨j, hj, rfl⟩
exact lift_le.2 (le_csSup hs hj) | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | lift_sSup | The lift of a supremum is the supremum of the lifts. |
lift_iSup {ι : Type v} {f : ι → Cardinal.{w}} (hf : BddAbove (range f)) :
lift.{u} (iSup f) = ⨆ i, lift.{u} (f i) := by
rw [iSup, iSup, lift_sSup hf, ← range_comp]
simp [Function.comp_def] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | lift_iSup | The lift of a supremum is the supremum of the lifts. |
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 := by
rw [lift_iSup hf]
exact ciSup_le' w
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | lift_iSup_le | 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`. |
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 := by
rw [lift_iSup hf]
exact ciSup_le_iff' (bddAbove_range_comp.{_,_,u} hf _) | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | lift_iSup_le_iff | null |
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') := by
rw [lift_iSup hf, lift_iSup hf']
exact ciSup_mono' (bddAbove_range_comp.{_,_,w} hf' _) fun i => ⟨_, h i⟩ | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | lift_iSup_le_lift_iSup | 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. |
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') :=
lift_iSup_le_lift_iSup hf hf' h
/-! ### Properties about the cast from `ℕ` -/ | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | lift_iSup_le_lift_iSup' | 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. |
mk_finset_of_fintype [Fintype α] : #(Finset α) = 2 ^ Fintype.card α := by
simp
@[norm_cast] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | mk_finset_of_fintype | null |
nat_succ (n : ℕ) : (n.succ : Cardinal) = succ ↑n := by
rw [Nat.cast_succ]
refine (add_one_le_succ _).antisymm (succ_le_of_lt ?_)
rw [← Nat.cast_succ]
exact Nat.cast_lt.2 (Nat.lt_succ_self _) | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | nat_succ | null |
succ_natCast (n : ℕ) : Order.succ (n : Cardinal) = n + 1 := by
rw [← Cardinal.nat_succ]
norm_cast | lemma | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | succ_natCast | null |
natCast_add_one_le_iff {n : ℕ} {c : Cardinal} : n + 1 ≤ c ↔ n < c := by
rw [← Order.succ_le_iff, Cardinal.succ_natCast] | lemma | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | natCast_add_one_le_iff | null |
two_le_iff_one_lt {c : Cardinal} : 2 ≤ c ↔ 1 < c := by
convert natCast_add_one_le_iff
norm_cast
@[simp] | lemma | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | two_le_iff_one_lt | null |
succ_zero : succ (0 : Cardinal) = 1 := by norm_cast | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | succ_zero | null |
one_lt_two : (1 : Cardinal) < 2 := by norm_cast | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | one_lt_two | null |
exists_finset_le_card (α : Type*) (n : ℕ) (h : n ≤ #α) :
∃ s : Finset α, n ≤ s.card := by
obtain hα|hα := finite_or_infinite α
· let hα := Fintype.ofFinite α
use Finset.univ
simpa only [mk_fintype, Nat.cast_le] using h
· obtain ⟨s, hs⟩ := Infinite.exists_subset_card_eq α n
exact ⟨s, hs.ge⟩ | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | exists_finset_le_card | null |
card_le_of {α : Type u} {n : ℕ} (H : ∀ s : Finset α, s.card ≤ n) : #α ≤ n := by
contrapose! H
apply exists_finset_le_card α (n + 1)
simpa only [nat_succ, succ_le_iff] using H | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | card_le_of | null |
cantor' (a) {b : Cardinal} (hb : 1 < b) : a < b ^ a := by
rw [← succ_le_iff, (by norm_cast : succ (1 : Cardinal) = 2)] at hb
exact (cantor a).trans_le (power_le_power_right hb) | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | cantor' | null |
one_le_iff_pos {c : Cardinal} : 1 ≤ c ↔ 0 < c := by
rw [← succ_zero, succ_le_iff] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | one_le_iff_pos | null |
one_le_iff_ne_zero {c : Cardinal} : 1 ≤ c ↔ c ≠ 0 := by
rw [one_le_iff_pos, pos_iff_ne_zero]
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | one_le_iff_ne_zero | null |
lt_one_iff_zero {c : Cardinal} : c < 1 ↔ c = 0 := by
simpa using lt_succ_bot_iff (a := c)
/-! ### Properties about `aleph0` -/ | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | lt_one_iff_zero | null |
nat_lt_aleph0 (n : ℕ) : (n : Cardinal.{u}) < ℵ₀ :=
succ_le_iff.1
(by
rw [← nat_succ, ← lift_mk_fin, aleph0, lift_mk_le.{u}]
exact ⟨⟨(↑), fun a b => Fin.ext⟩⟩)
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | nat_lt_aleph0 | null |
one_lt_aleph0 : 1 < ℵ₀ := by simpa using nat_lt_aleph0 1
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | one_lt_aleph0 | null |
one_le_aleph0 : 1 ≤ ℵ₀ :=
one_lt_aleph0.le | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | one_le_aleph0 | null |
lt_aleph0 {c : Cardinal} : c < ℵ₀ ↔ ∃ n : ℕ, c = n :=
⟨fun h => by
rcases lt_lift_iff.1 h with ⟨c, h', rfl⟩
rcases le_mk_iff_exists_set.1 h'.1 with ⟨S, rfl⟩
suffices S.Finite by
lift S to Finset ℕ using this
simp
contrapose! h'
haveI := Infinite.to_subtype h'
exact ⟨Infinite.natEmbedding S⟩, fun ⟨_, e⟩ => e.symm ▸ nat_lt_aleph0 _⟩ | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | lt_aleph0 | null |
succ_eq_of_lt_aleph0 {c : Cardinal} (h : c < ℵ₀) : Order.succ c = c + 1 := by
obtain ⟨n, hn⟩ := Cardinal.lt_aleph0.mp h
rw [hn, succ_natCast] | lemma | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | succ_eq_of_lt_aleph0 | null |
aleph0_le {c : Cardinal} : ℵ₀ ≤ c ↔ ∀ n : ℕ, ↑n ≤ c :=
⟨fun h _ => (nat_lt_aleph0 _).le.trans h, fun h =>
le_of_not_gt fun hn => by
rcases lt_aleph0.1 hn with ⟨n, rfl⟩
exact (Nat.lt_succ_self _).not_ge (Nat.cast_le.1 (h (n + 1)))⟩ | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | aleph0_le | null |
isSuccPrelimit_aleph0 : IsSuccPrelimit ℵ₀ :=
isSuccPrelimit_of_succ_lt fun a ha => by
rcases lt_aleph0.1 ha with ⟨n, rfl⟩
rw [← nat_succ]
apply nat_lt_aleph0 | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | isSuccPrelimit_aleph0 | null |
isSuccLimit_aleph0 : IsSuccLimit ℵ₀ := by
rw [Cardinal.isSuccLimit_iff]
exact ⟨aleph0_ne_zero, isSuccPrelimit_aleph0⟩ | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | isSuccLimit_aleph0 | null |
not_isSuccLimit_natCast : (n : ℕ) → ¬ IsSuccLimit (n : Cardinal.{u})
| 0, e => e.1 isMin_bot
| Nat.succ n, e => Order.not_isSuccPrelimit_succ _ (nat_succ n ▸ e.2) | lemma | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | not_isSuccLimit_natCast | null |
not_isSuccLimit_of_lt_aleph0 {c : Cardinal} (h : c < ℵ₀) : ¬ IsSuccLimit c := by
obtain ⟨n, rfl⟩ := lt_aleph0.1 h
exact not_isSuccLimit_natCast n | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | not_isSuccLimit_of_lt_aleph0 | null |
aleph0_le_of_isSuccLimit {c : Cardinal} (h : IsSuccLimit c) : ℵ₀ ≤ c := by
contrapose! h
exact not_isSuccLimit_of_lt_aleph0 h | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | aleph0_le_of_isSuccLimit | null |
isStrongLimit_aleph0 : IsStrongLimit ℵ₀ := by
refine ⟨aleph0_ne_zero, fun x hx ↦ ?_⟩
obtain ⟨n, rfl⟩ := lt_aleph0.1 hx
exact_mod_cast nat_lt_aleph0 _ | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | isStrongLimit_aleph0 | null |
IsStrongLimit.aleph0_le {c} (H : IsStrongLimit c) : ℵ₀ ≤ c :=
aleph0_le_of_isSuccLimit H.isSuccLimit | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | IsStrongLimit.aleph0_le | null |
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 :=
exists_eq_of_iSup_eq_of_not_isSuccLimit.{u, v} f hf (not_isSuccLimit_natCast n) h
@[simp] | lemma | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | exists_eq_natCast_of_iSup_eq | null |
range_natCast : range ((↑) : ℕ → Cardinal) = Iio ℵ₀ :=
ext fun x => by simp only [mem_Iio, mem_range, eq_comm, lt_aleph0] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | range_natCast | null |
mk_eq_nat_iff {α : Type u} {n : ℕ} : #α = n ↔ Nonempty (α ≃ Fin n) := by
rw [← lift_mk_fin, ← lift_uzero #α, lift_mk_eq'] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | mk_eq_nat_iff | null |
lt_aleph0_iff_finite {α : Type u} : #α < ℵ₀ ↔ Finite α := by
simp only [lt_aleph0, mk_eq_nat_iff, finite_iff_exists_equiv_fin] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | lt_aleph0_iff_finite | null |
lt_aleph0_iff_fintype {α : Type u} : #α < ℵ₀ ↔ Nonempty (Fintype α) :=
lt_aleph0_iff_finite.trans (finite_iff_nonempty_fintype _) | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | lt_aleph0_iff_fintype | null |
lt_aleph0_of_finite (α : Type u) [Finite α] : #α < ℵ₀ :=
lt_aleph0_iff_finite.2 ‹_› | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | lt_aleph0_of_finite | null |
lt_aleph0_iff_set_finite {S : Set α} : #S < ℵ₀ ↔ S.Finite :=
lt_aleph0_iff_finite.trans finite_coe_iff
alias ⟨_, _root_.Set.Finite.lt_aleph0⟩ := lt_aleph0_iff_set_finite
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | lt_aleph0_iff_set_finite | null |
lt_aleph0_iff_subtype_finite {p : α → Prop} : #{ x // p x } < ℵ₀ ↔ { x | p x }.Finite :=
lt_aleph0_iff_set_finite | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | lt_aleph0_iff_subtype_finite | null |
mk_le_aleph0_iff : #α ≤ ℵ₀ ↔ Countable α := by
rw [countable_iff_nonempty_embedding, aleph0, ← lift_uzero #α, lift_mk_le']
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | mk_le_aleph0_iff | null |
mk_le_aleph0 [Countable α] : #α ≤ ℵ₀ :=
mk_le_aleph0_iff.mpr ‹_› | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | mk_le_aleph0 | null |
le_aleph0_iff_set_countable {s : Set α} : #s ≤ ℵ₀ ↔ s.Countable := mk_le_aleph0_iff
alias ⟨_, _root_.Set.Countable.le_aleph0⟩ := le_aleph0_iff_set_countable
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | le_aleph0_iff_set_countable | null |
le_aleph0_iff_subtype_countable {p : α → Prop} :
#{ x // p x } ≤ ℵ₀ ↔ { x | p x }.Countable :=
le_aleph0_iff_set_countable | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | le_aleph0_iff_subtype_countable | null |
aleph0_lt_mk_iff : ℵ₀ < #α ↔ Uncountable α := by
rw [← not_le, ← not_countable_iff, not_iff_not, mk_le_aleph0_iff]
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | aleph0_lt_mk_iff | null |
aleph0_lt_mk [Uncountable α] : ℵ₀ < #α :=
aleph0_lt_mk_iff.mpr ‹_› | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | aleph0_lt_mk | null |
canLiftCardinalNat : CanLift Cardinal ℕ (↑) fun x => x < ℵ₀ :=
⟨fun _ hx =>
let ⟨n, hn⟩ := lt_aleph0.mp hx
⟨n, hn.symm⟩⟩ | instance | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | canLiftCardinalNat | null |
add_lt_aleph0 {a b : Cardinal} (ha : a < ℵ₀) (hb : b < ℵ₀) : a + b < ℵ₀ :=
match a, b, lt_aleph0.1 ha, lt_aleph0.1 hb with
| _, _, ⟨m, rfl⟩, ⟨n, rfl⟩ => by rw [← Nat.cast_add]; apply nat_lt_aleph0 | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | add_lt_aleph0 | null |
add_lt_aleph0_iff {a b : Cardinal} : a + b < ℵ₀ ↔ a < ℵ₀ ∧ b < ℵ₀ :=
⟨fun h => ⟨(self_le_add_right _ _).trans_lt h, (self_le_add_left _ _).trans_lt h⟩,
fun ⟨h1, h2⟩ => add_lt_aleph0 h1 h2⟩ | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | add_lt_aleph0_iff | null |
aleph0_le_add_iff {a b : Cardinal} : ℵ₀ ≤ a + b ↔ ℵ₀ ≤ a ∨ ℵ₀ ≤ b := by
simp only [← not_lt, add_lt_aleph0_iff, not_and_or] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | aleph0_le_add_iff | null |
nsmul_lt_aleph0_iff {n : ℕ} {a : Cardinal} : n • a < ℵ₀ ↔ n = 0 ∨ a < ℵ₀ := by
cases n with
| zero => simpa using nat_lt_aleph0 0
| succ n =>
simp only [Nat.succ_ne_zero, false_or]
induction n with
| zero => simp
| succ n ih => rw [succ_nsmul, add_lt_aleph0_iff, ih, and_self_iff] | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | nsmul_lt_aleph0_iff | See also `Cardinal.nsmul_lt_aleph0_iff_of_ne_zero` if you already have `n ≠ 0`. |
nsmul_lt_aleph0_iff_of_ne_zero {n : ℕ} {a : Cardinal} (h : n ≠ 0) : n • a < ℵ₀ ↔ a < ℵ₀ :=
nsmul_lt_aleph0_iff.trans <| or_iff_right h | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | nsmul_lt_aleph0_iff_of_ne_zero | See also `Cardinal.nsmul_lt_aleph0_iff` for a hypothesis-free version. |
mul_lt_aleph0 {a b : Cardinal} (ha : a < ℵ₀) (hb : b < ℵ₀) : a * b < ℵ₀ :=
match a, b, lt_aleph0.1 ha, lt_aleph0.1 hb with
| _, _, ⟨m, rfl⟩, ⟨n, rfl⟩ => by rw [← Nat.cast_mul]; apply nat_lt_aleph0 | theorem | SetTheory | [
"Mathlib.Data.Countable.Small",
"Mathlib.Data.Fintype.BigOperators",
"Mathlib.Data.Fintype.Powerset",
"Mathlib.Data.Nat.Cast.Order.Basic",
"Mathlib.Data.Set.Countable",
"Mathlib.Logic.Small.Set",
"Mathlib.Logic.UnivLE",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/SetTheory/Cardinal/Basic.lean | mul_lt_aleph0 | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.