ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Nat.find_le
lemma find_le {h : ∃ n, p n} (hn : p n) : Nat.find h ≤ n 
Arguments: {n : ℕ} {p : ℕ → Prop} [DecidablePred p] {h : ∃ n, p n} (hn : p n)
Goal: Nat.find h ≤ n
-- Nat.find_comp_succ
lemma find_comp_succ (h₁ : ∃ n, p n) (h₂ : ∃ n, p (n + 1)) (h0 : ¬ p 0) :
    Nat.find h₁ = Nat.find h₂ + 1 
Arguments: {p : ℕ → Prop} [DecidablePred p] (h₁ : ∃ n, p n) (h₂ : ∃ n, p (n + 1)) (h0 : ¬p 0)
Goal: Nat.find h₁ = Nat.find h₂ + 1
-- Nat.find_pos
lemma find_pos (h : ∃ n : ℕ, p n) : 0 < Nat.find h ↔ ¬p 0 
Arguments: {p : ℕ → Prop} [DecidablePred p] (h : ∃ n, p n)
Goal: 0 < Nat.find h ↔ ¬p 0
-- Nat.find_add
lemma find_add {hₘ : ∃ m, p (m + n)} {hₙ : ∃ n, p n} (hn : n ≤ Nat.find hₙ) :
    Nat.find hₘ + n = Nat.find hₙ 
Arguments: {n : ℕ} {p : ℕ → Prop} [DecidablePred p] {hₘ : ∃ m, p (m + n)} {hₙ : ∃ n, p n} (hn : n ≤ Nat.find hₙ)
Goal: Nat.find hₘ + n = Nat.find hₙ
-- Nat.findGreatest_zero
@[simp] lemma findGreatest_zero : Nat.findGreatest P 0 = 0 
Arguments: {P : ℕ → Prop} [DecidablePred P]
Goal: Nat.findGreatest P 0 = 0
-- Nat.findGreatest_succ
lemma findGreatest_succ (n : ℕ) :
    Nat.findGreatest P (n + 1) = if P (n + 1) then n + 1 else Nat.findGreatest P n 
Arguments: {P : ℕ → Prop} [DecidablePred P] (n : ℕ)
Goal: Nat.findGreatest P (n + 1) = if P (n + 1) then n + 1 else Nat.findGreatest P n
-- Nat.findGreatest_eq
@[simp] lemma findGreatest_eq : ∀ {n}, P n → Nat.findGreatest P n = n
  
Arguments: {P : ℕ → Prop} [DecidablePred P] {n : ℕ}
Goal: P n → Nat.findGreatest P n = n
-- Nat.findGreatest_of_not
@[simp]
lemma findGreatest_of_not (h : ¬ P (n + 1)) : findGreatest P (n + 1) = findGreatest P n 
Arguments: {P : ℕ → Prop} [DecidablePred P] {n : ℕ} (h : ¬P (n + 1))
Goal: Nat.findGreatest P (n + 1) = Nat.findGreatest P n
-- Nat.findGreatest_eq_iff
lemma findGreatest_eq_iff :
    Nat.findGreatest P k = m ↔ m ≤ k ∧ (m ≠ 0 → P m) ∧ ∀ ⦃n⦄, m < n → n ≤ k → ¬P n 
Arguments: {m k : ℕ} {P : ℕ → Prop} [DecidablePred P]
Goal: Nat.findGreatest P k = m ↔ m ≤ k ∧ (m ≠ 0 → P m) ∧ ∀ ⦃n : ℕ⦄, m < n → n ≤ k → ¬P n
-- Nat.findGreatest_eq_zero_iff
lemma findGreatest_eq_zero_iff : Nat.findGreatest P k = 0 ↔ ∀ ⦃n⦄, 0 < n → n ≤ k → ¬P n 
Arguments: {k : ℕ} {P : ℕ → Prop} [DecidablePred P]
Goal: Nat.findGreatest P k = 0 ↔ ∀ ⦃n : ℕ⦄, 0 < n → n ≤ k → ¬P n
-- Nat.findGreatest_pos
@[simp] lemma findGreatest_pos : 0 < Nat.findGreatest P k ↔ ∃ n, 0 < n ∧ n ≤ k ∧ P n 
Arguments: {k : ℕ} {P : ℕ → Prop} [DecidablePred P]
Goal: 0 < Nat.findGreatest P k ↔ ∃ n, 0 < n ∧ n ≤ k ∧ P n
-- Nat.findGreatest_spec
lemma findGreatest_spec (hmb : m ≤ n) (hm : P m) : P (Nat.findGreatest P n) 
Arguments: {m : ℕ} {P : ℕ → Prop} [DecidablePred P] {n : ℕ} (hmb : m ≤ n) (hm : P m)
Goal: P (Nat.findGreatest P n)
-- Nat.findGreatest_le
lemma findGreatest_le (n : ℕ) : Nat.findGreatest P n ≤ n 
Arguments: {P : ℕ → Prop} [DecidablePred P] (n : ℕ)
Goal: Nat.findGreatest P n ≤ n
-- Nat.le_findGreatest
lemma le_findGreatest (hmb : m ≤ n) (hm : P m) : m ≤ Nat.findGreatest P n 
Arguments: {m : ℕ} {P : ℕ → Prop} [DecidablePred P] {n : ℕ} (hmb : m ≤ n) (hm : P m)
Goal: m ≤ Nat.findGreatest P n
-- Nat.findGreatest_mono_right
lemma findGreatest_mono_right (P : ℕ → Prop) [DecidablePred P] {m n} (hmn : m ≤ n) :
    Nat.findGreatest P m ≤ Nat.findGreatest P n 
