File: Mathlib/Data/Real/Cardinality.lean

full_name: Cardinal.cantorFunctionAux
code: /-- The body of the sum in `cantorFunction`.
`cantorFunctionAux c f n = c ^ n` if `f n = true`;
`cantorFunctionAux c f n = 0` if `f n = false`. -/
def cantorFunctionAux (c : ℝ) (f : ℕ → Bool) (n : ℕ) : ℝ 
goal: ℝ

full_name: Cardinal.cantorFunctionAux_true
code: @[simp]
theorem cantorFunctionAux_true (h : f n = true) : cantorFunctionAux c f n = c ^ n 
goal: Cardinal.cantorFunctionAux c f n = c ^ n

full_name: Cardinal.cantorFunctionAux_false
code: @[simp]
theorem cantorFunctionAux_false (h : f n = false) : cantorFunctionAux c f n = 0 
goal: Cardinal.cantorFunctionAux c f n = 0

full_name: Cardinal.cantorFunctionAux_nonneg
code: theorem cantorFunctionAux_nonneg (h : 0 ≤ c) : 0 ≤ cantorFunctionAux c f n 
goal: 0 ≤ Cardinal.cantorFunctionAux c f n

full_name: Cardinal.cantorFunctionAux_eq
code: theorem cantorFunctionAux_eq (h : f n = g n) :
    cantorFunctionAux c f n = cantorFunctionAux c g n 
goal: Cardinal.cantorFunctionAux c f n = Cardinal.cantorFunctionAux c g n

full_name: Cardinal.cantorFunctionAux_zero
code: theorem cantorFunctionAux_zero (f : ℕ → Bool) : cantorFunctionAux c f 0 = cond (f 0) 1 0 
goal: Cardinal.cantorFunctionAux c f 0 = bif f 0 then 1 else 0

full_name: Cardinal.cantorFunctionAux_succ
code: theorem cantorFunctionAux_succ (f : ℕ → Bool) :
    (fun n => cantorFunctionAux c f (n + 1)) = fun n =>
      c * cantorFunctionAux c (fun n => f (n + 1)) n 
goal: (fun n => Cardinal.cantorFunctionAux c f (n + 1)) = fun n => c * Cardinal.cantorFunctionAux c (fun n => f (n + 1)) n

full_name: Cardinal.summable_cantor_function
code: theorem summable_cantor_function (f : ℕ → Bool) (h1 : 0 ≤ c) (h2 : c < 1) :
    Summable (cantorFunctionAux c f) 
goal: Summable (Cardinal.cantorFunctionAux c f)

full_name: Cardinal.cantorFunction
code: /-- `cantorFunction c (f : ℕ → Bool)` is `Σ n, f n * c ^ n`, where `true` is interpreted as `1` and
`false` is interpreted as `0`. It is implemented using `cantorFunctionAux`. -/
def cantorFunction (c : ℝ) (f : ℕ → Bool) : ℝ 
goal: ℝ

full_name: Cardinal.cantorFunction_le
code: theorem cantorFunction_le (h1 : 0 ≤ c) (h2 : c < 1) (h3 : ∀ n, f n → g n) :
    cantorFunction c f ≤ cantorFunction c g 
goal: Cardinal.cantorFunction c f ≤ Cardinal.cantorFunction c g

full_name: Cardinal.cantorFunction_succ
code: theorem cantorFunction_succ (f : ℕ → Bool) (h1 : 0 ≤ c) (h2 : c < 1) :
    cantorFunction c f = cond (f 0) 1 0 + c * cantorFunction c fun n => f (n + 1) 
goal: Cardinal.cantorFunction c f = (bif f 0 then 1 else 0) + c * Cardinal.cantorFunction c fun n => f (n + 1)

full_name: Cardinal.increasing_cantorFunction
code: /-- `cantorFunction c` is strictly increasing with if `0 < c < 1/2`, if we endow `ℕ → Bool` with a
lexicographic order. The lexicographic order doesn't exist for these infinitary products, so we
explicitly write out what it means. -/
theorem increasing_cantorFunction (h1 : 0 < c) (h2 : c < 1 / 2) {n : ℕ} {f g : ℕ → Bool}
    (hn : ∀ k < n, f k = g k) (fn : f n = false) (gn : g n = true) :
    cantorFunction c f < cantorFunction c g 
goal: Cardinal.cantorFunction c f < Cardinal.cantorFunction c g

full_name: Cardinal.cantorFunction_injective
code: /-- `cantorFunction c` is injective if `0 < c < 1/2`. -/
theorem cantorFunction_injective (h1 : 0 < c) (h2 : c < 1 / 2) :
    Function.Injective (cantorFunction c) 
goal: Function.Injective (Cardinal.cantorFunction c)

full_name: Cardinal.mk_real
code: /-- The cardinality of the reals, as a type. -/
theorem mk_real : #ℝ = 𝔠 
goal: #ℝ = 𝔠

full_name: Cardinal.mk_univ_real
code: /-- The cardinality of the reals, as a set. -/
theorem mk_univ_real : #(Set.univ : Set ℝ) = 𝔠 
goal: #↑Set.univ = 𝔠

full_name: Cardinal.not_countable_real
code: /-- **Non-Denumerability of the Continuum**: The reals are not countable. -/
theorem not_countable_real : ¬(Set.univ : Set ℝ).Countable 
goal: ¬Set.univ.Countable

full_name: Cardinal.mk_Ioi_real
code: /-- The cardinality of the interval (a, ∞). -/
theorem mk_Ioi_real (a : ℝ) : #(Ioi a) = 𝔠 
goal: #↑(Set.Ioi a) = 𝔠

full_name: Cardinal.mk_Ici_real
code: /-- The cardinality of the interval [a, ∞). -/
theorem mk_Ici_real (a : ℝ) : #(Ici a) = 𝔠 
goal: #↑(Set.Ici a) = 𝔠

full_name: Cardinal.mk_Iio_real
code: /-- The cardinality of the interval (-∞, a). -/
theorem mk_Iio_real (a : ℝ) : #(Iio a) = 𝔠 
goal: #↑(Set.Iio a) = 𝔠

full_name: Cardinal.mk_Iic_real
code: /-- The cardinality of the interval (-∞, a]. -/
theorem mk_Iic_real (a : ℝ) : #(Iic a) = 𝔠 
goal: #↑(Set.Iic a) = 𝔠

full_name: Cardinal.mk_Ioo_real
code: /-- The cardinality of the interval (a, b). -/
theorem mk_Ioo_real {a b : ℝ} (h : a < b) : #(Ioo a b) = 𝔠 
goal: #↑(Set.Ioo a b) = 𝔠

full_name: Cardinal.mk_Ico_real
code: /-- The cardinality of the interval [a, b). -/
theorem mk_Ico_real {a b : ℝ} (h : a < b) : #(Ico a b) = 𝔠 
goal: #↑(Set.Ico a b) = 𝔠

full_name: Cardinal.mk_Icc_real
code: /-- The cardinality of the interval [a, b]. -/
theorem mk_Icc_real {a b : ℝ} (h : a < b) : #(Icc a b) = 𝔠 
goal: #↑(Set.Icc a b) = 𝔠

full_name: Cardinal.mk_Ioc_real
code: /-- The cardinality of the interval (a, b]. -/
theorem mk_Ioc_real {a b : ℝ} (h : a < b) : #(Ioc a b) = 𝔠 
goal: #↑(Set.Ioc a b) = 𝔠