ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Real.toNNReal_le_one
@[simp]
lemma toNNReal_le_one {r : ℝ} : r.toNNReal ≤ 1 ↔ r ≤ 1 
Arguments: {r : ℝ}
Goal: r.toNNReal ≤ 1 ↔ r ≤ 1
-- Real.one_lt_toNNReal
@[simp]
lemma one_lt_toNNReal {r : ℝ} : 1 < r.toNNReal ↔ 1 < r 
Arguments: {r : ℝ}
Goal: 1 < r.toNNReal ↔ 1 < r
-- Real.toNNReal_le_natCast
@[simp]
lemma toNNReal_le_natCast {r : ℝ} {n : ℕ} : r.toNNReal ≤ n ↔ r ≤ n 
Arguments: {r : ℝ} {n : ℕ}
Goal: r.toNNReal ≤ ↑n ↔ r ≤ ↑n
-- Real.natCast_lt_toNNReal
@[simp]
lemma natCast_lt_toNNReal {r : ℝ} {n : ℕ} : n < r.toNNReal ↔ n < r 
Arguments: {r : ℝ} {n : ℕ}
Goal: ↑n < r.toNNReal ↔ ↑n < r
-- Real.toNNReal_le_ofNat
@[simp]
lemma toNNReal_le_ofNat {r : ℝ} {n : ℕ} [n.AtLeastTwo] :
    r.toNNReal ≤ no_index (OfNat.ofNat n) ↔ r ≤ n 
Arguments: {r : ℝ} {n : ℕ} [n.AtLeastTwo]
Goal: r.toNNReal ≤ OfNat.ofNat n ↔ r ≤ ↑n
-- Real.ofNat_lt_toNNReal
@[simp]
lemma ofNat_lt_toNNReal {r : ℝ} {n : ℕ} [n.AtLeastTwo] :
    no_index (OfNat.ofNat n) < r.toNNReal ↔ n < r 
Arguments: {r : ℝ} {n : ℕ} [n.AtLeastTwo]
Goal: OfNat.ofNat n < r.toNNReal ↔ ↑n < r
-- Real.toNNReal_eq_toNNReal_iff
@[simp]
theorem toNNReal_eq_toNNReal_iff {r p : ℝ} (hr : 0 ≤ r) (hp : 0 ≤ p) :
    toNNReal r = toNNReal p ↔ r = p 
Arguments: {r p : ℝ} (hr : 0 ≤ r) (hp : 0 ≤ p)
Goal: r.toNNReal = p.toNNReal ↔ r = p
-- Real.toNNReal_lt_toNNReal_iff'
@[simp]
theorem toNNReal_lt_toNNReal_iff' {r p : ℝ} : Real.toNNReal r < Real.toNNReal p ↔ r < p ∧ 0 < p 
Arguments: {r p : ℝ}
Goal: r.toNNReal < p.toNNReal ↔ r < p ∧ 0 < p
-- Real.toNNReal_lt_toNNReal_iff
theorem toNNReal_lt_toNNReal_iff {r p : ℝ} (h : 0 < p) :
    Real.toNNReal r < Real.toNNReal p ↔ r < p 
Arguments: {r p : ℝ} (h : 0 < p)
Goal: r.toNNReal < p.toNNReal ↔ r < p
-- Real.lt_of_toNNReal_lt
theorem lt_of_toNNReal_lt {r p : ℝ} (h : r.toNNReal < p.toNNReal) : r < p 
Arguments: {r p : ℝ} (h : r.toNNReal < p.toNNReal)
Goal: r < p
-- Real.toNNReal_lt_toNNReal_iff_of_nonneg
theorem toNNReal_lt_toNNReal_iff_of_nonneg {r p : ℝ} (hr : 0 ≤ r) :
    Real.toNNReal r < Real.toNNReal p ↔ r < p 
Arguments: {r p : ℝ} (hr : 0 ≤ r)
Goal: r.toNNReal < p.toNNReal ↔ r < p
-- Real.toNNReal_le_toNNReal_iff'
lemma toNNReal_le_toNNReal_iff' {r p : ℝ} : r.toNNReal ≤ p.toNNReal ↔ r ≤ p ∨ r ≤ 0 
Arguments: {r p : ℝ}
Goal: r.toNNReal ≤ p.toNNReal ↔ r ≤ p ∨ r ≤ 0
-- Real.toNNReal_le_toNNReal_iff_of_pos
lemma toNNReal_le_toNNReal_iff_of_pos {r p : ℝ} (hr : 0 < r) : r.toNNReal ≤ p.toNNReal ↔ r ≤ p 
Arguments: {r p : ℝ} (hr : 0 < r)
Goal: r.toNNReal ≤ p.toNNReal ↔ r ≤ p
-- Real.one_le_toNNReal
@[simp]
lemma one_le_toNNReal {r : ℝ} : 1 ≤ r.toNNReal ↔ 1 ≤ r 
Arguments: {r : ℝ}
Goal: 1 ≤ r.toNNReal ↔ 1 ≤ r
-- Real.toNNReal_lt_one
@[simp]
lemma toNNReal_lt_one {r : ℝ} : r.toNNReal < 1 ↔ r < 1 
Arguments: {r : ℝ}
Goal: r.toNNReal < 1 ↔ r < 1
-- Real.natCastle_toNNReal'
@[simp]
lemma natCastle_toNNReal' {n : ℕ} {r : ℝ} : ↑n ≤ r.toNNReal ↔ n ≤ r ∨ n = 0 
Arguments: {n : ℕ} {r : ℝ}
Goal: ↑n ≤ r.toNNReal ↔ ↑n ≤ r ∨ n = 0
-- Real.toNNReal_lt_natCast'
@[simp]
lemma toNNReal_lt_natCast' {n : ℕ} {r : ℝ} : r.toNNReal < n ↔ r < n ∧ n ≠ 0 
Arguments: {n : ℕ} {r : ℝ}
Goal: r.toNNReal < ↑n ↔ r < ↑n ∧ n ≠ 0
-- Real.natCast_le_toNNReal
lemma natCast_le_toNNReal {n : ℕ} {r : ℝ} (hn : n ≠ 0) : ↑n ≤ r.toNNReal ↔ n ≤ r 
Arguments: {n : ℕ} {r : ℝ} (hn : n ≠ 0)
Goal: ↑n ≤ r.toNNReal ↔ ↑n ≤ r
-- Real.toNNReal_lt_natCast
lemma toNNReal_lt_natCast {r : ℝ} {n : ℕ} (hn : n ≠ 0) : r.toNNReal < n ↔ r < n 
Arguments: {r : ℝ} {n : ℕ} (hn : n ≠ 0)
Goal: r.toNNReal < ↑n ↔ r < ↑n
-- Real.toNNReal_lt_ofNat
@[simp]
lemma toNNReal_lt_ofNat {r : ℝ} {n : ℕ} [n.AtLeastTwo] :
    r.toNNReal < no_index (OfNat.ofNat n) ↔ r < OfNat.ofNat n 
