ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- irrational_div_rat_iff
@[simp]
theorem irrational_div_rat_iff : Irrational (x / q) ↔ q ≠ 0 ∧ Irrational x 
Arguments: {q : ℚ} {x : ℝ}
Goal: Irrational (x / ↑q) ↔ q ≠ 0 ∧ Irrational x
-- irrational_int_div_iff
@[simp]
theorem irrational_int_div_iff : Irrational (m / x) ↔ m ≠ 0 ∧ Irrational x 
Arguments: {m : ℤ} {x : ℝ}
Goal: Irrational (↑m / x) ↔ m ≠ 0 ∧ Irrational x
-- irrational_div_int_iff
@[simp]
theorem irrational_div_int_iff : Irrational (x / m) ↔ m ≠ 0 ∧ Irrational x 
Arguments: {m : ℤ} {x : ℝ}
Goal: Irrational (x / ↑m) ↔ m ≠ 0 ∧ Irrational x
-- irrational_nat_div_iff
@[simp]
theorem irrational_nat_div_iff : Irrational (n / x) ↔ n ≠ 0 ∧ Irrational x 
Arguments: {n : ℕ} {x : ℝ}
Goal: Irrational (↑n / x) ↔ n ≠ 0 ∧ Irrational x
-- irrational_div_nat_iff
@[simp]
theorem irrational_div_nat_iff : Irrational (x / n) ↔ n ≠ 0 ∧ Irrational x 
Arguments: {n : ℕ} {x : ℝ}
Goal: Irrational (x / ↑n) ↔ n ≠ 0 ∧ Irrational x
-- exists_irrational_btwn
theorem exists_irrational_btwn {x y : ℝ} (h : x < y) : ∃ r, Irrational r ∧ x < r ∧ r < y 
Arguments: {x y : ℝ} (h : x < y)
Goal: ∃ r, Irrational r ∧ x < r ∧ r < y
-- Quotient.eq_rel
theorem Quotient.eq_rel {r : Setoid α} {x y} :
    (Quotient.mk' x : Quotient r) = Quotient.mk' y ↔ r.Rel x y 
Arguments: {α : Type u_1} {r : Setoid α} {x y : α}
Goal: Quotient.mk' x = Quotient.mk' y ↔ r.Rel x y
-- Setoid.ext'
@[ext]
theorem ext' {r s : Setoid α} (H : ∀ a b, r.Rel a b ↔ s.Rel a b) : r = s 
Arguments: {α : Type u_1} {r s : Setoid α} (H : ∀ (a b : α), r.Rel a b ↔ s.Rel a b)
Goal: r = s
-- Setoid.ext_iff
theorem ext_iff {r s : Setoid α} : r = s ↔ ∀ a b, r.Rel a b ↔ s.Rel a b 
Arguments: {α : Type u_1} {r s : Setoid α}
Goal: r = s ↔ ∀ (a b : α), r.Rel a b ↔ s.Rel a b
-- Setoid.eq_iff_rel_eq
theorem eq_iff_rel_eq {r₁ r₂ : Setoid α} : r₁ = r₂ ↔ r₁.Rel = r₂.Rel 
Arguments: {α : Type u_1} {r₁ r₂ : Setoid α}
Goal: r₁ = r₂ ↔ r₁.Rel = r₂.Rel
-- Setoid.le_def
theorem le_def {r s : Setoid α} : r ≤ s ↔ ∀ {x y}, r.Rel x y → s.Rel x y 
Arguments: {α : Type u_1} {r s : Setoid α}
Goal: r ≤ s ↔ ∀ {x y : α}, r.Rel x y → s.Rel x y
-- Setoid.refl'
@[refl]
theorem refl' (r : Setoid α) (x) : r.Rel x x 
Arguments: {α : Type u_1} (r : Setoid α) (x : α)
Goal: r.Rel x x
-- Setoid.symm'
@[symm]
theorem symm' (r : Setoid α) : ∀ {x y}, r.Rel x y → r.Rel y x 
Arguments: {α : Type u_1} (r : Setoid α) {x y : α}
Goal: r.Rel x y → r.Rel y x
-- Setoid.trans'
@[trans]
theorem trans' (r : Setoid α) : ∀ {x y z}, r.Rel x y → r.Rel y z → r.Rel x z 
Arguments: {α : Type u_1} (r : Setoid α) {x y z : α}
Goal: r.Rel x y → r.Rel y z → r.Rel x z
-- Setoid.comm'
theorem comm' (s : Setoid α) {x y} : s.Rel x y ↔ s.Rel y x 
Arguments: {α : Type u_1} (s : Setoid α) {x y : α}
Goal: s.Rel x y ↔ s.Rel y x
-- Setoid.ker_mk_eq
@[simp]
theorem ker_mk_eq (r : Setoid α) : ker (@Quotient.mk'' _ r) = r 
Arguments: {α : Type u_1} (r : Setoid α)
Goal: Setoid.ker Quotient.mk'' = r
-- Setoid.ker_apply_mk_out
theorem ker_apply_mk_out {f : α → β} (a : α) : f (haveI := Setoid.ker f; ⟦a⟧.out) = f a 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} (a : α)
Goal: f ⟦a⟧.out = f a
-- Setoid.ker_apply_mk_out'
theorem ker_apply_mk_out' {f : α → β} (a : α) :
    f (Quotient.mk _ a : Quotient <| Setoid.ker f).out' = f a 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} (a : α)
