ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Real.cauchy_add
theorem cauchy_add : ∀ a b, (a + b : ℝ).cauchy = a.cauchy + b.cauchy
  
Arguments: (a b : ℝ)
Goal: (a + b).cauchy = a.cauchy + b.cauchy
-- Real.cauchy_neg
theorem cauchy_neg : ∀ a, (-a : ℝ).cauchy = -a.cauchy
  
Arguments: (a : ℝ)
Goal: (-a).cauchy = -a.cauchy
-- Real.cauchy_mul
theorem cauchy_mul : ∀ a b, (a * b : ℝ).cauchy = a.cauchy * b.cauchy
  
Arguments: (a b : ℝ)
Goal: (a * b).cauchy = a.cauchy * b.cauchy
-- Real.cauchy_sub
theorem cauchy_sub : ∀ a b, (a - b : ℝ).cauchy = a.cauchy - b.cauchy
  
Arguments: (a b : ℝ)
Goal: (a - b).cauchy = a.cauchy - b.cauchy
-- Real.cauchy_inv
theorem cauchy_inv : ∀ f, (f⁻¹ : ℝ).cauchy = f.cauchy⁻¹
  
Arguments: (f : ℝ)
Goal: f⁻¹.cauchy = f.cauchy⁻¹
-- Real.ofCauchy_natCast
lemma ofCauchy_natCast (n : ℕ) : (⟨n⟩ : ℝ) = n 
Arguments: (n : ℕ)
Goal: { cauchy := ↑n } = ↑n
-- Real.ofCauchy_intCast
lemma ofCauchy_intCast (z : ℤ) : (⟨z⟩ : ℝ) = z 
Arguments: (z : ℤ)
Goal: { cauchy := ↑z } = ↑z
-- Real.ofCauchy_nnratCast
lemma ofCauchy_nnratCast (q : ℚ≥0) : (⟨q⟩ : ℝ) = q 
Arguments: (q : ℚ≥0)
Goal: { cauchy := ↑q } = ↑q
-- Real.ofCauchy_ratCast
lemma ofCauchy_ratCast (q : ℚ) : (⟨q⟩ : ℝ) = q 
Arguments: (q : ℚ)
Goal: { cauchy := ↑q } = ↑q
-- Real.cauchy_natCast
lemma cauchy_natCast (n : ℕ) : (n : ℝ).cauchy = n 
Arguments: (n : ℕ)
Goal: (↑n).cauchy = ↑n
-- Real.cauchy_intCast
lemma cauchy_intCast (z : ℤ) : (z : ℝ).cauchy = z 
Arguments: (z : ℤ)
Goal: (↑z).cauchy = ↑z
-- Real.cauchy_nnratCast
lemma cauchy_nnratCast (q : ℚ≥0) : (q : ℝ).cauchy = q 
Arguments: (q : ℚ≥0)
Goal: (↑q).cauchy = ↑q
-- Real.cauchy_ratCast
lemma cauchy_ratCast (q : ℚ) : (q : ℝ).cauchy = q 
Arguments: (q : ℚ)
Goal: (↑q).cauchy = ↑q
-- Real.ringEquivCauchy_symm_apply_cauchy
@[simps]
def ringEquivCauchy : ℝ ≃+* CauSeq.Completion.Cauchy (abs : ℚ → ℚ) 
Arguments: (cauchy : CauSeq.Completion.Cauchy abs)
Goal: (Real.ringEquivCauchy.symm cauchy).cauchy = cauchy
-- Real.ringEquivCauchy_apply
@[simps]
def ringEquivCauchy : ℝ ≃+* CauSeq.Completion.Cauchy (abs : ℚ → ℚ) 
Arguments: (self : ℝ)
Goal: Real.ringEquivCauchy self = self.cauchy
-- Real.mk_eq
theorem mk_eq {f g : CauSeq ℚ abs} : mk f = mk g ↔ f ≈ g 
Arguments: {f g : CauSeq ℚ abs}
Goal: Real.mk f = Real.mk g ↔ f ≈ g
-- _private.Mathlib.Data.Real.Basic.0.Real.lt_def
private irreducible_def lt : ℝ → ℝ → Prop
  
Goal: ∀ (x x_1 : ℝ),
  Real.lt x x_1 =
    match x, x_1 with
    | { cauchy := x }, { cauchy := y } => Quotient.liftOn₂ x y (fun x x_2 => x < x_2) Real.definition.proof_1✝
