ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Real.exp_lt_exp_of_lt
@[gcongr]
theorem exp_lt_exp_of_lt {x y : ℝ} (h : x < y) : exp x < exp y 
Arguments: {x y : ℝ} (h : x < y)
Goal: Real.exp x < Real.exp y
-- Real.exp_monotone
@[mono]
theorem exp_monotone : Monotone exp 
Goal: Monotone Real.exp
-- Real.exp_le_exp_of_le
@[gcongr]
theorem exp_le_exp_of_le {x y : ℝ} (h : x ≤ y) : exp x ≤ exp y 
Arguments: {x y : ℝ} (h : x ≤ y)
Goal: Real.exp x ≤ Real.exp y
-- Real.exp_lt_exp
@[simp]
theorem exp_lt_exp {x y : ℝ} : exp x < exp y ↔ x < y 
Arguments: {x y : ℝ}
Goal: Real.exp x < Real.exp y ↔ x < y
-- Real.exp_le_exp
@[simp]
theorem exp_le_exp {x y : ℝ} : exp x ≤ exp y ↔ x ≤ y 
Arguments: {x y : ℝ}
Goal: Real.exp x ≤ Real.exp y ↔ x ≤ y
-- Real.exp_injective
theorem exp_injective : Function.Injective exp 
Goal: Function.Injective Real.exp
-- Real.exp_eq_exp
@[simp]
theorem exp_eq_exp {x y : ℝ} : exp x = exp y ↔ x = y 
Arguments: {x y : ℝ}
Goal: Real.exp x = Real.exp y ↔ x = y
-- Real.exp_eq_one_iff
@[simp]
theorem exp_eq_one_iff : exp x = 1 ↔ x = 0 
Arguments: (x : ℝ)
Goal: Real.exp x = 1 ↔ x = 0
-- Real.one_lt_exp_iff
@[simp]
theorem one_lt_exp_iff {x : ℝ} : 1 < exp x ↔ 0 < x 
Arguments: {x : ℝ}
Goal: 1 < Real.exp x ↔ 0 < x
-- Real.exp_lt_one_iff
@[simp]
theorem exp_lt_one_iff {x : ℝ} : exp x < 1 ↔ x < 0 
Arguments: {x : ℝ}
Goal: Real.exp x < 1 ↔ x < 0
-- Real.exp_le_one_iff
@[simp]
theorem exp_le_one_iff {x : ℝ} : exp x ≤ 1 ↔ x ≤ 0 
Arguments: {x : ℝ}
Goal: Real.exp x ≤ 1 ↔ x ≤ 0
-- Real.one_le_exp_iff
@[simp]
theorem one_le_exp_iff {x : ℝ} : 1 ≤ exp x ↔ 0 ≤ x 
Arguments: {x : ℝ}
Goal: 1 ≤ Real.exp x ↔ 0 ≤ x
-- Real.cosh_pos
theorem cosh_pos (x : ℝ) : 0 < Real.cosh x 
Arguments: (x : ℝ)
Goal: 0 < Real.cosh x
-- Real.sinh_lt_cosh
theorem sinh_lt_cosh : sinh x < cosh x 
Arguments: (x : ℝ)
Goal: Real.sinh x < Real.cosh x
-- Complex.sum_div_factorial_le
theorem sum_div_factorial_le {α : Type*} [LinearOrderedField α] (n j : ℕ) (hn : 0 < n) :
    (∑ m ∈ filter (fun k => n ≤ k) (range j),
      (1 / m.factorial : α)) ≤ n.succ / (n.factorial * n) 
Arguments: {α : Type u_1} [LinearOrderedField α] (n j : ℕ) (hn : 0 < n)
Goal: ∑ m ∈ Finset.filter (fun k => n ≤ k) (Finset.range j), 1 / ↑m.factorial ≤ ↑n.succ / (↑n.factorial * ↑n)
-- Complex.exp_bound
theorem exp_bound {x : ℂ} (hx : abs x ≤ 1) {n : ℕ} (hn : 0 < n) :
    abs (exp x - ∑ m ∈ range n, x ^ m / m.factorial) ≤
      abs x ^ n * ((n.succ : ℝ) * (n.factorial * n : ℝ)⁻¹) 
Arguments: {x : ℂ} (hx : Complex.abs x ≤ 1) {n : ℕ} (hn : 0 < n)
Goal: Complex.abs (Complex.exp x - ∑ m ∈ Finset.range n, x ^ m / ↑m.factorial) ≤
  Complex.abs x ^ n * (↑n.succ * (↑n.factorial * ↑n)⁻¹)
-- Complex.exp_bound'
theorem exp_bound' {x : ℂ} {n : ℕ} (hx : abs x / n.succ ≤ 1 / 2) :
    abs (exp x - ∑ m ∈ range n, x ^ m / m.factorial) ≤ abs x ^ n / n.factorial * 2 