Arguments: {r : ℝ} {n : ℕ} [n.AtLeastTwo]
Goal: r.toNNReal < OfNat.ofNat n ↔ r < OfNat.ofNat n
-- Real.ofNat_le_toNNReal
@[simp]
lemma ofNat_le_toNNReal {n : ℕ} {r : ℝ} [n.AtLeastTwo] :
    no_index (OfNat.ofNat n) ≤ r.toNNReal ↔ OfNat.ofNat n ≤ r 
Arguments: {n : ℕ} {r : ℝ} [n.AtLeastTwo]
Goal: OfNat.ofNat n ≤ r.toNNReal ↔ OfNat.ofNat n ≤ r
-- Real.toNNReal_add
@[simp]
theorem toNNReal_add {r p : ℝ} (hr : 0 ≤ r) (hp : 0 ≤ p) :
    Real.toNNReal (r + p) = Real.toNNReal r + Real.toNNReal p 
Arguments: {r p : ℝ} (hr : 0 ≤ r) (hp : 0 ≤ p)
Goal: (r + p).toNNReal = r.toNNReal + p.toNNReal
-- Real.toNNReal_add_toNNReal
theorem toNNReal_add_toNNReal {r p : ℝ} (hr : 0 ≤ r) (hp : 0 ≤ p) :
    Real.toNNReal r + Real.toNNReal p = Real.toNNReal (r + p) 
Arguments: {r p : ℝ} (hr : 0 ≤ r) (hp : 0 ≤ p)
Goal: r.toNNReal + p.toNNReal = (r + p).toNNReal
-- Real.toNNReal_le_toNNReal
theorem toNNReal_le_toNNReal {r p : ℝ} (h : r ≤ p) : Real.toNNReal r ≤ Real.toNNReal p 
Arguments: {r p : ℝ} (h : r ≤ p)
Goal: r.toNNReal ≤ p.toNNReal
-- Real.toNNReal_add_le
theorem toNNReal_add_le {r p : ℝ} : Real.toNNReal (r + p) ≤ Real.toNNReal r + Real.toNNReal p 
Arguments: {r p : ℝ}
Goal: (r + p).toNNReal ≤ r.toNNReal + p.toNNReal
-- Real.toNNReal_le_iff_le_coe
theorem toNNReal_le_iff_le_coe {r : ℝ} {p : ℝ≥0} : toNNReal r ≤ p ↔ r ≤ ↑p 
Arguments: {r : ℝ} {p : ℝ≥0}
Goal: r.toNNReal ≤ p ↔ r ≤ ↑p
-- Real.le_toNNReal_iff_coe_le
theorem le_toNNReal_iff_coe_le {r : ℝ≥0} {p : ℝ} (hp : 0 ≤ p) : r ≤ Real.toNNReal p ↔ ↑r ≤ p 
Arguments: {r : ℝ≥0} {p : ℝ} (hp : 0 ≤ p)
Goal: r ≤ p.toNNReal ↔ ↑r ≤ p
-- Real.le_toNNReal_iff_coe_le'
theorem le_toNNReal_iff_coe_le' {r : ℝ≥0} {p : ℝ} (hr : 0 < r) : r ≤ Real.toNNReal p ↔ ↑r ≤ p 
Arguments: {r : ℝ≥0} {p : ℝ} (hr : 0 < r)
Goal: r ≤ p.toNNReal ↔ ↑r ≤ p
-- Real.toNNReal_lt_iff_lt_coe
theorem toNNReal_lt_iff_lt_coe {r : ℝ} {p : ℝ≥0} (ha : 0 ≤ r) : Real.toNNReal r < p ↔ r < ↑p 
Arguments: {r : ℝ} {p : ℝ≥0} (ha : 0 ≤ r)
Goal: r.toNNReal < p ↔ r < ↑p
-- Real.lt_toNNReal_iff_coe_lt
theorem lt_toNNReal_iff_coe_lt {r : ℝ≥0} {p : ℝ} : r < Real.toNNReal p ↔ ↑r < p 
Arguments: {r : ℝ≥0} {p : ℝ}
Goal: r < p.toNNReal ↔ ↑r < p
-- Real.toNNReal_pow
theorem toNNReal_pow {x : ℝ} (hx : 0 ≤ x) (n : ℕ) : (x ^ n).toNNReal = x.toNNReal ^ n 
Arguments: {x : ℝ} (hx : 0 ≤ x) (n : ℕ)
Goal: (x ^ n).toNNReal = x.toNNReal ^ n
-- Real.toNNReal_mul
theorem toNNReal_mul {p q : ℝ} (hp : 0 ≤ p) :
    Real.toNNReal (p * q) = Real.toNNReal p * Real.toNNReal q 