Arguments: (P : ℕ → Prop) [DecidablePred P] {m n : ℕ} (hmn : m ≤ n)
Goal: Nat.findGreatest P m ≤ Nat.findGreatest P n
-- Nat.findGreatest_mono_left
lemma findGreatest_mono_left [DecidablePred Q] (hPQ : ∀ n, P n → Q n) (n : ℕ) :
    Nat.findGreatest P n ≤ Nat.findGreatest Q n 
Arguments: {P Q : ℕ → Prop} [DecidablePred P] [DecidablePred Q] (hPQ : ∀ (n : ℕ), P n → Q n) (n : ℕ)
Goal: Nat.findGreatest P n ≤ Nat.findGreatest Q n
-- Nat.findGreatest_mono
lemma findGreatest_mono [DecidablePred Q] (hPQ : ∀ n, P n → Q n) (hmn : m ≤ n) :
    Nat.findGreatest P m ≤ Nat.findGreatest Q n 
Arguments: {m : ℕ} {P Q : ℕ → Prop} [DecidablePred P] {n : ℕ} [DecidablePred Q] (hPQ : ∀ (n : ℕ), P n → Q n) (hmn : m ≤ n)
Goal: Nat.findGreatest P m ≤ Nat.findGreatest Q n
-- Nat.findGreatest_is_greatest
theorem findGreatest_is_greatest (hk : Nat.findGreatest P n < k) (hkb : k ≤ n) : ¬P k 
Arguments: {k : ℕ} {P : ℕ → Prop} [DecidablePred P] {n : ℕ} (hk : Nat.findGreatest P n < k) (hkb : k ≤ n)
Goal: ¬P k
-- Nat.findGreatest_of_ne_zero
theorem findGreatest_of_ne_zero (h : Nat.findGreatest P n = m) (h0 : m ≠ 0) : P m 
Arguments: {m : ℕ} {P : ℕ → Prop} [DecidablePred P] {n : ℕ} (h : Nat.findGreatest P n = m) (h0 : m ≠ 0)
Goal: P m
-- Nat.dist_comm
theorem dist_comm (n m : ℕ) : dist n m = dist m n 
Arguments: (n m : ℕ)
Goal: n.dist m = m.dist n
-- Nat.dist_self
@[simp]
theorem dist_self (n : ℕ) : dist n n = 0 
Arguments: (n : ℕ)
Goal: n.dist n = 0
-- Nat.eq_of_dist_eq_zero
theorem eq_of_dist_eq_zero {n m : ℕ} (h : dist n m = 0) : n = m 
Arguments: {n m : ℕ} (h : n.dist m = 0)
Goal: n = m
-- Nat.dist_eq_zero
theorem dist_eq_zero {n m : ℕ} (h : n = m) : dist n m = 0 
Arguments: {n m : ℕ} (h : n = m)
Goal: n.dist m = 0
-- Nat.dist_eq_sub_of_le
theorem dist_eq_sub_of_le {n m : ℕ} (h : n ≤ m) : dist n m = m - n 
Arguments: {n m : ℕ} (h : n ≤ m)
Goal: n.dist m = m - n
-- Nat.dist_eq_sub_of_le_right
theorem dist_eq_sub_of_le_right {n m : ℕ} (h : m ≤ n) : dist n m = n - m 
Arguments: {n m : ℕ} (h : m ≤ n)
Goal: n.dist m = n - m
-- Nat.dist_tri_left
theorem dist_tri_left (n m : ℕ) : m ≤ dist n m + n 
Arguments: (n m : ℕ)
Goal: m ≤ n.dist m + n
-- Nat.dist_tri_right
theorem dist_tri_right (n m : ℕ) : m ≤ n + dist n m 
Arguments: (n m : ℕ)
Goal: m ≤ n + n.dist m
-- Nat.dist_tri_left'
theorem dist_tri_left' (n m : ℕ) : n ≤ dist n m + m 
Arguments: (n m : ℕ)
Goal: n ≤ n.dist m + m
-- Nat.dist_tri_right'
theorem dist_tri_right' (n m : ℕ) : n ≤ m + dist n m 
Arguments: (n m : ℕ)
Goal: n ≤ m + n.dist m
-- Nat.dist_zero_right
theorem dist_zero_right (n : ℕ) : dist n 0 = n 
Arguments: (n : ℕ)
Goal: n.dist 0 = n
-- Nat.dist_zero_left
theorem dist_zero_left (n : ℕ) : dist 0 n = n 
Arguments: (n : ℕ)
Goal: Nat.dist 0 n = n
-- Nat.dist_add_add_right
theorem dist_add_add_right (n k m : ℕ) : dist (n + k) (m + k) = dist n m 
Arguments: (n k m : ℕ)
Goal: (n + k).dist (m + k) = n.dist m
-- Nat.dist_add_add_left
theorem dist_add_add_left (k n m : ℕ) : dist (k + n) (k + m) = dist n m 
Arguments: (k n m : ℕ)
Goal: (k + n).dist (k + m) = n.dist m
-- Nat.dist_eq_intro
theorem dist_eq_intro {n m k l : ℕ} (h : n + m = k + l) : dist n k = dist l m 
Arguments: {n m k l : ℕ} (h : n + m = k + l)
Goal: n.dist k = l.dist m
-- Nat.dist.triangle_inequality
theorem dist.triangle_inequality (n m k : ℕ) : dist n k ≤ dist n m + dist m k 
Arguments: (n m k : ℕ)
Goal: n.dist k ≤ n.dist m + m.dist k
-- Nat.dist_mul_right
theorem dist_mul_right (n k m : ℕ) : dist (n * k) (m * k) = dist n m * k 
Arguments: (n k m : ℕ)
Goal: (n * k).dist (m * k) = n.dist m * k
-- Nat.dist_mul_left
theorem dist_mul_left (k n m : ℕ) : dist (k * n) (k * m) = k * dist n m 
Arguments: (k n m : ℕ)
Goal: (k * n).dist (k * m) = k * n.dist m
-- Nat.dist_eq_max_sub_min
theorem dist_eq_max_sub_min {i j : ℕ} : dist i j = (max i j) - min i j 
Arguments: {i j : ℕ}
Goal: i.dist j = max i j - min i j
-- Nat.dist_succ_succ
theorem dist_succ_succ {i j : Nat} : dist (succ i) (succ j) = dist i j 
Arguments: {i j : ℕ}
Goal: i.succ.dist j.succ = i.dist j
-- Nat.dist_pos_of_ne
theorem dist_pos_of_ne {i j : Nat} : i ≠ j → 0 < dist i j 
Arguments: {i j : ℕ}
Goal: i ≠ j → 0 < i.dist j
-- ENNReal.toReal_add
theorem toReal_add (ha : a ≠ ∞) (hb : b ≠ ∞) : (a + b).toReal = a.toReal + b.toReal 
Arguments: {a b : ℝ≥0∞} (ha : a ≠ ⊤) (hb : b ≠ ⊤)
Goal: (a + b).toReal = a.toReal + b.toReal
-- ENNReal.toReal_sub_of_le
theorem toReal_sub_of_le {a b : ℝ≥0∞} (h : b ≤ a) (ha : a ≠ ∞) :
    (a - b).toReal = a.toReal - b.toReal 