Goal: f ⟦a⟧.out' = f a
-- Setoid.ker_def
theorem ker_def {f : α → β} {x y : α} : (ker f).Rel x y ↔ f x = f y 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {x y : α}
Goal: (Setoid.ker f).Rel x y ↔ f x = f y
-- Setoid.inf_def
theorem inf_def {r s : Setoid α} : (r ⊓ s).Rel = r.Rel ⊓ s.Rel 
Arguments: {α : Type u_1} {r s : Setoid α}
Goal: (r ⊓ s).Rel = r.Rel ⊓ s.Rel
-- Setoid.inf_iff_and
theorem inf_iff_and {r s : Setoid α} {x y} : (r ⊓ s).Rel x y ↔ r.Rel x y ∧ s.Rel x y 
Arguments: {α : Type u_1} {r s : Setoid α} {x y : α}
Goal: (r ⊓ s).Rel x y ↔ r.Rel x y ∧ s.Rel x y
-- Setoid.sInf_def
theorem sInf_def {s : Set (Setoid α)} : (sInf s).Rel = sInf (Rel '' s) 
Arguments: {α : Type u_1} {s : Set (Setoid α)}
Goal: (sInf s).Rel = sInf (Setoid.Rel '' s)
-- Setoid.top_def
@[simp]
theorem top_def : (⊤ : Setoid α).Rel = ⊤ 
Arguments: {α : Type u_1}
Goal: ⊤.Rel = ⊤
-- Setoid.bot_def
@[simp]
theorem bot_def : (⊥ : Setoid α).Rel = (· = ·) 
Arguments: {α : Type u_1}
Goal: ⊥.Rel = fun x x_1 => x = x_1
-- Setoid.eq_top_iff
theorem eq_top_iff {s : Setoid α} : s = (⊤ : Setoid α) ↔ ∀ x y : α, s.Rel x y 
Arguments: {α : Type u_1} {s : Setoid α}
Goal: s = ⊤ ↔ ∀ (x y : α), s.Rel x y
-- Setoid.sInf_equiv
lemma sInf_equiv {S : Set (Setoid α)} {x y : α} :
    letI := sInf S
    x ≈ y ↔ ∀ s ∈ S, s.Rel x y 
Arguments: {α : Type u_1} {S : Set (Setoid α)} {x y : α}
Goal: x ≈ y ↔ ∀ s ∈ S, s.Rel x y
-- Setoid.quotient_mk_sInf_eq
lemma quotient_mk_sInf_eq {S : Set (Setoid α)} {x y : α} :
    Quotient.mk (sInf S) x = Quotient.mk (sInf S) y ↔ ∀ s ∈ S, s.Rel x y 
Arguments: {α : Type u_1} {S : Set (Setoid α)} {x y : α}
Goal: ⟦x⟧ = ⟦y⟧ ↔ ∀ s ∈ S, s.Rel x y
-- Setoid.eqvGen_eq
theorem eqvGen_eq (r : α → α → Prop) :
    EqvGen.Setoid r = sInf { s : Setoid α | ∀ ⦃x y⦄, r x y → s.Rel x y } 
Arguments: {α : Type u_1} (r : α → α → Prop)
Goal: EqvGen.Setoid r = sInf {s | ∀ ⦃x y : α⦄, r x y → s.Rel x y}
-- Setoid.sup_eq_eqvGen
theorem sup_eq_eqvGen (r s : Setoid α) :
    r ⊔ s = EqvGen.Setoid fun x y => r.Rel x y ∨ s.Rel x y 
Arguments: {α : Type u_1} (r s : Setoid α)
Goal: r ⊔ s = EqvGen.Setoid fun x y => r.Rel x y ∨ s.Rel x y
-- Setoid.sup_def
theorem sup_def {r s : Setoid α} : r ⊔ s = EqvGen.Setoid (r.Rel ⊔ s.Rel) 
Arguments: {α : Type u_1} {r s : Setoid α}
Goal: r ⊔ s = EqvGen.Setoid (r.Rel ⊔ s.Rel)
-- Setoid.sSup_eq_eqvGen
theorem sSup_eq_eqvGen (S : Set (Setoid α)) :
    sSup S = EqvGen.Setoid fun x y => ∃ r : Setoid α, r ∈ S ∧ r.Rel x y 