Arguments: {p q : ℝ} (hp : 0 ≤ p)
Goal: (p * q).toNNReal = p.toNNReal * q.toNNReal
-- NNReal.mul_eq_mul_left
theorem mul_eq_mul_left {a b c : ℝ≥0} (h : a ≠ 0) : a * b = a * c ↔ b = c 
Arguments: {a b c : ℝ≥0} (h : a ≠ 0)
Goal: a * b = a * c ↔ b = c
-- NNReal.pow_antitone_exp
theorem pow_antitone_exp {a : ℝ≥0} (m n : ℕ) (mn : m ≤ n) (a1 : a ≤ 1) : a ^ n ≤ a ^ m 
Arguments: {a : ℝ≥0} (m n : ℕ) (mn : m ≤ n) (a1 : a ≤ 1)
Goal: a ^ n ≤ a ^ m
-- NNReal.exists_pow_lt_of_lt_one
nonrec theorem exists_pow_lt_of_lt_one {a b : ℝ≥0} (ha : 0 < a) (hb : b < 1) :
    ∃ n : ℕ, b ^ n < a 
Arguments: {a b : ℝ≥0} (ha : 0 < a) (hb : b < 1)
Goal: ∃ n, b ^ n < a
-- NNReal.exists_mem_Ico_zpow
nonrec theorem exists_mem_Ico_zpow {x : ℝ≥0} {y : ℝ≥0} (hx : x ≠ 0) (hy : 1 < y) :
    ∃ n : ℤ, x ∈ Set.Ico (y ^ n) (y ^ (n + 1)) 
Arguments: {x y : ℝ≥0} (hx : x ≠ 0) (hy : 1 < y)
Goal: ∃ n, x ∈ Set.Ico (y ^ n) (y ^ (n + 1))
-- NNReal.exists_mem_Ioc_zpow
nonrec theorem exists_mem_Ioc_zpow {x : ℝ≥0} {y : ℝ≥0} (hx : x ≠ 0) (hy : 1 < y) :
    ∃ n : ℤ, x ∈ Set.Ioc (y ^ n) (y ^ (n + 1)) 