Arguments: {a b : ℝ≥0∞} (h : b ≤ a) (ha : a ≠ ⊤)
Goal: (a - b).toReal = a.toReal - b.toReal
-- ENNReal.le_toReal_sub
theorem le_toReal_sub {a b : ℝ≥0∞} (hb : b ≠ ∞) : a.toReal - b.toReal ≤ (a - b).toReal 
Arguments: {a b : ℝ≥0∞} (hb : b ≠ ⊤)
Goal: a.toReal - b.toReal ≤ (a - b).toReal
-- ENNReal.toReal_add_le
theorem toReal_add_le : (a + b).toReal ≤ a.toReal + b.toReal 
Arguments: {a b : ℝ≥0∞}
Goal: (a + b).toReal ≤ a.toReal + b.toReal
-- ENNReal.ofReal_add
theorem ofReal_add {p q : ℝ} (hp : 0 ≤ p) (hq : 0 ≤ q) :
    ENNReal.ofReal (p + q) = ENNReal.ofReal p + ENNReal.ofReal q 
Arguments: {p q : ℝ} (hp : 0 ≤ p) (hq : 0 ≤ q)
Goal: ENNReal.ofReal (p + q) = ENNReal.ofReal p + ENNReal.ofReal q
-- ENNReal.ofReal_add_le
theorem ofReal_add_le {p q : ℝ} : ENNReal.ofReal (p + q) ≤ ENNReal.ofReal p + ENNReal.ofReal q 
Arguments: {p q : ℝ}
Goal: ENNReal.ofReal (p + q) ≤ ENNReal.ofReal p + ENNReal.ofReal q
-- ENNReal.toReal_le_toReal
@[simp]
theorem toReal_le_toReal (ha : a ≠ ∞) (hb : b ≠ ∞) : a.toReal ≤ b.toReal ↔ a ≤ b 
Arguments: {a b : ℝ≥0∞} (ha : a ≠ ⊤) (hb : b ≠ ⊤)
Goal: a.toReal ≤ b.toReal ↔ a ≤ b
-- ENNReal.toReal_mono
@[gcongr]
theorem toReal_mono (hb : b ≠ ∞) (h : a ≤ b) : a.toReal ≤ b.toReal 
Arguments: {a b : ℝ≥0∞} (hb : b ≠ ⊤) (h : a ≤ b)
Goal: a.toReal ≤ b.toReal
-- ENNReal.toReal_mono'
theorem toReal_mono' (h : a ≤ b) (ht : b = ∞ → a = ∞) : a.toReal ≤ b.toReal 
Arguments: {a b : ℝ≥0∞} (h : a ≤ b) (ht : b = ⊤ → a = ⊤)
Goal: a.toReal ≤ b.toReal
-- ENNReal.toReal_lt_toReal
@[simp]
theorem toReal_lt_toReal (ha : a ≠ ∞) (hb : b ≠ ∞) : a.toReal < b.toReal ↔ a < b 
Arguments: {a b : ℝ≥0∞} (ha : a ≠ ⊤) (hb : b ≠ ⊤)
Goal: a.toReal < b.toReal ↔ a < b
-- ENNReal.toReal_strict_mono
@[gcongr]
theorem toReal_strict_mono (hb : b ≠ ∞) (h : a < b) : a.toReal < b.toReal 
Arguments: {a b : ℝ≥0∞} (hb : b ≠ ⊤) (h : a < b)
Goal: a.toReal < b.toReal
-- ENNReal.toNNReal_mono
@[gcongr]
theorem toNNReal_mono (hb : b ≠ ∞) (h : a ≤ b) : a.toNNReal ≤ b.toNNReal 
Arguments: {a b : ℝ≥0∞} (hb : b ≠ ⊤) (h : a ≤ b)
Goal: a.toNNReal ≤ b.toNNReal
-- ENNReal.le_toNNReal_of_coe_le
theorem le_toNNReal_of_coe_le (h : p ≤ a) (ha : a ≠ ∞) : p ≤ a.toNNReal 
Arguments: {a : ℝ≥0∞} {p : ℝ≥0} (h : ↑p ≤ a) (ha : a ≠ ⊤)
Goal: p ≤ a.toNNReal
-- ENNReal.toReal_le_add'
theorem toReal_le_add' (hle : a ≤ b + c) (hb : b = ∞ → a = ∞) (hc : c = ∞ → a = ∞) :
    a.toReal ≤ b.toReal + c.toReal 