-- Real.lt_cauchy
theorem lt_cauchy {f g} : (⟨⟦f⟧⟩ : ℝ) < ⟨⟦g⟧⟩ ↔ f < g 
Arguments: {f g : CauSeq ℚ abs}
Goal: { cauchy := ⟦f⟧ } < { cauchy := ⟦g⟧ } ↔ f < g
-- Real.mk_lt
@[simp]
theorem mk_lt {f g : CauSeq ℚ abs} : mk f < mk g ↔ f < g 
Arguments: {f g : CauSeq ℚ abs}
Goal: Real.mk f < Real.mk g ↔ f < g
-- Real.mk_zero
theorem mk_zero : mk 0 = 0 
Goal: Real.mk 0 = 0
-- Real.mk_one
theorem mk_one : mk 1 = 1 
Goal: Real.mk 1 = 1
-- Real.mk_add
theorem mk_add {f g : CauSeq ℚ abs} : mk (f + g) = mk f + mk g 
Arguments: {f g : CauSeq ℚ abs}
Goal: Real.mk (f + g) = Real.mk f + Real.mk g
-- Real.mk_mul
theorem mk_mul {f g : CauSeq ℚ abs} : mk (f * g) = mk f * mk g 
Arguments: {f g : CauSeq ℚ abs}
Goal: Real.mk (f * g) = Real.mk f * Real.mk g
-- Real.mk_neg
theorem mk_neg {f : CauSeq ℚ abs} : mk (-f) = -mk f 
Arguments: {f : CauSeq ℚ abs}
Goal: Real.mk (-f) = -Real.mk f
-- Real.mk_pos
@[simp]
theorem mk_pos {f : CauSeq ℚ abs} : 0 < mk f ↔ Pos f 
Arguments: {f : CauSeq ℚ abs}
Goal: 0 < Real.mk f ↔ f.Pos
-- _private.Mathlib.Data.Real.Basic.0.Real.le_def
private irreducible_def le (x y : ℝ) : Prop 
Arguments: (x y : ℝ)
Goal: Real.le x y = (x < y ∨ x = y)
-- _private.Mathlib.Data.Real.Basic.0.Real.le_def'
private theorem le_def' {x y : ℝ} : x ≤ y ↔ x < y ∨ x = y 
Arguments: {x y : ℝ}
Goal: x ≤ y ↔ x < y ∨ x = y
-- Real.mk_le
@[simp]
theorem mk_le {f g : CauSeq ℚ abs} : mk f ≤ mk g ↔ f ≤ g 
Arguments: {f g : CauSeq ℚ abs}
Goal: Real.mk f ≤ Real.mk g ↔ f ≤ g
-- Real.ind_mk
@[elab_as_elim]
protected theorem ind_mk {C : Real → Prop} (x : Real) (h : ∀ y, C (mk y)) : C x 
Arguments: {C : ℝ → Prop} (x : ℝ) (h : ∀ (y : CauSeq ℚ abs), C (Real.mk y))
Goal: C x
-- Real.add_lt_add_iff_left
theorem add_lt_add_iff_left {a b : ℝ} (c : ℝ) : c + a < c + b ↔ a < b 
Arguments: {a b : ℝ} (c : ℝ)
Goal: c + a < c + b ↔ a < b
-- Real.ratCast_lt
theorem ratCast_lt {x y : ℚ} : (x : ℝ) < (y : ℝ) ↔ x < y 
Arguments: {x y : ℚ}
Goal: ↑x < ↑y ↔ x < y
-- Real.zero_lt_one
protected theorem zero_lt_one : (0 : ℝ) < 1 
Goal: 0 < 1
-- Real.fact_zero_lt_one
protected theorem fact_zero_lt_one : Fact ((0 : ℝ) < 1) 
Goal: Fact (0 < 1)
-- Real.mul_pos
protected theorem mul_pos {a b : ℝ} : 0 < a → 0 < b → 0 < a * b 
Arguments: {a b : ℝ}
Goal: 0 < a → 0 < b → 0 < a * b
-- _private.Mathlib.Data.Real.Basic.0.Real.sup_def
private irreducible_def sup : ℝ → ℝ → ℝ
  
Goal: ∀ (x x_1 : ℝ),
  Real.sup x x_1 =
    match x, x_1 with
    | { cauchy := x }, { cauchy := y } => { cauchy := Quotient.map₂ (fun x x_2 => x ⊔ x_2) ⋯ x y }
-- Real.ofCauchy_sup
theorem ofCauchy_sup (a b) : (⟨⟦a ⊔ b⟧⟩ : ℝ) = ⟨⟦a⟧⟩ ⊔ ⟨⟦b⟧⟩ 
Arguments: (a b : CauSeq ℚ abs)
Goal: { cauchy := ⟦a ⊔ b⟧ } = { cauchy := ⟦a⟧ } ⊔ { cauchy := ⟦b⟧ }
-- Real.mk_sup
@[simp]
theorem mk_sup (a b) : (mk (a ⊔ b) : ℝ) = mk a ⊔ mk b 
Arguments: (a b : CauSeq ℚ abs)
Goal: Real.mk (a ⊔ b) = Real.mk a ⊔ Real.mk b
-- _private.Mathlib.Data.Real.Basic.0.Real.inf_def
private irreducible_def inf : ℝ → ℝ → ℝ
  
Goal: ∀ (x x_1 : ℝ),
  Real.inf x x_1 =
    match x, x_1 with
    | { cauchy := x }, { cauchy := y } => { cauchy := Quotient.map₂ (fun x x_2 => x ⊓ x_2) ⋯ x y }
-- Real.ofCauchy_inf
theorem ofCauchy_inf (a b) : (⟨⟦a ⊓ b⟧⟩ : ℝ) = ⟨⟦a⟧⟩ ⊓ ⟨⟦b⟧⟩ 
Arguments: (a b : CauSeq ℚ abs)
Goal: { cauchy := ⟦a ⊓ b⟧ } = { cauchy := ⟦a⟧ } ⊓ { cauchy := ⟦b⟧ }
-- Real.mk_inf
@[simp]
theorem mk_inf (a b) : (mk (a ⊓ b) : ℝ) = mk a ⊓ mk b 
Arguments: (a b : CauSeq ℚ abs)
Goal: Real.mk (a ⊓ b) = Real.mk a ⊓ Real.mk b
-- Real.ofCauchy_div
lemma ofCauchy_div (f g) : (⟨f / g⟩ : ℝ) = (⟨f⟩ : ℝ) / (⟨g⟩ : ℝ) 
Arguments: (f g : CauSeq.Completion.Cauchy abs)
Goal: { cauchy := f / g } = { cauchy := f } / { cauchy := g }
-- Real.le_mk_of_forall_le
theorem le_mk_of_forall_le {f : CauSeq ℚ abs} : (∃ i, ∀ j ≥ i, x ≤ f j) → x ≤ mk f 
Arguments: {x : ℝ} {f : CauSeq ℚ abs}
Goal: (∃ i, ∀ j ≥ i, x ≤ ↑(↑f j)) → x ≤ Real.mk f
-- Real.mk_le_of_forall_le
theorem mk_le_of_forall_le {f : CauSeq ℚ abs} {x : ℝ} (h : ∃ i, ∀ j ≥ i, (f j : ℝ) ≤ x) :
    mk f ≤ x 