Arguments: {x y : ℝ≥0} (hx : x ≠ 0) (hy : 1 < y)
Goal: ∃ n, x ∈ Set.Ioc (y ^ n) (y ^ (n + 1))
-- NNReal.sub_def
theorem sub_def {r p : ℝ≥0} : r - p = Real.toNNReal (r - p) 
Arguments: {r p : ℝ≥0}
Goal: r - p = (↑r - ↑p).toNNReal
-- NNReal.coe_sub_def
theorem coe_sub_def {r p : ℝ≥0} : ↑(r - p) = max (r - p : ℝ) 0 
Arguments: {r p : ℝ≥0}
Goal: ↑(r - p) = max (↑r - ↑p) 0
-- NNReal.sub_div
theorem sub_div (a b c : ℝ≥0) : (a - b) / c = a / c - b / c 
Arguments: (a b c : ℝ≥0)
Goal: (a - b) / c = a / c - b / c
-- NNReal.inv_le
@[simp]
theorem inv_le {r p : ℝ≥0} (h : r ≠ 0) : r⁻¹ ≤ p ↔ 1 ≤ r * p 
Arguments: {r p : ℝ≥0} (h : r ≠ 0)
Goal: r⁻¹ ≤ p ↔ 1 ≤ r * p
-- NNReal.inv_le_of_le_mul
theorem inv_le_of_le_mul {r p : ℝ≥0} (h : 1 ≤ r * p) : r⁻¹ ≤ p 
Arguments: {r p : ℝ≥0} (h : 1 ≤ r * p)
Goal: r⁻¹ ≤ p
-- NNReal.le_inv_iff_mul_le
@[simp]
theorem le_inv_iff_mul_le {r p : ℝ≥0} (h : p ≠ 0) : r ≤ p⁻¹ ↔ r * p ≤ 1 
Arguments: {r p : ℝ≥0} (h : p ≠ 0)
Goal: r ≤ p⁻¹ ↔ r * p ≤ 1
-- NNReal.lt_inv_iff_mul_lt
@[simp]
theorem lt_inv_iff_mul_lt {r p : ℝ≥0} (h : p ≠ 0) : r < p⁻¹ ↔ r * p < 1 
Arguments: {r p : ℝ≥0} (h : p ≠ 0)
Goal: r < p⁻¹ ↔ r * p < 1
-- NNReal.mul_le_iff_le_inv
theorem mul_le_iff_le_inv {a b r : ℝ≥0} (hr : r ≠ 0) : r * a ≤ b ↔ a ≤ r⁻¹ * b 
Arguments: {a b r : ℝ≥0} (hr : r ≠ 0)
Goal: r * a ≤ b ↔ a ≤ r⁻¹ * b
-- NNReal.le_div_iff_mul_le
theorem le_div_iff_mul_le {a b r : ℝ≥0} (hr : r ≠ 0) : a ≤ b / r ↔ a * r ≤ b 
Arguments: {a b r : ℝ≥0} (hr : r ≠ 0)
Goal: a ≤ b / r ↔ a * r ≤ b
-- NNReal.div_le_iff
theorem div_le_iff {a b r : ℝ≥0} (hr : r ≠ 0) : a / r ≤ b ↔ a ≤ b * r 
Arguments: {a b r : ℝ≥0} (hr : r ≠ 0)
Goal: a / r ≤ b ↔ a ≤ b * r
-- NNReal.div_le_iff'
nonrec theorem div_le_iff' {a b r : ℝ≥0} (hr : r ≠ 0) : a / r ≤ b ↔ a ≤ r * b 
Arguments: {a b r : ℝ≥0} (hr : r ≠ 0)
Goal: a / r ≤ b ↔ a ≤ r * b
-- NNReal.div_le_of_le_mul
theorem div_le_of_le_mul {a b c : ℝ≥0} (h : a ≤ b * c) : a / c ≤ b 
Arguments: {a b c : ℝ≥0} (h : a ≤ b * c)
Goal: a / c ≤ b
-- NNReal.div_le_of_le_mul'
theorem div_le_of_le_mul' {a b c : ℝ≥0} (h : a ≤ b * c) : a / b ≤ c 
Arguments: {a b c : ℝ≥0} (h : a ≤ b * c)
Goal: a / b ≤ c
-- NNReal.le_div_iff
nonrec theorem le_div_iff {a b r : ℝ≥0} (hr : r ≠ 0) : a ≤ b / r ↔ a * r ≤ b 
Arguments: {a b r : ℝ≥0} (hr : r ≠ 0)
Goal: a ≤ b / r ↔ a * r ≤ b
-- NNReal.le_div_iff'
nonrec theorem le_div_iff' {a b r : ℝ≥0} (hr : r ≠ 0) : a ≤ b / r ↔ r * a ≤ b 
Arguments: {a b r : ℝ≥0} (hr : r ≠ 0)
Goal: a ≤ b / r ↔ r * a ≤ b
-- NNReal.div_lt_iff
theorem div_lt_iff {a b r : ℝ≥0} (hr : r ≠ 0) : a / r < b ↔ a < b * r 
Arguments: {a b r : ℝ≥0} (hr : r ≠ 0)
Goal: a / r < b ↔ a < b * r
-- NNReal.div_lt_iff'
theorem div_lt_iff' {a b r : ℝ≥0} (hr : r ≠ 0) : a / r < b ↔ a < r * b 
Arguments: {a b r : ℝ≥0} (hr : r ≠ 0)
Goal: a / r < b ↔ a < r * b
-- NNReal.lt_div_iff
theorem lt_div_iff {a b r : ℝ≥0} (hr : r ≠ 0) : a < b / r ↔ a * r < b 
Arguments: {a b r : ℝ≥0} (hr : r ≠ 0)
Goal: a < b / r ↔ a * r < b
-- NNReal.lt_div_iff'
theorem lt_div_iff' {a b r : ℝ≥0} (hr : r ≠ 0) : a < b / r ↔ r * a < b 
Arguments: {a b r : ℝ≥0} (hr : r ≠ 0)
Goal: a < b / r ↔ r * a < b
-- NNReal.mul_lt_of_lt_div
theorem mul_lt_of_lt_div {a b r : ℝ≥0} (h : a < b / r) : a * r < b 
Arguments: {a b r : ℝ≥0} (h : a < b / r)
Goal: a * r < b
-- NNReal.div_le_div_left_of_le
theorem div_le_div_left_of_le {a b c : ℝ≥0} (c0 : c ≠ 0) (cb : c ≤ b) :
    a / b ≤ a / c 
Arguments: {a b c : ℝ≥0} (c0 : c ≠ 0) (cb : c ≤ b)
Goal: a / b ≤ a / c
-- NNReal.div_le_div_left
nonrec theorem div_le_div_left {a b c : ℝ≥0} (a0 : 0 < a) (b0 : 0 < b) (c0 : 0 < c) :
    a / b ≤ a / c ↔ c ≤ b 
Arguments: {a b c : ℝ≥0} (a0 : 0 < a) (b0 : 0 < b) (c0 : 0 < c)
Goal: a / b ≤ a / c ↔ c ≤ b
-- NNReal.le_of_forall_lt_one_mul_le
theorem le_of_forall_lt_one_mul_le {x y : ℝ≥0} (h : ∀ a < 1, a * x ≤ y) : x ≤ y 
Arguments: {x y : ℝ≥0} (h : ∀ a < 1, a * x ≤ y)
Goal: x ≤ y
-- NNReal.half_le_self
nonrec theorem half_le_self (a : ℝ≥0) : a / 2 ≤ a 
Arguments: (a : ℝ≥0)
Goal: a / 2 ≤ a
-- NNReal.half_lt_self
nonrec theorem half_lt_self {a : ℝ≥0} (h : a ≠ 0) : a / 2 < a 
Arguments: {a : ℝ≥0} (h : a ≠ 0)
Goal: a / 2 < a
-- NNReal.div_lt_one_of_lt
theorem div_lt_one_of_lt {a b : ℝ≥0} (h : a < b) : a / b < 1 
Arguments: {a b : ℝ≥0} (h : a < b)
Goal: a / b < 1
-- Real.toNNReal_inv
theorem _root_.Real.toNNReal_inv {x : ℝ} : Real.toNNReal x⁻¹ = (Real.toNNReal x)⁻¹ 
Arguments: {x : ℝ}
Goal: x⁻¹.toNNReal = x.toNNReal⁻¹
-- Real.toNNReal_div
theorem _root_.Real.toNNReal_div {x y : ℝ} (hx : 0 ≤ x) :
    Real.toNNReal (x / y) = Real.toNNReal x / Real.toNNReal y 