Arguments: {a b c : ℝ≥0∞} (hle : a ≤ b + c) (hb : b = ⊤ → a = ⊤) (hc : c = ⊤ → a = ⊤)
Goal: a.toReal ≤ b.toReal + c.toReal
-- ENNReal.toReal_le_add
theorem toReal_le_add (hle : a ≤ b + c) (hb : b ≠ ∞) (hc : c ≠ ∞) :
    a.toReal ≤ b.toReal + c.toReal 
Arguments: {a b c : ℝ≥0∞} (hle : a ≤ b + c) (hb : b ≠ ⊤) (hc : c ≠ ⊤)
Goal: a.toReal ≤ b.toReal + c.toReal
-- ENNReal.toNNReal_le_toNNReal
@[simp]
theorem toNNReal_le_toNNReal (ha : a ≠ ∞) (hb : b ≠ ∞) : a.toNNReal ≤ b.toNNReal ↔ a ≤ b 
Arguments: {a b : ℝ≥0∞} (ha : a ≠ ⊤) (hb : b ≠ ⊤)
Goal: a.toNNReal ≤ b.toNNReal ↔ a ≤ b
-- ENNReal.toNNReal_strict_mono
@[gcongr]
theorem toNNReal_strict_mono (hb : b ≠ ∞) (h : a < b) : a.toNNReal < b.toNNReal 
Arguments: {a b : ℝ≥0∞} (hb : b ≠ ⊤) (h : a < b)
Goal: a.toNNReal < b.toNNReal
-- ENNReal.toNNReal_lt_toNNReal
@[simp]
theorem toNNReal_lt_toNNReal (ha : a ≠ ∞) (hb : b ≠ ∞) : a.toNNReal < b.toNNReal ↔ a < b 
Arguments: {a b : ℝ≥0∞} (ha : a ≠ ⊤) (hb : b ≠ ⊤)
Goal: a.toNNReal < b.toNNReal ↔ a < b
-- ENNReal.toNNReal_lt_of_lt_coe
theorem toNNReal_lt_of_lt_coe (h : a < p) : a.toNNReal < p 
Arguments: {a : ℝ≥0∞} {p : ℝ≥0} (h : a < ↑p)
Goal: a.toNNReal < p
-- ENNReal.toReal_max
theorem toReal_max (hr : a ≠ ∞) (hp : b ≠ ∞) :
    ENNReal.toReal (max a b) = max (ENNReal.toReal a) (ENNReal.toReal b) 
Arguments: {a b : ℝ≥0∞} (hr : a ≠ ⊤) (hp : b ≠ ⊤)
Goal: (max a b).toReal = max a.toReal b.toReal
-- ENNReal.toReal_min
theorem toReal_min {a b : ℝ≥0∞} (hr : a ≠ ∞) (hp : b ≠ ∞) :
    ENNReal.toReal (min a b) = min (ENNReal.toReal a) (ENNReal.toReal b) 
Arguments: {a b : ℝ≥0∞} (hr : a ≠ ⊤) (hp : b ≠ ⊤)
Goal: (min a b).toReal = min a.toReal b.toReal
-- ENNReal.toReal_sup
theorem toReal_sup {a b : ℝ≥0∞} : a ≠ ∞ → b ≠ ∞ → (a ⊔ b).toReal = a.toReal ⊔ b.toReal 
Arguments: {a b : ℝ≥0∞}
Goal: a ≠ ⊤ → b ≠ ⊤ → (a ⊔ b).toReal = a.toReal ⊔ b.toReal
-- ENNReal.toReal_inf
theorem toReal_inf {a b : ℝ≥0∞} : a ≠ ∞ → b ≠ ∞ → (a ⊓ b).toReal = a.toReal ⊓ b.toReal 
Arguments: {a b : ℝ≥0∞}
Goal: a ≠ ⊤ → b ≠ ⊤ → (a ⊓ b).toReal = a.toReal ⊓ b.toReal
-- ENNReal.toNNReal_pos_iff
theorem toNNReal_pos_iff : 0 < a.toNNReal ↔ 0 < a ∧ a < ∞ 
Arguments: {a : ℝ≥0∞}
Goal: 0 < a.toNNReal ↔ 0 < a ∧ a < ⊤
-- ENNReal.toNNReal_pos
theorem toNNReal_pos {a : ℝ≥0∞} (ha₀ : a ≠ 0) (ha_top : a ≠ ∞) : 0 < a.toNNReal 
Arguments: {a : ℝ≥0∞} (ha₀ : a ≠ 0) (ha_top : a ≠ ⊤)
Goal: 0 < a.toNNReal
-- ENNReal.toReal_pos_iff
theorem toReal_pos_iff : 0 < a.toReal ↔ 0 < a ∧ a < ∞ 
Arguments: {a : ℝ≥0∞}
Goal: 0 < a.toReal ↔ 0 < a ∧ a < ⊤
-- ENNReal.toReal_pos
theorem toReal_pos {a : ℝ≥0∞} (ha₀ : a ≠ 0) (ha_top : a ≠ ∞) : 0 < a.toReal 
Arguments: {a : ℝ≥0∞} (ha₀ : a ≠ 0) (ha_top : a ≠ ⊤)
Goal: 0 < a.toReal
-- ENNReal.ofReal_le_ofReal
@[gcongr]
theorem ofReal_le_ofReal {p q : ℝ} (h : p ≤ q) : ENNReal.ofReal p ≤ ENNReal.ofReal q 
Arguments: {p q : ℝ} (h : p ≤ q)
Goal: ENNReal.ofReal p ≤ ENNReal.ofReal q
-- ENNReal.ofReal_le_of_le_toReal
theorem ofReal_le_of_le_toReal {a : ℝ} {b : ℝ≥0∞} (h : a ≤ ENNReal.toReal b) :
    ENNReal.ofReal a ≤ b 