Arguments: {f : CauSeq ℚ abs} {x : ℝ} (h : ∃ i, ∀ j ≥ i, ↑(↑f j) ≤ x)
Goal: Real.mk f ≤ x
-- Real.mk_near_of_forall_near
theorem mk_near_of_forall_near {f : CauSeq ℚ abs} {x : ℝ} {ε : ℝ}
    (H : ∃ i, ∀ j ≥ i, |(f j : ℝ) - x| ≤ ε) : |mk f - x| ≤ ε 
Arguments: {f : CauSeq ℚ abs} {x ε : ℝ} (H : ∃ i, ∀ j ≥ i, |↑(↑f j) - x| ≤ ε)
Goal: |Real.mk f - x| ≤ ε
-- Real.pi_gt_sqrtTwoAddSeries
theorem pi_gt_sqrtTwoAddSeries (n : ℕ) :
    (2 : ℝ) ^ (n + 1) * √(2 - sqrtTwoAddSeries 0 n) < π 
Arguments: (n : ℕ)
Goal: 2 ^ (n + 1) * √(2 - Real.sqrtTwoAddSeries 0 n) < π
-- Real.pi_lt_sqrtTwoAddSeries
theorem pi_lt_sqrtTwoAddSeries (n : ℕ) :
    π < (2 : ℝ) ^ (n + 1) * √(2 - sqrtTwoAddSeries 0 n) + 1 / (4 : ℝ) ^ n 
Arguments: (n : ℕ)
Goal: π < 2 ^ (n + 1) * √(2 - Real.sqrtTwoAddSeries 0 n) + 1 / 4 ^ n
-- Real.pi_lower_bound_start
theorem pi_lower_bound_start (n : ℕ) {a}
    (h : sqrtTwoAddSeries ((0 : ℕ) / (1 : ℕ)) n ≤ (2 : ℝ) - (a / (2 : ℝ) ^ (n + 1)) ^ 2) :
    a < π 
Arguments: (n : ℕ) {a : ℝ} (h : (↑0 / ↑1).sqrtTwoAddSeries n ≤ 2 - (a / 2 ^ (n + 1)) ^ 2)
Goal: a < π
-- Real.sqrtTwoAddSeries_step_up
theorem sqrtTwoAddSeries_step_up (c d : ℕ) {a b n : ℕ} {z : ℝ} (hz : sqrtTwoAddSeries (c / d) n ≤ z)
    (hb : 0 < b) (hd : 0 < d) (h : (2 * b + a) * d ^ 2 ≤ c ^ 2 * b) :
    sqrtTwoAddSeries (a / b) (n + 1) ≤ z 
Arguments: (c d : ℕ) {a b n : ℕ} {z : ℝ} (hz : (↑c / ↑d).sqrtTwoAddSeries n ≤ z) (hb : 0 < b) (hd : 0 < d) (h : (2 * b + a) * d ^ 2 ≤ c ^ 2 * b)
Goal: (↑a / ↑b).sqrtTwoAddSeries (n + 1) ≤ z
-- Real.pi_upper_bound_start
theorem pi_upper_bound_start (n : ℕ) {a}
    (h : (2 : ℝ) - ((a - 1 / (4 : ℝ) ^ n) / (2 : ℝ) ^ (n + 1)) ^ 2 ≤
        sqrtTwoAddSeries ((0 : ℕ) / (1 : ℕ)) n)
    (h₂ : (1 : ℝ) / (4 : ℝ) ^ n ≤ a) : π < a 
Arguments: (n : ℕ) {a : ℝ} (h : 2 - ((a - 1 / 4 ^ n) / 2 ^ (n + 1)) ^ 2 ≤ (↑0 / ↑1).sqrtTwoAddSeries n) (h₂ : 1 / 4 ^ n ≤ a)
Goal: π < a
-- Real.sqrtTwoAddSeries_step_down
theorem sqrtTwoAddSeries_step_down (a b : ℕ) {c d n : ℕ} {z : ℝ}
    (hz : z ≤ sqrtTwoAddSeries (a / b) n) (hb : 0 < b) (hd : 0 < d)
    (h : a ^ 2 * d ≤ (2 * d + c) * b ^ 2) : z ≤ sqrtTwoAddSeries (c / d) (n + 1) 
Arguments: (a b : ℕ) {c d n : ℕ} {z : ℝ} (hz : z ≤ (↑a / ↑b).sqrtTwoAddSeries n) (hb : 0 < b) (hd : 0 < d) (h : a ^ 2 * d ≤ (2 * d + c) * b ^ 2)
Goal: z ≤ (↑c / ↑d).sqrtTwoAddSeries (n + 1)
-- Real.pi_gt_three
theorem pi_gt_three : 3 < π 
Goal: 3 < π
-- Real.pi_gt_314
theorem pi_gt_314 : 3.14 < π 
Goal: 3.14 < π
-- Real.pi_lt_315
theorem pi_lt_315 : π < 3.15 
Goal: π < 3.15
-- Real.pi_gt_31415
theorem pi_gt_31415 : 3.1415 < π 
Goal: 3.1415 < π
-- Real.pi_lt_31416
theorem pi_lt_31416 : π < 3.1416 
Goal: π < 3.1416
-- Real.pi_gt_3141592
theorem pi_gt_3141592 : 3.141592 < π 
Goal: 3.141592 < π
-- Real.pi_lt_3141593
theorem pi_lt_3141593 : π < 3.141593 
Goal: π < 3.141593
-- Real.tendsto_sum_pi_div_four
theorem tendsto_sum_pi_div_four :
    Tendsto (fun k => ∑ i ∈ range k, (-1 : ℝ) ^ i / (2 * i + 1)) atTop (𝓝 (π / 4)) 