Arguments: {x y : ℝ} (hx : 0 ≤ x)
Goal: (x / y).toNNReal = x.toNNReal / y.toNNReal
-- Real.toNNReal_div'
theorem _root_.Real.toNNReal_div' {x y : ℝ} (hy : 0 ≤ y) :
    Real.toNNReal (x / y) = Real.toNNReal x / Real.toNNReal y 
Arguments: {x y : ℝ} (hy : 0 ≤ y)
Goal: (x / y).toNNReal = x.toNNReal / y.toNNReal
-- NNReal.inv_lt_one_iff
theorem inv_lt_one_iff {x : ℝ≥0} (hx : x ≠ 0) : x⁻¹ < 1 ↔ 1 < x 
Arguments: {x : ℝ≥0} (hx : x ≠ 0)
Goal: x⁻¹ < 1 ↔ 1 < x
-- NNReal.zpow_pos
theorem zpow_pos {x : ℝ≥0} (hx : x ≠ 0) (n : ℤ) : 0 < x ^ n 
Arguments: {x : ℝ≥0} (hx : x ≠ 0) (n : ℤ)
Goal: 0 < x ^ n
-- NNReal.inv_lt_inv
theorem inv_lt_inv {x y : ℝ≥0} (hx : x ≠ 0) (h : x < y) : y⁻¹ < x⁻¹ 
Arguments: {x y : ℝ≥0} (hx : x ≠ 0) (h : x < y)
Goal: y⁻¹ < x⁻¹
-- NNReal.abs_eq
@[simp]
theorem abs_eq (x : ℝ≥0) : |(x : ℝ)| = x 
Arguments: (x : ℝ≥0)
Goal: |↑x| = ↑x
-- NNReal.le_toNNReal_of_coe_le
theorem le_toNNReal_of_coe_le {x : ℝ≥0} {y : ℝ} (h : ↑x ≤ y) : x ≤ y.toNNReal 
Arguments: {x : ℝ≥0} {y : ℝ} (h : ↑x ≤ y)
Goal: x ≤ y.toNNReal
-- NNReal.sSup_of_not_bddAbove
nonrec theorem sSup_of_not_bddAbove {s : Set ℝ≥0} (hs : ¬BddAbove s) : SupSet.sSup s = 0 
Arguments: {s : Set ℝ≥0} (hs : ¬BddAbove s)
Goal: sSup s = 0
-- NNReal.iSup_of_not_bddAbove
theorem iSup_of_not_bddAbove (hf : ¬BddAbove (range f)) : ⨆ i, f i = 0 
Arguments: {ι : Sort u_1} {f : ι → ℝ≥0} (hf : ¬BddAbove (Set.range f))
Goal: ⨆ i, f i = 0
-- NNReal.iSup_empty
theorem iSup_empty [IsEmpty ι] (f : ι → ℝ≥0) : ⨆ i, f i = 0 
Arguments: {ι : Sort u_1} [IsEmpty ι] (f : ι → ℝ≥0)
Goal: ⨆ i, f i = 0
-- NNReal.iInf_empty
theorem iInf_empty [IsEmpty ι] (f : ι → ℝ≥0) : ⨅ i, f i = 0 
Arguments: {ι : Sort u_1} [IsEmpty ι] (f : ι → ℝ≥0)
Goal: ⨅ i, f i = 0
-- NNReal.iInf_const_zero
@[simp]
theorem iInf_const_zero {α : Sort*} : ⨅ _ : α, (0 : ℝ≥0) = 0 
Arguments: {α : Sort u_2}
Goal: ⨅ x, 0 = 0
-- NNReal.iInf_mul
theorem iInf_mul (f : ι → ℝ≥0) (a : ℝ≥0) : iInf f * a = ⨅ i, f i * a 
Arguments: {ι : Sort u_1} (f : ι → ℝ≥0) (a : ℝ≥0)
Goal: iInf f * a = ⨅ i, f i * a
-- NNReal.mul_iInf
theorem mul_iInf (f : ι → ℝ≥0) (a : ℝ≥0) : a * iInf f = ⨅ i, a * f i 
Arguments: {ι : Sort u_1} (f : ι → ℝ≥0) (a : ℝ≥0)
Goal: a * iInf f = ⨅ i, a * f i
-- NNReal.mul_iSup
theorem mul_iSup (f : ι → ℝ≥0) (a : ℝ≥0) : (a * ⨆ i, f i) = ⨆ i, a * f i 
Arguments: {ι : Sort u_1} (f : ι → ℝ≥0) (a : ℝ≥0)
Goal: a * ⨆ i, f i = ⨆ i, a * f i
-- NNReal.iSup_mul
theorem iSup_mul (f : ι → ℝ≥0) (a : ℝ≥0) : (⨆ i, f i) * a = ⨆ i, f i * a 
Arguments: {ι : Sort u_1} (f : ι → ℝ≥0) (a : ℝ≥0)
Goal: (⨆ i, f i) * a = ⨆ i, f i * a
-- NNReal.iSup_div
theorem iSup_div (f : ι → ℝ≥0) (a : ℝ≥0) : (⨆ i, f i) / a = ⨆ i, f i / a 
Arguments: {ι : Sort u_1} (f : ι → ℝ≥0) (a : ℝ≥0)
Goal: (⨆ i, f i) / a = ⨆ i, f i / a
-- NNReal.mul_iSup_le
theorem mul_iSup_le {a : ℝ≥0} {g : ℝ≥0} {h : ι → ℝ≥0} (H : ∀ j, g * h j ≤ a) : g * iSup h ≤ a 
Arguments: {ι : Sort u_1} {a g : ℝ≥0} {h : ι → ℝ≥0} (H : ∀ (j : ι), g * h j ≤ a)
Goal: g * iSup h ≤ a
-- NNReal.iSup_mul_le
theorem iSup_mul_le {a : ℝ≥0} {g : ι → ℝ≥0} {h : ℝ≥0} (H : ∀ i, g i * h ≤ a) : iSup g * h ≤ a 
Arguments: {ι : Sort u_1} {a : ℝ≥0} {g : ι → ℝ≥0} {h : ℝ≥0} (H : ∀ (i : ι), g i * h ≤ a)
Goal: iSup g * h ≤ a
-- NNReal.iSup_mul_iSup_le
theorem iSup_mul_iSup_le {a : ℝ≥0} {g h : ι → ℝ≥0} (H : ∀ i j, g i * h j ≤ a) :
    iSup g * iSup h ≤ a 