Arguments: {x : ℂ} {n : ℕ} (hx : Complex.abs x / ↑n.succ ≤ 1 / 2)
Goal: Complex.abs (Complex.exp x - ∑ m ∈ Finset.range n, x ^ m / ↑m.factorial) ≤ Complex.abs x ^ n / ↑n.factorial * 2
-- Complex.abs_exp_sub_one_le
theorem abs_exp_sub_one_le {x : ℂ} (hx : abs x ≤ 1) : abs (exp x - 1) ≤ 2 * abs x 
Arguments: {x : ℂ} (hx : Complex.abs x ≤ 1)
Goal: Complex.abs (Complex.exp x - 1) ≤ 2 * Complex.abs x
-- Complex.abs_exp_sub_one_sub_id_le
theorem abs_exp_sub_one_sub_id_le {x : ℂ} (hx : abs x ≤ 1) : abs (exp x - 1 - x) ≤ abs x ^ 2 
Arguments: {x : ℂ} (hx : Complex.abs x ≤ 1)
Goal: Complex.abs (Complex.exp x - 1 - x) ≤ Complex.abs x ^ 2
-- Real.exp_bound
nonrec theorem exp_bound {x : ℝ} (hx : |x| ≤ 1) {n : ℕ} (hn : 0 < n) :
    |exp x - ∑ m ∈ range n, x ^ m / m.factorial| ≤ |x| ^ n * (n.succ / (n.factorial * n)) 
Arguments: {x : ℝ} (hx : |x| ≤ 1) {n : ℕ} (hn : 0 < n)
Goal: |Real.exp x - ∑ m ∈ Finset.range n, x ^ m / ↑m.factorial| ≤ |x| ^ n * (↑n.succ / (↑n.factorial * ↑n))
-- Real.exp_bound'
theorem exp_bound' {x : ℝ} (h1 : 0 ≤ x) (h2 : x ≤ 1) {n : ℕ} (hn : 0 < n) :
    Real.exp x ≤ (∑ m ∈ Finset.range n, x ^ m / m.factorial) +
      x ^ n * (n + 1) / (n.factorial * n) 
Arguments: {x : ℝ} (h1 : 0 ≤ x) (h2 : x ≤ 1) {n : ℕ} (hn : 0 < n)
Goal: Real.exp x ≤ ∑ m ∈ Finset.range n, x ^ m / ↑m.factorial + x ^ n * (↑n + 1) / (↑n.factorial * ↑n)
-- Real.abs_exp_sub_one_le
theorem abs_exp_sub_one_le {x : ℝ} (hx : |x| ≤ 1) : |exp x - 1| ≤ 2 * |x| 
Arguments: {x : ℝ} (hx : |x| ≤ 1)
Goal: |Real.exp x - 1| ≤ 2 * |x|
-- Real.abs_exp_sub_one_sub_id_le
theorem abs_exp_sub_one_sub_id_le {x : ℝ} (hx : |x| ≤ 1) : |exp x - 1 - x| ≤ x ^ 2 
Arguments: {x : ℝ} (hx : |x| ≤ 1)
Goal: |Real.exp x - 1 - x| ≤ x ^ 2
-- Real.expNear_zero
@[simp]
theorem expNear_zero (x r) : expNear 0 x r = r 
Arguments: (x r : ℝ)
Goal: Real.expNear 0 x r = r
-- Real.expNear_succ
@[simp]
theorem expNear_succ (n x r) : expNear (n + 1) x r = expNear n x (1 + x / (n + 1) * r) 
Arguments: (n : ℕ) (x r : ℝ)
Goal: Real.expNear (n + 1) x r = Real.expNear n x (1 + x / (↑n + 1) * r)
-- Real.expNear_sub
theorem expNear_sub (n x r₁ r₂) : expNear n x r₁ -
    expNear n x r₂ = x ^ n / n.factorial * (r₁ - r₂) 
Arguments: (n : ℕ) (x r₁ r₂ : ℝ)
Goal: Real.expNear n x r₁ - Real.expNear n x r₂ = x ^ n / ↑n.factorial * (r₁ - r₂)
-- Real.exp_approx_end
theorem exp_approx_end (n m : ℕ) (x : ℝ) (e₁ : n + 1 = m) (h : |x| ≤ 1) :
    |exp x - expNear m x 0| ≤ |x| ^ m / m.factorial * ((m + 1) / m) 
Arguments: (n m : ℕ) (x : ℝ) (e₁ : n + 1 = m) (h : |x| ≤ 1)
Goal: |Real.exp x - Real.expNear m x 0| ≤ |x| ^ m / ↑m.factorial * ((↑m + 1) / ↑m)
-- Real.exp_approx_succ
theorem exp_approx_succ {n} {x a₁ b₁ : ℝ} (m : ℕ) (e₁ : n + 1 = m) (a₂ b₂ : ℝ)
    (e : |1 + x / m * a₂ - a₁| ≤ b₁ - |x| / m * b₂)
    (h : |exp x - expNear m x a₂| ≤ |x| ^ m / m.factorial * b₂) :
    |exp x - expNear n x a₁| ≤ |x| ^ n / n.factorial * b₁ 