Goal: Filter.Tendsto (fun k => ∑ i ∈ Finset.range k, (-1) ^ i / (2 * ↑i + 1)) Filter.atTop (nhds (Real.pi / 4))
-- NNReal.val_eq_coe
@[simp]
theorem val_eq_coe (n : ℝ≥0) : n.val = n 
Arguments: (n : ℝ≥0)
Goal: ↑n = ↑n
-- NNReal.eq
@[ext] protected theorem eq {n m : ℝ≥0} : (n : ℝ) = (m : ℝ) → n = m 
Arguments: {n m : ℝ≥0}
Goal: ↑n = ↑m → n = m
-- NNReal.eq_iff
protected theorem eq_iff {n m : ℝ≥0} : n = m ↔ (n : ℝ) = (m : ℝ) 
Arguments: {n m : ℝ≥0}
Goal: n = m ↔ ↑n = ↑m
-- NNReal.ne_iff
theorem ne_iff {x y : ℝ≥0} : (x : ℝ) ≠ (y : ℝ) ↔ x ≠ y 
Arguments: {x y : ℝ≥0}
Goal: ↑x ≠ ↑y ↔ x ≠ y
-- NNReal.forall
protected theorem «forall» {p : ℝ≥0 → Prop} :
    (∀ x : ℝ≥0, p x) ↔ ∀ (x : ℝ) (hx : 0 ≤ x), p ⟨x, hx⟩ 
Arguments: {p : ℝ≥0 → Prop}
Goal: (∀ (x : ℝ≥0), p x) ↔ ∀ (x : ℝ) (hx : 0 ≤ x), p ⟨x, hx⟩
-- NNReal.exists
protected theorem «exists» {p : ℝ≥0 → Prop} :
    (∃ x : ℝ≥0, p x) ↔ ∃ (x : ℝ) (hx : 0 ≤ x), p ⟨x, hx⟩ 
Arguments: {p : ℝ≥0 → Prop}
Goal: (∃ x, p x) ↔ ∃ x, ∃ (hx : 0 ≤ x), p ⟨x, hx⟩
-- Real.coe_toNNReal
theorem _root_.Real.coe_toNNReal (r : ℝ) (hr : 0 ≤ r) : (Real.toNNReal r : ℝ) = r 
Arguments: (r : ℝ) (hr : 0 ≤ r)
Goal: ↑r.toNNReal = r
-- Real.toNNReal_of_nonneg
theorem _root_.Real.toNNReal_of_nonneg {r : ℝ} (hr : 0 ≤ r) : r.toNNReal = ⟨r, hr⟩ 
Arguments: {r : ℝ} (hr : 0 ≤ r)
Goal: r.toNNReal = ⟨r, hr⟩
-- Real.le_coe_toNNReal
theorem _root_.Real.le_coe_toNNReal (r : ℝ) : r ≤ Real.toNNReal r 
Arguments: (r : ℝ)
Goal: r ≤ ↑r.toNNReal
-- NNReal.coe_nonneg
theorem coe_nonneg (r : ℝ≥0) : (0 : ℝ) ≤ r 
Arguments: (r : ℝ≥0)
Goal: 0 ≤ ↑r
-- NNReal.coe_mk
@[simp, norm_cast] theorem coe_mk (a : ℝ) (ha) : toReal ⟨a, ha⟩ = a 
Arguments: (a : ℝ) (ha : 0 ≤ a)
Goal: ↑⟨a, ha⟩ = a
-- NNReal.coe_injective
protected theorem coe_injective : Injective ((↑) : ℝ≥0 → ℝ) 
Goal: Function.Injective NNReal.toReal
-- NNReal.coe_inj
@[simp, norm_cast] lemma coe_inj {r₁ r₂ : ℝ≥0} : (r₁ : ℝ) = r₂ ↔ r₁ = r₂ 
Arguments: {r₁ r₂ : ℝ≥0}
Goal: ↑r₁ = ↑r₂ ↔ r₁ = r₂
-- NNReal.coe_zero
@[simp, norm_cast] lemma coe_zero : ((0 : ℝ≥0) : ℝ) = 0 
Goal: ↑0 = 0
-- NNReal.coe_one
@[simp, norm_cast] lemma coe_one : ((1 : ℝ≥0) : ℝ) = 1 
Goal: ↑1 = 1
-- NNReal.coe_add
@[simp, norm_cast]
protected theorem coe_add (r₁ r₂ : ℝ≥0) : ((r₁ + r₂ : ℝ≥0) : ℝ) = r₁ + r₂ 
Arguments: (r₁ r₂ : ℝ≥0)
Goal: ↑(r₁ + r₂) = ↑r₁ + ↑r₂
-- NNReal.coe_mul
@[simp, norm_cast]
protected theorem coe_mul (r₁ r₂ : ℝ≥0) : ((r₁ * r₂ : ℝ≥0) : ℝ) = r₁ * r₂ 
Arguments: (r₁ r₂ : ℝ≥0)
Goal: ↑(r₁ * r₂) = ↑r₁ * ↑r₂
-- NNReal.coe_inv
@[simp, norm_cast]
protected theorem coe_inv (r : ℝ≥0) : ((r⁻¹ : ℝ≥0) : ℝ) = (r : ℝ)⁻¹ 
Arguments: (r : ℝ≥0)
Goal: ↑r⁻¹ = (↑r)⁻¹
-- NNReal.coe_div
@[simp, norm_cast]
protected theorem coe_div (r₁ r₂ : ℝ≥0) : ((r₁ / r₂ : ℝ≥0) : ℝ) = (r₁ : ℝ) / r₂ 
Arguments: (r₁ r₂ : ℝ≥0)
Goal: ↑(r₁ / r₂) = ↑r₁ / ↑r₂
-- NNReal.coe_two
protected theorem coe_two : ((2 : ℝ≥0) : ℝ) = 2 
Goal: ↑2 = 2
-- NNReal.coe_sub
@[simp, norm_cast]
protected theorem coe_sub {r₁ r₂ : ℝ≥0} (h : r₂ ≤ r₁) : ((r₁ - r₂ : ℝ≥0) : ℝ) = ↑r₁ - ↑r₂ 
Arguments: {r₁ r₂ : ℝ≥0} (h : r₂ ≤ r₁)
Goal: ↑(r₁ - r₂) = ↑r₁ - ↑r₂
-- NNReal.coe_eq_zero
@[simp, norm_cast] lemma coe_eq_zero : (r : ℝ) = 0 ↔ r = 0 
Arguments: {r : ℝ≥0}
Goal: ↑r = 0 ↔ r = 0
-- NNReal.coe_eq_one
@[simp, norm_cast] lemma coe_eq_one : (r : ℝ) = 1 ↔ r = 1 
Arguments: {r : ℝ≥0}
Goal: ↑r = 1 ↔ r = 1
-- NNReal.coe_ne_zero
@[norm_cast] lemma coe_ne_zero : (r : ℝ) ≠ 0 ↔ r ≠ 0 
Arguments: {r : ℝ≥0}
Goal: ↑r ≠ 0 ↔ r ≠ 0
-- NNReal.coe_ne_one
@[norm_cast] lemma coe_ne_one : (r : ℝ) ≠ 1 ↔ r ≠ 1 
Arguments: {r : ℝ≥0}
Goal: ↑r ≠ 1 ↔ r ≠ 1
-- NNReal.coe_toRealHom
@[simp] theorem coe_toRealHom : ⇑toRealHom = toReal 
Goal: ⇑NNReal.toRealHom = NNReal.toReal
-- NNReal.smul_def
theorem smul_def {M : Type*} [MulAction ℝ M] (c : ℝ≥0) (x : M) : c • x = (c : ℝ) • x 
Arguments: {M : Type u_1} [MulAction ℝ M] (c : ℝ≥0) (x : M)
Goal: c • x = ↑c • x
-- NNReal.coe_indicator
@[simp, norm_cast]
theorem coe_indicator {α} (s : Set α) (f : α → ℝ≥0) (a : α) :
    ((s.indicator f a : ℝ≥0) : ℝ) = s.indicator (fun x => ↑(f x)) a 