Arguments: {α : Type u_1} (S : Set (Setoid α))
Goal: sSup S = EqvGen.Setoid fun x y => ∃ r ∈ S, r.Rel x y
-- Setoid.sSup_def
theorem sSup_def {s : Set (Setoid α)} : sSup s = EqvGen.Setoid (sSup (Rel '' s)) 
Arguments: {α : Type u_1} {s : Set (Setoid α)}
Goal: sSup s = EqvGen.Setoid (sSup (Setoid.Rel '' s))
-- Setoid.eqvGen_of_setoid
@[simp]
theorem eqvGen_of_setoid (r : Setoid α) : EqvGen.Setoid r.r = r 
Arguments: {α : Type u_1} (r : Setoid α)
Goal: EqvGen.Setoid Setoid.r = r
-- Setoid.eqvGen_idem
@[simp]
theorem eqvGen_idem (r : α → α → Prop) : EqvGen.Setoid (EqvGen.Setoid r).Rel = EqvGen.Setoid r 
Arguments: {α : Type u_1} (r : α → α → Prop)
Goal: EqvGen.Setoid (EqvGen.Setoid r).Rel = EqvGen.Setoid r
-- Setoid.eqvGen_le
theorem eqvGen_le {r : α → α → Prop} {s : Setoid α} (h : ∀ x y, r x y → s.Rel x y) :
    EqvGen.Setoid r ≤ s 
Arguments: {α : Type u_1} {r : α → α → Prop} {s : Setoid α} (h : ∀ (x y : α), r x y → s.Rel x y)
Goal: EqvGen.Setoid r ≤ s
-- Setoid.eqvGen_mono
theorem eqvGen_mono {r s : α → α → Prop} (h : ∀ x y, r x y → s x y) :
    EqvGen.Setoid r ≤ EqvGen.Setoid s 
Arguments: {α : Type u_1} {r s : α → α → Prop} (h : ∀ (x y : α), r x y → s x y)
Goal: EqvGen.Setoid r ≤ EqvGen.Setoid s
-- Setoid.injective_iff_ker_bot
theorem injective_iff_ker_bot (f : α → β) : Injective f ↔ ker f = ⊥ 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β)
Goal: Function.Injective f ↔ Setoid.ker f = ⊥
-- Setoid.ker_iff_mem_preimage
theorem ker_iff_mem_preimage {f : α → β} {x y} : (ker f).Rel x y ↔ x ∈ f ⁻¹' {f y} 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {x y : α}
Goal: (Setoid.ker f).Rel x y ↔ x ∈ f ⁻¹' {f y}
-- Setoid.lift_unique
theorem lift_unique {r : Setoid α} {f : α → β} (H : r ≤ ker f) (g : Quotient r → β)
    (Hg : f = g ∘ Quotient.mk'') : Quotient.lift f H = g 
Arguments: {α : Type u_1} {β : Type u_2} {r : Setoid α} {f : α → β} (H : r ≤ Setoid.ker f) (g : Quotient r → β) (Hg : f = g ∘ Quotient.mk'')
Goal: Quotient.lift f H = g
-- Setoid.ker_lift_injective
theorem ker_lift_injective (f : α → β) : Injective (@Quotient.lift _ _ (ker f) f fun _ _ h => h) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β)
Goal: Function.Injective (Quotient.lift f ⋯)
-- Setoid.ker_eq_lift_of_injective
theorem ker_eq_lift_of_injective {r : Setoid α} (f : α → β) (H : ∀ x y, r.Rel x y → f x = f y)
    (h : Injective (Quotient.lift f H)) : ker f = r 
Arguments: {α : Type u_1} {β : Type u_2} {r : Setoid α} (f : α → β) (H : ∀ (x y : α), r.Rel x y → f x = f y) (h : Function.Injective (Quotient.lift f H))
Goal: Setoid.ker f = r
-- Setoid.quotientKerEquivOfRightInverse_apply
@[simps]
def quotientKerEquivOfRightInverse (g : β → α) (hf : Function.RightInverse g f) :
    Quotient (ker f) ≃ β 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (g : β → α) (hf : Function.RightInverse g f) (a : Quotient (Setoid.ker f))
Goal: (Setoid.quotientKerEquivOfRightInverse f g hf) a = a.liftOn' f ⋯
-- Setoid.quotientKerEquivOfRightInverse_symm_apply
@[simps]
def quotientKerEquivOfRightInverse (g : β → α) (hf : Function.RightInverse g f) :
    Quotient (ker f) ≃ β 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (g : β → α) (hf : Function.RightInverse g f) (b : β)
Goal: (Setoid.quotientKerEquivOfRightInverse f g hf).symm b = Quotient.mk'' (g b)
-- Setoid.mapOfSurjective_eq_map
theorem mapOfSurjective_eq_map (h : ker f ≤ r) (hf : Surjective f) :
    map r f = mapOfSurjective r f h hf 
