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_Prop : #Prop = 2 := by simp | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | mk_Prop | null |
power_mul {a b c : Cardinal} : a ^ (b * c) = (a ^ b) ^ c := by
rw [mul_comm b c]
exact inductionOn₃ a b c fun α β γ => mk_congr <| Equiv.curry γ β α
@[simp, norm_cast] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | power_mul | null |
power_natCast (a : Cardinal.{u}) (n : ℕ) : a ^ (↑n : Cardinal.{u}) = a ^ n :=
rfl
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | power_natCast | null |
lift_eq_one {a : Cardinal.{v}} : lift.{u} a = 1 ↔ a = 1 :=
lift_injective.eq_iff' lift_one
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_eq_one | null |
lift_mul (a b : Cardinal.{u}) : lift.{v} (a * b) = lift.{v} a * lift.{v} b :=
inductionOn₂ a b fun _ _ =>
mk_congr <| Equiv.ulift.trans (Equiv.prodCongr Equiv.ulift Equiv.ulift).symm | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_mul | null |
lift_two : lift.{u, v} 2 = 2 := by simp [← one_add_one_eq_two]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_two | null |
mk_set {α : Type u} : #(Set α) = 2 ^ #α := by simp [← one_add_one_eq_two, Set] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | mk_set | null |
@[simp]
mk_powerset {α : Type u} (s : Set α) : #(↥(𝒫 s)) = 2 ^ #(↥s) :=
(mk_congr (Equiv.Set.powerset s)).trans mk_set | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | mk_powerset | A variant of `Cardinal.mk_set` expressed in terms of a `Set` instead of a `Type`. |
lift_two_power (a : Cardinal) : lift.{v} (2 ^ a) = 2 ^ lift.{v} a := by
simp [← one_add_one_eq_two]
/-! ### Order properties -/ | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_two_power | null |
protected zero_le : ∀ a : Cardinal, 0 ≤ a := by
rintro ⟨α⟩
exact ⟨Embedding.ofIsEmpty⟩ | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | zero_le | null |
private add_le_add' : ∀ {a b c d : Cardinal}, a ≤ b → c ≤ d → a + c ≤ b + d := by
rintro ⟨α⟩ ⟨β⟩ ⟨γ⟩ ⟨δ⟩ ⟨e₁⟩ ⟨e₂⟩; exact ⟨e₁.sumMap e₂⟩ | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | add_le_add' | null |
addLeftMono : AddLeftMono Cardinal :=
⟨fun _ _ _ => add_le_add' le_rfl⟩ | instance | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | addLeftMono | null |
addRightMono : AddRightMono Cardinal :=
⟨fun _ _ _ h => add_le_add' h le_rfl⟩ | instance | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | addRightMono | null |
canonicallyOrderedAdd : CanonicallyOrderedAdd Cardinal.{u} where
exists_add_of_le {a b} :=
inductionOn₂ a b fun α β ⟨⟨f, hf⟩⟩ =>
have : α ⊕ ((range f)ᶜ : Set β) ≃ β := by
classical
exact (Equiv.sumCongr (Equiv.ofInjective f hf) (Equiv.refl _)).trans <|
Equiv.Set.sumCompl (range f)
⟨#(↥(range f)ᶜ), mk_congr this.symm⟩
le_self_add a _ := (add_zero a).ge.trans <| add_le_add_left (Cardinal.zero_le _) _
le_add_self a _ := (zero_add a).ge.trans <| add_le_add_right (Cardinal.zero_le _) _ | instance | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | canonicallyOrderedAdd | null |
isOrderedRing : IsOrderedRing Cardinal.{u} :=
CanonicallyOrderedAdd.toIsOrderedRing | instance | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | isOrderedRing | null |
orderBot : OrderBot Cardinal.{u} where
bot := 0
bot_le := zero_le | instance | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | orderBot | null |
noZeroDivisors : NoZeroDivisors Cardinal.{u} where
eq_zero_or_eq_zero_of_mul_eq_zero := fun {a b} =>
inductionOn₂ a b fun α β => by
simpa only [mul_def, mk_eq_zero_iff, isEmpty_prod] using id | instance | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | noZeroDivisors | null |
zero_power_le (c : Cardinal.{u}) : (0 : Cardinal.{u}) ^ c ≤ 1 := by
by_cases h : c = 0
· rw [h, power_zero]
· rw [zero_power h]
apply zero_le | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | zero_power_le | null |
power_le_power_left : ∀ {a b c : Cardinal}, a ≠ 0 → b ≤ c → a ^ b ≤ a ^ c := by
rintro ⟨α⟩ ⟨β⟩ ⟨γ⟩ hα ⟨e⟩
let ⟨a⟩ := mk_ne_zero_iff.1 hα
exact ⟨@Function.Embedding.arrowCongrLeft _ _ _ ⟨a⟩ e⟩ | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | power_le_power_left | null |
self_le_power (a : Cardinal) {b : Cardinal} (hb : 1 ≤ b) : a ≤ a ^ b := by
rcases eq_or_ne a 0 with (rfl | ha)
· exact zero_le _
· convert power_le_power_left ha hb
exact (power_one a).symm | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | self_le_power | null |
cantor (a : Cardinal.{u}) : a < 2 ^ a := by
induction a using Cardinal.inductionOn with | _ α
rw [← mk_set]
refine ⟨⟨⟨singleton, fun a b => singleton_eq_singleton_iff.1⟩⟩, ?_⟩
rintro ⟨⟨f, hf⟩⟩
exact cantor_injective f hf | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | cantor | **Cantor's theorem** |
power_le_max_power_one {a b c : Cardinal} (h : b ≤ c) : a ^ b ≤ max (a ^ c) 1 := by
by_cases ha : a = 0
· simp [ha, zero_power_le]
· exact (power_le_power_left ha h).trans (le_max_left _ _) | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | power_le_max_power_one | null |
power_le_power_right {a b c : Cardinal} : a ≤ b → a ^ c ≤ b ^ c :=
inductionOn₃ a b c fun _ _ _ ⟨e⟩ => ⟨Embedding.arrowCongrRight e⟩ | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | power_le_power_right | null |
power_pos {a : Cardinal} (b : Cardinal) (ha : 0 < a) : 0 < a ^ b :=
(power_ne_zero _ ha.ne').bot_lt | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | power_pos | null |
protected lt_wf : @WellFounded Cardinal.{u} (· < ·) :=
⟨fun a =>
by_contradiction fun h => by
let ι := { c : Cardinal // ¬Acc (· < ·) c }
let f : ι → Cardinal := Subtype.val
haveI hι : Nonempty ι := ⟨⟨_, h⟩⟩
obtain ⟨⟨c : Cardinal, hc : ¬Acc (· < ·) c⟩, ⟨h_1 : ∀ j, (f ⟨c, hc⟩).out ↪ (f j).out⟩⟩ :=
Embedding.min_injective fun i => (f i).out
refine hc (Acc.intro _ fun j h' => by_contradiction fun hj => h'.2 ?_)
have : #_ ≤ #_ := ⟨h_1 ⟨j, hj⟩⟩
simpa only [mk_out] using this⟩ | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lt_wf | null |
@[simp]
sInf_empty : sInf (∅ : Set Cardinal.{u}) = 0 :=
dif_neg Set.not_nonempty_empty | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | sInf_empty | null |
ne_zero_of_isSuccLimit {c} (h : IsSuccLimit c) : c ≠ 0 :=
h.ne_bot | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | ne_zero_of_isSuccLimit | Note that the successor of `c` is not the same as `c + 1` except in the case of finite `c`. -/
instance : SuccOrder Cardinal := ConditionallyCompleteLinearOrder.toSuccOrder
theorem succ_def (c : Cardinal) : succ c = sInf { c' | c < c' } :=
dif_neg <| not_isMax c
theorem succ_pos : ∀ c : Cardinal, 0 < succ c :=
bot_lt_succ
theorem succ_ne_zero (c : Cardinal) : succ c ≠ 0 :=
(succ_pos _).ne'
theorem add_one_le_succ (c : Cardinal.{u}) : c + 1 ≤ succ c := by
have : Set.Nonempty { c' | c < c' } := exists_gt c
simp_rw [succ_def, le_csInf_iff'' this, mem_setOf]
intro b hlt
rcases b, c with ⟨⟨β⟩, ⟨γ⟩⟩
obtain ⟨f⟩ := le_of_lt hlt
have : ¬Surjective f := fun hn => (not_le_of_gt hlt) (mk_le_of_surjective hn)
simp only [Surjective, not_forall] at this
rcases this with ⟨b, hb⟩
calc
#γ + 1 = #(Option γ) := mk_option.symm
_ ≤ #β := (f.optionElim b hb).cardinal_le
@[simp]
theorem lift_succ (a) : lift.{v, u} (succ a) = succ (lift.{v, u} a) :=
le_antisymm
(le_of_not_gt fun h => by
rcases lt_lift_iff.1 h with ⟨b, h, e⟩
rw [lt_succ_iff, ← lift_le, e] at h
exact h.not_gt (lt_succ _))
(succ_le_of_lt <| lift_lt.2 <| lt_succ a)
/-! ### Limit cardinals |
isSuccPrelimit_zero : IsSuccPrelimit (0 : Cardinal) :=
isSuccPrelimit_bot | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | isSuccPrelimit_zero | null |
protected isSuccLimit_iff {c : Cardinal} : IsSuccLimit c ↔ c ≠ 0 ∧ IsSuccPrelimit c :=
isSuccLimit_iff
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | isSuccLimit_iff | null |
protected not_isSuccLimit_zero : ¬ IsSuccLimit (0 : Cardinal) :=
not_isSuccLimit_bot | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | not_isSuccLimit_zero | null |
IsStrongLimit (c : Cardinal) : Prop where
ne_zero : c ≠ 0
two_power_lt ⦃x⦄ : x < c → 2 ^ x < c | structure | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | IsStrongLimit | A cardinal is a strong limit if it is not zero and it is closed under powersets.
Note that `ℵ₀` is a strong limit by this definition. |
protected IsStrongLimit.isSuccLimit {c} (H : IsStrongLimit c) : IsSuccLimit c := by
rw [Cardinal.isSuccLimit_iff]
exact ⟨H.ne_zero, isSuccPrelimit_of_succ_lt fun x h ↦
(succ_le_of_lt <| cantor x).trans_lt (H.two_power_lt h)⟩ | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | IsStrongLimit.isSuccLimit | null |
protected IsStrongLimit.isSuccPrelimit {c} (H : IsStrongLimit c) : IsSuccPrelimit c :=
H.isSuccLimit.isSuccPrelimit
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | IsStrongLimit.isSuccPrelimit | null |
not_isStrongLimit_zero : ¬ IsStrongLimit (0 : Cardinal) :=
fun h ↦ h.ne_zero rfl
/-! ### Indexed cardinal `sum` -/ | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | not_isStrongLimit_zero | null |
le_sum {ι} (f : ι → Cardinal) (i) : f i ≤ sum f := by
rw [← Quotient.out_eq (f i)]
exact ⟨⟨fun a => ⟨i, a⟩, fun a b h => by injection h⟩⟩ | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | le_sum | null |
iSup_le_sum {ι} (f : ι → Cardinal) : iSup f ≤ sum f :=
ciSup_le' <| le_sum _
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | iSup_le_sum | null |
sum_add_distrib {ι} (f g : ι → Cardinal) : sum (f + g) = sum f + sum g := by
have := mk_congr (Equiv.sigmaSumDistrib (Quotient.out ∘ f) (Quotient.out ∘ g))
simp only [comp_apply, mk_sigma, mk_sum, mk_out, lift_id] at this
exact this
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | sum_add_distrib | null |
sum_add_distrib' {ι} (f g : ι → Cardinal) :
(Cardinal.sum fun i => f i + g i) = sum f + sum g :=
sum_add_distrib f g | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | sum_add_distrib' | null |
sum_le_sum {ι} (f g : ι → Cardinal) (H : ∀ i, f i ≤ g i) : sum f ≤ sum g :=
⟨(Embedding.refl _).sigmaMap fun i =>
Classical.choice <| by have := H i; rwa [← Quot.out_eq (f i), ← Quot.out_eq (g i)] at this⟩ | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | sum_le_sum | null |
mk_le_mk_mul_of_mk_preimage_le {c : Cardinal} (f : α → β) (hf : ∀ b : β, #(f ⁻¹' {b}) ≤ c) :
#α ≤ #β * c := by
simpa only [← mk_congr (@Equiv.sigmaFiberEquiv α β f), mk_sigma, ← sum_const'] using
sum_le_sum _ _ hf | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | mk_le_mk_mul_of_mk_preimage_le | null |
lift_mk_le_lift_mk_mul_of_lift_mk_preimage_le {α : Type u} {β : Type v} {c : Cardinal}
(f : α → β) (hf : ∀ b : β, lift.{v} #(f ⁻¹' {b}) ≤ c) : lift.{v} #α ≤ lift.{u} #β * c :=
(mk_le_mk_mul_of_mk_preimage_le fun x : ULift.{v} α => ULift.up.{u} (f x.1)) <|
ULift.forall.2 fun b =>
(mk_congr <|
(Equiv.ulift.image _).trans
(Equiv.trans
(by
rw [Equiv.image_eq_preimage]
simp only [preimage, mem_singleton_iff, ULift.up_inj, mem_setOf_eq, coe_setOf]
exact Equiv.refl _)
Equiv.ulift.symm)).trans_le
(hf b) | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_mk_le_lift_mk_mul_of_lift_mk_preimage_le | null |
nonempty_embedding_to_cardinal : Nonempty (α ↪ Cardinal.{u}) :=
(Embedding.total _ _).resolve_left fun ⟨⟨f, hf⟩⟩ =>
let g : α → Cardinal.{u} := invFun f
let ⟨x, (hx : g x = 2 ^ sum g)⟩ := invFun_surjective hf (2 ^ sum g)
have : g x ≤ sum g := le_sum.{u, u} g x
not_le_of_gt (by rw [hx]; exact cantor _) this | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | nonempty_embedding_to_cardinal | null |
embeddingToCardinal : α ↪ Cardinal.{u} :=
Classical.choice nonempty_embedding_to_cardinal | def | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | embeddingToCardinal | An embedding of any type to the set of cardinals in its universe. |
WellOrderingRel : α → α → Prop :=
embeddingToCardinal ⁻¹'o (· < ·) | def | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | WellOrderingRel | Any type can be endowed with a well order, obtained by pulling back the well order over
cardinals by some embedding. |
WellOrderingRel.isWellOrder : IsWellOrder α WellOrderingRel :=
(RelEmbedding.preimage _ _).isWellOrder | instance | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | WellOrderingRel.isWellOrder | null |
IsWellOrder.subtype_nonempty : Nonempty { r // IsWellOrder α r } :=
⟨⟨WellOrderingRel, inferInstance⟩⟩
variable (α) in | instance | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | IsWellOrder.subtype_nonempty | null |
exists_wellOrder : ∃ (_ : LinearOrder α), WellFoundedLT α := by
classical
exact ⟨linearOrderOfSTO WellOrderingRel, WellOrderingRel.isWellOrder.toIsWellFounded⟩ | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | exists_wellOrder | The **well-ordering theorem** (or **Zermelo's theorem**): every type has a well-order |
exists_eq_of_iSup_eq_of_not_isSuccPrelimit
{ι : Type u} (f : ι → Cardinal.{v}) (ω : Cardinal.{v})
(hω : ¬ IsSuccPrelimit ω)
(h : ⨆ i : ι, f i = ω) : ∃ i, f i = ω := by
subst h
suffices BddAbove (range f) from (isLUB_csSup' this).mem_of_not_isSuccPrelimit hω
contrapose! hω with hf
rw [iSup, csSup_of_not_bddAbove hf, csSup_empty]
exact isSuccPrelimit_bot | lemma | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | exists_eq_of_iSup_eq_of_not_isSuccPrelimit | null |
exists_eq_of_iSup_eq_of_not_isSuccLimit
{ι : Type u} [hι : Nonempty ι] (f : ι → Cardinal.{v}) (hf : BddAbove (range f))
{c : Cardinal.{v}} (hc : ¬ IsSuccLimit c)
(h : ⨆ i, f i = c) : ∃ i, f i = c := by
rw [Cardinal.isSuccLimit_iff] at hc
refine (not_and_or.mp hc).elim (fun e ↦ ⟨hι.some, ?_⟩)
(Cardinal.exists_eq_of_iSup_eq_of_not_isSuccPrelimit.{u, v} f c · h)
cases not_not.mp e
rw [← le_zero_iff] at h ⊢
exact (le_ciSup hf _).trans h
/-! ### Indexed cardinal `prod` -/ | lemma | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | exists_eq_of_iSup_eq_of_not_isSuccLimit | null |
sum_lt_prod {ι} (f g : ι → Cardinal) (H : ∀ i, f i < g i) : sum f < prod g :=
lt_of_not_ge fun ⟨F⟩ => by
have : Inhabited (∀ i : ι, (g i).out) := by
refine ⟨fun i => Classical.choice <| mk_ne_zero_iff.1 ?_⟩
rw [mk_out]
exact (H i).ne_bot
let G := invFun F
have sG : Surjective G := invFun_surjective F.2
choose C hc using
show ∀ i, ∃ b, ∀ a, G ⟨i, a⟩ i ≠ b by
intro i
simp only [not_exists.symm, not_forall.symm]
refine fun h => (H i).not_ge ?_
rw [← mk_out (f i), ← mk_out (g i)]
exact ⟨Embedding.ofSurjective _ h⟩
let ⟨⟨i, a⟩, h⟩ := sG C
exact hc i a (congr_fun h _) | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | sum_lt_prod | **König's theorem** |
prod_le_prod {ι} (f g : ι → Cardinal) (H : ∀ i, f i ≤ g i) : prod f ≤ prod g :=
⟨Embedding.piCongrRight fun i =>
Classical.choice <| by have := H i; rwa [← mk_out (f i), ← mk_out (g i)] at this⟩
/-! ### The first infinite cardinal `aleph0` -/ | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | prod_le_prod | null |
aleph0_pos : 0 < ℵ₀ :=
pos_iff_ne_zero.2 aleph0_ne_zero
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | aleph0_pos | null |
aleph0_le_lift {c : Cardinal.{u}} : ℵ₀ ≤ lift.{v} c ↔ ℵ₀ ≤ c := by
simpa using lift_le (a := ℵ₀)
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | aleph0_le_lift | null |
lift_le_aleph0 {c : Cardinal.{u}} : lift.{v} c ≤ ℵ₀ ↔ c ≤ ℵ₀ := by
simpa using lift_le (b := ℵ₀)
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_le_aleph0 | null |
aleph0_lt_lift {c : Cardinal.{u}} : ℵ₀ < lift.{v} c ↔ ℵ₀ < c := by
simpa using lift_lt (a := ℵ₀)
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | aleph0_lt_lift | null |
lift_lt_aleph0 {c : Cardinal.{u}} : lift.{v} c < ℵ₀ ↔ c < ℵ₀ := by
simpa using lift_lt (b := ℵ₀)
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_lt_aleph0 | null |
aleph0_eq_lift {c : Cardinal.{u}} : ℵ₀ = lift.{v} c ↔ ℵ₀ = c := by
simpa using lift_inj (a := ℵ₀)
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | aleph0_eq_lift | null |
lift_eq_aleph0 {c : Cardinal.{u}} : lift.{v} c = ℵ₀ ↔ c = ℵ₀ := by
simpa using lift_inj (b := ℵ₀)
/-! ### Properties about the cast from `ℕ` -/ | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_eq_aleph0 | null |
mk_fin (n : ℕ) : #(Fin n) = n := by simp
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | mk_fin | null |
lift_natCast (n : ℕ) : lift.{u} (n : Cardinal.{v}) = n := by induction n <;> simp [*]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_natCast | null |
lift_ofNat (n : ℕ) [n.AtLeastTwo] :
lift.{u} (ofNat(n) : Cardinal.{v}) = OfNat.ofNat n :=
lift_natCast n
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_ofNat | null |
lift_eq_nat_iff {a : Cardinal.{u}} {n : ℕ} : lift.{v} a = n ↔ a = n :=
lift_injective.eq_iff' (lift_natCast n)
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_eq_nat_iff | null |
lift_eq_ofNat_iff {a : Cardinal.{u}} {n : ℕ} [n.AtLeastTwo] :
lift.{v} a = ofNat(n) ↔ a = OfNat.ofNat n :=
lift_eq_nat_iff
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_eq_ofNat_iff | null |
nat_eq_lift_iff {n : ℕ} {a : Cardinal.{u}} :
(n : Cardinal) = lift.{v} a ↔ (n : Cardinal) = a := by
rw [← lift_natCast.{v,u} n, lift_inj]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | nat_eq_lift_iff | null |
zero_eq_lift_iff {a : Cardinal.{u}} :
(0 : Cardinal) = lift.{v} a ↔ 0 = a := by
simpa using nat_eq_lift_iff (n := 0)
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | zero_eq_lift_iff | null |
one_eq_lift_iff {a : Cardinal.{u}} :
(1 : Cardinal) = lift.{v} a ↔ 1 = a := by
simpa using nat_eq_lift_iff (n := 1)
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | one_eq_lift_iff | null |
ofNat_eq_lift_iff {a : Cardinal.{u}} {n : ℕ} [n.AtLeastTwo] :
(ofNat(n) : Cardinal) = lift.{v} a ↔ (OfNat.ofNat n : Cardinal) = a :=
nat_eq_lift_iff
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | ofNat_eq_lift_iff | null |
lift_le_nat_iff {a : Cardinal.{u}} {n : ℕ} : lift.{v} a ≤ n ↔ a ≤ n := by
rw [← lift_natCast.{v,u}, lift_le]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_le_nat_iff | null |
lift_le_one_iff {a : Cardinal.{u}} :
lift.{v} a ≤ 1 ↔ a ≤ 1 := by
simpa using lift_le_nat_iff (n := 1)
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_le_one_iff | null |
lift_le_ofNat_iff {a : Cardinal.{u}} {n : ℕ} [n.AtLeastTwo] :
lift.{v} a ≤ ofNat(n) ↔ a ≤ OfNat.ofNat n :=
lift_le_nat_iff
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_le_ofNat_iff | null |
nat_le_lift_iff {n : ℕ} {a : Cardinal.{u}} : n ≤ lift.{v} a ↔ n ≤ a := by
rw [← lift_natCast.{v,u}, lift_le]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | nat_le_lift_iff | null |
one_le_lift_iff {a : Cardinal.{u}} :
(1 : Cardinal) ≤ lift.{v} a ↔ 1 ≤ a := by
simpa using nat_le_lift_iff (n := 1)
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | one_le_lift_iff | null |
ofNat_le_lift_iff {a : Cardinal.{u}} {n : ℕ} [n.AtLeastTwo] :
(ofNat(n) : Cardinal) ≤ lift.{v} a ↔ (OfNat.ofNat n : Cardinal) ≤ a :=
nat_le_lift_iff
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | ofNat_le_lift_iff | null |
lift_lt_nat_iff {a : Cardinal.{u}} {n : ℕ} : lift.{v} a < n ↔ a < n := by
rw [← lift_natCast.{v,u}, lift_lt]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_lt_nat_iff | null |
lift_lt_ofNat_iff {a : Cardinal.{u}} {n : ℕ} [n.AtLeastTwo] :
lift.{v} a < ofNat(n) ↔ a < OfNat.ofNat n :=
lift_lt_nat_iff
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | lift_lt_ofNat_iff | null |
nat_lt_lift_iff {n : ℕ} {a : Cardinal.{u}} : n < lift.{v} a ↔ n < a := by
rw [← lift_natCast.{v,u}, lift_lt]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | nat_lt_lift_iff | null |
zero_lt_lift_iff {a : Cardinal.{u}} :
(0 : Cardinal) < lift.{v} a ↔ 0 < a := by
simpa using nat_lt_lift_iff (n := 0)
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | zero_lt_lift_iff | null |
one_lt_lift_iff {a : Cardinal.{u}} :
(1 : Cardinal) < lift.{v} a ↔ 1 < a := by
simpa using nat_lt_lift_iff (n := 1)
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | one_lt_lift_iff | null |
ofNat_lt_lift_iff {a : Cardinal.{u}} {n : ℕ} [n.AtLeastTwo] :
(ofNat(n) : Cardinal) < lift.{v} a ↔ (OfNat.ofNat n : Cardinal) < a :=
nat_lt_lift_iff | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | ofNat_lt_lift_iff | null |
mk_coe_finset {α : Type u} {s : Finset α} : #s = ↑(Finset.card s) := by simp | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | mk_coe_finset | null |
card_le_of_finset {α} (s : Finset α) : (s.card : Cardinal) ≤ #α :=
@mk_coe_finset _ s ▸ mk_set_le _ | theorem | SetTheory | [
"Mathlib.Algebra.Order.GroupWithZero.Canonical",
"Mathlib.Algebra.Order.Ring.Canonical",
"Mathlib.Data.Fintype.Option",
"Mathlib.Order.InitialSeg",
"Mathlib.Order.Nat",
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.SetTheory.Cardinal.Defs",
"Mathlib.SetTheory.Cardinal.SchroederBernstein"
] | Mathlib/SetTheory/Cardinal/Order.lean | card_le_of_finset | null |
mk_iUnion_Ordinal_lift_le_of_le {β : Type v} {o : Ordinal.{u}} {c : Cardinal.{v}}
(ho : lift.{v} o.card ≤ lift.{u} c) (hc : ℵ₀ ≤ c) (A : Ordinal → Set β)
(hA : ∀ j < o, #(A j) ≤ c) : #(⋃ j < o, A j) ≤ c := by
simp_rw [← mem_Iio, biUnion_eq_iUnion, iUnion, iSup, ← o.enumIsoToType.symm.surjective.range_comp]
rw [← lift_le.{u}]
apply ((mk_iUnion_le_lift _).trans _).trans_eq (mul_eq_self (aleph0_le_lift.2 hc))
rw [mk_toType]
refine mul_le_mul' ho (ciSup_le' ?_)
intro i
simpa using hA _ (o.enumIsoToType.symm i).2 | lemma | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.Principal"
] | Mathlib/SetTheory/Cardinal/Ordinal.lean | mk_iUnion_Ordinal_lift_le_of_le | Bounds the cardinal of an ordinal-indexed union of sets. |
mk_iUnion_Ordinal_le_of_le {β : Type*} {o : Ordinal} {c : Cardinal}
(ho : o.card ≤ c) (hc : ℵ₀ ≤ c) (A : Ordinal → Set β)
(hA : ∀ j < o, #(A j) ≤ c) : #(⋃ j < o, A j) ≤ c := by
apply mk_iUnion_Ordinal_lift_le_of_le _ hc A hA
rwa [Cardinal.lift_le] | lemma | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.Principal"
] | Mathlib/SetTheory/Cardinal/Ordinal.lean | mk_iUnion_Ordinal_le_of_le | null |
lift_card_iSup_le_sum_card {ι : Type u} [Small.{v} ι] (f : ι → Ordinal.{v}) :
Cardinal.lift.{u} (⨆ i, f i).card ≤ Cardinal.sum fun i ↦ (f i).card := by
simp_rw [← mk_toType]
rw [← mk_sigma, ← Cardinal.lift_id'.{v} #(Σ _, _), ← Cardinal.lift_umax.{v, u}]
apply lift_mk_le_lift_mk_of_surjective (f := enumIsoToType _ ∘ (⟨(enumIsoToType _).symm ·.2,
(mem_Iio.mp ((enumIsoToType _).symm _).2).trans_le (Ordinal.le_iSup _ _)⟩))
rw [EquivLike.comp_surjective]
rintro ⟨x, hx⟩
obtain ⟨i, hi⟩ := Ordinal.lt_iSup_iff.mp hx
exact ⟨⟨i, enumIsoToType _ ⟨x, hi⟩⟩, by simp⟩ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.Principal"
] | Mathlib/SetTheory/Cardinal/Ordinal.lean | lift_card_iSup_le_sum_card | null |
card_iSup_le_sum_card {ι : Type u} (f : ι → Ordinal.{max u v}) :
(⨆ i, f i).card ≤ Cardinal.sum (fun i ↦ (f i).card) := by
have := lift_card_iSup_le_sum_card f
rwa [Cardinal.lift_id'] at this | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.Principal"
] | Mathlib/SetTheory/Cardinal/Ordinal.lean | card_iSup_le_sum_card | null |
card_iSup_Iio_le_sum_card {o : Ordinal.{u}} (f : Iio o → Ordinal.{max u v}) :
(⨆ a : Iio o, f a).card ≤ Cardinal.sum fun i ↦ (f ((enumIsoToType o).symm i)).card := by
apply le_of_eq_of_le (congr_arg _ _).symm (card_iSup_le_sum_card _)
simpa using (enumIsoToType o).symm.iSup_comp (g := fun x ↦ f x) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.Principal"
] | Mathlib/SetTheory/Cardinal/Ordinal.lean | card_iSup_Iio_le_sum_card | null |
card_iSup_Iio_le_card_mul_iSup {o : Ordinal.{u}} (f : Iio o → Ordinal.{max u v}) :
(⨆ a : Iio o, f a).card ≤ Cardinal.lift.{v} o.card * ⨆ a : Iio o, (f a).card := by
apply (card_iSup_Iio_le_sum_card f).trans
convert ← sum_le_iSup_lift _
· exact mk_toType o
· exact (enumIsoToType o).symm.iSup_comp (g := fun x ↦ (f x).card) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.Principal"
] | Mathlib/SetTheory/Cardinal/Ordinal.lean | card_iSup_Iio_le_card_mul_iSup | null |
card_opow_le_of_omega0_le_left {a : Ordinal} (ha : ω ≤ a) (b : Ordinal) :
(a ^ b).card ≤ max a.card b.card := by
refine limitRecOn b ?_ ?_ ?_
· simpa using one_lt_omega0.le.trans ha
· intro b IH
rw [opow_succ, card_mul, card_succ, Cardinal.mul_eq_max_of_aleph0_le_right, max_comm]
· grw [IH]
rw [← max_assoc, max_self]
grw [← le_self_add]
· rw [ne_eq, card_eq_zero, opow_eq_zero]
rintro ⟨rfl, -⟩
cases omega0_pos.not_ge ha
· rwa [aleph0_le_card]
· intro b hb IH
rw [(isNormal_opow (one_lt_omega0.trans_le ha)).apply_of_isSuccLimit hb]
apply (card_iSup_Iio_le_card_mul_iSup _).trans
rw [Cardinal.lift_id, Cardinal.mul_eq_max_of_aleph0_le_right, max_comm]
· apply max_le _ (le_max_right _ _)
apply ciSup_le'
rintro ⟨c, (hcb : c < b)⟩
grw [IH c hcb, hcb]
· simpa using hb.ne_bot
· refine le_ciSup_of_le ?_ ⟨1, one_lt_omega0.trans_le <| omega0_le_of_isSuccLimit hb⟩ ?_
· exact Cardinal.bddAbove_of_small _
· simpa | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.Principal"
] | Mathlib/SetTheory/Cardinal/Ordinal.lean | card_opow_le_of_omega0_le_left | null |
card_opow_le_of_omega0_le_right (a : Ordinal) {b : Ordinal} (hb : ω ≤ b) :
(a ^ b).card ≤ max a.card b.card := by
obtain ⟨n, rfl⟩ | ha := eq_nat_or_omega0_le a
· apply (card_le_card <| opow_le_opow_left b (nat_lt_omega0 n).le).trans
apply (card_opow_le_of_omega0_le_left le_rfl _).trans
simp [hb]
· exact card_opow_le_of_omega0_le_left ha b | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.Principal"
] | Mathlib/SetTheory/Cardinal/Ordinal.lean | card_opow_le_of_omega0_le_right | null |
card_opow_le (a b : Ordinal) : (a ^ b).card ≤ max ℵ₀ (max a.card b.card) := by
obtain ⟨n, rfl⟩ | ha := eq_nat_or_omega0_le a
· obtain ⟨m, rfl⟩ | hb := eq_nat_or_omega0_le b
· rw [← natCast_opow, card_nat]
exact le_max_of_le_left (nat_lt_aleph0 _).le
· exact (card_opow_le_of_omega0_le_right _ hb).trans (le_max_right _ _)
· exact (card_opow_le_of_omega0_le_left ha _).trans (le_max_right _ _) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.Principal"
] | Mathlib/SetTheory/Cardinal/Ordinal.lean | card_opow_le | null |
card_opow_eq_of_omega0_le_left {a b : Ordinal} (ha : ω ≤ a) (hb : 0 < b) :
(a ^ b).card = max a.card b.card := by
apply (card_opow_le_of_omega0_le_left ha b).antisymm (max_le _ _) <;> apply card_le_card
· exact left_le_opow a hb
· exact right_le_opow b (one_lt_omega0.trans_le ha) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.Principal"
] | Mathlib/SetTheory/Cardinal/Ordinal.lean | card_opow_eq_of_omega0_le_left | null |
card_opow_eq_of_omega0_le_right {a b : Ordinal} (ha : 1 < a) (hb : ω ≤ b) :
(a ^ b).card = max a.card b.card := by
apply (card_opow_le_of_omega0_le_right a hb).antisymm (max_le _ _) <;> apply card_le_card
· exact left_le_opow a (omega0_pos.trans_le hb)
· exact right_le_opow b ha | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.Principal"
] | Mathlib/SetTheory/Cardinal/Ordinal.lean | card_opow_eq_of_omega0_le_right | null |
card_omega0_opow {a : Ordinal} (h : a ≠ 0) : card (ω ^ a) = max ℵ₀ a.card := by
rw [card_opow_eq_of_omega0_le_left le_rfl h.bot_lt, card_omega0] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.Principal"
] | Mathlib/SetTheory/Cardinal/Ordinal.lean | card_omega0_opow | null |
card_opow_omega0 {a : Ordinal} (h : 1 < a) : card (a ^ ω) = max ℵ₀ a.card := by
rw [card_opow_eq_of_omega0_le_right h le_rfl, card_omega0, max_comm] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.Principal"
] | Mathlib/SetTheory/Cardinal/Ordinal.lean | card_opow_omega0 | null |
principal_opow_omega (o : Ordinal) : Principal (· ^ ·) (ω_ o) := by
obtain rfl | ho := Ordinal.eq_zero_or_pos o
· rw [omega_zero]
exact principal_opow_omega0
· intro a b ha hb
rw [lt_omega_iff_card_lt] at ha hb ⊢
apply (card_opow_le a b).trans_lt (max_lt _ (max_lt ha hb))
rwa [← aleph_zero, aleph_lt_aleph] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.Principal"
] | Mathlib/SetTheory/Cardinal/Ordinal.lean | principal_opow_omega | null |
IsInitial.principal_opow {o : Ordinal} (h : IsInitial o) (ho : ω ≤ o) :
Principal (· ^ ·) o := by
obtain ⟨a, rfl⟩ := mem_range_omega_iff.2 ⟨ho, h⟩
exact principal_opow_omega a | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.Principal"
] | Mathlib/SetTheory/Cardinal/Ordinal.lean | IsInitial.principal_opow | null |
principal_opow_ord {c : Cardinal} (hc : ℵ₀ ≤ c) : Principal (· ^ ·) c.ord := by
apply (isInitial_ord c).principal_opow
rwa [omega0_le_ord]
/-! ### Initial ordinals are principal -/ | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.Principal"
] | Mathlib/SetTheory/Cardinal/Ordinal.lean | principal_opow_ord | null |
principal_add_ord {c : Cardinal} (hc : ℵ₀ ≤ c) : Principal (· + ·) c.ord := by
intro a b ha hb
rw [lt_ord, card_add] at *
exact add_lt_of_lt hc ha hb | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.Principal"
] | Mathlib/SetTheory/Cardinal/Ordinal.lean | principal_add_ord | null |
IsInitial.principal_add {o : Ordinal} (h : IsInitial o) (ho : ω ≤ o) :
Principal (· + ·) o := by
rw [← h.ord_card]
apply principal_add_ord
rwa [aleph0_le_card] | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.Principal"
] | Mathlib/SetTheory/Cardinal/Ordinal.lean | IsInitial.principal_add | null |
principal_add_omega (o : Ordinal) : Principal (· + ·) (ω_ o) :=
(isInitial_omega o).principal_add (omega0_le_omega o) | theorem | SetTheory | [
"Mathlib.SetTheory.Cardinal.Arithmetic",
"Mathlib.SetTheory.Ordinal.Principal"
] | Mathlib/SetTheory/Cardinal/Ordinal.lean | principal_add_omega | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.