Arguments: {α : Type u_1} (s : Set α) (f : α → ℝ≥0) (a : α)
Goal: ↑(s.indicator f a) = s.indicator (fun x => ↑(f x)) a
-- NNReal.coe_pow
@[simp, norm_cast]
theorem coe_pow (r : ℝ≥0) (n : ℕ) : ((r ^ n : ℝ≥0) : ℝ) = (r : ℝ) ^ n 
Arguments: (r : ℝ≥0) (n : ℕ)
Goal: ↑(r ^ n) = ↑r ^ n
-- NNReal.coe_zpow
@[simp, norm_cast]
theorem coe_zpow (r : ℝ≥0) (n : ℤ) : ((r ^ n : ℝ≥0) : ℝ) = (r : ℝ) ^ n 
Arguments: (r : ℝ≥0) (n : ℤ)
Goal: ↑(r ^ n) = ↑r ^ n
-- NNReal.coe_list_sum
@[norm_cast]
theorem coe_list_sum (l : List ℝ≥0) : ((l.sum : ℝ≥0) : ℝ) = (l.map (↑)).sum 
Arguments: (l : List ℝ≥0)
Goal: ↑l.sum = (List.map NNReal.toReal l).sum
-- NNReal.coe_list_prod
@[norm_cast]
theorem coe_list_prod (l : List ℝ≥0) : ((l.prod : ℝ≥0) : ℝ) = (l.map (↑)).prod 
Arguments: (l : List ℝ≥0)
Goal: ↑l.prod = (List.map NNReal.toReal l).prod
-- NNReal.coe_multiset_sum
@[norm_cast]
theorem coe_multiset_sum (s : Multiset ℝ≥0) : ((s.sum : ℝ≥0) : ℝ) = (s.map (↑)).sum 
Arguments: (s : Multiset ℝ≥0)
Goal: ↑s.sum = (Multiset.map NNReal.toReal s).sum
-- NNReal.coe_multiset_prod
@[norm_cast]
theorem coe_multiset_prod (s : Multiset ℝ≥0) : ((s.prod : ℝ≥0) : ℝ) = (s.map (↑)).prod 
Arguments: (s : Multiset ℝ≥0)
Goal: ↑s.prod = (Multiset.map NNReal.toReal s).prod
-- NNReal.coe_sum
@[norm_cast]
theorem coe_sum {α} {s : Finset α} {f : α → ℝ≥0} : ↑(∑ a ∈ s, f a) = ∑ a ∈ s, (f a : ℝ) 
Arguments: {α : Type u_1} {s : Finset α} {f : α → ℝ≥0}
Goal: ↑(∑ a ∈ s, f a) = ∑ a ∈ s, ↑(f a)
-- Real.toNNReal_sum_of_nonneg
theorem _root_.Real.toNNReal_sum_of_nonneg {α} {s : Finset α} {f : α → ℝ}
    (hf : ∀ a, a ∈ s → 0 ≤ f a) :
    Real.toNNReal (∑ a ∈ s, f a) = ∑ a ∈ s, Real.toNNReal (f a) 