Arguments: {α : Type u_1} {β : Type u_2} {r : Setoid α} {f : α → β} (h : Setoid.ker f ≤ r) (hf : Function.Surjective f)
Goal: r.map f = r.mapOfSurjective f h hf
-- Setoid.comap_rel
theorem comap_rel (f : α → β) (r : Setoid β) (x y : α) : (comap f r).Rel x y ↔ r.Rel (f x) (f y) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (r : Setoid β) (x y : α)
Goal: (Setoid.comap f r).Rel x y ↔ r.Rel (f x) (f y)
-- Setoid.comap_eq
theorem comap_eq {f : α → β} {r : Setoid β} : comap f r = ker (@Quotient.mk'' _ r ∘ f) 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {r : Setoid β}
Goal: Setoid.comap f r = Setoid.ker (Quotient.mk'' ∘ f)
-- Quotient.subsingleton_iff
@[simp]
theorem Quotient.subsingleton_iff {s : Setoid α} : Subsingleton (Quotient s) ↔ s = ⊤ 
Arguments: {α : Type u_1} {s : Setoid α}
Goal: Subsingleton (Quotient s) ↔ s = ⊤
-- Quot.subsingleton_iff
theorem Quot.subsingleton_iff (r : α → α → Prop) : Subsingleton (Quot r) ↔ EqvGen r = ⊤ 
Arguments: {α : Type u_1} (r : α → α → Prop)
Goal: Subsingleton (Quot r) ↔ EqvGen r = ⊤
-- Real.Wallis.W_succ
theorem W_succ (k : ℕ) :
    W (k + 1) = W k * ((2 * k + 2) / (2 * k + 1) * ((2 * k + 2) / (2 * k + 3))) 
Arguments: (k : ℕ)
Goal: Real.Wallis.W (k + 1) = Real.Wallis.W k * ((2 * ↑k + 2) / (2 * ↑k + 1) * ((2 * ↑k + 2) / (2 * ↑k + 3)))
-- Real.Wallis.W_pos
theorem W_pos (k : ℕ) : 0 < W k 
Arguments: (k : ℕ)
Goal: 0 < Real.Wallis.W k
-- Real.Wallis.W_eq_factorial_ratio
theorem W_eq_factorial_ratio (n : ℕ) :
    W n = 2 ^ (4 * n) * n ! ^ 4 / ((2 * n)! ^ 2 * (2 * n + 1)) 
Arguments: (n : ℕ)
Goal: Real.Wallis.W n = 2 ^ (4 * n) * ↑n ! ^ 4 / (↑(2 * n)! ^ 2 * (2 * ↑n + 1))
-- Real.Wallis.W_eq_integral_sin_pow_div_integral_sin_pow
theorem W_eq_integral_sin_pow_div_integral_sin_pow (k : ℕ) : (π / 2)⁻¹ * W k =
    (∫ x : ℝ in (0)..π, sin x ^ (2 * k + 1)) / ∫ x : ℝ in (0)..π, sin x ^ (2 * k) 
Arguments: (k : ℕ)
Goal: (π / 2)⁻¹ * Real.Wallis.W k = (∫ (x : ℝ) in 0 ..π, Real.sin x ^ (2 * k + 1)) / ∫ (x : ℝ) in 0 ..π, Real.sin x ^ (2 * k)
-- Real.Wallis.W_le
theorem W_le (k : ℕ) : W k ≤ π / 2 
Arguments: (k : ℕ)
Goal: Real.Wallis.W k ≤ π / 2
-- Real.Wallis.le_W
theorem le_W (k : ℕ) : ((2 : ℝ) * k + 1) / (2 * k + 2) * (π / 2) ≤ W k 
Arguments: (k : ℕ)
Goal: (2 * ↑k + 1) / (2 * ↑k + 2) * (π / 2) ≤ Real.Wallis.W k
-- Real.Wallis.tendsto_W_nhds_pi_div_two
theorem tendsto_W_nhds_pi_div_two : Tendsto W atTop (𝓝 <| π / 2) 
Goal: Filter.Tendsto Real.Wallis.W Filter.atTop (𝓝 (π / 2))
-- Real.tendsto_prod_pi_div_two
theorem Real.tendsto_prod_pi_div_two :
    Tendsto (fun k => ∏ i ∈ range k, ((2 : ℝ) * i + 2) / (2 * i + 1) * ((2 * i + 2) / (2 * i + 3)))
      atTop (𝓝 (π / 2)) 
Goal: Filter.Tendsto (fun k => ∏ i ∈ Finset.range k, (2 * ↑i + 2) / (2 * ↑i + 1) * ((2 * ↑i + 2) / (2 * ↑i + 3))) Filter.atTop
  (𝓝 (π / 2))
