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 ⌀ |
|---|---|---|---|---|---|---|
mul_lt_aleph0_iff {a b : Cardinal} : a * b < ℵ₀ ↔ a = 0 ∨ b = 0 ∨ a < ℵ₀ ∧ b < ℵ₀ := by
refine ⟨fun h => ?_, ?_⟩
· by_cases ha : a = 0
· exact Or.inl ha
right
by_cases hb : b = 0
· exact Or.inl hb
right
rw [← Ne, ← one_le_iff_ne_zero] at ha hb
constructor
· rw [← mul_one a]
exact (mul_le_mul' le_rfl hb).trans_lt h
· rw [← one_mul b]
exact (mul_le_mul' ha le_rfl).trans_lt h
rintro (rfl | rfl | ⟨ha, hb⟩) <;> simp only [*, mul_lt_aleph0, aleph0_pos, zero_mul, mul_zero] | 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_iff | null |
aleph0_le_mul_iff {a b : Cardinal} : ℵ₀ ≤ a * b ↔ a ≠ 0 ∧ b ≠ 0 ∧ (ℵ₀ ≤ a ∨ ℵ₀ ≤ b) := by
let h := (@mul_lt_aleph0_iff a b).not
rwa [not_lt, not_or, not_or, not_and_or, not_lt, not_lt] at 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_mul_iff | See also `Cardinal.aleph0_le_mul_iff`. |
aleph0_le_mul_iff' {a b : Cardinal.{u}} : ℵ₀ ≤ a * b ↔ a ≠ 0 ∧ ℵ₀ ≤ b ∨ ℵ₀ ≤ a ∧ b ≠ 0 := by
have : ∀ {a : Cardinal.{u}}, ℵ₀ ≤ a → a ≠ 0 := fun a => ne_bot_of_le_ne_bot aleph0_ne_zero a
simp only [aleph0_le_mul_iff, and_or_left, and_iff_right_of_imp this, @and_left_comm (a ≠ 0)]
simp only [and_comm, or_comm] | 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_mul_iff' | See also `Cardinal.aleph0_le_mul_iff'`. |
mul_lt_aleph0_iff_of_ne_zero {a b : Cardinal} (ha : a ≠ 0) (hb : b ≠ 0) :
a * b < ℵ₀ ↔ a < ℵ₀ ∧ b < ℵ₀ := by simp [mul_lt_aleph0_iff, ha, 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 | mul_lt_aleph0_iff_of_ne_zero | null |
power_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 [power_natCast, ← Nat.cast_pow]; 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 | power_lt_aleph0 | null |
eq_one_iff_unique {α : Type*} : #α = 1 ↔ Subsingleton α ∧ Nonempty α :=
calc
#α = 1 ↔ #α ≤ 1 ∧ 1 ≤ #α := le_antisymm_iff
_ ↔ Subsingleton α ∧ Nonempty α :=
le_one_iff_subsingleton.and (one_le_iff_ne_zero.trans mk_ne_zero_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 | eq_one_iff_unique | null |
infinite_iff {α : Type u} : Infinite α ↔ ℵ₀ ≤ #α := by
rw [← not_lt, lt_aleph0_iff_finite, not_finite_iff_infinite] | 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 | infinite_iff | null |
aleph0_le_mk_iff : ℵ₀ ≤ #α ↔ Infinite α := infinite_iff.symm | 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 | aleph0_le_mk_iff | null |
mk_lt_aleph0_iff : #α < ℵ₀ ↔ Finite α := by simp [← not_le, aleph0_le_mk_iff]
@[simp] lemma mk_lt_aleph0 [Finite α] : #α < ℵ₀ := mk_lt_aleph0_iff.2 ‹_›
@[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 | mk_lt_aleph0_iff | null |
aleph0_le_mk (α : Type u) [Infinite α] : ℵ₀ ≤ #α :=
infinite_iff.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 | aleph0_le_mk | null |
mk_eq_aleph0 (α : Type*) [Countable α] [Infinite α] : #α = ℵ₀ :=
mk_le_aleph0.antisymm <| aleph0_le_mk _ | 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_aleph0 | null |
denumerable_iff {α : Type u} : Nonempty (Denumerable α) ↔ #α = ℵ₀ :=
⟨fun ⟨h⟩ => mk_congr ((@Denumerable.eqv α h).trans Equiv.ulift.symm), fun h => by
obtain ⟨f⟩ := Quotient.exact h
exact ⟨Denumerable.mk' <| f.trans Equiv.ulift⟩⟩ | 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 | denumerable_iff | null |
mk_denumerable (α : Type u) [Denumerable α] : #α = ℵ₀ :=
denumerable_iff.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 | mk_denumerable | null |
_root_.Set.countable_infinite_iff_nonempty_denumerable {α : Type*} {s : Set α} :
s.Countable ∧ s.Infinite ↔ Nonempty (Denumerable s) := by
rw [nonempty_denumerable_iff, ← Set.infinite_coe_iff, countable_coe_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 | _root_.Set.countable_infinite_iff_nonempty_denumerable | null |
aleph0_add_aleph0 : ℵ₀ + ℵ₀ = ℵ₀ :=
mk_denumerable _ | 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_add_aleph0 | null |
aleph0_mul_aleph0 : ℵ₀ * ℵ₀ = ℵ₀ :=
mk_denumerable _
@[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_mul_aleph0 | null |
nat_mul_aleph0 {n : ℕ} (hn : n ≠ 0) : ↑n * ℵ₀ = ℵ₀ :=
le_antisymm (lift_mk_fin n ▸ mk_le_aleph0) <|
le_mul_of_one_le_left (zero_le _) <| by
rwa [← Nat.cast_one, Nat.cast_le, Nat.one_le_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 | nat_mul_aleph0 | null |
aleph0_mul_nat {n : ℕ} (hn : n ≠ 0) : ℵ₀ * n = ℵ₀ := by rw [mul_comm, nat_mul_aleph0 hn]
@[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_mul_nat | null |
ofNat_mul_aleph0 {n : ℕ} [Nat.AtLeastTwo n] : ofNat(n) * ℵ₀ = ℵ₀ :=
nat_mul_aleph0 (NeZero.ne n)
@[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 | ofNat_mul_aleph0 | null |
aleph0_mul_ofNat {n : ℕ} [Nat.AtLeastTwo n] : ℵ₀ * ofNat(n) = ℵ₀ :=
aleph0_mul_nat (NeZero.ne n)
@[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_mul_ofNat | null |
add_le_aleph0 {c₁ c₂ : Cardinal} : c₁ + c₂ ≤ ℵ₀ ↔ c₁ ≤ ℵ₀ ∧ c₂ ≤ ℵ₀ :=
⟨fun h => ⟨le_self_add.trans h, le_add_self.trans h⟩, fun h =>
aleph0_add_aleph0 ▸ add_le_add h.1 h.2⟩
@[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 | add_le_aleph0 | null |
aleph0_add_nat (n : ℕ) : ℵ₀ + n = ℵ₀ :=
(add_le_aleph0.2 ⟨le_rfl, (nat_lt_aleph0 n).le⟩).antisymm le_self_add
@[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_add_nat | null |
nat_add_aleph0 (n : ℕ) : ↑n + ℵ₀ = ℵ₀ := by rw [add_comm, aleph0_add_nat]
@[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_add_aleph0 | null |
ofNat_add_aleph0 {n : ℕ} [Nat.AtLeastTwo n] : ofNat(n) + ℵ₀ = ℵ₀ :=
nat_add_aleph0 n
@[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 | ofNat_add_aleph0 | null |
aleph0_add_ofNat {n : ℕ} [Nat.AtLeastTwo n] : ℵ₀ + ofNat(n) = ℵ₀ :=
aleph0_add_nat 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 | aleph0_add_ofNat | null |
exists_nat_eq_of_le_nat {c : Cardinal} {n : ℕ} (h : c ≤ n) : ∃ m, m ≤ n ∧ c = m := by
lift c to ℕ using h.trans_lt (nat_lt_aleph0 _)
exact ⟨c, mod_cast h, rfl⟩ | 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_nat_eq_of_le_nat | null |
mk_int : #ℤ = ℵ₀ :=
mk_denumerable ℤ | 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_int | null |
mk_pnat : #ℕ+ = ℵ₀ :=
mk_denumerable ℕ+
@[deprecated (since := "2025-04-27")]
alias mk_pNat := mk_pnat
/-! ### Cardinalities of basic sets and types -/
@[simp] theorem mk_additive : #(Additive α) = #α := rfl
@[simp] theorem mk_multiplicative : #(Multiplicative α) = #α := rfl
@[to_additive (attr := simp)] theorem mk_mulOpposite : #(MulOpposite α) = #α :=
mk_congr MulOpposite.opEquiv.symm | 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_pnat | null |
mk_singleton {α : Type u} (x : α) : #({x} : Set α) = 1 :=
mk_eq_one _
@[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_singleton | null |
mk_vector (α : Type u) (n : ℕ) : #(List.Vector α n) = #α ^ n :=
(mk_congr (Equiv.vectorEquivFin α n)).trans <| by 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_vector | null |
mk_list_eq_sum_pow (α : Type u) : #(List α) = sum fun n : ℕ => #α ^ n :=
calc
#(List α) = #(Σ n, List.Vector α n) := mk_congr (Equiv.sigmaFiberEquiv List.length).symm
_ = sum fun n : ℕ => #α ^ n := by 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_list_eq_sum_pow | null |
mk_quot_le {α : Type u} {r : α → α → Prop} : #(Quot r) ≤ #α :=
mk_le_of_surjective Quot.exists_rep | 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_quot_le | null |
mk_quotient_le {α : Type u} {s : Setoid α} : #(Quotient s) ≤ #α :=
mk_quot_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 | mk_quotient_le | null |
mk_subtype_le_of_subset {α : Type u} {p q : α → Prop} (h : ∀ ⦃x⦄, p x → q x) :
#(Subtype p) ≤ #(Subtype q) :=
⟨Embedding.subtypeMap (Embedding.refl α) 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 | mk_subtype_le_of_subset | null |
mk_emptyCollection (α : Type u) : #(∅ : Set α) = 0 :=
mk_eq_zero _ | 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_emptyCollection | null |
mk_emptyCollection_iff {α : Type u} {s : Set α} : #s = 0 ↔ s = ∅ := by
rw [mk_eq_zero_iff, isEmpty_coe_sort] | 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_emptyCollection_iff | null |
mk_set_ne_zero_iff {α : Type u} (s : Set α) : #s ≠ 0 ↔ s.Nonempty := by
rw [mk_ne_zero_iff, nonempty_coe_sort]
@[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 | mk_set_ne_zero_iff | null |
mk_univ {α : Type u} : #(@univ α) = #α :=
mk_congr (Equiv.Set.univ α)
@[simp] lemma mk_setProd {α β : Type u} (s : Set α) (t : Set β) : #(s ×ˢ t) = #s * #t := by
rw [mul_def, mk_congr (Equiv.Set.prod ..)] | 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_univ | null |
mk_image_le {α β : Type u} {f : α → β} {s : Set α} : #(f '' s) ≤ #s :=
mk_le_of_surjective imageFactorization_surjective | 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_image_le | null |
mk_image2_le {α β γ : Type u} {f : α → β → γ} {s : Set α} {t : Set β} :
#(image2 f s t) ≤ #s * #t := by
rw [← image_uncurry_prod, ← mk_setProd]
exact mk_image_le | 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_image2_le | null |
mk_image_le_lift {α : Type u} {β : Type v} {f : α → β} {s : Set α} :
lift.{u} #(f '' s) ≤ lift.{v} #s :=
lift_mk_le.{0}.mpr ⟨Embedding.ofSurjective _ imageFactorization_surjective⟩ | 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_image_le_lift | null |
mk_range_le {α β : Type u} {f : α → β} : #(range f) ≤ #α :=
mk_le_of_surjective rangeFactorization_surjective | 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_range_le | null |
mk_range_le_lift {α : Type u} {β : Type v} {f : α → β} :
lift.{u} #(range f) ≤ lift.{v} #α :=
lift_mk_le.{0}.mpr ⟨Embedding.ofSurjective _ rangeFactorization_surjective⟩ | 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_range_le_lift | null |
mk_range_eq (f : α → β) (h : Injective f) : #(range f) = #α :=
mk_congr (Equiv.ofInjective f h).symm | 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_range_eq | null |
mk_range_eq_lift {α : Type u} {β : Type v} {f : α → β} (hf : Injective f) :
lift.{max u w} #(range f) = lift.{max v w} #α :=
lift_mk_eq.{v,u,w}.mpr ⟨(Equiv.ofInjective f hf).symm⟩ | 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_range_eq_lift | null |
mk_range_eq_of_injective {α : Type u} {β : Type v} {f : α → β} (hf : Injective f) :
lift.{u} #(range f) = lift.{v} #α :=
lift_mk_eq'.mpr ⟨(Equiv.ofInjective f hf).symm⟩ | 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_range_eq_of_injective | null |
lift_mk_le_lift_mk_of_injective {α : Type u} {β : Type v} {f : α → β} (hf : Injective f) :
Cardinal.lift.{v} (#α) ≤ Cardinal.lift.{u} (#β) := by
rw [← Cardinal.mk_range_eq_of_injective hf]
exact Cardinal.lift_le.2 (Cardinal.mk_set_le _) | 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 | lift_mk_le_lift_mk_of_injective | null |
lift_mk_le_lift_mk_of_surjective {α : Type u} {β : Type v} {f : α → β} (hf : Surjective f) :
Cardinal.lift.{u} (#β) ≤ Cardinal.lift.{v} (#α) :=
lift_mk_le_lift_mk_of_injective (injective_surjInv hf) | 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 | lift_mk_le_lift_mk_of_surjective | null |
mk_image_eq_of_injOn {α β : Type u} (f : α → β) (s : Set α) (h : InjOn f s) :
#(f '' s) = #s :=
mk_congr (Equiv.Set.imageOfInjOn f s h).symm | 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_image_eq_of_injOn | null |
mk_image_eq_of_injOn_lift {α : Type u} {β : Type v} (f : α → β) (s : Set α)
(h : InjOn f s) : lift.{u} #(f '' s) = lift.{v} #s :=
lift_mk_eq.{v, u, 0}.mpr ⟨(Equiv.Set.imageOfInjOn f s h).symm⟩ | 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_image_eq_of_injOn_lift | null |
mk_image_eq {α β : Type u} {f : α → β} {s : Set α} (hf : Injective f) : #(f '' s) = #s :=
mk_image_eq_of_injOn _ _ hf.injOn | 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_image_eq | null |
mk_image_eq_lift {α : Type u} {β : Type v} (f : α → β) (s : Set α) (h : Injective f) :
lift.{u} #(f '' s) = lift.{v} #s :=
mk_image_eq_of_injOn_lift _ _ h.injOn
@[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_image_eq_lift | null |
mk_image_embedding_lift {β : Type v} (f : α ↪ β) (s : Set α) :
lift.{u} #(f '' s) = lift.{v} #s :=
mk_image_eq_lift _ _ f.injective
@[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_image_embedding_lift | null |
mk_image_embedding (f : α ↪ β) (s : Set α) : #(f '' s) = #s := by
simpa using mk_image_embedding_lift f s | 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_image_embedding | null |
mk_iUnion_le_sum_mk {α ι : Type u} {f : ι → Set α} : #(⋃ i, f i) ≤ sum fun i => #(f i) :=
calc
#(⋃ i, f i) ≤ #(Σ i, f i) := mk_le_of_surjective (Set.sigmaToiUnion_surjective f)
_ = sum fun i => #(f i) := mk_sigma _ | 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_iUnion_le_sum_mk | null |
mk_iUnion_le_sum_mk_lift {α : Type u} {ι : Type v} {f : ι → Set α} :
lift.{v} #(⋃ i, f i) ≤ sum fun i => #(f i) :=
calc
lift.{v} #(⋃ i, f i) ≤ #(Σ i, f i) :=
mk_le_of_surjective <| ULift.up_surjective.comp (Set.sigmaToiUnion_surjective f)
_ = sum fun i => #(f i) := mk_sigma _ | 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_iUnion_le_sum_mk_lift | null |
mk_iUnion_eq_sum_mk {α ι : Type u} {f : ι → Set α}
(h : Pairwise (Disjoint on f)) : #(⋃ i, f i) = sum fun i => #(f i) :=
calc
#(⋃ i, f i) = #(Σ i, f i) := mk_congr (Set.unionEqSigmaOfDisjoint h)
_ = sum fun i => #(f i) := mk_sigma _ | 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_iUnion_eq_sum_mk | null |
mk_iUnion_eq_sum_mk_lift {α : Type u} {ι : Type v} {f : ι → Set α}
(h : Pairwise (Disjoint on f)) :
lift.{v} #(⋃ i, f i) = sum fun i => #(f i) :=
calc
lift.{v} #(⋃ i, f i) = #(Σ i, f i) :=
mk_congr <| .trans Equiv.ulift (Set.unionEqSigmaOfDisjoint h)
_ = sum fun i => #(f i) := mk_sigma _ | 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_iUnion_eq_sum_mk_lift | null |
mk_iUnion_le {α ι : Type u} (f : ι → Set α) : #(⋃ i, f i) ≤ #ι * ⨆ i, #(f i) :=
mk_iUnion_le_sum_mk.trans (sum_le_iSup _) | 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_iUnion_le | null |
mk_iUnion_le_lift {α : Type u} {ι : Type v} (f : ι → Set α) :
lift.{v} #(⋃ i, f i) ≤ lift.{u} #ι * ⨆ i, lift.{v} #(f i) := by
refine mk_iUnion_le_sum_mk_lift.trans <| Eq.trans_le ?_ (sum_le_iSup_lift _)
rw [← lift_sum, lift_id'.{_,u}] | 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_iUnion_le_lift | null |
mk_sUnion_le {α : Type u} (A : Set (Set α)) : #(⋃₀ A) ≤ #A * ⨆ s : A, #s := by
rw [sUnion_eq_iUnion]
apply mk_iUnion_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 | mk_sUnion_le | null |
mk_biUnion_le {ι α : Type u} (A : ι → Set α) (s : Set ι) :
#(⋃ x ∈ s, A x) ≤ #s * ⨆ x : s, #(A x.1) := by
rw [biUnion_eq_iUnion]
apply mk_iUnion_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 | mk_biUnion_le | null |
mk_biUnion_le_lift {α : Type u} {ι : Type v} (A : ι → Set α) (s : Set ι) :
lift.{v} #(⋃ x ∈ s, A x) ≤ lift.{u} #s * ⨆ x : s, lift.{v} #(A x.1) := by
rw [biUnion_eq_iUnion]
apply mk_iUnion_le_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 | mk_biUnion_le_lift | null |
finset_card_lt_aleph0 (s : Finset α) : #(↑s : Set α) < ℵ₀ :=
lt_aleph0_of_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 | finset_card_lt_aleph0 | null |
mk_set_eq_nat_iff_finset {α} {s : Set α} {n : ℕ} :
#s = n ↔ ∃ t : Finset α, (t : Set α) = s ∧ t.card = n := by
constructor
· intro h
lift s to Finset α using lt_aleph0_iff_set_finite.1 (h.symm ▸ nat_lt_aleph0 n)
simpa using h
· rintro ⟨t, rfl, rfl⟩
exact mk_coe_finset | 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_set_eq_nat_iff_finset | null |
mk_eq_nat_iff_finset {n : ℕ} :
#α = n ↔ ∃ t : Finset α, (t : Set α) = univ ∧ t.card = n := by
rw [← mk_univ, mk_set_eq_nat_iff_finset] | 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_finset | null |
mk_eq_nat_iff_fintype {n : ℕ} : #α = n ↔ ∃ h : Fintype α, @Fintype.card α h = n := by
rw [mk_eq_nat_iff_finset]
constructor
· rintro ⟨t, ht, hn⟩
exact ⟨⟨t, eq_univ_iff_forall.1 ht⟩, hn⟩
· rintro ⟨⟨t, ht⟩, hn⟩
exact ⟨t, eq_univ_iff_forall.2 ht, hn⟩ | 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_fintype | null |
mk_union_add_mk_inter {α : Type u} {S T : Set α} :
#(S ∪ T : Set α) + #(S ∩ T : Set α) = #S + #T := by
classical
exact Quot.sound ⟨Equiv.Set.unionSumInter S T⟩ | 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_union_add_mk_inter | null |
mk_union_le {α : Type u} (S T : Set α) : #(S ∪ T : Set α) ≤ #S + #T :=
@mk_union_add_mk_inter α S T ▸ self_le_add_right #(S ∪ T : Set α) #(S ∩ T : Set α) | 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_union_le | The cardinality of a union is at most the sum of the cardinalities
of the two sets. |
mk_union_of_disjoint {α : Type u} {S T : Set α} (H : Disjoint S T) :
#(S ∪ T : Set α) = #S + #T := by
classical
exact Quot.sound ⟨Equiv.Set.union 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 | mk_union_of_disjoint | null |
mk_insert {α : Type u} {s : Set α} {a : α} (h : a ∉ s) :
#(insert a s : Set α) = #s + 1 := by
rw [← union_singleton, mk_union_of_disjoint, mk_singleton]
simpa | 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_insert | null |
mk_insert_le {α : Type u} {s : Set α} {a : α} : #(insert a s : Set α) ≤ #s + 1 := by
by_cases h : a ∈ s
· simp only [insert_eq_of_mem h, self_le_add_right]
· rw [mk_insert 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 | mk_insert_le | null |
mk_sum_compl {α} (s : Set α) : #s + #(sᶜ : Set α) = #α := by
classical
exact mk_congr (Equiv.Set.sumCompl s) | 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_sum_compl | null |
mk_le_mk_of_subset {α} {s t : Set α} (h : s ⊆ t) : #s ≤ #t :=
⟨Set.embeddingOfSubset s t 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 | mk_le_mk_of_subset | null |
mk_le_iff_forall_finset_subset_card_le {α : Type u} {n : ℕ} {t : Set α} :
#t ≤ n ↔ ∀ s : Finset α, (s : Set α) ⊆ t → s.card ≤ n := by
refine ⟨fun H s hs ↦ by simpa using (mk_le_mk_of_subset hs).trans H, fun H ↦ ?_⟩
apply card_le_of (fun s ↦ ?_)
classical
let u : Finset α := s.image Subtype.val
have : u.card = s.card := Finset.card_image_of_injOn Subtype.coe_injective.injOn
rw [← this]
apply H
simp only [u, Finset.coe_image, image_subset_iff, Subtype.coe_preimage_self, subset_univ] | 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_iff_forall_finset_subset_card_le | null |
mk_subtype_mono {p q : α → Prop} (h : ∀ x, p x → q x) :
#{ x // p x } ≤ #{ x // q x } :=
⟨embeddingOfSubset _ _ 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 | mk_subtype_mono | null |
le_mk_diff_add_mk (S T : Set α) : #S ≤ #(S \ T : Set α) + #T :=
(mk_le_mk_of_subset <| subset_diff_union _ _).trans <| mk_union_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 | le_mk_diff_add_mk | null |
mk_diff_add_mk {S T : Set α} (h : T ⊆ S) : #(S \ T : Set α) + #T = #S := by
refine (mk_union_of_disjoint <| ?_).symm.trans <| by rw [diff_union_of_subset h]
exact disjoint_sdiff_self_left | 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_diff_add_mk | null |
diff_nonempty_of_mk_lt_mk {S T : Set α} (h : #S < #T) : (T \ S).Nonempty := by
rw [← mk_set_ne_zero_iff]
intro h'
exact h.not_ge ((le_mk_diff_add_mk T S).trans (by simp [h'])) | 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 | diff_nonempty_of_mk_lt_mk | null |
compl_nonempty_of_mk_lt_mk {S : Set α} (h : #S < #α) : Sᶜ.Nonempty := by
rw [← mk_univ (α := α)] at h
simpa [Set.compl_eq_univ_diff] using diff_nonempty_of_mk_lt_mk h | 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 | compl_nonempty_of_mk_lt_mk | null |
mk_union_le_aleph0 {α} {P Q : Set α} :
#(P ∪ Q : Set α) ≤ ℵ₀ ↔ #P ≤ ℵ₀ ∧ #Q ≤ ℵ₀ := by
simp only [le_aleph0_iff_subtype_countable, setOf_mem_eq, Set.union_def,
← countable_union] | 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_union_le_aleph0 | null |
mk_sep (s : Set α) (t : α → Prop) : #({ x ∈ s | t x } : Set α) = #{ x : s | t x.1 } :=
mk_congr (Equiv.Set.sep s t) | 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_sep | null |
mk_preimage_of_injective_lift {α : Type u} {β : Type v} (f : α → β) (s : Set β)
(h : Injective f) : lift.{v} #(f ⁻¹' s) ≤ lift.{u} #s := by
rw [lift_mk_le.{0}]
use Subtype.coind (fun x => f x.1) fun x => mem_preimage.mp x.2
apply Subtype.coind_injective; exact h.comp Subtype.val_injective | 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_preimage_of_injective_lift | null |
mk_preimage_of_subset_range_lift {α : Type u} {β : Type v} (f : α → β) (s : Set β)
(h : s ⊆ range f) : lift.{u} #s ≤ lift.{v} #(f ⁻¹' s) := by
rw [← image_preimage_eq_iff] at h
nth_rewrite 1 [← h]
apply mk_image_le_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 | mk_preimage_of_subset_range_lift | null |
mk_preimage_of_injective_of_subset_range_lift {β : Type v} (f : α → β) (s : Set β)
(h : Injective f) (h2 : s ⊆ range f) : lift.{v} #(f ⁻¹' s) = lift.{u} #s :=
le_antisymm (mk_preimage_of_injective_lift f s h) (mk_preimage_of_subset_range_lift f s 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 | mk_preimage_of_injective_of_subset_range_lift | null |
mk_preimage_of_injective_of_subset_range (f : α → β) (s : Set β) (h : Injective f)
(h2 : s ⊆ range f) : #(f ⁻¹' s) = #s := by
convert mk_preimage_of_injective_of_subset_range_lift.{u, u} f s h h2 using 1 <;> rw [lift_id]
@[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_preimage_of_injective_of_subset_range | null |
mk_preimage_equiv_lift {β : Type v} (f : α ≃ β) (s : Set β) :
lift.{v} #(f ⁻¹' s) = lift.{u} #s := by
apply mk_preimage_of_injective_of_subset_range_lift _ _ f.injective
rw [f.range_eq_univ]
exact fun _ _ ↦ ⟨⟩
@[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_preimage_equiv_lift | null |
mk_preimage_equiv (f : α ≃ β) (s : Set β) : #(f ⁻¹' s) = #s := by
simpa using mk_preimage_equiv_lift f s | 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_preimage_equiv | null |
mk_preimage_of_injective (f : α → β) (s : Set β) (h : Injective f) :
#(f ⁻¹' s) ≤ #s := by
rw [← lift_id #(↑(f ⁻¹' s)), ← lift_id #(↑s)]
exact mk_preimage_of_injective_lift f s 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 | mk_preimage_of_injective | null |
mk_preimage_of_subset_range (f : α → β) (s : Set β) (h : s ⊆ range f) :
#s ≤ #(f ⁻¹' s) := by
rw [← lift_id #(↑(f ⁻¹' s)), ← lift_id #(↑s)]
exact mk_preimage_of_subset_range_lift f s 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 | mk_preimage_of_subset_range | null |
mk_subset_ge_of_subset_image_lift {α : Type u} {β : Type v} (f : α → β) {s : Set α}
{t : Set β} (h : t ⊆ f '' s) : lift.{u} #t ≤ lift.{v} #({ x ∈ s | f x ∈ t } : Set α) := by
rw [image_eq_range] at h
convert mk_preimage_of_subset_range_lift _ _ h using 1
rw [mk_sep]
rfl | 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_subset_ge_of_subset_image_lift | null |
mk_subset_ge_of_subset_image (f : α → β) {s : Set α} {t : Set β} (h : t ⊆ f '' s) :
#t ≤ #({ x ∈ s | f x ∈ t } : Set α) := by
rw [image_eq_range] at h
convert mk_preimage_of_subset_range _ _ h using 1
rw [mk_sep]
rfl | 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_subset_ge_of_subset_image | null |
le_mk_iff_exists_subset {c : Cardinal} {α : Type u} {s : Set α} :
c ≤ #s ↔ ∃ p : Set α, p ⊆ s ∧ #p = c := by
rw [le_mk_iff_exists_set, ← Subtype.exists_set_subtype]
apply exists_congr; intro t; rw [mk_image_eq]; apply Subtype.val_injective
@[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_mk_iff_exists_subset | null |
mk_range_inl {α : Type u} {β : Type v} : #(range (@Sum.inl α β)) = lift.{v} #α := by
rw [← lift_id'.{u, v} #_, (Equiv.Set.rangeInl α β).lift_cardinal_eq, lift_umax.{u, v}]
@[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_range_inl | null |
mk_range_inr {α : Type u} {β : Type v} : #(range (@Sum.inr α β)) = lift.{u} #β := by
rw [← lift_id'.{v, u} #_, (Equiv.Set.rangeInr α β).lift_cardinal_eq, lift_umax.{v, u}] | 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_range_inr | null |
two_le_iff : (2 : Cardinal) ≤ #α ↔ ∃ x y : α, x ≠ y := by
rw [← Nat.cast_two, nat_succ, succ_le_iff, Nat.cast_one, one_lt_iff_nontrivial, nontrivial_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 | two_le_iff | null |
two_le_iff' (x : α) : (2 : Cardinal) ≤ #α ↔ ∃ y : α, y ≠ x := by
rw [two_le_iff, ← nontrivial_iff, nontrivial_iff_exists_ne x] | 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 | two_le_iff' | null |
mk_eq_two_iff : #α = 2 ↔ ∃ x y : α, x ≠ y ∧ ({x, y} : Set α) = univ := by
classical
simp only [← @Nat.cast_two Cardinal, mk_eq_nat_iff_finset, Finset.card_eq_two]
constructor
· rintro ⟨t, ht, x, y, hne, rfl⟩
exact ⟨x, y, hne, by simpa using ht⟩
· rintro ⟨x, y, hne, h⟩
exact ⟨{x, y}, by simpa using h, x, y, hne, rfl⟩ | 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_two_iff | null |
mk_eq_two_iff' (x : α) : #α = 2 ↔ ∃! y, y ≠ x := by
rw [mk_eq_two_iff]; constructor
· rintro ⟨a, b, hne, h⟩
simp only [eq_univ_iff_forall, mem_insert_iff, mem_singleton_iff] at h
rcases h x with (rfl | rfl)
exacts [⟨b, hne.symm, fun z => (h z).resolve_left⟩, ⟨a, hne, fun z => (h z).resolve_right⟩]
· rintro ⟨y, hne, hy⟩
exact ⟨x, y, hne.symm, eq_univ_of_forall fun z => or_iff_not_imp_left.2 (hy z)⟩ | 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_two_iff' | null |
exists_notMem_of_length_lt {α : Type*} (l : List α) (h : ↑l.length < #α) :
∃ z : α, z ∉ l := by
classical
contrapose! h
calc
#α = #(Set.univ : Set α) := mk_univ.symm
_ ≤ #l.toFinset := mk_le_mk_of_subset fun x _ => List.mem_toFinset.mpr (h x)
_ = l.toFinset.card := Cardinal.mk_coe_finset
_ ≤ l.length := Nat.cast_le.mpr (List.toFinset_card_le l)
@[deprecated (since := "2025-05-23")]
alias exists_not_mem_of_length_lt := exists_notMem_of_length_lt | 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_notMem_of_length_lt | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.