Arguments: {α : Type u_1} {s : Finset α} {f : α → ℝ} (hf : ∀ a ∈ s, 0 ≤ f a)
Goal: (∑ a ∈ s, f a).toNNReal = ∑ a ∈ s, (f a).toNNReal
-- NNReal.coe_prod
@[norm_cast]
theorem coe_prod {α} {s : Finset α} {f : α → ℝ≥0} : ↑(∏ a ∈ s, f a) = ∏ a ∈ s, (f a : ℝ) 
Arguments: {α : Type u_1} {s : Finset α} {f : α → ℝ≥0}
Goal: ↑(∏ a ∈ s, f a) = ∏ a ∈ s, ↑(f a)
-- Real.toNNReal_prod_of_nonneg
theorem _root_.Real.toNNReal_prod_of_nonneg {α} {s : Finset α} {f : α → ℝ}
    (hf : ∀ a, a ∈ s → 0 ≤ f a) :
    Real.toNNReal (∏ a ∈ s, f a) = ∏ a ∈ s, Real.toNNReal (f a) 
Arguments: {α : Type u_1} {s : Finset α} {f : α → ℝ} (hf : ∀ a ∈ s, 0 ≤ f a)
Goal: (∏ a ∈ s, f a).toNNReal = ∏ a ∈ s, (f a).toNNReal
-- NNReal.coe_nsmul
theorem coe_nsmul (r : ℝ≥0) (n : ℕ) : ↑(n • r) = n • (r : ℝ) 
Arguments: (r : ℝ≥0) (n : ℕ)
Goal: ↑(n • r) = n • ↑r
-- NNReal.coe_natCast
@[simp, norm_cast]
protected theorem coe_natCast (n : ℕ) : (↑(↑n : ℝ≥0) : ℝ) = n 
Arguments: (n : ℕ)
Goal: ↑↑n = ↑n
-- NNReal.coe_ofNat
@[simp, norm_cast]
protected theorem coe_ofNat (n : ℕ) [n.AtLeastTwo] :
    (no_index (OfNat.ofNat n : ℝ≥0) : ℝ) = OfNat.ofNat n 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: ↑(OfNat.ofNat n) = OfNat.ofNat n
-- NNReal.coe_ofScientific
@[simp, norm_cast]
protected theorem coe_ofScientific (m : ℕ) (s : Bool) (e : ℕ) :
    ↑(OfScientific.ofScientific m s e : ℝ≥0) = (OfScientific.ofScientific m s e : ℝ) 
Arguments: (m : ℕ) (s : Bool) (e : ℕ)
Goal: ↑(OfScientific.ofScientific m s e) = OfScientific.ofScientific m s e
-- NNReal.algebraMap_eq_coe
@[simp, norm_cast]
lemma algebraMap_eq_coe : (algebraMap ℝ≥0 ℝ : ℝ≥0 → ℝ) = (↑) 
Goal: ⇑(algebraMap ℝ≥0 ℝ) = NNReal.toReal
-- NNReal.coe_le_coe
@[simp, norm_cast] lemma coe_le_coe : (r₁ : ℝ) ≤ r₂ ↔ r₁ ≤ r₂ 
Arguments: {r₁ r₂ : ℝ≥0}
Goal: ↑r₁ ≤ ↑r₂ ↔ r₁ ≤ r₂
-- NNReal.coe_lt_coe
@[simp, norm_cast] lemma coe_lt_coe : (r₁ : ℝ) < r₂ ↔ r₁ < r₂ 
Arguments: {r₁ r₂ : ℝ≥0}
Goal: ↑r₁ < ↑r₂ ↔ r₁ < r₂
-- NNReal.coe_pos
@[simp, norm_cast] lemma coe_pos : (0 : ℝ) < r ↔ 0 < r 
Arguments: {r : ℝ≥0}
Goal: 0 < ↑r ↔ 0 < r
-- NNReal.one_le_coe
@[simp, norm_cast] lemma one_le_coe : 1 ≤ (r : ℝ) ↔ 1 ≤ r 
Arguments: {r : ℝ≥0}
Goal: 1 ≤ ↑r ↔ 1 ≤ r
-- NNReal.one_lt_coe
@[simp, norm_cast] lemma one_lt_coe : 1 < (r : ℝ) ↔ 1 < r 
Arguments: {r : ℝ≥0}
Goal: 1 < ↑r ↔ 1 < r
-- NNReal.coe_le_one
@[simp, norm_cast] lemma coe_le_one : (r : ℝ) ≤ 1 ↔ r ≤ 1 
Arguments: {r : ℝ≥0}
Goal: ↑r ≤ 1 ↔ r ≤ 1
-- NNReal.coe_lt_one
@[simp, norm_cast] lemma coe_lt_one : (r : ℝ) < 1 ↔ r < 1 
Arguments: {r : ℝ≥0}
Goal: ↑r < 1 ↔ r < 1
-- NNReal.coe_mono
@[mono] lemma coe_mono : Monotone ((↑) : ℝ≥0 → ℝ) 
Goal: Monotone NNReal.toReal
-- Real.toNNReal_mono
protected theorem _root_.Real.toNNReal_mono : Monotone Real.toNNReal 
Goal: Monotone Real.toNNReal
-- Real.toNNReal_coe
@[simp]
theorem _root_.Real.toNNReal_coe {r : ℝ≥0} : Real.toNNReal r = r 
Arguments: {r : ℝ≥0}
Goal: (↑r).toNNReal = r
-- NNReal.mk_natCast
@[simp]
theorem mk_natCast (n : ℕ) : @Eq ℝ≥0 (⟨(n : ℝ), n.cast_nonneg⟩ : ℝ≥0) n 
Arguments: (n : ℕ)
Goal: ⟨↑n, ⋯⟩ = ↑n
-- NNReal.toNNReal_coe_nat
@[simp]
theorem toNNReal_coe_nat (n : ℕ) : Real.toNNReal n = n 
Arguments: (n : ℕ)
Goal: (↑n).toNNReal = ↑n
-- Real.toNNReal_ofNat
@[simp]
theorem _root_.Real.toNNReal_ofNat (n : ℕ) [n.AtLeastTwo] :
    Real.toNNReal (no_index (OfNat.ofNat n)) = OfNat.ofNat n 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: (OfNat.ofNat n).toNNReal = OfNat.ofNat n