Arguments: {n : ℕ} {x a₁ b₁ : ℝ} (m : ℕ) (e₁ : n + 1 = m) (a₂ b₂ : ℝ) (e : |1 + x / ↑m * a₂ - a₁| ≤ b₁ - |x| / ↑m * b₂) (h : |Real.exp x - Real.expNear m x a₂| ≤ |x| ^ m / ↑m.factorial * b₂)
Goal: |Real.exp x - Real.expNear n x a₁| ≤ |x| ^ n / ↑n.factorial * b₁
-- Real.exp_approx_end'
theorem exp_approx_end' {n} {x a b : ℝ} (m : ℕ) (e₁ : n + 1 = m) (rm : ℝ) (er : ↑m = rm)
    (h : |x| ≤ 1) (e : |1 - a| ≤ b - |x| / rm * ((rm + 1) / rm)) :
    |exp x - expNear n x a| ≤ |x| ^ n / n.factorial * b 
Arguments: {n : ℕ} {x a b : ℝ} (m : ℕ) (e₁ : n + 1 = m) (rm : ℝ) (er : ↑m = rm) (h : |x| ≤ 1) (e : |1 - a| ≤ b - |x| / rm * ((rm + 1) / rm))
Goal: |Real.exp x - Real.expNear n x a| ≤ |x| ^ n / ↑n.factorial * b
-- Real.exp_1_approx_succ_eq
theorem exp_1_approx_succ_eq {n} {a₁ b₁ : ℝ} {m : ℕ} (en : n + 1 = m) {rm : ℝ} (er : ↑m = rm)
    (h : |exp 1 - expNear m 1 ((a₁ - 1) * rm)| ≤ |1| ^ m / m.factorial * (b₁ * rm)) :
    |exp 1 - expNear n 1 a₁| ≤ |1| ^ n / n.factorial * b₁ 
Arguments: {n : ℕ} {a₁ b₁ : ℝ} {m : ℕ} (en : n + 1 = m) {rm : ℝ} (er : ↑m = rm) (h : |Real.exp 1 - Real.expNear m 1 ((a₁ - 1) * rm)| ≤ |1| ^ m / ↑m.factorial * (b₁ * rm))
Goal: |Real.exp 1 - Real.expNear n 1 a₁| ≤ |1| ^ n / ↑n.factorial * b₁
-- Real.exp_approx_start
theorem exp_approx_start (x a b : ℝ) (h : |exp x - expNear 0 x a| ≤ |x| ^ 0 / Nat.factorial 0 * b) :
    |exp x - a| ≤ b 
Arguments: (x a b : ℝ) (h : |Real.exp x - Real.expNear 0 x a| ≤ |x| ^ 0 / ↑(Nat.factorial 0) * b)
Goal: |Real.exp x - a| ≤ b
-- Real.cos_bound
theorem cos_bound {x : ℝ} (hx : |x| ≤ 1) : |cos x - (1 - x ^ 2 / 2)| ≤ |x| ^ 4 * (5 / 96) 
Arguments: {x : ℝ} (hx : |x| ≤ 1)
Goal: |Real.cos x - (1 - x ^ 2 / 2)| ≤ |x| ^ 4 * (5 / 96)
-- Real.sin_bound
theorem sin_bound {x : ℝ} (hx : |x| ≤ 1) : |sin x - (x - x ^ 3 / 6)| ≤ |x| ^ 4 * (5 / 96) 
Arguments: {x : ℝ} (hx : |x| ≤ 1)
Goal: |Real.sin x - (x - x ^ 3 / 6)| ≤ |x| ^ 4 * (5 / 96)
-- Real.cos_pos_of_le_one
theorem cos_pos_of_le_one {x : ℝ} (hx : |x| ≤ 1) : 0 < cos x 
Arguments: {x : ℝ} (hx : |x| ≤ 1)
Goal: 0 < Real.cos x
-- Real.sin_pos_of_pos_of_le_one
theorem sin_pos_of_pos_of_le_one {x : ℝ} (hx0 : 0 < x) (hx : x ≤ 1) : 0 < sin x 
Arguments: {x : ℝ} (hx0 : 0 < x) (hx : x ≤ 1)
Goal: 0 < Real.sin x
-- Real.sin_pos_of_pos_of_le_two
theorem sin_pos_of_pos_of_le_two {x : ℝ} (hx0 : 0 < x) (hx : x ≤ 2) : 0 < sin x 
Arguments: {x : ℝ} (hx0 : 0 < x) (hx : x ≤ 2)
Goal: 0 < Real.sin x
-- Real.cos_one_le
theorem cos_one_le : cos 1 ≤ 2 / 3 
Goal: Real.cos 1 ≤ 2 / 3
-- Real.cos_one_pos
theorem cos_one_pos : 0 < cos 1 
Goal: 0 < Real.cos 1
-- Real.cos_two_neg
theorem cos_two_neg : cos 2 < 0 
Goal: Real.cos 2 < 0
-- Real.exp_bound_div_one_sub_of_interval'
theorem exp_bound_div_one_sub_of_interval' {x : ℝ} (h1 : 0 < x) (h2 : x < 1) :
    Real.exp x < 1 / (1 - x) 
Arguments: {x : ℝ} (h1 : 0 < x) (h2 : x < 1)
Goal: Real.exp x < 1 / (1 - x)
-- Real.exp_bound_div_one_sub_of_interval
theorem exp_bound_div_one_sub_of_interval {x : ℝ} (h1 : 0 ≤ x) (h2 : x < 1) :
    Real.exp x ≤ 1 / (1 - x) 