Arguments: {a : ℝ} {b : ℝ≥0∞} (h : a ≤ b.toReal)
Goal: ENNReal.ofReal a ≤ b
-- ENNReal.ofReal_le_ofReal_iff
@[simp]
theorem ofReal_le_ofReal_iff {p q : ℝ} (h : 0 ≤ q) :
    ENNReal.ofReal p ≤ ENNReal.ofReal q ↔ p ≤ q 
Arguments: {p q : ℝ} (h : 0 ≤ q)
Goal: ENNReal.ofReal p ≤ ENNReal.ofReal q ↔ p ≤ q
-- ENNReal.ofReal_le_ofReal_iff'
lemma ofReal_le_ofReal_iff' {p q : ℝ} : ENNReal.ofReal p ≤ .ofReal q ↔ p ≤ q ∨ p ≤ 0 
Arguments: {p q : ℝ}
Goal: ENNReal.ofReal p ≤ ENNReal.ofReal q ↔ p ≤ q ∨ p ≤ 0
-- ENNReal.ofReal_lt_ofReal_iff'
lemma ofReal_lt_ofReal_iff' {p q : ℝ} : ENNReal.ofReal p < .ofReal q ↔ p < q ∧ 0 < q 
Arguments: {p q : ℝ}
Goal: ENNReal.ofReal p < ENNReal.ofReal q ↔ p < q ∧ 0 < q
-- ENNReal.ofReal_eq_ofReal_iff
@[simp]
theorem ofReal_eq_ofReal_iff {p q : ℝ} (hp : 0 ≤ p) (hq : 0 ≤ q) :
    ENNReal.ofReal p = ENNReal.ofReal q ↔ p = q 
Arguments: {p q : ℝ} (hp : 0 ≤ p) (hq : 0 ≤ q)
Goal: ENNReal.ofReal p = ENNReal.ofReal q ↔ p = q
-- ENNReal.ofReal_lt_ofReal_iff
@[simp]
theorem ofReal_lt_ofReal_iff {p q : ℝ} (h : 0 < q) :
    ENNReal.ofReal p < ENNReal.ofReal q ↔ p < q 
Arguments: {p q : ℝ} (h : 0 < q)
Goal: ENNReal.ofReal p < ENNReal.ofReal q ↔ p < q
-- ENNReal.ofReal_lt_ofReal_iff_of_nonneg
theorem ofReal_lt_ofReal_iff_of_nonneg {p q : ℝ} (hp : 0 ≤ p) :
    ENNReal.ofReal p < ENNReal.ofReal q ↔ p < q 
Arguments: {p q : ℝ} (hp : 0 ≤ p)
Goal: ENNReal.ofReal p < ENNReal.ofReal q ↔ p < q
-- ENNReal.ofReal_pos
@[simp]
theorem ofReal_pos {p : ℝ} : 0 < ENNReal.ofReal p ↔ 0 < p 
Arguments: {p : ℝ}
Goal: 0 < ENNReal.ofReal p ↔ 0 < p
-- ENNReal.ofReal_eq_zero
@[simp]
theorem ofReal_eq_zero {p : ℝ} : ENNReal.ofReal p = 0 ↔ p ≤ 0 
Arguments: {p : ℝ}
Goal: ENNReal.ofReal p = 0 ↔ p ≤ 0
-- ENNReal.zero_eq_ofReal
@[simp]
theorem zero_eq_ofReal {p : ℝ} : 0 = ENNReal.ofReal p ↔ p ≤ 0 
Arguments: {p : ℝ}
Goal: 0 = ENNReal.ofReal p ↔ p ≤ 0
-- ENNReal.ofReal_lt_natCast
@[simp]
lemma ofReal_lt_natCast {p : ℝ} {n : ℕ} (hn : n ≠ 0) : ENNReal.ofReal p < n ↔ p < n 
Arguments: {p : ℝ} {n : ℕ} (hn : n ≠ 0)
Goal: ENNReal.ofReal p < ↑n ↔ p < ↑n
-- ENNReal.ofReal_lt_one
@[simp]
lemma ofReal_lt_one {p : ℝ} : ENNReal.ofReal p < 1 ↔ p < 1 
Arguments: {p : ℝ}
Goal: ENNReal.ofReal p < 1 ↔ p < 1
-- ENNReal.ofReal_lt_ofNat
@[simp]
lemma ofReal_lt_ofNat {p : ℝ} {n : ℕ} [n.AtLeastTwo] :
    ENNReal.ofReal p < no_index (OfNat.ofNat n) ↔ p < OfNat.ofNat n 