-- NNReal.orderIsoIccZeroCoe_apply_coe_coe
@[simp]
theorem orderIsoIccZeroCoe_apply_coe_coe (a : ℝ≥0) (b : Set.Icc (0 : ℝ) a) :
    (orderIsoIccZeroCoe a b : ℝ) = b 
Arguments: (a : ℝ≥0) (b : ↑(Set.Icc 0 ↑a))
Goal: ↑↑(a.orderIsoIccZeroCoe b) = ↑b
-- NNReal.orderIsoIccZeroCoe_symm_apply_coe
@[simp]
theorem orderIsoIccZeroCoe_symm_apply_coe (a : ℝ≥0) (b : Set.Iic a) :
    ((orderIsoIccZeroCoe a).symm b : ℝ) = b 
Arguments: (a : ℝ≥0) (b : ↑(Set.Iic a))
Goal: ↑(a.orderIsoIccZeroCoe.symm b) = ↑↑b
-- NNReal.coe_image
theorem coe_image {s : Set ℝ≥0} :
    (↑) '' s = { x : ℝ | ∃ h : 0 ≤ x, @Membership.mem ℝ≥0 _ _ ⟨x, h⟩ s } 
Arguments: {s : Set ℝ≥0}
Goal: NNReal.toReal '' s = {x | ∃ (h : 0 ≤ x), ⟨x, h⟩ ∈ s}
-- NNReal.bddAbove_coe
theorem bddAbove_coe {s : Set ℝ≥0} : BddAbove (((↑) : ℝ≥0 → ℝ) '' s) ↔ BddAbove s 
Arguments: {s : Set ℝ≥0}
Goal: BddAbove (NNReal.toReal '' s) ↔ BddAbove s
-- NNReal.bddBelow_coe
theorem bddBelow_coe (s : Set ℝ≥0) : BddBelow (((↑) : ℝ≥0 → ℝ) '' s) 
Arguments: (s : Set ℝ≥0)
Goal: BddBelow (NNReal.toReal '' s)
-- NNReal.coe_sSup
@[norm_cast]
theorem coe_sSup (s : Set ℝ≥0) : (↑(sSup s) : ℝ) = sSup (((↑) : ℝ≥0 → ℝ) '' s) 
Arguments: (s : Set ℝ≥0)
Goal: ↑(sSup s) = sSup (NNReal.toReal '' s)
-- NNReal.coe_iSup
@[simp, norm_cast] -- Porting note: add `simp`
theorem coe_iSup {ι : Sort*} (s : ι → ℝ≥0) : (↑(⨆ i, s i) : ℝ) = ⨆ i, ↑(s i) 
Arguments: {ι : Sort u_1} (s : ι → ℝ≥0)
Goal: ↑(⨆ i, s i) = ⨆ i, ↑(s i)
-- NNReal.coe_sInf
@[norm_cast]
theorem coe_sInf (s : Set ℝ≥0) : (↑(sInf s) : ℝ) = sInf (((↑) : ℝ≥0 → ℝ) '' s) 
Arguments: (s : Set ℝ≥0)
Goal: ↑(sInf s) = sInf (NNReal.toReal '' s)
-- NNReal.sInf_empty
@[simp]
theorem sInf_empty : sInf (∅ : Set ℝ≥0) = 0 
Goal: sInf ∅ = 0
-- NNReal.coe_iInf
@[norm_cast]
theorem coe_iInf {ι : Sort*} (s : ι → ℝ≥0) : (↑(⨅ i, s i) : ℝ) = ⨅ i, ↑(s i) 
Arguments: {ι : Sort u_1} (s : ι → ℝ≥0)
Goal: ↑(⨅ i, s i) = ⨅ i, ↑(s i)
-- NNReal.le_iInf_add_iInf
theorem le_iInf_add_iInf {ι ι' : Sort*} [Nonempty ι] [Nonempty ι'] {f : ι → ℝ≥0} {g : ι' → ℝ≥0}
    {a : ℝ≥0} (h : ∀ i j, a ≤ f i + g j) : a ≤ (⨅ i, f i) + ⨅ j, g j 
Arguments: {ι : Sort u_1} {ι' : Sort u_2} [Nonempty ι] [Nonempty ι'] {f : ι → ℝ≥0} {g : ι' → ℝ≥0} {a : ℝ≥0} (h : ∀ (i : ι) (j : ι'), a ≤ f i + g j)
Goal: a ≤ (⨅ i, f i) + ⨅ j, g j
-- NNReal.le_of_forall_pos_le_add
nonrec theorem le_of_forall_pos_le_add {a b : ℝ≥0} (h : ∀ ε, 0 < ε → a ≤ b + ε) : a ≤ b 
Arguments: {a b : ℝ≥0} (h : ∀ (ε : ℝ≥0), 0 < ε → a ≤ b + ε)
Goal: a ≤ b
-- NNReal.lt_iff_exists_rat_btwn
theorem lt_iff_exists_rat_btwn (a b : ℝ≥0) :
    a < b ↔ ∃ q : ℚ, 0 ≤ q ∧ a < Real.toNNReal q ∧ Real.toNNReal q < b 