Arguments: {ι : Sort u_1} {a : ℝ≥0} {g h : ι → ℝ≥0} (H : ∀ (i j : ι), g i * h j ≤ a)
Goal: iSup g * iSup h ≤ a
-- NNReal.le_mul_iInf
theorem le_mul_iInf {a : ℝ≥0} {g : ℝ≥0} {h : ι → ℝ≥0} (H : ∀ j, a ≤ g * h j) : a ≤ g * iInf h 
Arguments: {ι : Sort u_1} [Nonempty ι] {a g : ℝ≥0} {h : ι → ℝ≥0} (H : ∀ (j : ι), a ≤ g * h j)
Goal: a ≤ g * iInf h
-- NNReal.le_iInf_mul
theorem le_iInf_mul {a : ℝ≥0} {g : ι → ℝ≥0} {h : ℝ≥0} (H : ∀ i, a ≤ g i * h) : a ≤ iInf g * h 
Arguments: {ι : Sort u_1} [Nonempty ι] {a : ℝ≥0} {g : ι → ℝ≥0} {h : ℝ≥0} (H : ∀ (i : ι), a ≤ g i * h)
Goal: a ≤ iInf g * h
-- NNReal.le_iInf_mul_iInf
theorem le_iInf_mul_iInf {a : ℝ≥0} {g h : ι → ℝ≥0} (H : ∀ i j, a ≤ g i * h j) :
    a ≤ iInf g * iInf h 