Arguments: {p : ℝ} {n : ℕ} [n.AtLeastTwo]
Goal: ENNReal.ofReal p < OfNat.ofNat n ↔ p < OfNat.ofNat n
-- ENNReal.natCast_le_ofReal
@[simp]
lemma natCast_le_ofReal {n : ℕ} {p : ℝ} (hn : n ≠ 0) : n ≤ ENNReal.ofReal p ↔ n ≤ p 
Arguments: {n : ℕ} {p : ℝ} (hn : n ≠ 0)
Goal: ↑n ≤ ENNReal.ofReal p ↔ ↑n ≤ p
-- ENNReal.one_le_ofReal
@[simp]
lemma one_le_ofReal {p : ℝ} : 1 ≤ ENNReal.ofReal p ↔ 1 ≤ p 
Arguments: {p : ℝ}
Goal: 1 ≤ ENNReal.ofReal p ↔ 1 ≤ p
-- ENNReal.ofNat_le_ofReal
@[simp]
lemma ofNat_le_ofReal {n : ℕ} [n.AtLeastTwo] {p : ℝ} :
    no_index (OfNat.ofNat n) ≤ ENNReal.ofReal p ↔ OfNat.ofNat n ≤ p 
Arguments: {n : ℕ} [n.AtLeastTwo] {p : ℝ}
Goal: OfNat.ofNat n ≤ ENNReal.ofReal p ↔ OfNat.ofNat n ≤ p
-- ENNReal.ofReal_le_natCast
@[simp]
lemma ofReal_le_natCast {r : ℝ} {n : ℕ} : ENNReal.ofReal r ≤ n ↔ r ≤ n 
Arguments: {r : ℝ} {n : ℕ}
Goal: ENNReal.ofReal r ≤ ↑n ↔ r ≤ ↑n
-- ENNReal.ofReal_le_one
@[simp]
lemma ofReal_le_one {r : ℝ} : ENNReal.ofReal r ≤ 1 ↔ r ≤ 1 
Arguments: {r : ℝ}
Goal: ENNReal.ofReal r ≤ 1 ↔ r ≤ 1
-- ENNReal.ofReal_le_ofNat
@[simp]
lemma ofReal_le_ofNat {r : ℝ} {n : ℕ} [n.AtLeastTwo] :
    ENNReal.ofReal r ≤ no_index (OfNat.ofNat n) ↔ r ≤ OfNat.ofNat n 
Arguments: {r : ℝ} {n : ℕ} [n.AtLeastTwo]
Goal: ENNReal.ofReal r ≤ OfNat.ofNat n ↔ r ≤ OfNat.ofNat n
-- ENNReal.natCast_lt_ofReal
@[simp]
lemma natCast_lt_ofReal {n : ℕ} {r : ℝ} : n < ENNReal.ofReal r ↔ n < r 
Arguments: {n : ℕ} {r : ℝ}
Goal: ↑n < ENNReal.ofReal r ↔ ↑n < r
-- ENNReal.one_lt_ofReal
@[simp]
lemma one_lt_ofReal {r : ℝ} : 1 < ENNReal.ofReal r ↔ 1 < r 
Arguments: {r : ℝ}
Goal: 1 < ENNReal.ofReal r ↔ 1 < r
-- ENNReal.ofNat_lt_ofReal
@[simp]
lemma ofNat_lt_ofReal {n : ℕ} [n.AtLeastTwo] {r : ℝ} :
    no_index (OfNat.ofNat n) < ENNReal.ofReal r ↔ OfNat.ofNat n < r 
Arguments: {n : ℕ} [n.AtLeastTwo] {r : ℝ}
Goal: OfNat.ofNat n < ENNReal.ofReal r ↔ OfNat.ofNat n < r
-- ENNReal.ofReal_eq_natCast
@[simp]
lemma ofReal_eq_natCast {r : ℝ} {n : ℕ} (h : n ≠ 0) : ENNReal.ofReal r = n ↔ r = n 
Arguments: {r : ℝ} {n : ℕ} (h : n ≠ 0)
Goal: ENNReal.ofReal r = ↑n ↔ r = ↑n
-- ENNReal.ofReal_eq_one
@[simp]
lemma ofReal_eq_one {r : ℝ} : ENNReal.ofReal r = 1 ↔ r = 1 
Arguments: {r : ℝ}
Goal: ENNReal.ofReal r = 1 ↔ r = 1
-- ENNReal.ofReal_eq_ofNat
@[simp]
lemma ofReal_eq_ofNat {r : ℝ} {n : ℕ} [n.AtLeastTwo] :
    ENNReal.ofReal r = no_index (OfNat.ofNat n) ↔ r = OfNat.ofNat n 
Arguments: {r : ℝ} {n : ℕ} [n.AtLeastTwo]
Goal: ENNReal.ofReal r = OfNat.ofNat n ↔ r = OfNat.ofNat n
-- ENNReal.ofReal_sub
theorem ofReal_sub (p : ℝ) {q : ℝ} (hq : 0 ≤ q) :
    ENNReal.ofReal (p - q) = ENNReal.ofReal p - ENNReal.ofReal q 