-- inv_gold
theorem inv_gold : φ⁻¹ = -ψ 
Goal: φ⁻¹ = -ψ
-- inv_goldConj
theorem inv_goldConj : ψ⁻¹ = -φ 
Goal: ψ⁻¹ = -φ
-- gold_mul_goldConj
@[simp]
theorem gold_mul_goldConj : φ * ψ = -1 
Goal: φ * ψ = -1
-- goldConj_mul_gold
@[simp]
theorem goldConj_mul_gold : ψ * φ = -1 
Goal: ψ * φ = -1
-- gold_add_goldConj
@[simp]
theorem gold_add_goldConj : φ + ψ = 1 
Goal: φ + ψ = 1
-- one_sub_goldConj
theorem one_sub_goldConj : 1 - φ = ψ 
Goal: 1 - φ = ψ
-- one_sub_gold
theorem one_sub_gold : 1 - ψ = φ 
Goal: 1 - ψ = φ
-- gold_sub_goldConj
@[simp]
theorem gold_sub_goldConj : φ - ψ = √5 
Goal: φ - ψ = √5
-- gold_pow_sub_gold_pow
theorem gold_pow_sub_gold_pow (n : ℕ) : φ ^ (n + 2) - φ ^ (n + 1) = φ ^ n 
Arguments: (n : ℕ)
Goal: φ ^ (n + 2) - φ ^ (n + 1) = φ ^ n
-- gold_sq
@[simp 1200]
theorem gold_sq : φ ^ 2 = φ + 1 
Goal: φ ^ 2 = φ + 1
-- goldConj_sq
@[simp 1200]
theorem goldConj_sq : ψ ^ 2 = ψ + 1 
Goal: ψ ^ 2 = ψ + 1
-- gold_pos
theorem gold_pos : 0 < φ 
Goal: 0 < φ
-- gold_ne_zero
theorem gold_ne_zero : φ ≠ 0 
Goal: φ ≠ 0
-- one_lt_gold
theorem one_lt_gold : 1 < φ 
Goal: 1 < φ
-- gold_lt_two
theorem gold_lt_two : φ < 2 
Goal: φ < 2
-- goldConj_neg
theorem goldConj_neg : ψ < 0 
Goal: ψ < 0
-- goldConj_ne_zero
theorem goldConj_ne_zero : ψ ≠ 0 
Goal: ψ ≠ 0
-- neg_one_lt_goldConj
theorem neg_one_lt_goldConj : -1 < ψ 
Goal: -1 < ψ
-- gold_irrational
theorem gold_irrational : Irrational φ 
Goal: Irrational φ
-- goldConj_irrational
theorem goldConj_irrational : Irrational ψ 
Goal: Irrational ψ
-- fibRec_charPoly_eq
theorem fibRec_charPoly_eq {β : Type*} [CommRing β] :
    fibRec.charPoly = X ^ 2 - (X + (1 : β[X])) 
Arguments: {β : Type u_2} [CommRing β]
Goal: fibRec.charPoly = Polynomial.X ^ 2 - (Polynomial.X + 1)
-- fib_isSol_fibRec
theorem fib_isSol_fibRec : fibRec.IsSolution (fun x => x.fib : ℕ → α) 
Arguments: {α : Type u_1} [CommSemiring α]
Goal: fibRec.IsSolution fun x => ↑(Nat.fib x)
-- geom_gold_isSol_fibRec
theorem geom_gold_isSol_fibRec : fibRec.IsSolution (φ ^ ·) 
Goal: fibRec.IsSolution fun x => φ ^ x
-- geom_goldConj_isSol_fibRec
theorem geom_goldConj_isSol_fibRec : fibRec.IsSolution (ψ ^ ·) 
Goal: fibRec.IsSolution fun x => ψ ^ x
-- Real.coe_fib_eq'
theorem Real.coe_fib_eq' :
    (fun n => Nat.fib n : ℕ → ℝ) = fun n => (φ ^ n - ψ ^ n) / √5 
Goal: (fun n => ↑(Nat.fib n)) = fun n => (φ ^ n - ψ ^ n) / √5
-- Real.coe_fib_eq
theorem Real.coe_fib_eq : ∀ n, (Nat.fib n : ℝ) = (φ ^ n - ψ ^ n) / √5 
Arguments: (n : ℕ)
Goal: ↑(Nat.fib n) = (φ ^ n - ψ ^ n) / √5
-- fib_golden_conj_exp
theorem fib_golden_conj_exp (n : ℕ) : Nat.fib (n + 1) - φ * Nat.fib n = ψ ^ n 
Arguments: (n : ℕ)
Goal: ↑(Nat.fib (n + 1)) - φ * ↑(Nat.fib n) = ψ ^ n
-- fib_golden_exp'
theorem fib_golden_exp' (n : ℕ) : φ * Nat.fib (n + 1) + Nat.fib n = φ ^ (n + 1) 
Arguments: (n : ℕ)
Goal: φ * ↑(Nat.fib (n + 1)) + ↑(Nat.fib n) = φ ^ (n + 1)
-- Cardinal.cantorFunctionAux_true
@[simp]
theorem cantorFunctionAux_true (h : f n = true) : cantorFunctionAux c f n = c ^ n 
Arguments: {c : ℝ} {f : ℕ → Bool} {n : ℕ} (h : f n = true)
Goal: Cardinal.cantorFunctionAux c f n = c ^ n
-- Cardinal.cantorFunctionAux_false
@[simp]
theorem cantorFunctionAux_false (h : f n = false) : cantorFunctionAux c f n = 0 
Arguments: {c : ℝ} {f : ℕ → Bool} {n : ℕ} (h : f n = false)
Goal: Cardinal.cantorFunctionAux c f n = 0
-- Cardinal.cantorFunctionAux_nonneg
theorem cantorFunctionAux_nonneg (h : 0 ≤ c) : 0 ≤ cantorFunctionAux c f n 
Arguments: {c : ℝ} {f : ℕ → Bool} {n : ℕ} (h : 0 ≤ c)
Goal: 0 ≤ Cardinal.cantorFunctionAux c f n
-- Cardinal.cantorFunctionAux_eq
theorem cantorFunctionAux_eq (h : f n = g n) :
    cantorFunctionAux c f n = cantorFunctionAux c g n 