Arguments: {ι : Sort u_1} [Nonempty ι] {a : ℝ≥0} {g h : ι → ℝ≥0} (H : ∀ (i j : ι), a ≤ g i * h j)
Goal: a ≤ iInf g * iInf h
-- Set.OrdConnected.preimage_coe_nnreal_real
theorem preimage_coe_nnreal_real (h : s.OrdConnected) : ((↑) ⁻¹' s : Set ℝ≥0).OrdConnected 
Arguments: {s : Set ℝ} (h : s.OrdConnected)
Goal: (NNReal.toReal ⁻¹' s).OrdConnected
-- Set.OrdConnected.image_coe_nnreal_real
theorem image_coe_nnreal_real (h : t.OrdConnected) : ((↑) '' t : Set ℝ).OrdConnected 
Arguments: {t : Set ℝ≥0} (h : t.OrdConnected)
Goal: (NNReal.toReal '' t).OrdConnected
-- Set.OrdConnected.image_real_toNNReal
theorem image_real_toNNReal (h : s.OrdConnected) : (Real.toNNReal '' s).OrdConnected 
Arguments: {s : Set ℝ} (h : s.OrdConnected)
Goal: (Real.toNNReal '' s).OrdConnected
-- Set.OrdConnected.preimage_real_toNNReal
theorem preimage_real_toNNReal (h : t.OrdConnected) : (Real.toNNReal ⁻¹' t).OrdConnected 
Arguments: {t : Set ℝ≥0} (h : t.OrdConnected)
Goal: (Real.toNNReal ⁻¹' t).OrdConnected
-- Real.coe_nnabs
@[norm_cast, simp]
theorem coe_nnabs (x : ℝ) : (nnabs x : ℝ) = |x| 
Arguments: (x : ℝ)
Goal: ↑(Real.nnabs x) = |x|
-- Real.nnabs_of_nonneg
@[simp]
theorem nnabs_of_nonneg {x : ℝ} (h : 0 ≤ x) : nnabs x = toNNReal x 
Arguments: {x : ℝ} (h : 0 ≤ x)
Goal: Real.nnabs x = x.toNNReal
-- Real.nnabs_coe
theorem nnabs_coe (x : ℝ≥0) : nnabs x = x 
Arguments: (x : ℝ≥0)
Goal: Real.nnabs ↑x = x
-- Real.coe_toNNReal_le
theorem coe_toNNReal_le (x : ℝ) : (toNNReal x : ℝ) ≤ |x| 
Arguments: (x : ℝ)
Goal: ↑x.toNNReal ≤ |x|
-- Real.toNNReal_abs
@[simp] lemma toNNReal_abs (x : ℝ) : |x|.toNNReal = nnabs x 
Arguments: (x : ℝ)
Goal: |x|.toNNReal = Real.nnabs x
-- Real.cast_natAbs_eq_nnabs_cast
theorem cast_natAbs_eq_nnabs_cast (n : ℤ) : (n.natAbs : ℝ≥0) = nnabs n 
Arguments: (n : ℤ)
Goal: ↑n.natAbs = Real.nnabs ↑n
-- NNReal.exists_lt_of_strictMono
theorem NNReal.exists_lt_of_strictMono [h : Nontrivial Γ₀ˣ] {f : Γ₀ →*₀ ℝ≥0} (hf : StrictMono f)
    {r : ℝ≥0} (hr : 0 < r) : ∃ d : Γ₀ˣ, f d < r 
Arguments: {Γ₀ : Type u_1} [LinearOrderedCommGroupWithZero Γ₀] [h : Nontrivial Γ₀ˣ] {f : Γ₀ →*₀ ℝ≥0} (hf : StrictMono ⇑f) {r : ℝ≥0} (hr : 0 < r)
Goal: ∃ d, f ↑d < r
-- Real.exists_lt_of_strictMono
theorem Real.exists_lt_of_strictMono [h : Nontrivial Γ₀ˣ] {f : Γ₀ →*₀ ℝ≥0} (hf : StrictMono f)
    {r : ℝ} (hr : 0 < r) : ∃ d : Γ₀ˣ, (f d : ℝ) < r 
Arguments: {Γ₀ : Type u_1} [LinearOrderedCommGroupWithZero Γ₀] [h : Nontrivial Γ₀ˣ] {f : Γ₀ →*₀ ℝ≥0} (hf : StrictMono ⇑f) {r : ℝ} (hr : 0 < r)
Goal: ∃ d, ↑(f ↑d) < r
-- String.ltb_cons_addChar
theorem ltb_cons_addChar (c : Char) (cs₁ cs₂ : List Char) (i₁ i₂ : Pos) :
    ltb ⟨⟨c :: cs₁⟩, i₁ + c⟩ ⟨⟨c :: cs₂⟩, i₂ + c⟩ = ltb ⟨⟨cs₁⟩, i₁⟩ ⟨⟨cs₂⟩, i₂⟩ 
Arguments: (c : Char) (cs₁ cs₂ : List Char) (i₁ i₂ : String.Pos)
Goal: String.ltb { s := { data := c :: cs₁ }, i := i₁ + c } { s := { data := c :: cs₂ }, i := i₂ + c } =
  String.ltb { s := { data := cs₁ }, i := i₁ } { s := { data := cs₂ }, i := i₂ }
-- String.lt_iff_toList_lt
@[simp]
theorem lt_iff_toList_lt : ∀ {s₁ s₂ : String}, s₁ < s₂ ↔ s₁.toList < s₂.toList
  
Arguments: {s₁ s₂ : String}
Goal: s₁ < s₂ ↔ s₁.toList < s₂.toList
-- String.le_iff_toList_le
@[simp]
theorem le_iff_toList_le {s₁ s₂ : String} : s₁ ≤ s₂ ↔ s₁.toList ≤ s₂.toList 
Arguments: {s₁ s₂ : String}
Goal: s₁ ≤ s₂ ↔ s₁.toList ≤ s₂.toList
-- String.toList_inj
theorem toList_inj {s₁ s₂ : String} : s₁.toList = s₂.toList ↔ s₁ = s₂ 
Arguments: {s₁ s₂ : String}
Goal: s₁.toList = s₂.toList ↔ s₁ = s₂
-- String.asString_nil
theorem asString_nil : [].asString = "" 
Goal: [].asString = ""
-- String.toList_empty
@[simp]
theorem toList_empty : "".toList = [] 
Goal: "".toList = []
-- String.asString_toList
theorem asString_toList (s : String) : s.toList.asString = s 
Arguments: (s : String)
Goal: s.toList.asString = s
-- String.toList_nonempty
theorem toList_nonempty : ∀ {s : String}, s ≠ "" → s.toList = s.head :: (s.drop 1).toList
  
Arguments: {s : String}
Goal: s ≠ "" → s.toList = s.head :: (s.drop 1).toList
-- String.head_empty
@[simp]
theorem head_empty : "".data.head! = default 
Goal: "".data.head! = default
-- List.toList_asString
theorem toList_asString (l : List Char) : l.asString.toList = l 
Arguments: (l : List Char)
Goal: l.asString.toList = l
-- List.length_asString
@[simp]
theorem length_asString (l : List Char) : l.asString.length = l.length 
Arguments: (l : List Char)
Goal: l.asString.length = l.length
-- List.asString_inj
@[simp]
theorem asString_inj {l l' : List Char} : l.asString = l'.asString ↔ l = l' 
Arguments: {l l' : List Char}
Goal: l.asString = l'.asString ↔ l = l'
-- List.asString_eq
theorem asString_eq {l : List Char} {s : String} : l.asString = s ↔ l = s.toList 
Arguments: {l : List Char} {s : String}
Goal: l.asString = s ↔ l = s.toList
-- String.length_data
@[simp]
theorem String.length_data (s : String) : s.data.length = s.length 
Arguments: (s : String)
Goal: s.data.length = s.length
-- Real.isCauSeq_iff_lift
theorem isCauSeq_iff_lift {f : ℕ → ℚ} : IsCauSeq abs f ↔ IsCauSeq abs fun i => (f i : ℝ) 
Arguments: {f : ℕ → ℚ}
Goal: IsCauSeq abs f ↔ IsCauSeq abs fun i => ↑(f i)
-- Real.of_near
theorem of_near (f : ℕ → ℚ) (x : ℝ) (h : ∀ ε > 0, ∃ i, ∀ j ≥ i, |(f j : ℝ) - x| < ε) :
    ∃ h', Real.mk ⟨f, h'⟩ = x 
Arguments: (f : ℕ → ℚ) (x : ℝ) (h : ∀ ε > 0, ∃ i, ∀ j ≥ i, |↑(f j) - x| < ε)
Goal: ∃ (h' : IsCauSeq abs f), Real.mk ⟨f, h'⟩ = x
-- Real.exists_floor
theorem exists_floor (x : ℝ) : ∃ ub : ℤ, (ub : ℝ) ≤ x ∧ ∀ z : ℤ, (z : ℝ) ≤ x → z ≤ ub 
Arguments: (x : ℝ)
Goal: ∃ ub, ↑ub ≤ x ∧ ∀ (z : ℤ), ↑z ≤ x → z ≤ ub
-- Real.exists_isLUB
theorem exists_isLUB {S : Set ℝ} (hne : S.Nonempty) (hbdd : BddAbove S) : ∃ x, IsLUB S x 
Arguments: {S : Set ℝ} (hne : S.Nonempty) (hbdd : BddAbove S)
Goal: ∃ x, IsLUB S x
-- Real.exists_isGLB
theorem exists_isGLB {S : Set ℝ} (hne : S.Nonempty) (hbdd : BddBelow S) : ∃ x, IsGLB S x 
Arguments: {S : Set ℝ} (hne : S.Nonempty) (hbdd : BddBelow S)
Goal: ∃ x, IsGLB S x
-- Real.sSup_def
theorem sSup_def (S : Set ℝ) :
    sSup S = if h : S.Nonempty ∧ BddAbove S then Classical.choose (exists_isLUB h.1 h.2) else 0 
Arguments: (S : Set ℝ)
Goal: sSup S = if h : S.Nonempty ∧ BddAbove S then Classical.choose ⋯ else 0
-- Real.isLUB_sSup
protected theorem isLUB_sSup (S : Set ℝ) (h₁ : S.Nonempty) (h₂ : BddAbove S) :
    IsLUB S (sSup S) 
Arguments: (S : Set ℝ) (h₁ : S.Nonempty) (h₂ : BddAbove S)
Goal: IsLUB S (sSup S)
-- Real.sInf_def
theorem sInf_def (S : Set ℝ) : sInf S = -sSup (-S) 
Arguments: (S : Set ℝ)
Goal: sInf S = -sSup (-S)
-- Real.is_glb_sInf
protected theorem is_glb_sInf (S : Set ℝ) (h₁ : S.Nonempty) (h₂ : BddBelow S) :
    IsGLB S (sInf S) 
Arguments: (S : Set ℝ) (h₁ : S.Nonempty) (h₂ : BddBelow S)
Goal: IsGLB S (sInf S)
-- Real.lt_sInf_add_pos
theorem lt_sInf_add_pos {s : Set ℝ} (h : s.Nonempty) {ε : ℝ} (hε : 0 < ε) :
    ∃ a ∈ s, a < sInf s + ε 
Arguments: {s : Set ℝ} (h : s.Nonempty) {ε : ℝ} (hε : 0 < ε)
Goal: ∃ a ∈ s, a < sInf s + ε
-- Real.add_neg_lt_sSup
theorem add_neg_lt_sSup {s : Set ℝ} (h : s.Nonempty) {ε : ℝ} (hε : ε < 0) :
    ∃ a ∈ s, sSup s + ε < a 
Arguments: {s : Set ℝ} (h : s.Nonempty) {ε : ℝ} (hε : ε < 0)
Goal: ∃ a ∈ s, sSup s + ε < a
-- Real.sInf_le_iff
theorem sInf_le_iff {s : Set ℝ} (h : BddBelow s) (h' : s.Nonempty) {a : ℝ} :
    sInf s ≤ a ↔ ∀ ε, 0 < ε → ∃ x ∈ s, x < a + ε 
Arguments: {s : Set ℝ} (h : BddBelow s) (h' : s.Nonempty) {a : ℝ}
Goal: sInf s ≤ a ↔ ∀ (ε : ℝ), 0 < ε → ∃ x ∈ s, x < a + ε
-- Real.le_sSup_iff
theorem le_sSup_iff {s : Set ℝ} (h : BddAbove s) (h' : s.Nonempty) {a : ℝ} :
    a ≤ sSup s ↔ ∀ ε, ε < 0 → ∃ x ∈ s, a + ε < x 
Arguments: {s : Set ℝ} (h : BddAbove s) (h' : s.Nonempty) {a : ℝ}
Goal: a ≤ sSup s ↔ ∀ ε < 0, ∃ x ∈ s, a + ε < x
-- Real.sSup_empty
@[simp]
theorem sSup_empty : sSup (∅ : Set ℝ) = 0 
Goal: sSup ∅ = 0
-- Real.iSup_of_isEmpty
@[simp] lemma iSup_of_isEmpty {α : Sort*} [IsEmpty α] (f : α → ℝ) : ⨆ i, f i = 0 
Arguments: {α : Sort u_1} [IsEmpty α] (f : α → ℝ)
Goal: ⨆ i, f i = 0
-- Real.ciSup_const_zero
@[simp]
theorem ciSup_const_zero {α : Sort*} : ⨆ _ : α, (0 : ℝ) = 0 
Arguments: {α : Sort u_1}
Goal: ⨆ x, 0 = 0
-- Real.sSup_of_not_bddAbove
theorem sSup_of_not_bddAbove {s : Set ℝ} (hs : ¬BddAbove s) : sSup s = 0 
Arguments: {s : Set ℝ} (hs : ¬BddAbove s)
Goal: sSup s = 0
-- Real.iSup_of_not_bddAbove
theorem iSup_of_not_bddAbove {α : Sort*} {f : α → ℝ} (hf : ¬BddAbove (Set.range f)) :
    ⨆ i, f i = 0 
Arguments: {α : Sort u_1} {f : α → ℝ} (hf : ¬BddAbove (Set.range f))
Goal: ⨆ i, f i = 0
-- Real.sSup_univ
theorem sSup_univ : sSup (@Set.univ ℝ) = 0 
Goal: sSup Set.univ = 0
-- Real.sInf_empty
@[simp]
theorem sInf_empty : sInf (∅ : Set ℝ) = 0 
Goal: sInf ∅ = 0