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 ⌀ |
|---|---|---|---|---|---|---|
beth_mono : Monotone beth :=
beth_strictMono.monotone
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat",
"Mathlib.SetTheory.Ordinal.Enum"
] | Mathlib/SetTheory/Cardinal/Aleph.lean | beth_mono | null |
beth_lt_beth {o₁ o₂ : Ordinal} : ℶ_ o₁ < ℶ_ o₂ ↔ o₁ < o₂ :=
beth_strictMono.lt_iff_lt
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat",
"Mathlib.SetTheory.Ordinal.Enum"
] | Mathlib/SetTheory/Cardinal/Aleph.lean | beth_lt_beth | null |
beth_le_beth {o₁ o₂ : Ordinal} : ℶ_ o₁ ≤ ℶ_ o₂ ↔ o₁ ≤ o₂ :=
beth_strictMono.le_iff_le
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat",
"Mathlib.SetTheory.Ordinal.Enum"
] | Mathlib/SetTheory/Cardinal/Aleph.lean | beth_le_beth | null |
beth_zero : ℶ_ 0 = ℵ₀ := by
simp [beth]
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat",
"Mathlib.SetTheory.Ordinal.Enum"
] | Mathlib/SetTheory/Cardinal/Aleph.lean | beth_zero | null |
beth_succ (o : Ordinal) : ℶ_ (succ o) = 2 ^ ℶ_ o := by
simp [beth, add_succ] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat",
"Mathlib.SetTheory.Ordinal.Enum"
] | Mathlib/SetTheory/Cardinal/Aleph.lean | beth_succ | null |
isNormal_beth : Order.IsNormal beth :=
isNormal_preBeth.comp (isNormal_add_right _) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat",
"Mathlib.SetTheory.Ordinal.Enum"
] | Mathlib/SetTheory/Cardinal/Aleph.lean | isNormal_beth | null |
beth_limit {o : Ordinal} (ho : IsSuccLimit o) : ℶ_ o = ⨆ a : Iio o, ℶ_ a :=
isNormal_beth.apply_of_isSuccLimit ho | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat",
"Mathlib.SetTheory.Ordinal.Enum"
] | Mathlib/SetTheory/Cardinal/Aleph.lean | beth_limit | null |
aleph_le_beth (o : Ordinal) : ℵ_ o ≤ ℶ_ o :=
preAleph_le_preBeth _ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat",
"Mathlib.SetTheory.Ordinal.Enum"
] | Mathlib/SetTheory/Cardinal/Aleph.lean | aleph_le_beth | null |
aleph0_le_beth (o : Ordinal) : ℵ₀ ≤ ℶ_ o :=
(aleph0_le_aleph o).trans <| aleph_le_beth o | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat",
"Mathlib.SetTheory.Ordinal.Enum"
] | Mathlib/SetTheory/Cardinal/Aleph.lean | aleph0_le_beth | null |
beth_pos (o : Ordinal) : 0 < ℶ_ o :=
aleph0_pos.trans_le <| aleph0_le_beth o | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat",
"Mathlib.SetTheory.Ordinal.Enum"
] | Mathlib/SetTheory/Cardinal/Aleph.lean | beth_pos | null |
beth_ne_zero (o : Ordinal) : ℶ_ o ≠ 0 :=
(beth_pos o).ne' | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat",
"Mathlib.SetTheory.Ordinal.Enum"
] | Mathlib/SetTheory/Cardinal/Aleph.lean | beth_ne_zero | null |
isStrongLimit_beth {o : Ordinal} : IsStrongLimit (ℶ_ o) ↔ IsSuccPrelimit o := by
rw [beth_eq_preBeth, isStrongLimit_preBeth, isSuccLimit_add_iff_of_isSuccLimit isSuccLimit_omega0] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.ToNat",
"Mathlib.SetTheory.Cardinal.ENat",
"Mathlib.SetTheory.Ordinal.Enum"
] | Mathlib/SetTheory/Cardinal/Aleph.lean | isStrongLimit_beth | null |
mul_eq_self {c : Cardinal} (h : ℵ₀ ≤ c) : c * c = c := by
refine le_antisymm ?_ (by simpa only [mul_one] using mul_le_mul_left' (one_le_aleph0.trans h) c)
refine Acc.recOn (Cardinal.lt_wf.apply c) (fun c _ => Cardinal.inductionOn c fun α IH ol => ?_) h
rcases ord_eq α with ⟨r, wo, e⟩
classical
letI := linearOrderOfSTO r
haveI : IsWellOrder α (· < ·) := wo
let g : α × α → α := fun p => max p.1 p.2
let f : α × α ↪ Ordinal × α × α :=
⟨fun p : α × α => (typein (· < ·) (g p), p), fun p q => congr_arg Prod.snd⟩
let s := f ⁻¹'o Prod.Lex (· < ·) (Prod.Lex (· < ·) (· < ·))
haveI : IsWellOrder _ s := (RelEmbedding.preimage _ _).isWellOrder
/- it suffices to show that this well order is smaller than `r`
if it were larger, then `r` would be a strict prefix of `s`. It would be contained in
`β × β` for some `β` of cardinality `< c`. By the inductive assumption, this set has the
same cardinality as `β` (or it is finite if `β` is finite), so it is `< c`, which is a
contradiction. -/
suffices type s ≤ type r by exact card_le_card this
refine le_of_forall_lt fun o h => ?_
rcases typein_surj s h with ⟨p, rfl⟩
rw [← e, lt_ord]
refine lt_of_le_of_lt
(?_ : _ ≤ card (succ (typein (· < ·) (g p))) * card (succ (typein (· < ·) (g p)))) ?_
· have : { q | s q p } ⊆ insert (g p) { x | x < g p } ×ˢ insert (g p) { x | x < g p } := by
intro q h
simp only [s, f, Preimage, Embedding.coeFn_mk, Prod.lex_def, typein_lt_typein,
typein_inj, mem_setOf_eq] at h
exact max_le_iff.1 (le_iff_lt_or_eq.2 <| h.imp_right And.left)
suffices H : (insert (g p) { x | r x (g p) } : Set α) ≃ { x | r x (g p) } ⊕ PUnit from
⟨(Set.embeddingOfSubset _ _ this).trans
((Equiv.Set.prod _ _).trans (H.prodCongr H)).toEmbedding⟩
refine (Equiv.Set.insert ?_).trans ((Equiv.refl _).sumCongr punitEquivPUnit)
apply @irrefl _ r
rcases lt_or_ge (card (succ (typein (· < ·) (g p)))) ℵ₀ with qo | qo
· exact (mul_lt_aleph0 qo qo).trans_le ol
· suffices (succ (typein LT.lt (g p))).card < #α from (IH _ this qo).trans_lt this
rw [← lt_ord]
apply (isSuccLimit_ord ol).succ_lt
rw [e]
apply typein_lt_type | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mul_eq_self | If `α` is an infinite type, then `α × α` and `α` have the same cardinality. |
mul_eq_max {a b : Cardinal} (ha : ℵ₀ ≤ a) (hb : ℵ₀ ≤ b) : a * b = max a b :=
le_antisymm
(mul_eq_self (ha.trans (le_max_left a b)) ▸
mul_le_mul' (le_max_left _ _) (le_max_right _ _)) <|
max_le (by simpa only [mul_one] using mul_le_mul_left' (one_le_aleph0.trans hb) a)
(by simpa only [one_mul] using mul_le_mul_right' (one_le_aleph0.trans ha) b)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mul_eq_max | If `α` and `β` are infinite types, then the cardinality of `α × β` is the maximum
of the cardinalities of `α` and `β`. |
mul_mk_eq_max {α β : Type u} [Infinite α] [Infinite β] : #α * #β = max #α #β :=
mul_eq_max (aleph0_le_mk α) (aleph0_le_mk β)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mul_mk_eq_max | null |
aleph_mul_aleph (o₁ o₂ : Ordinal) : ℵ_ o₁ * ℵ_ o₂ = ℵ_ (max o₁ o₂) := by
rw [Cardinal.mul_eq_max (aleph0_le_aleph o₁) (aleph0_le_aleph o₂), aleph_max]
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | aleph_mul_aleph | null |
aleph0_mul_eq {a : Cardinal} (ha : ℵ₀ ≤ a) : ℵ₀ * a = a :=
(mul_eq_max le_rfl ha).trans (max_eq_right ha)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | aleph0_mul_eq | null |
mul_aleph0_eq {a : Cardinal} (ha : ℵ₀ ≤ a) : a * ℵ₀ = a :=
(mul_eq_max ha le_rfl).trans (max_eq_left ha) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mul_aleph0_eq | null |
aleph0_mul_mk_eq {α : Type*} [Infinite α] : ℵ₀ * #α = #α :=
aleph0_mul_eq (aleph0_le_mk α) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | aleph0_mul_mk_eq | null |
mk_mul_aleph0_eq {α : Type*} [Infinite α] : #α * ℵ₀ = #α :=
mul_aleph0_eq (aleph0_le_mk α)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_mul_aleph0_eq | null |
aleph0_mul_aleph (o : Ordinal) : ℵ₀ * ℵ_ o = ℵ_ o :=
aleph0_mul_eq (aleph0_le_aleph o)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | aleph0_mul_aleph | null |
aleph_mul_aleph0 (o : Ordinal) : ℵ_ o * ℵ₀ = ℵ_ o :=
mul_aleph0_eq (aleph0_le_aleph o) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | aleph_mul_aleph0 | null |
mul_lt_of_lt {a b c : Cardinal} (hc : ℵ₀ ≤ c) (h1 : a < c) (h2 : b < c) : a * b < c :=
(mul_le_mul' (le_max_left a b) (le_max_right a b)).trans_lt <|
(lt_or_ge (max a b) ℵ₀).elim (fun h => (mul_lt_aleph0 h h).trans_le hc) fun h => by
rw [mul_eq_self h]
exact max_lt h1 h2 | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mul_lt_of_lt | null |
mul_le_max_of_aleph0_le_left {a b : Cardinal} (h : ℵ₀ ≤ a) : a * b ≤ max a b := by
convert mul_le_mul' (le_max_left a b) (le_max_right a b) using 1
rw [mul_eq_self]
exact h.trans (le_max_left a b) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mul_le_max_of_aleph0_le_left | null |
mul_eq_max_of_aleph0_le_left {a b : Cardinal} (h : ℵ₀ ≤ a) (h' : b ≠ 0) :
a * b = max a b := by
rcases le_or_gt ℵ₀ b with hb | hb
· exact mul_eq_max h hb
refine (mul_le_max_of_aleph0_le_left h).antisymm ?_
have : b ≤ a := hb.le.trans h
rw [max_eq_left this]
convert mul_le_mul_left' (one_le_iff_ne_zero.mpr h') a
rw [mul_one] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mul_eq_max_of_aleph0_le_left | null |
mul_le_max_of_aleph0_le_right {a b : Cardinal} (h : ℵ₀ ≤ b) : a * b ≤ max a b := by
simpa only [mul_comm b, max_comm b] using mul_le_max_of_aleph0_le_left h | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mul_le_max_of_aleph0_le_right | null |
mul_eq_max_of_aleph0_le_right {a b : Cardinal} (h' : a ≠ 0) (h : ℵ₀ ≤ b) :
a * b = max a b := by
rw [mul_comm, max_comm]
exact mul_eq_max_of_aleph0_le_left h h' | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mul_eq_max_of_aleph0_le_right | null |
mul_eq_max' {a b : Cardinal} (h : ℵ₀ ≤ a * b) : a * b = max a b := by
rcases aleph0_le_mul_iff.mp h with ⟨ha, hb, ha' | hb'⟩
· exact mul_eq_max_of_aleph0_le_left ha' hb
· exact mul_eq_max_of_aleph0_le_right ha hb' | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mul_eq_max' | null |
mul_le_max (a b : Cardinal) : a * b ≤ max (max a b) ℵ₀ := by
rcases eq_or_ne a 0 with (rfl | ha0); · simp
rcases eq_or_ne b 0 with (rfl | hb0); · simp
rcases le_or_gt ℵ₀ a with ha | ha
· rw [mul_eq_max_of_aleph0_le_left ha hb0]
exact le_max_left _ _
· rcases le_or_gt ℵ₀ b with hb | hb
· rw [mul_comm, mul_eq_max_of_aleph0_le_left hb ha0, max_comm]
exact le_max_left _ _
· exact le_max_of_le_right (mul_lt_aleph0 ha hb).le | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mul_le_max | null |
mul_eq_left {a b : Cardinal} (ha : ℵ₀ ≤ a) (hb : b ≤ a) (hb' : b ≠ 0) : a * b = a := by
rw [mul_eq_max_of_aleph0_le_left ha hb', max_eq_left hb] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mul_eq_left | null |
mul_eq_right {a b : Cardinal} (hb : ℵ₀ ≤ b) (ha : a ≤ b) (ha' : a ≠ 0) : a * b = b := by
rw [mul_comm, mul_eq_left hb ha ha'] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mul_eq_right | null |
le_mul_left {a b : Cardinal} (h : b ≠ 0) : a ≤ b * a := by
convert mul_le_mul_right' (one_le_iff_ne_zero.mpr h) a
rw [one_mul] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | le_mul_left | null |
le_mul_right {a b : Cardinal} (h : b ≠ 0) : a ≤ a * b := by
rw [mul_comm]
exact le_mul_left h | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | le_mul_right | null |
mul_eq_left_iff {a b : Cardinal} : a * b = a ↔ max ℵ₀ b ≤ a ∧ b ≠ 0 ∨ b = 1 ∨ a = 0 := by
rw [max_le_iff]
refine ⟨fun h => ?_, ?_⟩
· rcases le_or_gt ℵ₀ a with ha | ha
· have : a ≠ 0 := by
rintro rfl
exact ha.not_gt aleph0_pos
left
rw [and_assoc]
use ha
constructor
· rw [← not_lt]
exact fun hb => ne_of_gt (hb.trans_le (le_mul_left this)) h
· rintro rfl
apply this
rw [mul_zero] at h
exact h.symm
right
by_cases h2a : a = 0
· exact Or.inr h2a
have hb : b ≠ 0 := by
rintro rfl
apply h2a
rw [mul_zero] at h
exact h.symm
left
rw [← h, mul_lt_aleph0_iff, lt_aleph0, lt_aleph0] at ha
rcases ha with (rfl | rfl | ⟨⟨n, rfl⟩, ⟨m, rfl⟩⟩)
· contradiction
· contradiction
rw [← Ne] at h2a
rw [← one_le_iff_ne_zero] at h2a hb
norm_cast at h2a hb h ⊢
apply le_antisymm _ hb
rw [← not_lt]
apply fun h2b => ne_of_gt _ h
conv_rhs => left; rw [← mul_one n]
rw [Nat.mul_lt_mul_left]
· exact id
apply Nat.lt_of_succ_le h2a
· rintro (⟨⟨ha, hab⟩, hb⟩ | rfl | rfl)
· rw [mul_eq_max_of_aleph0_le_left ha hb, max_eq_left hab]
all_goals simp | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mul_eq_left_iff | null |
add_eq_self {c : Cardinal} (h : ℵ₀ ≤ c) : c + c = c :=
le_antisymm
(by
convert mul_le_mul_right' ((nat_lt_aleph0 2).le.trans h) c using 1
<;> simp [two_mul, mul_eq_self h])
(self_le_add_left c c) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_eq_self | If `α` is an infinite type, then `α ⊕ α` and `α` have the same cardinality. |
add_eq_max {a b : Cardinal} (ha : ℵ₀ ≤ a) : a + b = max a b :=
le_antisymm
(add_eq_self (ha.trans (le_max_left a b)) ▸
add_le_add (le_max_left _ _) (le_max_right _ _)) <|
max_le (self_le_add_right _ _) (self_le_add_left _ _) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_eq_max | If `α` is an infinite type, then the cardinality of `α ⊕ β` is the maximum
of the cardinalities of `α` and `β`. |
add_eq_max' {a b : Cardinal} (ha : ℵ₀ ≤ b) : a + b = max a b := by
rw [add_comm, max_comm, add_eq_max ha]
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_eq_max' | null |
add_mk_eq_max {α β : Type u} [Infinite α] : #α + #β = max #α #β :=
add_eq_max (aleph0_le_mk α)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_mk_eq_max | null |
add_mk_eq_max' {α β : Type u} [Infinite β] : #α + #β = max #α #β :=
add_eq_max' (aleph0_le_mk β) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_mk_eq_max' | null |
add_mk_eq_self {α : Type*} [Infinite α] : #α + #α = #α := by
simp | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_mk_eq_self | null |
add_le_max (a b : Cardinal) : a + b ≤ max (max a b) ℵ₀ := by
rcases le_or_gt ℵ₀ a with ha | ha
· rw [add_eq_max ha]
exact le_max_left _ _
· rcases le_or_gt ℵ₀ b with hb | hb
· rw [add_comm, add_eq_max hb, max_comm]
exact le_max_left _ _
· exact le_max_of_le_right (add_lt_aleph0 ha hb).le | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_le_max | null |
add_le_of_le {a b c : Cardinal} (hc : ℵ₀ ≤ c) (h1 : a ≤ c) (h2 : b ≤ c) : a + b ≤ c :=
(add_le_add h1 h2).trans <| le_of_eq <| add_eq_self hc | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_le_of_le | null |
add_lt_of_lt {a b c : Cardinal} (hc : ℵ₀ ≤ c) (h1 : a < c) (h2 : b < c) : a + b < c :=
(add_le_add (le_max_left a b) (le_max_right a b)).trans_lt <|
(lt_or_ge (max a b) ℵ₀).elim (fun h => (add_lt_aleph0 h h).trans_le hc) fun h => by
rw [add_eq_self h]; exact max_lt h1 h2 | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_lt_of_lt | null |
eq_of_add_eq_of_aleph0_le {a b c : Cardinal} (h : a + b = c) (ha : a < c) (hc : ℵ₀ ≤ c) :
b = c := by
apply le_antisymm
· rw [← h]
apply self_le_add_left
rw [← not_lt]; intro hb
have : a + b < c := add_lt_of_lt hc ha hb
simp [h] at this | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | eq_of_add_eq_of_aleph0_le | null |
add_eq_left {a b : Cardinal} (ha : ℵ₀ ≤ a) (hb : b ≤ a) : a + b = a := by
rw [add_eq_max ha, max_eq_left hb] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_eq_left | null |
add_eq_right {a b : Cardinal} (hb : ℵ₀ ≤ b) (ha : a ≤ b) : a + b = b := by
rw [add_comm, add_eq_left hb ha] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_eq_right | null |
add_eq_left_iff {a b : Cardinal} : a + b = a ↔ max ℵ₀ b ≤ a ∨ b = 0 := by
rw [max_le_iff]
refine ⟨fun h => ?_, ?_⟩
· rcases le_or_gt ℵ₀ a with ha | ha
· left
use ha
rw [← not_lt]
apply fun hb => ne_of_gt _ h
intro hb
exact hb.trans_le (self_le_add_left b a)
right
rw [← h, add_lt_aleph0_iff, lt_aleph0, lt_aleph0] at ha
rcases ha with ⟨⟨n, rfl⟩, ⟨m, rfl⟩⟩
norm_cast at h ⊢
rw [← add_right_inj, h, add_zero]
· rintro (⟨h1, h2⟩ | h3)
· rw [add_eq_max h1, max_eq_left h2]
· rw [h3, add_zero] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_eq_left_iff | null |
add_eq_right_iff {a b : Cardinal} : a + b = b ↔ max ℵ₀ a ≤ b ∨ a = 0 := by
rw [add_comm, add_eq_left_iff] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_eq_right_iff | null |
add_nat_eq {a : Cardinal} (n : ℕ) (ha : ℵ₀ ≤ a) : a + n = a :=
add_eq_left ha ((nat_lt_aleph0 _).le.trans ha) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_nat_eq | null |
nat_add_eq {a : Cardinal} (n : ℕ) (ha : ℵ₀ ≤ a) : n + a = a := by
rw [add_comm, add_nat_eq n ha] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | nat_add_eq | null |
add_one_eq {a : Cardinal} (ha : ℵ₀ ≤ a) : a + 1 = a :=
add_one_of_aleph0_le ha | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_one_eq | null |
mk_add_one_eq {α : Type*} [Infinite α] : #α + 1 = #α :=
add_one_eq (aleph0_le_mk α) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_add_one_eq | null |
protected eq_of_add_eq_add_left {a b c : Cardinal} (h : a + b = a + c) (ha : a < ℵ₀) :
b = c := by
rcases le_or_gt ℵ₀ b with hb | hb
· have : a < b := ha.trans_le hb
rw [add_eq_right hb this.le, eq_comm] at h
rw [eq_of_add_eq_of_aleph0_le h this hb]
· have hc : c < ℵ₀ := by
rw [← not_le]
intro hc
apply lt_irrefl ℵ₀
apply (hc.trans (self_le_add_left _ a)).trans_lt
rw [← h]
apply add_lt_aleph0 ha hb
rw [lt_aleph0] at *
rcases ha with ⟨n, rfl⟩
rcases hb with ⟨m, rfl⟩
rcases hc with ⟨k, rfl⟩
norm_cast at h ⊢
apply add_left_cancel h | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | eq_of_add_eq_add_left | null |
protected eq_of_add_eq_add_right {a b c : Cardinal} (h : a + b = c + b) (hb : b < ℵ₀) :
a = c := by
rw [add_comm a b, add_comm c b] at h
exact Cardinal.eq_of_add_eq_add_left h hb | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | eq_of_add_eq_add_right | null |
protected ciSup_add (hf : BddAbove (range f)) (c : Cardinal.{v}) :
(⨆ i, f i) + c = ⨆ i, f i + c := by
have : ∀ i, f i + c ≤ (⨆ i, f i) + c := fun i ↦ add_le_add_right (le_ciSup hf i) c
refine le_antisymm ?_ (ciSup_le' this)
have bdd : BddAbove (range (f · + c)) := ⟨_, forall_mem_range.mpr this⟩
obtain hs | hs := lt_or_ge (⨆ i, f i) ℵ₀
· obtain ⟨i, hi⟩ := exists_eq_of_iSup_eq_of_not_isSuccLimit
f hf (not_isSuccLimit_of_lt_aleph0 hs) rfl
exact hi ▸ le_ciSup bdd i
rw [add_eq_max hs, max_le_iff]
exact ⟨ciSup_mono bdd fun i ↦ self_le_add_right _ c,
(self_le_add_left _ _).trans (le_ciSup bdd <| Classical.arbitrary ι)⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | ciSup_add | null |
protected add_ciSup (hf : BddAbove (range f)) (c : Cardinal.{v}) :
c + (⨆ i, f i) = ⨆ i, c + f i := by
rw [add_comm, Cardinal.ciSup_add f hf]; simp_rw [add_comm] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_ciSup | null |
protected ciSup_add_ciSup (hf : BddAbove (range f)) (g : ι' → Cardinal.{v})
(hg : BddAbove (range g)) :
(⨆ i, f i) + (⨆ j, g j) = ⨆ (i) (j), f i + g j := by
simp_rw [Cardinal.ciSup_add f hf, Cardinal.add_ciSup g hg] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | ciSup_add_ciSup | null |
protected ciSup_mul (c : Cardinal.{v}) : (⨆ i, f i) * c = ⨆ i, f i * c := by
cases isEmpty_or_nonempty ι; · simp
obtain rfl | h0 := eq_or_ne c 0; · simp
by_cases hf : BddAbove (range f); swap
· have hfc : ¬ BddAbove (range (f · * c)) := fun bdd ↦ hf
⟨⨆ i, f i * c, forall_mem_range.mpr fun i ↦ (le_mul_right h0).trans (le_ciSup bdd i)⟩
simp [iSup, csSup_of_not_bddAbove, hf, hfc]
have : ∀ i, f i * c ≤ (⨆ i, f i) * c := fun i ↦ mul_le_mul_right' (le_ciSup hf i) c
refine le_antisymm ?_ (ciSup_le' this)
have bdd : BddAbove (range (f · * c)) := ⟨_, forall_mem_range.mpr this⟩
obtain hs | hs := lt_or_ge (⨆ i, f i) ℵ₀
· obtain ⟨i, hi⟩ := exists_eq_of_iSup_eq_of_not_isSuccLimit
f hf (not_isSuccLimit_of_lt_aleph0 hs) rfl
exact hi ▸ le_ciSup bdd i
rw [mul_eq_max_of_aleph0_le_left hs h0, max_le_iff]
obtain ⟨i, hi⟩ := exists_lt_of_lt_ciSup' (one_lt_aleph0.trans_le hs)
exact ⟨ciSup_mono bdd fun i ↦ le_mul_right h0,
(le_mul_left (zero_lt_one.trans hi).ne').trans (le_ciSup bdd i)⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | ciSup_mul | null |
protected mul_ciSup (c : Cardinal.{v}) : c * (⨆ i, f i) = ⨆ i, c * f i := by
rw [mul_comm, Cardinal.ciSup_mul f]; simp_rw [mul_comm] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mul_ciSup | null |
protected ciSup_mul_ciSup (g : ι' → Cardinal.{v}) :
(⨆ i, f i) * (⨆ j, g j) = ⨆ (i) (j), f i * g j := by
simp_rw [Cardinal.ciSup_mul f, Cardinal.mul_ciSup g] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | ciSup_mul_ciSup | null |
sum_eq_iSup_lift {f : ι → Cardinal.{max u v}} (hι : ℵ₀ ≤ #ι)
(h : lift.{v} #ι ≤ iSup f) : sum f = iSup f := by
apply (iSup_le_sum f).antisymm'
convert sum_le_iSup_lift f
rw [mul_eq_max (aleph0_le_lift.mpr hι) ((aleph0_le_lift.mpr hι).trans h), max_eq_right h] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | sum_eq_iSup_lift | null |
sum_eq_iSup {f : ι → Cardinal.{u}} (hι : ℵ₀ ≤ #ι) (h : #ι ≤ iSup f) : sum f = iSup f :=
sum_eq_iSup_lift hι ((lift_id #ι).symm ▸ h) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | sum_eq_iSup | null |
@[simp]
aleph_add_aleph (o₁ o₂ : Ordinal) : ℵ_ o₁ + ℵ_ o₂ = ℵ_ (max o₁ o₂) := by
rw [Cardinal.add_eq_max (aleph0_le_aleph o₁), aleph_max] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | aleph_add_aleph | null |
add_right_inj_of_lt_aleph0 {α β γ : Cardinal} (γ₀ : γ < aleph0) : α + γ = β + γ ↔ α = β :=
⟨fun h => Cardinal.eq_of_add_eq_add_right h γ₀, fun h => congr_arg (· + γ) h⟩
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_right_inj_of_lt_aleph0 | null |
add_nat_inj {α β : Cardinal} (n : ℕ) : α + n = β + n ↔ α = β :=
add_right_inj_of_lt_aleph0 (nat_lt_aleph0 _)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_nat_inj | null |
add_one_inj {α β : Cardinal} : α + 1 = β + 1 ↔ α = β :=
add_right_inj_of_lt_aleph0 one_lt_aleph0 | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_one_inj | null |
add_le_add_iff_of_lt_aleph0 {α β γ : Cardinal} (γ₀ : γ < ℵ₀) :
α + γ ≤ β + γ ↔ α ≤ β := by
refine ⟨fun h => ?_, fun h => add_le_add_right h γ⟩
contrapose h
rw [not_le, lt_iff_le_and_ne, Ne] at h ⊢
exact ⟨add_le_add_right h.1 γ, mt (add_right_inj_of_lt_aleph0 γ₀).1 h.2⟩
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_le_add_iff_of_lt_aleph0 | null |
add_nat_le_add_nat_iff {α β : Cardinal} (n : ℕ) : α + n ≤ β + n ↔ α ≤ β :=
add_le_add_iff_of_lt_aleph0 (nat_lt_aleph0 n)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_nat_le_add_nat_iff | null |
add_one_le_add_one_iff {α β : Cardinal} : α + 1 ≤ β + 1 ↔ α ≤ β :=
add_le_add_iff_of_lt_aleph0 one_lt_aleph0 | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | add_one_le_add_one_iff | null |
pow_le {κ μ : Cardinal.{u}} (H1 : ℵ₀ ≤ κ) (H2 : μ < ℵ₀) : κ ^ μ ≤ κ :=
let ⟨n, H3⟩ := lt_aleph0.1 H2
H3.symm ▸
Quotient.inductionOn κ
(fun α H1 =>
Nat.recOn n
(lt_of_lt_of_le
(by
rw [Nat.cast_zero, power_zero]
exact one_lt_aleph0)
H1).le
fun n ih =>
le_of_le_of_eq
(by
rw [Nat.cast_succ, power_add, power_one]
exact mul_le_mul_right' ih _)
(mul_eq_self H1))
H1 | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | pow_le | null |
pow_eq {κ μ : Cardinal.{u}} (H1 : ℵ₀ ≤ κ) (H2 : 1 ≤ μ) (H3 : μ < ℵ₀) : κ ^ μ = κ :=
(pow_le H1 H3).antisymm <| self_le_power κ H2 | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | pow_eq | null |
power_self_eq {c : Cardinal} (h : ℵ₀ ≤ c) : c ^ c = 2 ^ c := by
apply ((power_le_power_right <| (cantor c).le).trans _).antisymm
· exact power_le_power_right ((nat_lt_aleph0 2).le.trans h)
· rw [← power_mul, mul_eq_self h] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | power_self_eq | null |
prod_eq_two_power {ι : Type u} [Infinite ι] {c : ι → Cardinal.{v}} (h₁ : ∀ i, 2 ≤ c i)
(h₂ : ∀ i, lift.{u} (c i) ≤ lift.{v} #ι) : prod c = 2 ^ lift.{v} #ι := by
rw [← lift_id'.{u, v} (prod.{u, v} c), lift_prod, ← lift_two_power]
apply le_antisymm
· refine (prod_le_prod _ _ h₂).trans_eq ?_
rw [prod_const, lift_lift, ← lift_power, power_self_eq (aleph0_le_mk ι), lift_umax.{u, v}]
· rw [← prod_const', lift_prod]
refine prod_le_prod _ _ fun i => ?_
rw [lift_two, ← lift_two.{u, v}, lift_le]
exact h₁ i | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | prod_eq_two_power | null |
power_eq_two_power {c₁ c₂ : Cardinal} (h₁ : ℵ₀ ≤ c₁) (h₂ : 2 ≤ c₂) (h₂' : c₂ ≤ c₁) :
c₂ ^ c₁ = 2 ^ c₁ :=
le_antisymm (power_self_eq h₁ ▸ power_le_power_right h₂') (power_le_power_right h₂) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | power_eq_two_power | null |
nat_power_eq {c : Cardinal.{u}} (h : ℵ₀ ≤ c) {n : ℕ} (hn : 2 ≤ n) :
(n : Cardinal.{u}) ^ c = 2 ^ c :=
power_eq_two_power h (by assumption_mod_cast) ((nat_lt_aleph0 n).le.trans h) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | nat_power_eq | null |
power_nat_le {c : Cardinal.{u}} {n : ℕ} (h : ℵ₀ ≤ c) : c ^ n ≤ c :=
pow_le h (nat_lt_aleph0 n) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | power_nat_le | null |
power_nat_eq {c : Cardinal.{u}} {n : ℕ} (h1 : ℵ₀ ≤ c) (h2 : 1 ≤ n) : c ^ n = c :=
pow_eq h1 (mod_cast h2) (nat_lt_aleph0 n) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | power_nat_eq | null |
power_nat_le_max {c : Cardinal.{u}} {n : ℕ} : c ^ (n : Cardinal.{u}) ≤ max c ℵ₀ := by
rcases le_or_gt ℵ₀ c with hc | hc
· exact le_max_of_le_left (power_nat_le hc)
· exact le_max_of_le_right (power_lt_aleph0 hc (nat_lt_aleph0 _)).le | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | power_nat_le_max | null |
power_le_aleph0 {a b : Cardinal.{u}} (ha : a ≤ ℵ₀) (hb : b < ℵ₀) : a ^ b ≤ ℵ₀ := by
lift b to ℕ using hb; simpa [ha] using power_nat_le_max (c := a) | lemma | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | power_le_aleph0 | null |
powerlt_aleph0 {c : Cardinal} (h : ℵ₀ ≤ c) : c ^< ℵ₀ = c := by
apply le_antisymm
· rw [powerlt_le]
intro c'
rw [lt_aleph0]
rintro ⟨n, rfl⟩
apply power_nat_le h
convert le_powerlt c one_lt_aleph0; rw [power_one] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | powerlt_aleph0 | null |
powerlt_aleph0_le (c : Cardinal) : c ^< ℵ₀ ≤ max c ℵ₀ := by
rcases le_or_gt ℵ₀ c with h | h
· rw [powerlt_aleph0 h]
apply le_max_left
rw [powerlt_le]
exact fun c' hc' => (power_lt_aleph0 h hc').le.trans (le_max_right _ _) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | powerlt_aleph0_le | null |
mk_equiv_eq_zero_iff_lift_ne : #(α ≃ β') = 0 ↔ lift.{v} #α ≠ lift.{u} #β' := by
rw [mk_eq_zero_iff, ← not_nonempty_iff, ← lift_mk_eq'] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_equiv_eq_zero_iff_lift_ne | null |
mk_equiv_eq_zero_iff_ne : #(α ≃ β) = 0 ↔ #α ≠ #β := by
rw [mk_equiv_eq_zero_iff_lift_ne, lift_id, lift_id] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_equiv_eq_zero_iff_ne | null |
mk_equiv_comm : #(α ≃ β') = #(β' ≃ α) :=
(ofBijective _ symm_bijective).cardinal_eq | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_equiv_comm | This lemma makes lemmas assuming `Infinite α` applicable to the situation where we have
`Infinite β` instead. |
mk_embedding_eq_zero_iff_lift_lt : #(α ↪ β') = 0 ↔ lift.{u} #β' < lift.{v} #α := by
rw [mk_eq_zero_iff, ← not_nonempty_iff, ← lift_mk_le', not_le] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_embedding_eq_zero_iff_lift_lt | null |
mk_embedding_eq_zero_iff_lt : #(α ↪ β) = 0 ↔ #β < #α := by
rw [mk_embedding_eq_zero_iff_lift_lt, lift_lt] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_embedding_eq_zero_iff_lt | null |
mk_arrow_eq_zero_iff : #(α → β') = 0 ↔ #α ≠ 0 ∧ #β' = 0 := by
simp_rw [mk_eq_zero_iff, mk_ne_zero_iff, isEmpty_fun] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_arrow_eq_zero_iff | null |
mk_surjective_eq_zero_iff_lift :
#{f : α → β' | Surjective f} = 0 ↔ lift.{v} #α < lift.{u} #β' ∨ (#α ≠ 0 ∧ #β' = 0) := by
rw [← not_iff_not, not_or, not_lt, lift_mk_le', ← Ne, not_and_or, not_ne_iff, and_comm]
simp_rw [mk_ne_zero_iff, mk_eq_zero_iff, nonempty_coe_sort,
Set.Nonempty, mem_setOf, exists_surjective_iff, nonempty_fun] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_surjective_eq_zero_iff_lift | null |
mk_surjective_eq_zero_iff :
#{f : α → β | Surjective f} = 0 ↔ #α < #β ∨ (#α ≠ 0 ∧ #β = 0) := by
rw [mk_surjective_eq_zero_iff_lift, lift_lt]
variable (α β') | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_surjective_eq_zero_iff | null |
mk_equiv_le_embedding : #(α ≃ β') ≤ #(α ↪ β') := ⟨⟨_, Equiv.toEmbedding_injective⟩⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_equiv_le_embedding | null |
mk_embedding_le_arrow : #(α ↪ β') ≤ #(α → β') := ⟨⟨_, DFunLike.coe_injective⟩⟩
variable [Infinite α] {α β'} | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_embedding_le_arrow | null |
mk_perm_eq_self_power : #(Equiv.Perm α) = #α ^ #α :=
((mk_equiv_le_embedding α α).trans (mk_embedding_le_arrow α α)).antisymm <| by
suffices Nonempty ((α → Bool) ↪ Equiv.Perm (α × Bool)) by
obtain ⟨e⟩ : Nonempty (α ≃ α × Bool) := by
erw [← Cardinal.eq, mk_prod, lift_uzero, mk_bool,
lift_natCast, mul_two, add_eq_self (aleph0_le_mk α)]
erw [← le_def, mk_arrow, lift_uzero, mk_bool, lift_natCast 2] at this
rwa [← power_def, power_self_eq (aleph0_le_mk α), e.permCongr.cardinal_eq]
refine ⟨⟨fun f ↦ Involutive.toPerm (fun x ↦ ⟨x.1, xor (f x.1) x.2⟩) fun x ↦ ?_, fun f g h ↦ ?_⟩⟩
· simp_rw [← Bool.xor_assoc, Bool.xor_self, Bool.false_xor]
· ext a; rw [← (f a).xor_false, ← (g a).xor_false]; exact congr(($h ⟨a, false⟩).2) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_perm_eq_self_power | null |
mk_perm_eq_two_power : #(Equiv.Perm α) = 2 ^ #α := by
rw [mk_perm_eq_self_power, power_self_eq (aleph0_le_mk α)] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_perm_eq_two_power | null |
mk_equiv_eq_arrow_of_lift_eq (leq : lift.{v} #α = lift.{u} #β') :
#(α ≃ β') = #(α → β') := by
obtain ⟨e⟩ := lift_mk_eq'.mp leq
have e₁ := lift_mk_eq'.mpr ⟨.equivCongr (.refl α) e⟩
have e₂ := lift_mk_eq'.mpr ⟨.arrowCongr (.refl α) e⟩
rw [lift_id'.{u,v}] at e₁ e₂
rw [← e₁, ← e₂, lift_inj, mk_perm_eq_self_power, power_def] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_equiv_eq_arrow_of_lift_eq | null |
mk_equiv_eq_arrow_of_eq (eq : #α = #β) : #(α ≃ β) = #(α → β) :=
mk_equiv_eq_arrow_of_lift_eq congr(lift $eq) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_equiv_eq_arrow_of_eq | null |
mk_equiv_of_lift_eq (leq : lift.{v} #α = lift.{u} #β') : #(α ≃ β') = 2 ^ lift.{v} #α := by
erw [← (lift_mk_eq'.2 ⟨.equivCongr (.refl α) (lift_mk_eq'.1 leq).some⟩).trans (lift_id'.{u,v} _),
lift_umax.{u,v}, mk_perm_eq_two_power, lift_power, lift_natCast]; rfl | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_equiv_of_lift_eq | null |
mk_equiv_of_eq (eq : #α = #β) : #(α ≃ β) = 2 ^ #α := by
rw [mk_equiv_of_lift_eq (lift_inj.mpr eq), lift_id] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_equiv_of_eq | null |
mk_embedding_eq_arrow_of_lift_le (lle : lift.{u} #β' ≤ lift.{v} #α) :
#(β' ↪ α) = #(β' → α) :=
(mk_embedding_le_arrow _ _).antisymm <| by
conv_rhs => rw [← (Equiv.embeddingCongr (.refl _)
(Cardinal.eq.mp <| mul_eq_self <| aleph0_le_mk α).some).cardinal_eq]
obtain ⟨e⟩ := lift_mk_le'.mp lle
exact ⟨⟨fun f ↦ ⟨fun b ↦ ⟨e b, f b⟩, fun _ _ h ↦ e.injective congr(Prod.fst $h)⟩,
fun f g h ↦ funext fun b ↦ congr(Prod.snd <| $h b)⟩⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_embedding_eq_arrow_of_lift_le | null |
mk_embedding_eq_arrow_of_le (le : #β ≤ #α) : #(β ↪ α) = #(β → α) :=
mk_embedding_eq_arrow_of_lift_le (lift_le.mpr le) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_embedding_eq_arrow_of_le | null |
mk_surjective_eq_arrow_of_lift_le (lle : lift.{u} #β' ≤ lift.{v} #α) :
#{f : α → β' | Surjective f} = #(α → β') :=
(mk_set_le _).antisymm <|
have ⟨e⟩ : Nonempty (α ≃ α ⊕ β') := by
simp_rw [← lift_mk_eq', mk_sum, lift_add, lift_lift]; rw [lift_umax.{u,v}, eq_comm]
exact add_eq_left (aleph0_le_lift.mpr <| aleph0_le_mk α) lle
⟨⟨fun f ↦ ⟨fun a ↦ (e a).elim f id, fun b ↦ ⟨e.symm (.inr b), congr_arg _ (e.right_inv _)⟩⟩,
fun f g h ↦ funext fun a ↦ by
simpa only [e.apply_symm_apply] using congr_fun (Subtype.ext_iff.mp h) (e.symm <| .inl a)⟩⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Aleph"
] | Mathlib/SetTheory/Cardinal/Arithmetic.lean | mk_surjective_eq_arrow_of_lift_le | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.