Arguments: {c : ℝ} {f g : ℕ → Bool} {n : ℕ} (h : f n = g n)
Goal: Cardinal.cantorFunctionAux c f n = Cardinal.cantorFunctionAux c g n
-- Cardinal.cantorFunctionAux_zero
theorem cantorFunctionAux_zero (f : ℕ → Bool) : cantorFunctionAux c f 0 = cond (f 0) 1 0 
Arguments: {c : ℝ} (f : ℕ → Bool)
Goal: Cardinal.cantorFunctionAux c f 0 = bif f 0 then 1 else 0
-- Cardinal.cantorFunctionAux_succ
theorem cantorFunctionAux_succ (f : ℕ → Bool) :
    (fun n => cantorFunctionAux c f (n + 1)) = fun n =>
      c * cantorFunctionAux c (fun n => f (n + 1)) n 
Arguments: {c : ℝ} (f : ℕ → Bool)
Goal: (fun n => Cardinal.cantorFunctionAux c f (n + 1)) = fun n => c * Cardinal.cantorFunctionAux c (fun n => f (n + 1)) n
-- Cardinal.summable_cantor_function
theorem summable_cantor_function (f : ℕ → Bool) (h1 : 0 ≤ c) (h2 : c < 1) :
    Summable (cantorFunctionAux c f) 
Arguments: {c : ℝ} (f : ℕ → Bool) (h1 : 0 ≤ c) (h2 : c < 1)
Goal: Summable (Cardinal.cantorFunctionAux c f)
-- Cardinal.cantorFunction_le
theorem cantorFunction_le (h1 : 0 ≤ c) (h2 : c < 1) (h3 : ∀ n, f n → g n) :
    cantorFunction c f ≤ cantorFunction c g 
Arguments: {c : ℝ} {f g : ℕ → Bool} (h1 : 0 ≤ c) (h2 : c < 1) (h3 : ∀ (n : ℕ), f n = true → g n = true)
Goal: Cardinal.cantorFunction c f ≤ Cardinal.cantorFunction c g
-- Cardinal.cantorFunction_succ
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) 
Arguments: {c : ℝ} (f : ℕ → Bool) (h1 : 0 ≤ c) (h2 : c < 1)
Goal: Cardinal.cantorFunction c f = (bif f 0 then 1 else 0) + c * Cardinal.cantorFunction c fun n => f (n + 1)
-- Cardinal.increasing_cantorFunction
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 
Arguments: {c : ℝ} (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)
Goal: Cardinal.cantorFunction c f < Cardinal.cantorFunction c g
-- Cardinal.cantorFunction_injective
theorem cantorFunction_injective (h1 : 0 < c) (h2 : c < 1 / 2) :
    Function.Injective (cantorFunction c) 