Arguments: (a b : ℝ≥0)
Goal: a < b ↔ ∃ q, 0 ≤ q ∧ a < (↑q).toNNReal ∧ (↑q).toNNReal < b
-- NNReal.bot_eq_zero
theorem bot_eq_zero : (⊥ : ℝ≥0) = 0 
Goal: ⊥ = 0
-- NNReal.mul_sup
theorem mul_sup (a b c : ℝ≥0) : a * (b ⊔ c) = a * b ⊔ a * c 
Arguments: (a b c : ℝ≥0)
Goal: a * (b ⊔ c) = a * b ⊔ a * c
-- NNReal.sup_mul
theorem sup_mul (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.mul_finset_sup
theorem mul_finset_sup {α} (r : ℝ≥0) (s : Finset α) (f : α → ℝ≥0) :
    r * s.sup f = s.sup fun a => r * f a 
Arguments: {α : Type u_1} (r : ℝ≥0) (s : Finset α) (f : α → ℝ≥0)
Goal: r * s.sup f = s.sup fun a => r * f a
-- NNReal.finset_sup_mul
theorem finset_sup_mul {α} (s : Finset α) (f : α → ℝ≥0) (r : ℝ≥0) :
    s.sup f * r = s.sup fun a => f a * r 
Arguments: {α : Type u_1} (s : Finset α) (f : α → ℝ≥0) (r : ℝ≥0)
Goal: s.sup f * r = s.sup fun a => f a * r
-- NNReal.finset_sup_div
theorem finset_sup_div {α} {f : α → ℝ≥0} {s : Finset α} (r : ℝ≥0) :
    s.sup f / r = s.sup fun a => f a / r 
Arguments: {α : Type u_1} {f : α → ℝ≥0} {s : Finset α} (r : ℝ≥0)
Goal: s.sup f / r = s.sup fun a => f a / r
-- NNReal.coe_max
@[simp, norm_cast]
theorem coe_max (x y : ℝ≥0) : ((max x y : ℝ≥0) : ℝ) = max (x : ℝ) (y : ℝ) 
Arguments: (x y : ℝ≥0)
Goal: ↑(max x y) = max ↑x ↑y
-- NNReal.coe_min
@[simp, norm_cast]
theorem coe_min (x y : ℝ≥0) : ((min x y : ℝ≥0) : ℝ) = min (x : ℝ) (y : ℝ) 
Arguments: (x y : ℝ≥0)
Goal: ↑(min x y) = min ↑x ↑y
-- NNReal.zero_le_coe
@[simp]
theorem zero_le_coe {q : ℝ≥0} : 0 ≤ (q : ℝ) 
Arguments: {q : ℝ≥0}
Goal: 0 ≤ ↑q
-- Real.coe_toNNReal'
@[simp]
theorem coe_toNNReal' (r : ℝ) : (Real.toNNReal r : ℝ) = max r 0 
Arguments: (r : ℝ)
Goal: ↑r.toNNReal = max r 0
-- Real.toNNReal_zero
@[simp]
theorem toNNReal_zero : Real.toNNReal 0 = 0 
Goal: Real.toNNReal 0 = 0
-- Real.toNNReal_one
@[simp]
theorem toNNReal_one : Real.toNNReal 1 = 1 
Goal: Real.toNNReal 1 = 1
-- Real.toNNReal_pos
@[simp]
theorem toNNReal_pos {r : ℝ} : 0 < Real.toNNReal r ↔ 0 < r 
Arguments: {r : ℝ}
Goal: 0 < r.toNNReal ↔ 0 < r
-- Real.toNNReal_eq_zero
@[simp]
theorem toNNReal_eq_zero {r : ℝ} : Real.toNNReal r = 0 ↔ r ≤ 0 
Arguments: {r : ℝ}
Goal: r.toNNReal = 0 ↔ r ≤ 0
-- Real.toNNReal_of_nonpos
theorem toNNReal_of_nonpos {r : ℝ} : r ≤ 0 → Real.toNNReal r = 0 
Arguments: {r : ℝ}
Goal: r ≤ 0 → r.toNNReal = 0
-- Real.toNNReal_eq_iff_eq_coe
lemma toNNReal_eq_iff_eq_coe {r : ℝ} {p : ℝ≥0} (hp : p ≠ 0) : r.toNNReal = p ↔ r = p 
Arguments: {r : ℝ} {p : ℝ≥0} (hp : p ≠ 0)
Goal: r.toNNReal = p ↔ r = ↑p
-- Real.toNNReal_eq_one
@[simp]
lemma toNNReal_eq_one {r : ℝ} : r.toNNReal = 1 ↔ r = 1 
Arguments: {r : ℝ}
Goal: r.toNNReal = 1 ↔ r = 1
-- Real.toNNReal_eq_natCast
@[simp]
lemma toNNReal_eq_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_eq_ofNat
@[simp]
lemma toNNReal_eq_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.toNNReal_le_toNNReal_iff
@[simp]
theorem toNNReal_le_toNNReal_iff {r p : ℝ} (hp : 0 ≤ p) :
    toNNReal r ≤ toNNReal p ↔ r ≤ p 
Arguments: {r p : ℝ} (hp : 0 ≤ p)
Goal: r.toNNReal ≤ p.toNNReal ↔ r ≤ p