ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Real.induction_Ico_mul
lemma Real.induction_Ico_mul {P : ℝ → Prop} (x₀ r : ℝ) (hr : 1 < r) (hx₀ : 0 < x₀)
    (base : ∀ x ∈ Set.Ico x₀ (r * x₀), P x)
    (step : ∀ n : ℕ, n ≥ 1 → (∀ z ∈ Set.Ico x₀ (r ^ n * x₀), P z) →
      (∀ z ∈ Set.Ico (r ^ n * x₀) (r ^ (n+1) * x₀), P z)) :
    ∀ x ≥ x₀, P x 
Arguments: {P : ℝ → Prop} (x₀ r : ℝ) (hr : 1 < r) (hx₀ : 0 < x₀) (base : ∀ x ∈ Set.Ico x₀ (r * x₀), P x) (step : ∀ n ≥ 1, (∀ z ∈ Set.Ico x₀ (r ^ n * x₀), P z) → ∀ z ∈ Set.Ico (r ^ n * x₀) (r ^ (n + 1) * x₀), P z) (x : ℝ)
Goal: x ≥ x₀ → P x
-- Real.log_of_ne_zero
theorem log_of_ne_zero (hx : x ≠ 0) : log x = expOrderIso.symm ⟨|x|, abs_pos.2 hx⟩ 
Arguments: {x : ℝ} (hx : x ≠ 0)
Goal: Real.log x = Real.expOrderIso.symm ⟨|x|, ⋯⟩
-- Real.log_of_pos
theorem log_of_pos (hx : 0 < x) : log x = expOrderIso.symm ⟨x, hx⟩ 
Arguments: {x : ℝ} (hx : 0 < x)
Goal: Real.log x = Real.expOrderIso.symm ⟨x, hx⟩
-- Real.exp_log_eq_abs
theorem exp_log_eq_abs (hx : x ≠ 0) : exp (log x) = |x| 
Arguments: {x : ℝ} (hx : x ≠ 0)
Goal: Real.exp (Real.log x) = |x|
-- Real.exp_log
theorem exp_log (hx : 0 < x) : exp (log x) = x 
Arguments: {x : ℝ} (hx : 0 < x)
Goal: Real.exp (Real.log x) = x
-- Real.exp_log_of_neg
theorem exp_log_of_neg (hx : x < 0) : exp (log x) = -x 
Arguments: {x : ℝ} (hx : x < 0)
Goal: Real.exp (Real.log x) = -x
-- Real.le_exp_log
theorem le_exp_log (x : ℝ) : x ≤ exp (log x) 
Arguments: (x : ℝ)
Goal: x ≤ Real.exp (Real.log x)
-- Real.log_exp
@[simp]
theorem log_exp (x : ℝ) : log (exp x) = x 
Arguments: (x : ℝ)
Goal: Real.log (Real.exp x) = x
-- Real.surjOn_log
theorem surjOn_log : SurjOn log (Ioi 0) univ 
Goal: Set.SurjOn Real.log (Set.Ioi 0) Set.univ
-- Real.log_surjective
theorem log_surjective : Surjective log 
Goal: Function.Surjective Real.log
-- Real.range_log
@[simp]
theorem range_log : range log = univ 
Goal: Set.range Real.log = Set.univ
-- Real.log_zero
@[simp]
theorem log_zero : log 0 = 0 
Goal: Real.log 0 = 0
-- Real.log_one
@[simp]
theorem log_one : log 1 = 0 
Goal: Real.log 1 = 0
-- Real.log_abs
@[simp]
theorem log_abs (x : ℝ) : log |x| = log x 
Arguments: (x : ℝ)
Goal: Real.log |x| = Real.log x
-- Real.log_neg_eq_log
@[simp]
theorem log_neg_eq_log (x : ℝ) : log (-x) = log x 
Arguments: (x : ℝ)
Goal: Real.log (-x) = Real.log x
-- Real.sinh_log
theorem sinh_log {x : ℝ} (hx : 0 < x) : sinh (log x) = (x - x⁻¹) / 2 
Arguments: {x : ℝ} (hx : 0 < x)
Goal: Real.sinh (Real.log x) = (x - x⁻¹) / 2
-- Real.cosh_log
theorem cosh_log {x : ℝ} (hx : 0 < x) : cosh (log x) = (x + x⁻¹) / 2 
Arguments: {x : ℝ} (hx : 0 < x)
Goal: Real.cosh (Real.log x) = (x + x⁻¹) / 2
-- Real.surjOn_log'
theorem surjOn_log' : SurjOn log (Iio 0) univ 
Goal: Set.SurjOn Real.log (Set.Iio 0) Set.univ
-- Real.log_mul
theorem log_mul (hx : x ≠ 0) (hy : y ≠ 0) : log (x * y) = log x + log y 
Arguments: {x y : ℝ} (hx : x ≠ 0) (hy : y ≠ 0)
Goal: Real.log (x * y) = Real.log x + Real.log y
-- Real.log_div
theorem log_div (hx : x ≠ 0) (hy : y ≠ 0) : log (x / y) = log x - log y 
Arguments: {x y : ℝ} (hx : x ≠ 0) (hy : y ≠ 0)
Goal: Real.log (x / y) = Real.log x - Real.log y
-- Real.log_inv
@[simp]
theorem log_inv (x : ℝ) : log x⁻¹ = -log x 
Arguments: (x : ℝ)
Goal: Real.log x⁻¹ = -Real.log x
-- Real.log_le_log_iff
theorem log_le_log_iff (h : 0 < x) (h₁ : 0 < y) : log x ≤ log y ↔ x ≤ y 
Arguments: {x y : ℝ} (h : 0 < x) (h₁ : 0 < y)
Goal: Real.log x ≤ Real.log y ↔ x ≤ y
-- Real.log_le_log
@[gcongr]
lemma log_le_log (hx : 0 < x) (hxy : x ≤ y) : log x ≤ log y 
Arguments: {x y : ℝ} (hx : 0 < x) (hxy : x ≤ y)
Goal: Real.log x ≤ Real.log y
-- Real.log_lt_log
@[gcongr]
theorem log_lt_log (hx : 0 < x) (h : x < y) : log x < log y 
Arguments: {x y : ℝ} (hx : 0 < x) (h : x < y)
Goal: Real.log x < Real.log y
-- Real.log_lt_log_iff
theorem log_lt_log_iff (hx : 0 < x) (hy : 0 < y) : log x < log y ↔ x < y 
Arguments: {x y : ℝ} (hx : 0 < x) (hy : 0 < y)
Goal: Real.log x < Real.log y ↔ x < y
-- Real.log_le_iff_le_exp
theorem log_le_iff_le_exp (hx : 0 < x) : log x ≤ y ↔ x ≤ exp y 
Arguments: {x y : ℝ} (hx : 0 < x)
Goal: Real.log x ≤ y ↔ x ≤ Real.exp y
-- Real.log_lt_iff_lt_exp
theorem log_lt_iff_lt_exp (hx : 0 < x) : log x < y ↔ x < exp y 
Arguments: {x y : ℝ} (hx : 0 < x)
Goal: Real.log x < y ↔ x < Real.exp y
-- Real.le_log_iff_exp_le
theorem le_log_iff_exp_le (hy : 0 < y) : x ≤ log y ↔ exp x ≤ y 
Arguments: {x y : ℝ} (hy : 0 < y)
Goal: x ≤ Real.log y ↔ Real.exp x ≤ y
-- Real.lt_log_iff_exp_lt
theorem lt_log_iff_exp_lt (hy : 0 < y) : x < log y ↔ exp x < y 
Arguments: {x y : ℝ} (hy : 0 < y)
Goal: x < Real.log y ↔ Real.exp x < y
-- Real.log_pos_iff
theorem log_pos_iff (hx : 0 < x) : 0 < log x ↔ 1 < x 
Arguments: {x : ℝ} (hx : 0 < x)
Goal: 0 < Real.log x ↔ 1 < x
-- Real.log_pos
theorem log_pos (hx : 1 < x) : 0 < log x 
Arguments: {x : ℝ} (hx : 1 < x)
Goal: 0 < Real.log x
-- Real.log_pos_of_lt_neg_one
theorem log_pos_of_lt_neg_one (hx : x < -1) : 0 < log x 
Arguments: {x : ℝ} (hx : x < -1)
Goal: 0 < Real.log x
-- Real.log_neg_iff
theorem log_neg_iff (h : 0 < x) : log x < 0 ↔ x < 1 
Arguments: {x : ℝ} (h : 0 < x)
Goal: Real.log x < 0 ↔ x < 1
-- Real.log_neg
theorem log_neg (h0 : 0 < x) (h1 : x < 1) : log x < 0 
Arguments: {x : ℝ} (h0 : 0 < x) (h1 : x < 1)
Goal: Real.log x < 0
-- Real.log_neg_of_lt_zero
theorem log_neg_of_lt_zero (h0 : x < 0) (h1 : -1 < x) : log x < 0 
Arguments: {x : ℝ} (h0 : x < 0) (h1 : -1 < x)
Goal: Real.log x < 0
-- Real.log_nonneg_iff
theorem log_nonneg_iff (hx : 0 < x) : 0 ≤ log x ↔ 1 ≤ x 
Arguments: {x : ℝ} (hx : 0 < x)
Goal: 0 ≤ Real.log x ↔ 1 ≤ x
-- Real.log_nonneg
theorem log_nonneg (hx : 1 ≤ x) : 0 ≤ log x 
Arguments: {x : ℝ} (hx : 1 ≤ x)
Goal: 0 ≤ Real.log x
-- Real.log_nonpos_iff
theorem log_nonpos_iff (hx : 0 < x) : log x ≤ 0 ↔ x ≤ 1 
Arguments: {x : ℝ} (hx : 0 < x)
Goal: Real.log x ≤ 0 ↔ x ≤ 1
-- Real.log_nonpos_iff'
theorem log_nonpos_iff' (hx : 0 ≤ x) : log x ≤ 0 ↔ x ≤ 1 
Arguments: {x : ℝ} (hx : 0 ≤ x)
Goal: Real.log x ≤ 0 ↔ x ≤ 1
-- Real.log_nonpos
theorem log_nonpos (hx : 0 ≤ x) (h'x : x ≤ 1) : log x ≤ 0 
Arguments: {x : ℝ} (hx : 0 ≤ x) (h'x : x ≤ 1)
Goal: Real.log x ≤ 0
-- Real.log_natCast_nonneg
theorem log_natCast_nonneg (n : ℕ) : 0 ≤ log n 
Arguments: (n : ℕ)
Goal: 0 ≤ Real.log ↑n
-- Real.log_neg_natCast_nonneg
theorem log_neg_natCast_nonneg (n : ℕ) : 0 ≤ log (-n) 
Arguments: (n : ℕ)
Goal: 0 ≤ Real.log (-↑n)
-- Real.log_intCast_nonneg
theorem log_intCast_nonneg (n : ℤ) : 0 ≤ log n 
Arguments: (n : ℤ)
Goal: 0 ≤ Real.log ↑n
-- Real.strictMonoOn_log
theorem strictMonoOn_log : StrictMonoOn log (Set.Ioi 0) 
Goal: StrictMonoOn Real.log (Set.Ioi 0)
-- Real.strictAntiOn_log
theorem strictAntiOn_log : StrictAntiOn log (Set.Iio 0) 
Goal: StrictAntiOn Real.log (Set.Iio 0)
-- Real.log_injOn_pos
theorem log_injOn_pos : Set.InjOn log (Set.Ioi 0) 
Goal: Set.InjOn Real.log (Set.Ioi 0)
-- Real.log_lt_sub_one_of_pos
theorem log_lt_sub_one_of_pos (hx1 : 0 < x) (hx2 : x ≠ 1) : log x < x - 1 
Arguments: {x : ℝ} (hx1 : 0 < x) (hx2 : x ≠ 1)
Goal: Real.log x < x - 1
-- Real.eq_one_of_pos_of_log_eq_zero
theorem eq_one_of_pos_of_log_eq_zero {x : ℝ} (h₁ : 0 < x) (h₂ : log x = 0) : x = 1 
Arguments: {x : ℝ} (h₁ : 0 < x) (h₂ : Real.log x = 0)
Goal: x = 1
-- Real.log_ne_zero_of_pos_of_ne_one
theorem log_ne_zero_of_pos_of_ne_one {x : ℝ} (hx_pos : 0 < x) (hx : x ≠ 1) : log x ≠ 0 
Arguments: {x : ℝ} (hx_pos : 0 < x) (hx : x ≠ 1)
Goal: Real.log x ≠ 0
-- Real.log_eq_zero
@[simp]
theorem log_eq_zero {x : ℝ} : log x = 0 ↔ x = 0 ∨ x = 1 ∨ x = -1 
Arguments: {x : ℝ}
Goal: Real.log x = 0 ↔ x = 0 ∨ x = 1 ∨ x = -1
-- Real.log_ne_zero
theorem log_ne_zero {x : ℝ} : log x ≠ 0 ↔ x ≠ 0 ∧ x ≠ 1 ∧ x ≠ -1 
Arguments: {x : ℝ}
Goal: Real.log x ≠ 0 ↔ x ≠ 0 ∧ x ≠ 1 ∧ x ≠ -1
-- Real.log_pow
@[simp]
theorem log_pow (x : ℝ) (n : ℕ) : log (x ^ n) = n * log x 
Arguments: (x : ℝ) (n : ℕ)
Goal: Real.log (x ^ n) = ↑n * Real.log x
-- Real.log_zpow
@[simp]
theorem log_zpow (x : ℝ) (n : ℤ) : log (x ^ n) = n * log x 
Arguments: (x : ℝ) (n : ℤ)
Goal: Real.log (x ^ n) = ↑n * Real.log x
-- Real.log_sqrt
theorem log_sqrt {x : ℝ} (hx : 0 ≤ x) : log (√x) = log x / 2 
Arguments: {x : ℝ} (hx : 0 ≤ x)
Goal: Real.log √x = Real.log x / 2
-- Real.log_le_sub_one_of_pos
theorem log_le_sub_one_of_pos {x : ℝ} (hx : 0 < x) : log x ≤ x - 1 
Arguments: {x : ℝ} (hx : 0 < x)
Goal: Real.log x ≤ x - 1
-- Real.abs_log_mul_self_lt
theorem abs_log_mul_self_lt (x : ℝ) (h1 : 0 < x) (h2 : x ≤ 1) : |log x * x| < 1 
Arguments: (x : ℝ) (h1 : 0 < x) (h2 : x ≤ 1)
Goal: |Real.log x * x| < 1
-- Real.tendsto_log_atTop
theorem tendsto_log_atTop : Tendsto log atTop atTop 
Goal: Filter.Tendsto Real.log Filter.atTop Filter.atTop
-- Real.tendsto_log_nhdsWithin_zero
theorem tendsto_log_nhdsWithin_zero : Tendsto log (𝓝[≠] 0) atBot 
Goal: Filter.Tendsto Real.log (𝓝[≠] 0) Filter.atBot
-- Real.tendsto_log_nhdsWithin_zero_right
lemma tendsto_log_nhdsWithin_zero_right : Tendsto log (𝓝[>] 0) atBot 
Goal: Filter.Tendsto Real.log (𝓝[>] 0) Filter.atBot
-- Real.continuousOn_log
theorem continuousOn_log : ContinuousOn log {0}ᶜ 
Goal: ContinuousOn Real.log {0}ᶜ
-- Real.continuous_log
@[continuity]
theorem continuous_log : Continuous fun x : { x : ℝ // x ≠ 0 } => log x 
Goal: Continuous fun x => Real.log ↑x
-- Real.continuous_log'
@[continuity]
theorem continuous_log' : Continuous fun x : { x : ℝ // 0 < x } => log x 
Goal: Continuous fun x => Real.log ↑x
-- Real.continuousAt_log
theorem continuousAt_log (hx : x ≠ 0) : ContinuousAt log x 
Arguments: {x : ℝ} (hx : x ≠ 0)
Goal: ContinuousAt Real.log x
-- Real.continuousAt_log_iff
@[simp]
theorem continuousAt_log_iff : ContinuousAt log x ↔ x ≠ 0 
Arguments: {x : ℝ}
Goal: ContinuousAt Real.log x ↔ x ≠ 0
-- Real.log_prod
theorem log_prod {α : Type*} (s : Finset α) (f : α → ℝ) (hf : ∀ x ∈ s, f x ≠ 0) :
    log (∏ i ∈ s, f i) = ∑ i ∈ s, log (f i) 
Arguments: {α : Type u_1} (s : Finset α) (f : α → ℝ) (hf : ∀ x ∈ s, f x ≠ 0)
Goal: Real.log (∏ i ∈ s, f i) = ∑ i ∈ s, Real.log (f i)
-- Finsupp.log_prod
protected theorem _root_.Finsupp.log_prod {α β : Type*} [Zero β] (f : α →₀ β) (g : α → β → ℝ)
    (hg : ∀ a, g a (f a) = 0 → f a = 0) : log (f.prod g) = f.sum fun a b ↦ log (g a b) 
Arguments: {α : Type u_1} {β : Type u_2} [Zero β] (f : α →₀ β) (g : α → β → ℝ) (hg : ∀ (a : α), g a (f a) = 0 → f a = 0)
Goal: Real.log (f.prod g) = f.sum fun a b => Real.log (g a b)
-- Real.log_nat_eq_sum_factorization
theorem log_nat_eq_sum_factorization (n : ℕ) :
    log n = n.factorization.sum fun p t => t * log p 
Arguments: (n : ℕ)
Goal: Real.log ↑n = n.factorization.sum fun p t => ↑t * Real.log ↑p
-- Real.tendsto_pow_log_div_mul_add_atTop
theorem tendsto_pow_log_div_mul_add_atTop (a b : ℝ) (n : ℕ) (ha : a ≠ 0) :
    Tendsto (fun x => log x ^ n / (a * x + b)) atTop (𝓝 0) 
Arguments: (a b : ℝ) (n : ℕ) (ha : a ≠ 0)
Goal: Filter.Tendsto (fun x => Real.log x ^ n / (a * x + b)) Filter.atTop (𝓝 0)
-- Real.isLittleO_pow_log_id_atTop
theorem isLittleO_pow_log_id_atTop {n : ℕ} : (fun x => log x ^ n) =o[atTop] id 
Arguments: {n : ℕ}
Goal: (fun x => Real.log x ^ n) =o[Filter.atTop] id
-- Real.isLittleO_log_id_atTop
theorem isLittleO_log_id_atTop : log =o[atTop] id 
Goal: Real.log =o[Filter.atTop] id
-- Real.isLittleO_const_log_atTop
theorem isLittleO_const_log_atTop {c : ℝ} : (fun _ => c) =o[atTop] log 
Arguments: {c : ℝ}
Goal: (fun x => c) =o[Filter.atTop] Real.log
-- Filter.Tendsto.log
theorem Filter.Tendsto.log {f : α → ℝ} {l : Filter α} {x : ℝ} (h : Tendsto f l (𝓝 x)) (hx : x ≠ 0) :
    Tendsto (fun x => log (f x)) l (𝓝 (log x)) 
Arguments: {α : Type u_1} {f : α → ℝ} {l : Filter α} {x : ℝ} (h : Filter.Tendsto f l (𝓝 x)) (hx : x ≠ 0)
Goal: Filter.Tendsto (fun x => Real.log (f x)) l (𝓝 (Real.log x))
-- Continuous.log
@[fun_prop]
theorem Continuous.log (hf : Continuous f) (h₀ : ∀ x, f x ≠ 0) : Continuous fun x => log (f x) 
Arguments: {α : Type u_1} [TopologicalSpace α] {f : α → ℝ} (hf : Continuous f) (h₀ : ∀ (x : α), f x ≠ 0)
Goal: Continuous fun x => Real.log (f x)
-- ContinuousAt.log
@[fun_prop]
nonrec theorem ContinuousAt.log (hf : ContinuousAt f a) (h₀ : f a ≠ 0) :
    ContinuousAt (fun x => log (f x)) a 
Arguments: {α : Type u_1} [TopologicalSpace α] {f : α → ℝ} {a : α} (hf : ContinuousAt f a) (h₀ : f a ≠ 0)
Goal: ContinuousAt (fun x => Real.log (f x)) a
-- ContinuousWithinAt.log
nonrec theorem ContinuousWithinAt.log (hf : ContinuousWithinAt f s a) (h₀ : f a ≠ 0) :
    ContinuousWithinAt (fun x => log (f x)) s a 
Arguments: {α : Type u_1} [TopologicalSpace α] {f : α → ℝ} {s : Set α} {a : α} (hf : ContinuousWithinAt f s a) (h₀ : f a ≠ 0)
Goal: ContinuousWithinAt (fun x => Real.log (f x)) s a
-- ContinuousOn.log
@[fun_prop]
theorem ContinuousOn.log (hf : ContinuousOn f s) (h₀ : ∀ x ∈ s, f x ≠ 0) :
    ContinuousOn (fun x => log (f x)) s 
Arguments: {α : Type u_1} [TopologicalSpace α] {f : α → ℝ} {s : Set α} (hf : ContinuousOn f s) (h₀ : ∀ x ∈ s, f x ≠ 0)
Goal: ContinuousOn (fun x => Real.log (f x)) s
-- Real.tendsto_log_comp_add_sub_log
theorem tendsto_log_comp_add_sub_log (y : ℝ) :
    Tendsto (fun x : ℝ => log (x + y) - log x) atTop (𝓝 0) 
Arguments: (y : ℝ)
Goal: Filter.Tendsto (fun x => Real.log (x + y) - Real.log x) Filter.atTop (𝓝 0)
-- Real.tendsto_log_nat_add_one_sub_log
theorem tendsto_log_nat_add_one_sub_log : Tendsto (fun k : ℕ => log (k + 1) - log k) atTop (𝓝 0) 
Goal: Filter.Tendsto (fun k => Real.log (↑k + 1) - Real.log ↑k) Filter.atTop (𝓝 0)
-- Mathlib.Meta.Positivity.log_nonneg_of_isNat
lemma log_nonneg_of_isNat {n : ℕ} (h : NormNum.IsNat e n) : 0 ≤ Real.log (e : ℝ) 
Arguments: {e : ℝ} {n : ℕ} (h : Mathlib.Meta.NormNum.IsNat e n)
Goal: 0 ≤ Real.log e
-- Mathlib.Meta.Positivity.log_pos_of_isNat
lemma log_pos_of_isNat {n : ℕ} (h : NormNum.IsNat e n) (w : Nat.blt 1 n = true) :
    0 < Real.log (e : ℝ) 
Arguments: {e : ℝ} {n : ℕ} (h : Mathlib.Meta.NormNum.IsNat e n) (w : Nat.blt 1 n = true)
Goal: 0 < Real.log e
-- Mathlib.Meta.Positivity.log_nonneg_of_isNegNat
lemma log_nonneg_of_isNegNat {n : ℕ} (h : NormNum.IsInt e (.negOfNat n)) :
    0 ≤ Real.log (e : ℝ) 
Arguments: {e : ℝ} {n : ℕ} (h : Mathlib.Meta.NormNum.IsInt e (Int.negOfNat n))
Goal: 0 ≤ Real.log e
-- Mathlib.Meta.Positivity.log_pos_of_isNegNat
lemma log_pos_of_isNegNat {n : ℕ} (h : NormNum.IsInt e (.negOfNat n)) (w : Nat.blt 1 n = true) :
    0 < Real.log (e : ℝ) 
Arguments: {e : ℝ} {n : ℕ} (h : Mathlib.Meta.NormNum.IsInt e (Int.negOfNat n)) (w : Nat.blt 1 n = true)
Goal: 0 < Real.log e
-- Mathlib.Meta.Positivity.log_pos_of_isRat
lemma log_pos_of_isRat {n : ℤ} :
    (NormNum.IsRat e n d) → (decide ((1 : ℚ) < n / d)) → (0 < Real.log (e : ℝ))
  
Arguments: {e : ℝ} {d : ℕ} {n : ℤ}
Goal: Mathlib.Meta.NormNum.IsRat e n d → decide (1 < ↑n / ↑d) = true → 0 < Real.log e
-- Mathlib.Meta.Positivity.log_pos_of_isRat_neg
lemma log_pos_of_isRat_neg {n : ℤ} :
    (NormNum.IsRat e n d) → (decide (n / d < (-1 : ℚ))) → (0 < Real.log (e : ℝ))
  
Arguments: {e : ℝ} {d : ℕ} {n : ℤ}
Goal: Mathlib.Meta.NormNum.IsRat e n d → decide (↑n / ↑d < -1) = true → 0 < Real.log e
-- Mathlib.Meta.Positivity.log_nz_of_isRat
lemma log_nz_of_isRat {n : ℤ} : (NormNum.IsRat e n d) → (decide ((0 : ℚ) < n / d))
    → (decide (n / d < (1 : ℚ))) → (Real.log (e : ℝ) ≠ 0)
  
Arguments: {e : ℝ} {d : ℕ} {n : ℤ}
Goal: Mathlib.Meta.NormNum.IsRat e n d → decide (0 < ↑n / ↑d) = true → decide (↑n / ↑d < 1) = true → Real.log e ≠ 0
-- Mathlib.Meta.Positivity.log_nz_of_isRat_neg
lemma log_nz_of_isRat_neg {n : ℤ} : (NormNum.IsRat e n d) → (decide (n / d < (0 : ℚ)))
    → (decide ((-1 : ℚ) < n / d)) → (Real.log (e : ℝ) ≠ 0)
  
Arguments: {e : ℝ} {d : ℕ} {n : ℤ}
Goal: Mathlib.Meta.NormNum.IsRat e n d → decide (↑n / ↑d < 0) = true → decide (-1 < ↑n / ↑d) = true → Real.log e ≠ 0
-- Real.tan_add
theorem tan_add {x y : ℝ}
    (h : ((∀ k : ℤ, x ≠ (2 * k + 1) * π / 2) ∧ ∀ l : ℤ, y ≠ (2 * l + 1) * π / 2) ∨
      (∃ k : ℤ, x = (2 * k + 1) * π / 2) ∧ ∃ l : ℤ, y = (2 * l + 1) * π / 2) :
    tan (x + y) = (tan x + tan y) / (1 - tan x * tan y) 
Arguments: {x y : ℝ} (h :
  ((∀ (k : ℤ), x ≠ (2 * ↑k + 1) * Real.pi / 2) ∧ ∀ (l : ℤ), y ≠ (2 * ↑l + 1) * Real.pi / 2) ∨
    (∃ k, x = (2 * ↑k + 1) * Real.pi / 2) ∧ ∃ l, y = (2 * ↑l + 1) * Real.pi / 2)
Goal: Real.tan (x + y) = (Real.tan x + Real.tan y) / (1 - Real.tan x * Real.tan y)
-- Real.tan_add'
theorem tan_add' {x y : ℝ}
    (h : (∀ k : ℤ, x ≠ (2 * k + 1) * π / 2) ∧ ∀ l : ℤ, y ≠ (2 * l + 1) * π / 2) :
    tan (x + y) = (tan x + tan y) / (1 - tan x * tan y) 
Arguments: {x y : ℝ} (h : (∀ (k : ℤ), x ≠ (2 * ↑k + 1) * Real.pi / 2) ∧ ∀ (l : ℤ), y ≠ (2 * ↑l + 1) * Real.pi / 2)
Goal: Real.tan (x + y) = (Real.tan x + Real.tan y) / (1 - Real.tan x * Real.tan y)
-- Real.tan_two_mul
theorem tan_two_mul {x : ℝ} : tan (2 * x) = 2 * tan x / (1 - tan x ^ 2) 
Arguments: {x : ℝ}
Goal: Real.tan (2 * x) = 2 * Real.tan x / (1 - Real.tan x ^ 2)
-- Real.tan_int_mul_pi_div_two
theorem tan_int_mul_pi_div_two (n : ℤ) : tan (n * π / 2) = 0 
Arguments: (n : ℤ)
Goal: Real.tan (↑n * Real.pi / 2) = 0
-- Real.continuousOn_tan
theorem continuousOn_tan : ContinuousOn tan {x | cos x ≠ 0} 
Goal: ContinuousOn Real.tan {x | Real.cos x ≠ 0}
-- Real.continuous_tan
@[continuity]
theorem continuous_tan : Continuous fun x : {x | cos x ≠ 0} => tan x 
Goal: Continuous fun x => Real.tan ↑x
-- Real.continuousOn_tan_Ioo
theorem continuousOn_tan_Ioo : ContinuousOn tan (Ioo (-(π / 2)) (π / 2)) 
Goal: ContinuousOn Real.tan (Set.Ioo (-(Real.pi / 2)) (Real.pi / 2))
-- Real.surjOn_tan
theorem surjOn_tan : SurjOn tan (Ioo (-(π / 2)) (π / 2)) univ 
Goal: Set.SurjOn Real.tan (Set.Ioo (-(Real.pi / 2)) (Real.pi / 2)) Set.univ
-- Real.tan_surjective
theorem tan_surjective : Function.Surjective tan 
Goal: Function.Surjective Real.tan
-- Real.image_tan_Ioo
theorem image_tan_Ioo : tan '' Ioo (-(π / 2)) (π / 2) = univ 
Goal: Real.tan '' Set.Ioo (-(Real.pi / 2)) (Real.pi / 2) = Set.univ
-- Real.tan_arctan
@[simp]
theorem tan_arctan (x : ℝ) : tan (arctan x) = x 
Arguments: (x : ℝ)
Goal: Real.tan (Real.arctan x) = x
-- Real.arctan_mem_Ioo
theorem arctan_mem_Ioo (x : ℝ) : arctan x ∈ Ioo (-(π / 2)) (π / 2) 
Arguments: (x : ℝ)
Goal: Real.arctan x ∈ Set.Ioo (-(Real.pi / 2)) (Real.pi / 2)
-- Real.range_arctan
@[simp]
theorem range_arctan : range arctan = Ioo (-(π / 2)) (π / 2) 
Goal: Set.range Real.arctan = Set.Ioo (-(Real.pi / 2)) (Real.pi / 2)
-- Real.arctan_tan
theorem arctan_tan {x : ℝ} (hx₁ : -(π / 2) < x) (hx₂ : x < π / 2) : arctan (tan x) = x 
Arguments: {x : ℝ} (hx₁ : -(Real.pi / 2) < x) (hx₂ : x < Real.pi / 2)
Goal: Real.arctan (Real.tan x) = x
-- Real.cos_arctan_pos
theorem cos_arctan_pos (x : ℝ) : 0 < cos (arctan x) 
Arguments: (x : ℝ)
Goal: 0 < Real.cos (Real.arctan x)
-- Real.cos_sq_arctan
theorem cos_sq_arctan (x : ℝ) : cos (arctan x) ^ 2 = 1 / (1 + x ^ 2) 
Arguments: (x : ℝ)
Goal: Real.cos (Real.arctan x) ^ 2 = 1 / (1 + x ^ 2)
-- Real.sin_arctan
theorem sin_arctan (x : ℝ) : sin (arctan x) = x / √(1 + x ^ 2) 
Arguments: (x : ℝ)
Goal: Real.sin (Real.arctan x) = x / √(1 + x ^ 2)
-- Real.cos_arctan
theorem cos_arctan (x : ℝ) : cos (arctan x) = 1 / √(1 + x ^ 2) 
Arguments: (x : ℝ)
Goal: Real.cos (Real.arctan x) = 1 / √(1 + x ^ 2)
-- Real.arctan_lt_pi_div_two
theorem arctan_lt_pi_div_two (x : ℝ) : arctan x < π / 2 
Arguments: (x : ℝ)
Goal: Real.arctan x < Real.pi / 2
-- Real.neg_pi_div_two_lt_arctan
theorem neg_pi_div_two_lt_arctan (x : ℝ) : -(π / 2) < arctan x 
Arguments: (x : ℝ)
Goal: -(Real.pi / 2) < Real.arctan x
-- Real.arctan_eq_arcsin
theorem arctan_eq_arcsin (x : ℝ) : arctan x = arcsin (x / √(1 + x ^ 2)) 
Arguments: (x : ℝ)
Goal: Real.arctan x = Real.arcsin (x / √(1 + x ^ 2))
-- Real.arcsin_eq_arctan
theorem arcsin_eq_arctan {x : ℝ} (h : x ∈ Ioo (-(1 : ℝ)) 1) :
    arcsin x = arctan (x / √(1 - x ^ 2)) 
Arguments: {x : ℝ} (h : x ∈ Set.Ioo (-1) 1)
Goal: Real.arcsin x = Real.arctan (x / √(1 - x ^ 2))
-- Real.arctan_zero
@[simp]
theorem arctan_zero : arctan 0 = 0 
Goal: Real.arctan 0 = 0
-- Real.arctan_strictMono
@[mono]
theorem arctan_strictMono : StrictMono arctan 
Goal: StrictMono Real.arctan
-- Real.arctan_injective
theorem arctan_injective : arctan.Injective 
Goal: Function.Injective Real.arctan
-- Real.arctan_eq_zero_iff
@[simp]
theorem arctan_eq_zero_iff {x : ℝ} : arctan x = 0 ↔ x = 0 
Arguments: {x : ℝ}
Goal: Real.arctan x = 0 ↔ x = 0
-- Real.tendsto_arctan_atTop
theorem tendsto_arctan_atTop : Tendsto arctan atTop (𝓝[<] (π / 2)) 
Goal: Filter.Tendsto Real.arctan Filter.atTop (nhdsWithin (Real.pi / 2) (Set.Iio (Real.pi / 2)))
-- Real.tendsto_arctan_atBot
theorem tendsto_arctan_atBot : Tendsto arctan atBot (𝓝[>] (-(π / 2))) 
Goal: Filter.Tendsto Real.arctan Filter.atBot (nhdsWithin (-(Real.pi / 2)) (Set.Ioi (-(Real.pi / 2))))
-- Real.arctan_eq_of_tan_eq
theorem arctan_eq_of_tan_eq {x y : ℝ} (h : tan x = y) (hx : x ∈ Ioo (-(π / 2)) (π / 2)) :
    arctan y = x 
Arguments: {x y : ℝ} (h : Real.tan x = y) (hx : x ∈ Set.Ioo (-(Real.pi / 2)) (Real.pi / 2))
Goal: Real.arctan y = x
-- Real.arctan_one
@[simp]
theorem arctan_one : arctan 1 = π / 4 
Goal: Real.arctan 1 = Real.pi / 4
-- Real.arctan_neg
@[simp]
theorem arctan_neg (x : ℝ) : arctan (-x) = -arctan x 
Arguments: (x : ℝ)
Goal: Real.arctan (-x) = -Real.arctan x
-- Real.arctan_eq_arccos
theorem arctan_eq_arccos {x : ℝ} (h : 0 ≤ x) : arctan x = arccos (√(1 + x ^ 2))⁻¹ 
Arguments: {x : ℝ} (h : 0 ≤ x)
Goal: Real.arctan x = Real.arccos (√(1 + x ^ 2))⁻¹
-- Real.arccos_eq_arctan
theorem arccos_eq_arctan {x : ℝ} (h : 0 < x) : arccos x = arctan (√(1 - x ^ 2) / x) 
Arguments: {x : ℝ} (h : 0 < x)
Goal: Real.arccos x = Real.arctan (√(1 - x ^ 2) / x)
-- Real.arctan_inv_of_pos
theorem arctan_inv_of_pos {x : ℝ} (h : 0 < x) : arctan x⁻¹ = π / 2 - arctan x 
Arguments: {x : ℝ} (h : 0 < x)
Goal: Real.arctan x⁻¹ = Real.pi / 2 - Real.arctan x
-- Real.arctan_inv_of_neg
theorem arctan_inv_of_neg {x : ℝ} (h : x < 0) : arctan x⁻¹ = -(π / 2) - arctan x 
Arguments: {x : ℝ} (h : x < 0)
Goal: Real.arctan x⁻¹ = -(Real.pi / 2) - Real.arctan x
-- Real.arctan_ne_mul_pi_div_two
lemma arctan_ne_mul_pi_div_two {x : ℝ} : ∀ (k : ℤ), arctan x ≠ (2 * k + 1) * π / 2 
Arguments: {x : ℝ} (k : ℤ)
Goal: Real.arctan x ≠ (2 * ↑k + 1) * Real.pi / 2
-- Real.arctan_add_arctan_lt_pi_div_two
lemma arctan_add_arctan_lt_pi_div_two {x y : ℝ} (h : x * y < 1) : arctan x + arctan y < π / 2 
Arguments: {x y : ℝ} (h : x * y < 1)
Goal: Real.arctan x + Real.arctan y < Real.pi / 2
-- Real.arctan_add
theorem arctan_add {x y : ℝ} (h : x * y < 1) :
    arctan x + arctan y = arctan ((x + y) / (1 - x * y)) 
Arguments: {x y : ℝ} (h : x * y < 1)
Goal: Real.arctan x + Real.arctan y = Real.arctan ((x + y) / (1 - x * y))
-- Real.arctan_add_eq_add_pi
theorem arctan_add_eq_add_pi {x y : ℝ} (h : 1 < x * y) (hx : 0 < x) :
    arctan x + arctan y = arctan ((x + y) / (1 - x * y)) + π 
Arguments: {x y : ℝ} (h : 1 < x * y) (hx : 0 < x)
Goal: Real.arctan x + Real.arctan y = Real.arctan ((x + y) / (1 - x * y)) + Real.pi
-- Real.arctan_add_eq_sub_pi
theorem arctan_add_eq_sub_pi {x y : ℝ} (h : 1 < x * y) (hx : x < 0) :
    arctan x + arctan y = arctan ((x + y) / (1 - x * y)) - π 
Arguments: {x y : ℝ} (h : 1 < x * y) (hx : x < 0)
Goal: Real.arctan x + Real.arctan y = Real.arctan ((x + y) / (1 - x * y)) - Real.pi
-- Real.two_mul_arctan
theorem two_mul_arctan {x : ℝ} (h₁ : -1 < x) (h₂ : x < 1) :
    2 * arctan x = arctan (2 * x / (1 - x ^ 2)) 
Arguments: {x : ℝ} (h₁ : -1 < x) (h₂ : x < 1)
Goal: 2 * Real.arctan x = Real.arctan (2 * x / (1 - x ^ 2))
-- Real.two_mul_arctan_add_pi
theorem two_mul_arctan_add_pi {x : ℝ} (h : 1 < x) :
    2 * arctan x = arctan (2 * x / (1 - x ^ 2)) + π 
Arguments: {x : ℝ} (h : 1 < x)
Goal: 2 * Real.arctan x = Real.arctan (2 * x / (1 - x ^ 2)) + Real.pi
-- Real.two_mul_arctan_sub_pi
theorem two_mul_arctan_sub_pi {x : ℝ} (h : x < -1) :
    2 * arctan x = arctan (2 * x / (1 - x ^ 2)) - π 
Arguments: {x : ℝ} (h : x < -1)
Goal: 2 * Real.arctan x = Real.arctan (2 * x / (1 - x ^ 2)) - Real.pi
-- Real.arctan_inv_2_add_arctan_inv_3
theorem arctan_inv_2_add_arctan_inv_3 : arctan 2⁻¹ + arctan 3⁻¹ = π / 4 
Goal: Real.arctan 2⁻¹ + Real.arctan 3⁻¹ = Real.pi / 4
-- Real.two_mul_arctan_inv_2_sub_arctan_inv_7
theorem two_mul_arctan_inv_2_sub_arctan_inv_7 : 2 * arctan 2⁻¹ - arctan 7⁻¹ = π / 4 
Goal: 2 * Real.arctan 2⁻¹ - Real.arctan 7⁻¹ = Real.pi / 4
-- Real.two_mul_arctan_inv_3_add_arctan_inv_7
theorem two_mul_arctan_inv_3_add_arctan_inv_7 : 2 * arctan 3⁻¹ + arctan 7⁻¹ = π / 4 
Goal: 2 * Real.arctan 3⁻¹ + Real.arctan 7⁻¹ = Real.pi / 4
-- Real.four_mul_arctan_inv_5_sub_arctan_inv_239
theorem four_mul_arctan_inv_5_sub_arctan_inv_239 : 4 * arctan 5⁻¹ - arctan 239⁻¹ = π / 4 
Goal: 4 * Real.arctan 5⁻¹ - Real.arctan 239⁻¹ = Real.pi / 4