Arguments: {x : ℝ} (h1 : 0 ≤ x) (h2 : x < 1)
Goal: Real.exp x ≤ 1 / (1 - x)
-- Real.add_one_lt_exp
theorem add_one_lt_exp {x : ℝ} (hx : x ≠ 0) : x + 1 < Real.exp x 
Arguments: {x : ℝ} (hx : x ≠ 0)
Goal: x + 1 < Real.exp x
-- Real.add_one_le_exp
theorem add_one_le_exp (x : ℝ) : x + 1 ≤ Real.exp x 
Arguments: (x : ℝ)
Goal: x + 1 ≤ Real.exp x
-- Real.one_sub_lt_exp_neg
lemma one_sub_lt_exp_neg {x : ℝ} (hx : x ≠ 0) : 1 - x < exp (-x) 
Arguments: {x : ℝ} (hx : x ≠ 0)
Goal: 1 - x < Real.exp (-x)
-- Real.one_sub_le_exp_neg
lemma one_sub_le_exp_neg (x : ℝ) : 1 - x ≤ exp (-x) 
Arguments: (x : ℝ)
Goal: 1 - x ≤ Real.exp (-x)
-- Real.one_sub_div_pow_le_exp_neg
theorem one_sub_div_pow_le_exp_neg {n : ℕ} {t : ℝ} (ht' : t ≤ n) : (1 - t / n) ^ n ≤ exp (-t) 
Arguments: {n : ℕ} {t : ℝ} (ht' : t ≤ ↑n)
Goal: (1 - t / ↑n) ^ n ≤ Real.exp (-t)
-- Complex.abs_cos_add_sin_mul_I
@[simp]
theorem abs_cos_add_sin_mul_I (x : ℝ) : abs (cos x + sin x * I) = 1 
Arguments: (x : ℝ)
Goal: Complex.abs (Complex.cos ↑x + Complex.sin ↑x * Complex.I) = 1
-- Complex.abs_exp_ofReal
@[simp]
theorem abs_exp_ofReal (x : ℝ) : abs (exp x) = Real.exp x 
Arguments: (x : ℝ)
Goal: Complex.abs (Complex.exp ↑x) = Real.exp x
-- Complex.abs_exp_ofReal_mul_I
@[simp]
theorem abs_exp_ofReal_mul_I (x : ℝ) : abs (exp (x * I)) = 1 
Arguments: (x : ℝ)
Goal: Complex.abs (Complex.exp (↑x * Complex.I)) = 1
-- Complex.abs_exp
theorem abs_exp (z : ℂ) : abs (exp z) = Real.exp z.re 
Arguments: (z : ℂ)
Goal: Complex.abs (Complex.exp z) = Real.exp z.re
-- Complex.abs_exp_eq_iff_re_eq
theorem abs_exp_eq_iff_re_eq {x y : ℂ} : abs (exp x) = abs (exp y) ↔ x.re = y.re 
Arguments: {x y : ℂ}
Goal: Complex.abs (Complex.exp x) = Complex.abs (Complex.exp y) ↔ x.re = y.re
-- PosNum.cast_one
@[simp, norm_cast]
theorem cast_one [One α] [Add α] : ((1 : PosNum) : α) = 1 
Arguments: {α : Type u_1} [One α] [Add α]
Goal: ↑1 = 1
-- PosNum.cast_one'
@[simp]
theorem cast_one' [One α] [Add α] : (PosNum.one : α) = 1 
Arguments: {α : Type u_1} [One α] [Add α]
Goal: ↑PosNum.one = 1
-- PosNum.cast_bit0
@[simp, norm_cast]
theorem cast_bit0 [One α] [Add α] (n : PosNum) : (n.bit0 : α) = (n : α) + n 
Arguments: {α : Type u_1} [One α] [Add α] (n : PosNum)
Goal: ↑n.bit0 = ↑n + ↑n
-- PosNum.cast_bit1
@[simp, norm_cast]
theorem cast_bit1 [One α] [Add α] (n : PosNum) : (n.bit1 : α) = ((n : α) + n) + 1 
Arguments: {α : Type u_1} [One α] [Add α] (n : PosNum)
Goal: ↑n.bit1 = ↑n + ↑n + 1
-- PosNum.cast_to_nat
@[simp, norm_cast]
theorem cast_to_nat [AddMonoidWithOne α] : ∀ n : PosNum, ((n : ℕ) : α) = n
  
Arguments: {α : Type u_1} [AddMonoidWithOne α] (n : PosNum)
Goal: ↑↑n = ↑n
-- PosNum.to_nat_to_int
@[norm_cast] -- @[simp] -- Porting note (#10618): simp can prove this
theorem to_nat_to_int (n : PosNum) : ((n : ℕ) : ℤ) = n 
Arguments: (n : PosNum)
Goal: ↑↑n = ↑n
-- PosNum.cast_to_int
@[simp, norm_cast]
theorem cast_to_int [AddGroupWithOne α] (n : PosNum) : ((n : ℤ) : α) = n 
Arguments: {α : Type u_1} [AddGroupWithOne α] (n : PosNum)
Goal: ↑↑n = ↑n
-- PosNum.succ_to_nat
theorem succ_to_nat : ∀ n, (succ n : ℕ) = n + 1
  
Arguments: (n : PosNum)
Goal: ↑n.succ = ↑n + 1
-- PosNum.one_add
theorem one_add (n : PosNum) : 1 + n = succ n 
Arguments: (n : PosNum)
Goal: 1 + n = n.succ
-- PosNum.add_one
theorem add_one (n : PosNum) : n + 1 = succ n 
Arguments: (n : PosNum)
Goal: n + 1 = n.succ
-- PosNum.add_to_nat
@[norm_cast]
theorem add_to_nat : ∀ m n, ((m + n : PosNum) : ℕ) = m + n
  
Arguments: (m n : PosNum)
Goal: ↑(m + n) = ↑m + ↑n
-- PosNum.add_succ
theorem add_succ : ∀ m n : PosNum, m + succ n = succ (m + n)
  
Arguments: (m n : PosNum)
Goal: m + n.succ = (m + n).succ
-- PosNum.bit0_of_bit0
theorem bit0_of_bit0 : ∀ n, n + n = bit0 n
  
Arguments: (n : PosNum)
Goal: n + n = n.bit0
-- PosNum.bit1_of_bit1
theorem bit1_of_bit1 (n : PosNum) : (n + n) + 1 = bit1 n 
Arguments: (n : PosNum)
Goal: n + n + 1 = n.bit1
-- PosNum.mul_to_nat
@[norm_cast]
theorem mul_to_nat (m) : ∀ n, ((m * n : PosNum) : ℕ) = m * n
  
Arguments: (m n : PosNum)
Goal: ↑(m * n) = ↑m * ↑n
-- PosNum.to_nat_pos
theorem to_nat_pos : ∀ n : PosNum, 0 < (n : ℕ)
  
Arguments: (n : PosNum)
Goal: 0 < ↑n
-- PosNum.cmp_to_nat_lemma
theorem cmp_to_nat_lemma {m n : PosNum} : (m : ℕ) < n → (bit1 m : ℕ) < bit0 n 
Arguments: {m n : PosNum}
Goal: ↑m < ↑n → ↑m.bit1 < ↑n.bit0
-- PosNum.cmp_swap
theorem cmp_swap (m) : ∀ n, (cmp m n).swap = cmp n m 
Arguments: (m n : PosNum)
Goal: (m.cmp n).swap = n.cmp m
-- PosNum.cmp_to_nat
theorem cmp_to_nat : ∀ m n, (Ordering.casesOn (cmp m n) ((m : ℕ) < n) (m = n) ((n : ℕ) < m) : Prop)
  
Arguments: (m n : PosNum)
Goal: Ordering.casesOn (m.cmp n) (↑m < ↑n) (m = n) (↑n < ↑m)
-- PosNum.lt_to_nat
@[norm_cast]
theorem lt_to_nat {m n : PosNum} : (m : ℕ) < n ↔ m < n 
Arguments: {m n : PosNum}
Goal: ↑m < ↑n ↔ m < n
-- PosNum.le_to_nat
@[norm_cast]
theorem le_to_nat {m n : PosNum} : (m : ℕ) ≤ n ↔ m ≤ n 
Arguments: {m n : PosNum}
Goal: ↑m ≤ ↑n ↔ m ≤ n
-- Num.add_zero
theorem add_zero (n : Num) : n + 0 = n 
Arguments: (n : Num)
Goal: n + 0 = n
-- Num.zero_add
theorem zero_add (n : Num) : 0 + n = n 
Arguments: (n : Num)
Goal: 0 + n = n
-- Num.add_one
theorem add_one : ∀ n : Num, n + 1 = succ n
  
Arguments: (n : Num)
Goal: n + 1 = n.succ
-- Num.add_succ
theorem add_succ : ∀ m n : Num, m + succ n = succ (m + n)
  
Arguments: (m n : Num)
Goal: m + n.succ = (m + n).succ
-- Num.bit0_of_bit0
theorem bit0_of_bit0 : ∀ n : Num, n + n = n.bit0
  
Arguments: (n : Num)
Goal: n + n = n.bit0
-- Num.bit1_of_bit1
theorem bit1_of_bit1 : ∀ n : Num, (n + n) + 1 = n.bit1
  
Arguments: (n : Num)
Goal: n + n + 1 = n.bit1
-- Num.ofNat'_zero
@[simp]
theorem ofNat'_zero : Num.ofNat' 0 = 0 
Goal: Num.ofNat' 0 = 0
-- Num.ofNat'_bit
theorem ofNat'_bit (b n) : ofNat' (Nat.bit b n) = cond b Num.bit1 Num.bit0 (ofNat' n) 
Arguments: (b : Bool) (n : ℕ)
Goal: Num.ofNat' (Nat.bit b n) = (bif b then Num.bit1 else Num.bit0) (Num.ofNat' n)
-- Num.ofNat'_one
@[simp]
theorem ofNat'_one : Num.ofNat' 1 = 1 
Goal: Num.ofNat' 1 = 1
-- Num.bit1_succ
theorem bit1_succ : ∀ n : Num, n.bit1.succ = n.succ.bit0
  
Arguments: (n : Num)
Goal: n.bit1.succ = n.succ.bit0
-- Num.ofNat'_succ
theorem ofNat'_succ : ∀ {n}, ofNat' (n + 1) = ofNat' n + 1 
Arguments: {n : ℕ}
Goal: Num.ofNat' (n + 1) = Num.ofNat' n + 1
-- Num.add_ofNat'
@[simp]
theorem add_ofNat' (m n) : Num.ofNat' (m + n) = Num.ofNat' m + Num.ofNat' n 
Arguments: (m n : ℕ)
Goal: Num.ofNat' (m + n) = Num.ofNat' m + Num.ofNat' n
-- Num.cast_zero
@[simp, norm_cast]
theorem cast_zero [Zero α] [One α] [Add α] : ((0 : Num) : α) = 0 
Arguments: {α : Type u_1} [Zero α] [One α] [Add α]
Goal: ↑0 = 0
-- Num.cast_zero'
@[simp]
theorem cast_zero' [Zero α] [One α] [Add α] : (Num.zero : α) = 0 
Arguments: {α : Type u_1} [Zero α] [One α] [Add α]
Goal: ↑Num.zero = 0
-- Num.cast_one
@[simp, norm_cast]
theorem cast_one [Zero α] [One α] [Add α] : ((1 : Num) : α) = 1 
Arguments: {α : Type u_1} [Zero α] [One α] [Add α]
Goal: ↑1 = 1
-- Num.cast_pos
@[simp]
theorem cast_pos [Zero α] [One α] [Add α] (n : PosNum) : (Num.pos n : α) = n 
Arguments: {α : Type u_1} [Zero α] [One α] [Add α] (n : PosNum)
Goal: ↑(Num.pos n) = ↑n
-- Num.succ'_to_nat
theorem succ'_to_nat : ∀ n, (succ' n : ℕ) = n + 1
  
Arguments: (n : Num)
Goal: ↑n.succ' = ↑n + 1
-- Num.succ_to_nat
theorem succ_to_nat (n) : (succ n : ℕ) = n + 1 
Arguments: (n : Num)
Goal: ↑n.succ = ↑n + 1
-- Num.cast_to_nat
@[simp, norm_cast]
theorem cast_to_nat [AddMonoidWithOne α] : ∀ n : Num, ((n : ℕ) : α) = n
  
Arguments: {α : Type u_1} [AddMonoidWithOne α] (n : Num)
Goal: ↑↑n = ↑n
-- Num.add_to_nat
@[norm_cast]
theorem add_to_nat : ∀ m n, ((m + n : Num) : ℕ) = m + n
  
Arguments: (m n : Num)
Goal: ↑(m + n) = ↑m + ↑n
-- Num.mul_to_nat
@[norm_cast]
theorem mul_to_nat : ∀ m n, ((m * n : Num) : ℕ) = m * n
  
Arguments: (m n : Num)
Goal: ↑(m * n) = ↑m * ↑n
-- Num.cmp_to_nat
theorem cmp_to_nat : ∀ m n, (Ordering.casesOn (cmp m n) ((m : ℕ) < n) (m = n) ((n : ℕ) < m) : Prop)
  
Arguments: (m n : Num)
Goal: Ordering.casesOn (m.cmp n) (↑m < ↑n) (m = n) (↑n < ↑m)
-- Num.lt_to_nat
@[norm_cast]
theorem lt_to_nat {m n : Num} : (m : ℕ) < n ↔ m < n 
Arguments: {m n : Num}
Goal: ↑m < ↑n ↔ m < n
-- Num.le_to_nat
@[norm_cast]
theorem le_to_nat {m n : Num} : (m : ℕ) ≤ n ↔ m ≤ n 
Arguments: {m n : Num}
Goal: ↑m ≤ ↑n ↔ m ≤ n
-- PosNum.of_to_nat'
@[simp]
theorem of_to_nat' : ∀ n : PosNum, Num.ofNat' (n : ℕ) = Num.pos n
  
Arguments: (n : PosNum)
Goal: Num.ofNat' ↑n = Num.pos n
-- Num.of_to_nat'
@[simp, norm_cast]
theorem of_to_nat' : ∀ n : Num, Num.ofNat' (n : ℕ) = n
  
Arguments: (n : Num)
Goal: Num.ofNat' ↑n = n
-- Num.toNat_injective
lemma toNat_injective : Injective (castNum : Num → ℕ) 
Goal: Function.Injective castNum
-- Num.to_nat_inj
@[norm_cast]
theorem to_nat_inj {m n : Num} : (m : ℕ) = n ↔ m = n 
Arguments: {m n : Num}
Goal: ↑m = ↑n ↔ m = n
-- Num.add_of_nat
@[norm_cast] -- @[simp] -- Porting note (#10618): simp can prove this
theorem add_of_nat (m n) : ((m + n : ℕ) : Num) = m + n 
Arguments: (m n : ℕ)
Goal: ↑(m + n) = ↑m + ↑n
-- Num.to_nat_to_int
@[norm_cast]  -- @[simp] -- Porting note (#10618): simp can prove this
theorem to_nat_to_int (n : Num) : ((n : ℕ) : ℤ) = n 
Arguments: (n : Num)
Goal: ↑↑n = ↑n
-- Num.cast_to_int
@[simp, norm_cast]
theorem cast_to_int {α} [AddGroupWithOne α] (n : Num) : ((n : ℤ) : α) = n 
Arguments: {α : Type u_1} [AddGroupWithOne α] (n : Num)
Goal: ↑↑n = ↑n
-- Num.to_of_nat
theorem to_of_nat : ∀ n : ℕ, ((n : Num) : ℕ) = n
  
Arguments: (n : ℕ)
Goal: ↑↑n = n
-- Num.of_natCast
@[simp, norm_cast]
theorem of_natCast {α} [AddMonoidWithOne α] (n : ℕ) : ((n : Num) : α) = n 
Arguments: {α : Type u_1} [AddMonoidWithOne α] (n : ℕ)
Goal: ↑↑n = ↑n
-- Num.of_nat_inj
@[norm_cast] -- @[simp] -- Porting note (#10618): simp can prove this
theorem of_nat_inj {m n : ℕ} : (m : Num) = n ↔ m = n 
Arguments: {m n : ℕ}
Goal: ↑m = ↑n ↔ m = n
-- Num.of_to_nat
@[simp high, norm_cast]
theorem of_to_nat : ∀ n : Num, ((n : ℕ) : Num) = n 
Arguments: (n : Num)
Goal: ↑↑n = n
-- Num.dvd_to_nat
@[norm_cast]
theorem dvd_to_nat (m n : Num) : (m : ℕ) ∣ n ↔ m ∣ n 
Arguments: (m n : Num)
Goal: ↑m ∣ ↑n ↔ m ∣ n
-- PosNum.of_to_nat
@[simp high, norm_cast]
theorem of_to_nat : ∀ n : PosNum, ((n : ℕ) : Num) = Num.pos n 
Arguments: (n : PosNum)
Goal: ↑↑n = Num.pos n
-- PosNum.to_nat_inj
@[norm_cast]
theorem to_nat_inj {m n : PosNum} : (m : ℕ) = n ↔ m = n 
Arguments: {m n : PosNum}
Goal: ↑m = ↑n ↔ m = n
-- PosNum.pred'_to_nat
theorem pred'_to_nat : ∀ n, (pred' n : ℕ) = Nat.pred n
  
Arguments: (n : PosNum)
Goal: ↑n.pred' = (↑n).pred
-- PosNum.pred'_succ'
@[simp]
theorem pred'_succ' (n) : pred' (succ' n) = n 
Arguments: (n : Num)
Goal: n.succ'.pred' = n
-- PosNum.succ'_pred'
@[simp]
theorem succ'_pred' (n) : succ' (pred' n) = n 
Arguments: (n : PosNum)
Goal: n.pred'.succ' = n
-- PosNum.dvd_to_nat
@[norm_cast]
theorem dvd_to_nat {m n : PosNum} : (m : ℕ) ∣ n ↔ m ∣ n 
Arguments: {m n : PosNum}
Goal: ↑m ∣ ↑n ↔ m ∣ n
-- PosNum.size_to_nat
theorem size_to_nat : ∀ n, (size n : ℕ) = Nat.size n
  
Arguments: (n : PosNum)
Goal: ↑n.size = (↑n).size
-- PosNum.size_eq_natSize
theorem size_eq_natSize : ∀ n, (size n : ℕ) = natSize n
  
Arguments: (n : PosNum)
Goal: ↑n.size = n.natSize
-- PosNum.natSize_to_nat
theorem natSize_to_nat (n) : natSize n = Nat.size n 
Arguments: (n : PosNum)
Goal: n.natSize = (↑n).size
-- PosNum.natSize_pos
theorem natSize_pos (n) : 0 < natSize n 
Arguments: (n : PosNum)
Goal: 0 < n.natSize
-- PosNum.cast_to_num
@[simp]
theorem cast_to_num (n : PosNum) : ↑n = Num.pos n 
Arguments: (n : PosNum)
Goal: ↑n = Num.pos n
-- PosNum.bit_to_nat
@[simp, norm_cast]
theorem bit_to_nat (b n) : (bit b n : ℕ) = Nat.bit b n 
Arguments: (b : Bool) (n : PosNum)
Goal: ↑(PosNum.bit b n) = Nat.bit b ↑n
-- PosNum.cast_add
@[simp, norm_cast]
theorem cast_add [AddMonoidWithOne α] (m n) : ((m + n : PosNum) : α) = m + n 
Arguments: {α : Type u_1} [AddMonoidWithOne α] (m n : PosNum)
Goal: ↑(m + n) = ↑m + ↑n
-- PosNum.cast_succ
@[simp 500, norm_cast]
theorem cast_succ [AddMonoidWithOne α] (n : PosNum) : (succ n : α) = n + 1 
Arguments: {α : Type u_1} [AddMonoidWithOne α] (n : PosNum)
Goal: ↑n.succ = ↑n + 1
-- PosNum.cast_inj
@[simp, norm_cast]
theorem cast_inj [AddMonoidWithOne α] [CharZero α] {m n : PosNum} : (m : α) = n ↔ m = n 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [CharZero α] {m n : PosNum}
Goal: ↑m = ↑n ↔ m = n
-- PosNum.one_le_cast
@[simp]
theorem one_le_cast [LinearOrderedSemiring α] (n : PosNum) : (1 : α) ≤ n 
Arguments: {α : Type u_1} [LinearOrderedSemiring α] (n : PosNum)
Goal: 1 ≤ ↑n
-- PosNum.cast_pos
@[simp]
theorem cast_pos [LinearOrderedSemiring α] (n : PosNum) : 0 < (n : α) 
Arguments: {α : Type u_1} [LinearOrderedSemiring α] (n : PosNum)
Goal: 0 < ↑n
-- PosNum.cast_mul
@[simp, norm_cast]
theorem cast_mul [Semiring α] (m n) : ((m * n : PosNum) : α) = m * n 
Arguments: {α : Type u_1} [Semiring α] (m n : PosNum)
Goal: ↑(m * n) = ↑m * ↑n
-- PosNum.cmp_eq
@[simp]
theorem cmp_eq (m n) : cmp m n = Ordering.eq ↔ m = n 
Arguments: (m n : PosNum)
Goal: m.cmp n = Ordering.eq ↔ m = n
-- PosNum.cast_lt
@[simp, norm_cast]
theorem cast_lt [LinearOrderedSemiring α] {m n : PosNum} : (m : α) < n ↔ m < n 
Arguments: {α : Type u_1} [LinearOrderedSemiring α] {m n : PosNum}
Goal: ↑m < ↑n ↔ m < n
-- PosNum.cast_le
@[simp, norm_cast]
theorem cast_le [LinearOrderedSemiring α] {m n : PosNum} : (m : α) ≤ n ↔ m ≤ n 
Arguments: {α : Type u_1} [LinearOrderedSemiring α] {m n : PosNum}
Goal: ↑m ≤ ↑n ↔ m ≤ n
-- Num.bit_to_nat
theorem bit_to_nat (b n) : (bit b n : ℕ) = Nat.bit b n 
Arguments: (b : Bool) (n : Num)
Goal: ↑(Num.bit b n) = Nat.bit b ↑n
-- Num.cast_succ'
theorem cast_succ' [AddMonoidWithOne α] (n) : (succ' n : α) = n + 1 
Arguments: {α : Type u_1} [AddMonoidWithOne α] (n : Num)
Goal: ↑n.succ' = ↑n + 1
-- Num.cast_succ
theorem cast_succ [AddMonoidWithOne α] (n) : (succ n : α) = n + 1 
Arguments: {α : Type u_1} [AddMonoidWithOne α] (n : Num)
Goal: ↑n.succ = ↑n + 1
-- Num.cast_add
@[simp, norm_cast]
theorem cast_add [Semiring α] (m n) : ((m + n : Num) : α) = m + n 
Arguments: {α : Type u_1} [Semiring α] (m n : Num)
Goal: ↑(m + n) = ↑m + ↑n
-- Num.cast_bit0
@[simp, norm_cast]
theorem cast_bit0 [Semiring α] (n : Num) : (n.bit0 : α) = 2 * (n : α) 
Arguments: {α : Type u_1} [Semiring α] (n : Num)
Goal: ↑n.bit0 = 2 * ↑n
-- Num.cast_bit1
@[simp, norm_cast]
theorem cast_bit1 [Semiring α] (n : Num) : (n.bit1 : α) = 2 * (n : α) + 1 
Arguments: {α : Type u_1} [Semiring α] (n : Num)
Goal: ↑n.bit1 = 2 * ↑n + 1
-- Num.cast_mul
@[simp, norm_cast]
theorem cast_mul [Semiring α] : ∀ m n, ((m * n : Num) : α) = m * n
  
Arguments: {α : Type u_1} [Semiring α] (m n : Num)
Goal: ↑(m * n) = ↑m * ↑n
-- Num.size_to_nat
theorem size_to_nat : ∀ n, (size n : ℕ) = Nat.size n
  
Arguments: (n : Num)
Goal: ↑n.size = (↑n).size
-- Num.size_eq_natSize
theorem size_eq_natSize : ∀ n, (size n : ℕ) = natSize n
  
Arguments: (n : Num)
Goal: ↑n.size = n.natSize
-- Num.natSize_to_nat
theorem natSize_to_nat (n) : natSize n = Nat.size n 
Arguments: (n : Num)
Goal: n.natSize = (↑n).size
-- Num.ofNat'_eq
@[simp 999]
theorem ofNat'_eq : ∀ n, Num.ofNat' n = n 
Arguments: (n : ℕ)
Goal: Num.ofNat' n = ↑n
-- Num.zneg_toZNum
theorem zneg_toZNum (n : Num) : -n.toZNum = n.toZNumNeg 
Arguments: (n : Num)
Goal: -n.toZNum = n.toZNumNeg
-- Num.zneg_toZNumNeg
theorem zneg_toZNumNeg (n : Num) : -n.toZNumNeg = n.toZNum 
Arguments: (n : Num)
Goal: -n.toZNumNeg = n.toZNum
-- Num.toZNum_inj
theorem toZNum_inj {m n : Num} : m.toZNum = n.toZNum ↔ m = n 
Arguments: {m n : Num}
Goal: m.toZNum = n.toZNum ↔ m = n
-- Num.cast_toZNum
@[simp]
theorem cast_toZNum [Zero α] [One α] [Add α] [Neg α] : ∀ n : Num, (n.toZNum : α) = n
  
Arguments: {α : Type u_1} [Zero α] [One α] [Add α] [Neg α] (n : Num)
Goal: ↑n.toZNum = ↑n