Arguments: (p : ℝ) {q : ℝ} (hq : 0 ≤ q)
Goal: ENNReal.ofReal (p - q) = ENNReal.ofReal p - ENNReal.ofReal q
-- ENNReal.ofReal_le_iff_le_toReal
theorem ofReal_le_iff_le_toReal {a : ℝ} {b : ℝ≥0∞} (hb : b ≠ ∞) :
    ENNReal.ofReal a ≤ b ↔ a ≤ ENNReal.toReal b 
Arguments: {a : ℝ} {b : ℝ≥0∞} (hb : b ≠ ⊤)
Goal: ENNReal.ofReal a ≤ b ↔ a ≤ b.toReal
-- ENNReal.ofReal_lt_iff_lt_toReal
theorem ofReal_lt_iff_lt_toReal {a : ℝ} {b : ℝ≥0∞} (ha : 0 ≤ a) (hb : b ≠ ∞) :
    ENNReal.ofReal a < b ↔ a < ENNReal.toReal b 
Arguments: {a : ℝ} {b : ℝ≥0∞} (ha : 0 ≤ a) (hb : b ≠ ⊤)
Goal: ENNReal.ofReal a < b ↔ a < b.toReal
-- ENNReal.ofReal_lt_coe_iff
theorem ofReal_lt_coe_iff {a : ℝ} {b : ℝ≥0} (ha : 0 ≤ a) : ENNReal.ofReal a < b ↔ a < b 
Arguments: {a : ℝ} {b : ℝ≥0} (ha : 0 ≤ a)
Goal: ENNReal.ofReal a < ↑b ↔ a < ↑b
-- ENNReal.le_ofReal_iff_toReal_le
theorem le_ofReal_iff_toReal_le {a : ℝ≥0∞} {b : ℝ} (ha : a ≠ ∞) (hb : 0 ≤ b) :
    a ≤ ENNReal.ofReal b ↔ ENNReal.toReal a ≤ b 
Arguments: {a : ℝ≥0∞} {b : ℝ} (ha : a ≠ ⊤) (hb : 0 ≤ b)
Goal: a ≤ ENNReal.ofReal b ↔ a.toReal ≤ b
-- ENNReal.toReal_le_of_le_ofReal
theorem toReal_le_of_le_ofReal {a : ℝ≥0∞} {b : ℝ} (hb : 0 ≤ b) (h : a ≤ ENNReal.ofReal b) :
    ENNReal.toReal a ≤ b 
Arguments: {a : ℝ≥0∞} {b : ℝ} (hb : 0 ≤ b) (h : a ≤ ENNReal.ofReal b)
Goal: a.toReal ≤ b
-- ENNReal.lt_ofReal_iff_toReal_lt
theorem lt_ofReal_iff_toReal_lt {a : ℝ≥0∞} {b : ℝ} (ha : a ≠ ∞) :
    a < ENNReal.ofReal b ↔ ENNReal.toReal a < b 
Arguments: {a : ℝ≥0∞} {b : ℝ} (ha : a ≠ ⊤)
Goal: a < ENNReal.ofReal b ↔ a.toReal < b
-- ENNReal.toReal_lt_of_lt_ofReal
theorem toReal_lt_of_lt_ofReal {b : ℝ} (h : a < ENNReal.ofReal b) : ENNReal.toReal a < b 
Arguments: {a : ℝ≥0∞} {b : ℝ} (h : a < ENNReal.ofReal b)
Goal: a.toReal < b
-- ENNReal.ofReal_mul
theorem ofReal_mul {p q : ℝ} (hp : 0 ≤ p) :
    ENNReal.ofReal (p * q) = ENNReal.ofReal p * ENNReal.ofReal q 
Arguments: {p q : ℝ} (hp : 0 ≤ p)
Goal: ENNReal.ofReal (p * q) = ENNReal.ofReal p * ENNReal.ofReal q
-- ENNReal.ofReal_mul'
theorem ofReal_mul' {p q : ℝ} (hq : 0 ≤ q) :
    ENNReal.ofReal (p * q) = ENNReal.ofReal p * ENNReal.ofReal q 
Arguments: {p q : ℝ} (hq : 0 ≤ q)
Goal: ENNReal.ofReal (p * q) = ENNReal.ofReal p * ENNReal.ofReal q
-- ENNReal.ofReal_pow
theorem ofReal_pow {p : ℝ} (hp : 0 ≤ p) (n : ℕ) :
    ENNReal.ofReal (p ^ n) = ENNReal.ofReal p ^ n 
Arguments: {p : ℝ} (hp : 0 ≤ p) (n : ℕ)
Goal: ENNReal.ofReal (p ^ n) = ENNReal.ofReal p ^ n
-- ENNReal.ofReal_nsmul
theorem ofReal_nsmul {x : ℝ} {n : ℕ} : ENNReal.ofReal (n • x) = n • ENNReal.ofReal x 
Arguments: {x : ℝ} {n : ℕ}
Goal: ENNReal.ofReal (n • x) = n • ENNReal.ofReal x
-- ENNReal.ofReal_inv_of_pos
theorem ofReal_inv_of_pos {x : ℝ} (hx : 0 < x) : ENNReal.ofReal x⁻¹ = (ENNReal.ofReal x)⁻¹ 
Arguments: {x : ℝ} (hx : 0 < x)
Goal: ENNReal.ofReal x⁻¹ = (ENNReal.ofReal x)⁻¹
-- ENNReal.ofReal_div_of_pos
theorem ofReal_div_of_pos {x y : ℝ} (hy : 0 < y) :
    ENNReal.ofReal (x / y) = ENNReal.ofReal x / ENNReal.ofReal y 