Arguments: {c : ℝ} (h1 : 0 < c) (h2 : c < 1 / 2)
Goal: Function.Injective (Cardinal.cantorFunction c)
-- Cardinal.mk_real
theorem mk_real : #ℝ = 𝔠 
Goal: #ℝ = 𝔠
-- Cardinal.mk_univ_real
theorem mk_univ_real : #(Set.univ : Set ℝ) = 𝔠 
Goal: #↑Set.univ = 𝔠
-- Cardinal.not_countable_real
theorem not_countable_real : ¬(Set.univ : Set ℝ).Countable 
Goal: ¬Set.univ.Countable
-- Cardinal.mk_Ioi_real
theorem mk_Ioi_real (a : ℝ) : #(Ioi a) = 𝔠 
Arguments: (a : ℝ)
Goal: #↑(Set.Ioi a) = 𝔠
-- Cardinal.mk_Ici_real
theorem mk_Ici_real (a : ℝ) : #(Ici a) = 𝔠 
Arguments: (a : ℝ)
Goal: #↑(Set.Ici a) = 𝔠
-- Cardinal.mk_Iio_real
theorem mk_Iio_real (a : ℝ) : #(Iio a) = 𝔠 
Arguments: (a : ℝ)
Goal: #↑(Set.Iio a) = 𝔠
-- Cardinal.mk_Iic_real
theorem mk_Iic_real (a : ℝ) : #(Iic a) = 𝔠 
Arguments: (a : ℝ)
Goal: #↑(Set.Iic a) = 𝔠
-- Cardinal.mk_Ioo_real
theorem mk_Ioo_real {a b : ℝ} (h : a < b) : #(Ioo a b) = 𝔠 
Arguments: {a b : ℝ} (h : a < b)
Goal: #↑(Set.Ioo a b) = 𝔠
-- Cardinal.mk_Ico_real
theorem mk_Ico_real {a b : ℝ} (h : a < b) : #(Ico a b) = 𝔠 
Arguments: {a b : ℝ} (h : a < b)
Goal: #↑(Set.Ico a b) = 𝔠
-- Cardinal.mk_Icc_real
theorem mk_Icc_real {a b : ℝ} (h : a < b) : #(Icc a b) = 𝔠 
Arguments: {a b : ℝ} (h : a < b)
Goal: #↑(Set.Icc a b) = 𝔠
-- Cardinal.mk_Ioc_real
theorem mk_Ioc_real {a b : ℝ} (h : a < b) : #(Ioc a b) = 𝔠 
Arguments: {a b : ℝ} (h : a < b)
Goal: #↑(Set.Ioc a b) = 𝔠
-- Nat.digitsAux_zero
@[simp]
theorem digitsAux_zero (b : ℕ) (h : 2 ≤ b) : digitsAux b h 0 = [] 
Arguments: (b : ℕ) (h : 2 ≤ b)
Goal: b.digitsAux h 0 = []
-- Nat.digitsAux_def
theorem digitsAux_def (b : ℕ) (h : 2 ≤ b) (n : ℕ) (w : 0 < n) :
    digitsAux b h n = (n % b) :: digitsAux b h (n / b) 
Arguments: (b : ℕ) (h : 2 ≤ b) (n : ℕ) (w : 0 < n)
Goal: b.digitsAux h n = n % b :: b.digitsAux h (n / b)
-- Nat.digits_zero
@[simp]
theorem digits_zero (b : ℕ) : digits b 0 = [] 
Arguments: (b : ℕ)
Goal: b.digits 0 = []
-- Nat.digits_zero_zero
theorem digits_zero_zero : digits 0 0 = [] 
Goal: Nat.digits 0 0 = []
-- Nat.digits_zero_succ
@[simp]
theorem digits_zero_succ (n : ℕ) : digits 0 n.succ = [n + 1] 
Arguments: (n : ℕ)
Goal: Nat.digits 0 n.succ = [n + 1]
-- Nat.digits_zero_succ'
theorem digits_zero_succ' : ∀ {n : ℕ}, n ≠ 0 → digits 0 n = [n]
  
Arguments: {n : ℕ}
Goal: n ≠ 0 → Nat.digits 0 n = [n]
-- Nat.digits_one
@[simp]
theorem digits_one (n : ℕ) : digits 1 n = List.replicate n 1 
Arguments: (n : ℕ)
Goal: Nat.digits 1 n = List.replicate n 1
-- Nat.digits_one_succ
theorem digits_one_succ (n : ℕ) : digits 1 (n + 1) = 1 :: digits 1 n 
Arguments: (n : ℕ)
Goal: Nat.digits 1 (n + 1) = 1 :: Nat.digits 1 n
-- Nat.digits_add_two_add_one
theorem digits_add_two_add_one (b n : ℕ) :
    digits (b + 2) (n + 1) = ((n + 1) % (b + 2)) :: digits (b + 2) ((n + 1) / (b + 2)) 
Arguments: (b n : ℕ)
Goal: (b + 2).digits (n + 1) = (n + 1) % (b + 2) :: (b + 2).digits ((n + 1) / (b + 2))
-- Nat.digits_of_two_le_of_pos
@[simp]
lemma digits_of_two_le_of_pos {b : ℕ} (hb : 2 ≤ b) (hn : 0 < n) :
    Nat.digits b n = n % b :: Nat.digits b (n / b) 
Arguments: {n b : ℕ} (hb : 2 ≤ b) (hn : 0 < n)
Goal: b.digits n = n % b :: b.digits (n / b)
-- Nat.digits_def'
theorem digits_def' :
    ∀ {b : ℕ} (_ : 1 < b) {n : ℕ} (_ : 0 < n), digits b n = (n % b) :: digits b (n / b)
  
Arguments: {b : ℕ}
Goal: 1 < b → ∀ {n : ℕ}, 0 < n → b.digits n = n % b :: b.digits (n / b)
-- Nat.digits_of_lt
@[simp]
theorem digits_of_lt (b x : ℕ) (hx : x ≠ 0) (hxb : x < b) : digits b x = [x] 
Arguments: (b x : ℕ) (hx : x ≠ 0) (hxb : x < b)
Goal: b.digits x = [x]
-- Nat.digits_add
theorem digits_add (b : ℕ) (h : 1 < b) (x y : ℕ) (hxb : x < b) (hxy : x ≠ 0 ∨ y ≠ 0) :
    digits b (x + b * y) = x :: digits b y 
Arguments: (b : ℕ) (h : 1 < b) (x y : ℕ) (hxb : x < b) (hxy : x ≠ 0 ∨ y ≠ 0)
Goal: b.digits (x + b * y) = x :: b.digits y
-- Nat.ofDigits_eq_foldr
theorem ofDigits_eq_foldr {α : Type*} [Semiring α] (b : α) (L : List ℕ) :
    ofDigits b L = List.foldr (fun x y => ↑x + b * y) 0 L 
Arguments: {α : Type u_1} [Semiring α] (b : α) (L : List ℕ)
Goal: Nat.ofDigits b L = List.foldr (fun x y => ↑x + b * y) 0 L
-- Nat.ofDigits_eq_sum_map_with_index_aux
theorem ofDigits_eq_sum_map_with_index_aux (b : ℕ) (l : List ℕ) :
    ((List.range l.length).zipWith ((fun i a : ℕ => a * b ^ (i + 1))) l).sum =
      b * ((List.range l.length).zipWith (fun i a => a * b ^ i) l).sum 
Arguments: (b : ℕ) (l : List ℕ)
Goal: (List.zipWith (fun i a => a * b ^ (i + 1)) (List.range l.length) l).sum =
  b * (List.zipWith (fun i a => a * b ^ i) (List.range l.length) l).sum
-- Nat.ofDigits_eq_sum_mapIdx
theorem ofDigits_eq_sum_mapIdx (b : ℕ) (L : List ℕ) :
    ofDigits b L = (L.mapIdx fun i a => a * b ^ i).sum 
Arguments: (b : ℕ) (L : List ℕ)
Goal: Nat.ofDigits b L = (List.mapIdx (fun i a => a * b ^ i) L).sum
-- Nat.ofDigits_nil
@[simp]
theorem ofDigits_nil {b : ℕ} : ofDigits b [] = 0 
Arguments: {b : ℕ}
Goal: Nat.ofDigits b [] = 0
-- Nat.ofDigits_singleton
@[simp]
theorem ofDigits_singleton {b n : ℕ} : ofDigits b [n] = n 
Arguments: {b n : ℕ}
Goal: Nat.ofDigits b [n] = n
-- Nat.ofDigits_one_cons
@[simp]
theorem ofDigits_one_cons {α : Type*} [Semiring α] (h : ℕ) (L : List ℕ) :
    ofDigits (1 : α) (h :: L) = h + ofDigits 1 L 
Arguments: {α : Type u_1} [Semiring α] (h : ℕ) (L : List ℕ)
Goal: Nat.ofDigits 1 (h :: L) = ↑h + Nat.ofDigits 1 L
-- Nat.ofDigits_cons
theorem ofDigits_cons {b hd} {tl : List ℕ} :
    ofDigits b (hd :: tl) = hd + b * ofDigits b tl 
Arguments: {b hd : ℕ} {tl : List ℕ}
Goal: Nat.ofDigits b (hd :: tl) = hd + b * Nat.ofDigits b tl
-- Nat.ofDigits_append
theorem ofDigits_append {b : ℕ} {l1 l2 : List ℕ} :
    ofDigits b (l1 ++ l2) = ofDigits b l1 + b ^ l1.length * ofDigits b l2 
Arguments: {b : ℕ} {l1 l2 : List ℕ}
Goal: Nat.ofDigits b (l1 ++ l2) = Nat.ofDigits b l1 + b ^ l1.length * Nat.ofDigits b l2
-- Nat.coe_ofDigits
@[norm_cast]
theorem coe_ofDigits (α : Type*) [Semiring α] (b : ℕ) (L : List ℕ) :
    ((ofDigits b L : ℕ) : α) = ofDigits (b : α) L 
Arguments: (α : Type u_1) [Semiring α] (b : ℕ) (L : List ℕ)
Goal: ↑(Nat.ofDigits b L) = Nat.ofDigits (↑b) L
-- Nat.coe_int_ofDigits
@[norm_cast]
theorem coe_int_ofDigits (b : ℕ) (L : List ℕ) : ((ofDigits b L : ℕ) : ℤ) = ofDigits (b : ℤ) L 
Arguments: (b : ℕ) (L : List ℕ)
Goal: ↑(Nat.ofDigits b L) = Nat.ofDigits (↑b) L
-- Nat.digits_zero_of_eq_zero
theorem digits_zero_of_eq_zero {b : ℕ} (h : b ≠ 0) :
    ∀ {L : List ℕ} (_ : ofDigits b L = 0), ∀ l ∈ L, l = 0
  
Arguments: {b : ℕ} (h : b ≠ 0) {L : List ℕ}
Goal: Nat.ofDigits b L = 0 → ∀ l ∈ L, l = 0