Arguments: {x y : ℝ} (hy : 0 < y)
Goal: ENNReal.ofReal (x / y) = ENNReal.ofReal x / ENNReal.ofReal y
-- ENNReal.toNNReal_mul
@[simp]
theorem toNNReal_mul {a b : ℝ≥0∞} : (a * b).toNNReal = a.toNNReal * b.toNNReal 
Arguments: {a b : ℝ≥0∞}
Goal: (a * b).toNNReal = a.toNNReal * b.toNNReal
-- ENNReal.toNNReal_mul_top
theorem toNNReal_mul_top (a : ℝ≥0∞) : ENNReal.toNNReal (a * ∞) = 0 
Arguments: (a : ℝ≥0∞)
Goal: (a * ⊤).toNNReal = 0
-- ENNReal.toNNReal_top_mul
theorem toNNReal_top_mul (a : ℝ≥0∞) : ENNReal.toNNReal (∞ * a) = 0 
Arguments: (a : ℝ≥0∞)
Goal: (⊤ * a).toNNReal = 0
-- ENNReal.smul_toNNReal
@[simp]
theorem smul_toNNReal (a : ℝ≥0) (b : ℝ≥0∞) : (a • b).toNNReal = a * b.toNNReal 
Arguments: (a : ℝ≥0) (b : ℝ≥0∞)
Goal: (a • b).toNNReal = a * b.toNNReal
-- ENNReal.toNNReal_pow
@[simp]
theorem toNNReal_pow (a : ℝ≥0∞) (n : ℕ) : (a ^ n).toNNReal = a.toNNReal ^ n 
Arguments: (a : ℝ≥0∞) (n : ℕ)
Goal: (a ^ n).toNNReal = a.toNNReal ^ n
-- ENNReal.toNNReal_prod
@[simp]
theorem toNNReal_prod {ι : Type*} {s : Finset ι} {f : ι → ℝ≥0∞} :
    (∏ i ∈ s, f i).toNNReal = ∏ i ∈ s, (f i).toNNReal 
Arguments: {ι : Type u_1} {s : Finset ι} {f : ι → ℝ≥0∞}
Goal: (∏ i ∈ s, f i).toNNReal = ∏ i ∈ s, (f i).toNNReal
-- ENNReal.toReal_mul
@[simp]
theorem toReal_mul : (a * b).toReal = a.toReal * b.toReal 
Arguments: {a b : ℝ≥0∞}
Goal: (a * b).toReal = a.toReal * b.toReal
-- ENNReal.toReal_nsmul
theorem toReal_nsmul (a : ℝ≥0∞) (n : ℕ) : (n • a).toReal = n • a.toReal 
Arguments: (a : ℝ≥0∞) (n : ℕ)
Goal: (n • a).toReal = n • a.toReal
-- ENNReal.toReal_pow
@[simp]
theorem toReal_pow (a : ℝ≥0∞) (n : ℕ) : (a ^ n).toReal = a.toReal ^ n 
Arguments: (a : ℝ≥0∞) (n : ℕ)
Goal: (a ^ n).toReal = a.toReal ^ n
-- ENNReal.toReal_prod
@[simp]
theorem toReal_prod {ι : Type*} {s : Finset ι} {f : ι → ℝ≥0∞} :
    (∏ i ∈ s, f i).toReal = ∏ i ∈ s, (f i).toReal 
Arguments: {ι : Type u_1} {s : Finset ι} {f : ι → ℝ≥0∞}
Goal: (∏ i ∈ s, f i).toReal = ∏ i ∈ s, (f i).toReal
-- ENNReal.toReal_ofReal_mul
theorem toReal_ofReal_mul (c : ℝ) (a : ℝ≥0∞) (h : 0 ≤ c) :
    ENNReal.toReal (ENNReal.ofReal c * a) = c * ENNReal.toReal a 
Arguments: (c : ℝ) (a : ℝ≥0∞) (h : 0 ≤ c)
Goal: (ENNReal.ofReal c * a).toReal = c * a.toReal
-- ENNReal.toReal_mul_top
theorem toReal_mul_top (a : ℝ≥0∞) : ENNReal.toReal (a * ∞) = 0 
Arguments: (a : ℝ≥0∞)
Goal: (a * ⊤).toReal = 0
-- ENNReal.toReal_top_mul
theorem toReal_top_mul (a : ℝ≥0∞) : ENNReal.toReal (∞ * a) = 0 
Arguments: (a : ℝ≥0∞)
Goal: (⊤ * a).toReal = 0
-- ENNReal.toReal_eq_toReal
theorem toReal_eq_toReal (ha : a ≠ ∞) (hb : b ≠ ∞) : a.toReal = b.toReal ↔ a = b 
Arguments: {a b : ℝ≥0∞} (ha : a ≠ ⊤) (hb : b ≠ ⊤)
Goal: a.toReal = b.toReal ↔ a = b
-- ENNReal.toReal_smul
theorem toReal_smul (r : ℝ≥0) (s : ℝ≥0∞) : (r • s).toReal = r • s.toReal 
Arguments: (r : ℝ≥0) (s : ℝ≥0∞)
Goal: (r • s).toReal = r • s.toReal
-- ENNReal.trichotomy
protected theorem trichotomy (p : ℝ≥0∞) : p = 0 ∨ p = ∞ ∨ 0 < p.toReal 
Arguments: (p : ℝ≥0∞)
Goal: p = 0 ∨ p = ⊤ ∨ 0 < p.toReal