ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Real.hasDerivAt_mul_log
lemma hasDerivAt_mul_log {x : ℝ} (hx : x ≠ 0) : HasDerivAt (fun x ↦ x * log x) (log x + 1) x 
Arguments: {x : ℝ} (hx : x ≠ 0)
Goal: HasDerivAt (fun x => x * Real.log x) (Real.log x + 1) x
-- Real.deriv2_mul_log
lemma deriv2_mul_log {x : ℝ} (hx : x ≠ 0) : deriv^[2] (fun x ↦ x * log x) x = x⁻¹ 
Arguments: {x : ℝ} (hx : x ≠ 0)
Goal: deriv^[2] (fun x => x * Real.log x) x = x⁻¹
-- Real.strictConvexOn_mul_log
lemma strictConvexOn_mul_log : StrictConvexOn ℝ (Set.Ici (0 : ℝ)) (fun x ↦ x * log x) 
Goal: StrictConvexOn ℝ (Set.Ici 0) fun x => x * Real.log x
-- Real.convexOn_mul_log
lemma convexOn_mul_log : ConvexOn ℝ (Set.Ici (0 : ℝ)) (fun x ↦ x * log x) 
Goal: ConvexOn ℝ (Set.Ici 0) fun x => x * Real.log x
-- Real.mul_log_nonneg
lemma mul_log_nonneg {x : ℝ} (hx : 1 ≤ x) : 0 ≤ x * log x 
Arguments: {x : ℝ} (hx : 1 ≤ x)
Goal: 0 ≤ x * Real.log x
-- Real.mul_log_nonpos
lemma mul_log_nonpos {x : ℝ} (hx₀ : 0 ≤ x) (hx₁ : x ≤ 1) : x * log x ≤ 0 
Arguments: {x : ℝ} (hx₀ : 0 ≤ x) (hx₁ : x ≤ 1)
Goal: x * Real.log x ≤ 0
-- Real.negMulLog_def
lemma negMulLog_def : negMulLog = fun x ↦ - x * log x 
Goal: Real.negMulLog = fun x => -x * Real.log x
-- Real.negMulLog_eq_neg
lemma negMulLog_eq_neg : negMulLog = fun x ↦ - (x * log x) 
Goal: Real.negMulLog = fun x => -(x * Real.log x)
-- Real.negMulLog_zero
@[simp] lemma negMulLog_zero : negMulLog (0 : ℝ) = 0 
Goal: Real.negMulLog 0 = 0
-- Real.negMulLog_one
@[simp] lemma negMulLog_one : negMulLog (1 : ℝ) = 0 
Goal: Real.negMulLog 1 = 0
-- Real.negMulLog_nonneg
lemma negMulLog_nonneg {x : ℝ} (h1 : 0 ≤ x) (h2 : x ≤ 1) : 0 ≤ negMulLog x 
Arguments: {x : ℝ} (h1 : 0 ≤ x) (h2 : x ≤ 1)
Goal: 0 ≤ x.negMulLog
-- Real.negMulLog_mul
lemma negMulLog_mul (x y : ℝ) : negMulLog (x * y) = y * negMulLog x + x * negMulLog y 
Arguments: (x y : ℝ)
Goal: (x * y).negMulLog = y * x.negMulLog + x * y.negMulLog
-- Real.continuous_negMulLog
lemma continuous_negMulLog : Continuous negMulLog 
Goal: Continuous Real.negMulLog
-- Real.differentiableOn_negMulLog
lemma differentiableOn_negMulLog : DifferentiableOn ℝ negMulLog {0}ᶜ 
Goal: DifferentiableOn ℝ Real.negMulLog {0}ᶜ
-- Real.deriv_negMulLog
lemma deriv_negMulLog {x : ℝ} (hx : x ≠ 0) : deriv negMulLog x = - log x - 1 
Arguments: {x : ℝ} (hx : x ≠ 0)
Goal: deriv Real.negMulLog x = -Real.log x - 1
-- Real.hasDerivAt_negMulLog
lemma hasDerivAt_negMulLog {x : ℝ} (hx : x ≠ 0) : HasDerivAt negMulLog (- log x - 1) x 
Arguments: {x : ℝ} (hx : x ≠ 0)
Goal: HasDerivAt Real.negMulLog (-Real.log x - 1) x
-- Real.deriv2_negMulLog
lemma deriv2_negMulLog {x : ℝ} (hx : x ≠ 0) : deriv^[2] negMulLog x = - x⁻¹ 
Arguments: {x : ℝ} (hx : x ≠ 0)
Goal: deriv^[2] Real.negMulLog x = -x⁻¹
-- Real.strictConcaveOn_negMulLog
lemma strictConcaveOn_negMulLog : StrictConcaveOn ℝ (Set.Ici (0 : ℝ)) negMulLog 
Goal: StrictConcaveOn ℝ (Set.Ici 0) Real.negMulLog
-- Real.concaveOn_negMulLog
lemma concaveOn_negMulLog : ConcaveOn ℝ (Set.Ici (0 : ℝ)) negMulLog 
Goal: ConcaveOn ℝ (Set.Ici 0) Real.negMulLog
-- Complex.IsExpCmpFilter.tendsto_re
structure IsExpCmpFilter (l : Filter ℂ) : Prop where
  tendsto_re : Tendsto re l atTop
  isBigO_im_pow_re : ∀ n : ℕ, (fun z : ℂ => z.im ^ n) =O[l] fun z => Real.exp z.re
Arguments: {l : Filter ℂ} (self : Complex.IsExpCmpFilter l)
Goal: Filter.Tendsto Complex.re l Filter.atTop
-- Complex.IsExpCmpFilter.isBigO_im_pow_re
structure IsExpCmpFilter (l : Filter ℂ) : Prop where
  tendsto_re : Tendsto re l atTop
  isBigO_im_pow_re : ∀ n : ℕ, (fun z : ℂ => z.im ^ n) =O[l] fun z => Real.exp z.re
Arguments: {l : Filter ℂ} (self : Complex.IsExpCmpFilter l) (n : ℕ)
Goal: (fun z => z.im ^ n) =O[l] fun z => Real.exp z.re
-- Complex.IsExpCmpFilter.of_isBigO_im_re_rpow
theorem of_isBigO_im_re_rpow (hre : Tendsto re l atTop) (r : ℝ) (hr : im =O[l] fun z => z.re ^ r) :
    IsExpCmpFilter l 
Arguments: {l : Filter ℂ} (hre : Filter.Tendsto Complex.re l Filter.atTop) (r : ℝ) (hr : Complex.im =O[l] fun z => z.re ^ r)
Goal: Complex.IsExpCmpFilter l
-- Complex.IsExpCmpFilter.of_isBigO_im_re_pow
theorem of_isBigO_im_re_pow (hre : Tendsto re l atTop) (n : ℕ) (hr : im =O[l] fun z => z.re ^ n) :
    IsExpCmpFilter l 
Arguments: {l : Filter ℂ} (hre : Filter.Tendsto Complex.re l Filter.atTop) (n : ℕ) (hr : Complex.im =O[l] fun z => z.re ^ n)
Goal: Complex.IsExpCmpFilter l
-- Complex.IsExpCmpFilter.of_boundedUnder_abs_im
theorem of_boundedUnder_abs_im (hre : Tendsto re l atTop)
    (him : IsBoundedUnder (· ≤ ·) l fun z => |z.im|) : IsExpCmpFilter l 
Arguments: {l : Filter ℂ} (hre : Filter.Tendsto Complex.re l Filter.atTop) (him : Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun z => |z.im|)
Goal: Complex.IsExpCmpFilter l
-- Complex.IsExpCmpFilter.of_boundedUnder_im
theorem of_boundedUnder_im (hre : Tendsto re l atTop) (him_le : IsBoundedUnder (· ≤ ·) l im)
    (him_ge : IsBoundedUnder (· ≥ ·) l im) : IsExpCmpFilter l 
Arguments: {l : Filter ℂ} (hre : Filter.Tendsto Complex.re l Filter.atTop) (him_le : Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l Complex.im) (him_ge : Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l Complex.im)
Goal: Complex.IsExpCmpFilter l
-- Complex.IsExpCmpFilter.eventually_ne
theorem eventually_ne (hl : IsExpCmpFilter l) : ∀ᶠ w : ℂ in l, w ≠ 0 
Arguments: {l : Filter ℂ} (hl : Complex.IsExpCmpFilter l)
Goal: ∀ᶠ (w : ℂ) in l, w ≠ 0
-- Complex.IsExpCmpFilter.tendsto_abs_re
theorem tendsto_abs_re (hl : IsExpCmpFilter l) : Tendsto (fun z : ℂ => |z.re|) l atTop 
Arguments: {l : Filter ℂ} (hl : Complex.IsExpCmpFilter l)
Goal: Filter.Tendsto (fun z => |z.re|) l Filter.atTop
-- Complex.IsExpCmpFilter.tendsto_abs
theorem tendsto_abs (hl : IsExpCmpFilter l) : Tendsto abs l atTop 
Arguments: {l : Filter ℂ} (hl : Complex.IsExpCmpFilter l)
Goal: Filter.Tendsto (⇑Complex.abs) l Filter.atTop
-- Complex.IsExpCmpFilter.isLittleO_log_re_re
theorem isLittleO_log_re_re (hl : IsExpCmpFilter l) : (fun z => Real.log z.re) =o[l] re 
Arguments: {l : Filter ℂ} (hl : Complex.IsExpCmpFilter l)
Goal: (fun z => Real.log z.re) =o[l] Complex.re
-- Complex.IsExpCmpFilter.isLittleO_im_pow_exp_re
theorem isLittleO_im_pow_exp_re (hl : IsExpCmpFilter l) (n : ℕ) :
    (fun z : ℂ => z.im ^ n) =o[l] fun z => Real.exp z.re 
Arguments: {l : Filter ℂ} (hl : Complex.IsExpCmpFilter l) (n : ℕ)
Goal: (fun z => z.im ^ n) =o[l] fun z => Real.exp z.re
-- Complex.IsExpCmpFilter.abs_im_pow_eventuallyLE_exp_re
theorem abs_im_pow_eventuallyLE_exp_re (hl : IsExpCmpFilter l) (n : ℕ) :
    (fun z : ℂ => |z.im| ^ n) ≤ᶠ[l] fun z => Real.exp z.re 
Arguments: {l : Filter ℂ} (hl : Complex.IsExpCmpFilter l) (n : ℕ)
Goal: (fun z => |z.im| ^ n) ≤ᶠ[l] fun z => Real.exp z.re
-- Complex.IsExpCmpFilter.isLittleO_log_abs_re
theorem isLittleO_log_abs_re (hl : IsExpCmpFilter l) : (fun z => Real.log (abs z)) =o[l] re 
Arguments: {l : Filter ℂ} (hl : Complex.IsExpCmpFilter l)
Goal: (fun z => Real.log (Complex.abs z)) =o[l] Complex.re
-- Complex.IsExpCmpFilter.isTheta_cpow_exp_re_mul_log
lemma isTheta_cpow_exp_re_mul_log (hl : IsExpCmpFilter l) (a : ℂ) :
    (· ^ a) =Θ[l] fun z ↦ Real.exp (re a * Real.log (abs z)) 
Arguments: {l : Filter ℂ} (hl : Complex.IsExpCmpFilter l) (a : ℂ)
Goal: (fun x => x ^ a) =Θ[l] fun z => Real.exp (a.re * Real.log (Complex.abs z))
-- Complex.IsExpCmpFilter.isLittleO_cpow_exp
theorem isLittleO_cpow_exp (hl : IsExpCmpFilter l) (a : ℂ) {b : ℝ} (hb : 0 < b) :
    (fun z => z ^ a) =o[l] fun z => exp (b * z) 
Arguments: {l : Filter ℂ} (hl : Complex.IsExpCmpFilter l) (a : ℂ) {b : ℝ} (hb : 0 < b)
Goal: (fun z => z ^ a) =o[l] fun z => Complex.exp (↑b * z)
-- Complex.IsExpCmpFilter.isLittleO_cpow_mul_exp
theorem isLittleO_cpow_mul_exp {b₁ b₂ : ℝ} (hl : IsExpCmpFilter l) (hb : b₁ < b₂) (a₁ a₂ : ℂ) :
    (fun z => z ^ a₁ * exp (b₁ * z)) =o[l] fun z => z ^ a₂ * exp (b₂ * z) 
Arguments: {l : Filter ℂ} {b₁ b₂ : ℝ} (hl : Complex.IsExpCmpFilter l) (hb : b₁ < b₂) (a₁ a₂ : ℂ)
Goal: (fun z => z ^ a₁ * Complex.exp (↑b₁ * z)) =o[l] fun z => z ^ a₂ * Complex.exp (↑b₂ * z)
-- Complex.IsExpCmpFilter.isLittleO_exp_cpow
theorem isLittleO_exp_cpow (hl : IsExpCmpFilter l) (a : ℂ) {b : ℝ} (hb : b < 0) :
    (fun z => exp (b * z)) =o[l] fun z => z ^ a 
Arguments: {l : Filter ℂ} (hl : Complex.IsExpCmpFilter l) (a : ℂ) {b : ℝ} (hb : b < 0)
Goal: (fun z => Complex.exp (↑b * z)) =o[l] fun z => z ^ a
-- Complex.IsExpCmpFilter.isLittleO_pow_mul_exp
theorem isLittleO_pow_mul_exp {b₁ b₂ : ℝ} (hl : IsExpCmpFilter l) (hb : b₁ < b₂) (m n : ℕ) :
    (fun z => z ^ m * exp (b₁ * z)) =o[l] fun z => z ^ n * exp (b₂ * z) 
Arguments: {l : Filter ℂ} {b₁ b₂ : ℝ} (hl : Complex.IsExpCmpFilter l) (hb : b₁ < b₂) (m n : ℕ)
Goal: (fun z => z ^ m * Complex.exp (↑b₁ * z)) =o[l] fun z => z ^ n * Complex.exp (↑b₂ * z)
-- Complex.IsExpCmpFilter.isLittleO_zpow_mul_exp
theorem isLittleO_zpow_mul_exp {b₁ b₂ : ℝ} (hl : IsExpCmpFilter l) (hb : b₁ < b₂) (m n : ℤ) :
    (fun z => z ^ m * exp (b₁ * z)) =o[l] fun z => z ^ n * exp (b₂ * z) 
Arguments: {l : Filter ℂ} {b₁ b₂ : ℝ} (hl : Complex.IsExpCmpFilter l) (hb : b₁ < b₂) (m n : ℤ)
Goal: (fun z => z ^ m * Complex.exp (↑b₁ * z)) =o[l] fun z => z ^ n * Complex.exp (↑b₂ * z)
-- Real.log_div_log
theorem log_div_log : log x / log b = logb b x 
Arguments: {b x : ℝ}
Goal: Real.log x / Real.log b = Real.logb b x
-- Real.logb_zero
@[simp]
theorem logb_zero : logb b 0 = 0 
Arguments: {b : ℝ}
Goal: Real.logb b 0 = 0
-- Real.logb_one
@[simp]
theorem logb_one : logb b 1 = 0 
Arguments: {b : ℝ}
Goal: Real.logb b 1 = 0
-- Real.logb_self_eq_one
@[simp]
lemma logb_self_eq_one (hb : 1 < b) : logb b b = 1 
Arguments: {b : ℝ} (hb : 1 < b)
Goal: Real.logb b b = 1
-- Real.logb_self_eq_one_iff
lemma logb_self_eq_one_iff : logb b b = 1 ↔ b ≠ 0 ∧ b ≠ 1 ∧ b ≠ -1 
Arguments: {b : ℝ}
Goal: Real.logb b b = 1 ↔ b ≠ 0 ∧ b ≠ 1 ∧ b ≠ -1
-- Real.logb_abs
@[simp]
theorem logb_abs (x : ℝ) : logb b |x| = logb b x 
Arguments: {b : ℝ} (x : ℝ)
Goal: Real.logb b |x| = Real.logb b x
-- Real.logb_neg_eq_logb
@[simp]
theorem logb_neg_eq_logb (x : ℝ) : logb b (-x) = logb b x 
Arguments: {b : ℝ} (x : ℝ)
Goal: Real.logb b (-x) = Real.logb b x
-- Real.logb_mul
theorem logb_mul (hx : x ≠ 0) (hy : y ≠ 0) : logb b (x * y) = logb b x + logb b y 
Arguments: {b x y : ℝ} (hx : x ≠ 0) (hy : y ≠ 0)
Goal: Real.logb b (x * y) = Real.logb b x + Real.logb b y
-- Real.logb_div
theorem logb_div (hx : x ≠ 0) (hy : y ≠ 0) : logb b (x / y) = logb b x - logb b y 
Arguments: {b x y : ℝ} (hx : x ≠ 0) (hy : y ≠ 0)
Goal: Real.logb b (x / y) = Real.logb b x - Real.logb b y
-- Real.logb_inv
@[simp]
theorem logb_inv (x : ℝ) : logb b x⁻¹ = -logb b x 
Arguments: {b : ℝ} (x : ℝ)
Goal: Real.logb b x⁻¹ = -Real.logb b x
-- Real.inv_logb
theorem inv_logb (a b : ℝ) : (logb a b)⁻¹ = logb b a 
Arguments: (a b : ℝ)
Goal: (Real.logb a b)⁻¹ = Real.logb b a
-- Real.inv_logb_mul_base
theorem inv_logb_mul_base {a b : ℝ} (h₁ : a ≠ 0) (h₂ : b ≠ 0) (c : ℝ) :
    (logb (a * b) c)⁻¹ = (logb a c)⁻¹ + (logb b c)⁻¹ 
Arguments: {a b : ℝ} (h₁ : a ≠ 0) (h₂ : b ≠ 0) (c : ℝ)
Goal: (Real.logb (a * b) c)⁻¹ = (Real.logb a c)⁻¹ + (Real.logb b c)⁻¹
-- Real.inv_logb_div_base
theorem inv_logb_div_base {a b : ℝ} (h₁ : a ≠ 0) (h₂ : b ≠ 0) (c : ℝ) :
    (logb (a / b) c)⁻¹ = (logb a c)⁻¹ - (logb b c)⁻¹ 
Arguments: {a b : ℝ} (h₁ : a ≠ 0) (h₂ : b ≠ 0) (c : ℝ)
Goal: (Real.logb (a / b) c)⁻¹ = (Real.logb a c)⁻¹ - (Real.logb b c)⁻¹
-- Real.logb_mul_base
theorem logb_mul_base {a b : ℝ} (h₁ : a ≠ 0) (h₂ : b ≠ 0) (c : ℝ) :
    logb (a * b) c = ((logb a c)⁻¹ + (logb b c)⁻¹)⁻¹ 
Arguments: {a b : ℝ} (h₁ : a ≠ 0) (h₂ : b ≠ 0) (c : ℝ)
Goal: Real.logb (a * b) c = ((Real.logb a c)⁻¹ + (Real.logb b c)⁻¹)⁻¹
-- Real.logb_div_base
theorem logb_div_base {a b : ℝ} (h₁ : a ≠ 0) (h₂ : b ≠ 0) (c : ℝ) :
    logb (a / b) c = ((logb a c)⁻¹ - (logb b c)⁻¹)⁻¹ 
Arguments: {a b : ℝ} (h₁ : a ≠ 0) (h₂ : b ≠ 0) (c : ℝ)
Goal: Real.logb (a / b) c = ((Real.logb a c)⁻¹ - (Real.logb b c)⁻¹)⁻¹
-- Real.mul_logb
theorem mul_logb {a b c : ℝ} (h₁ : b ≠ 0) (h₂ : b ≠ 1) (h₃ : b ≠ -1) :
    logb a b * logb b c = logb a c 
Arguments: {a b c : ℝ} (h₁ : b ≠ 0) (h₂ : b ≠ 1) (h₃ : b ≠ -1)
Goal: Real.logb a b * Real.logb b c = Real.logb a c
-- Real.div_logb
theorem div_logb {a b c : ℝ} (h₁ : c ≠ 0) (h₂ : c ≠ 1) (h₃ : c ≠ -1) :
    logb a c / logb b c = logb a b 
Arguments: {a b c : ℝ} (h₁ : c ≠ 0) (h₂ : c ≠ 1) (h₃ : c ≠ -1)
Goal: Real.logb a c / Real.logb b c = Real.logb a b
-- Real.logb_rpow_eq_mul_logb_of_pos
theorem logb_rpow_eq_mul_logb_of_pos (hx : 0 < x) : logb b (x ^ y) = y * logb b x 
Arguments: {b x y : ℝ} (hx : 0 < x)
Goal: Real.logb b (x ^ y) = y * Real.logb b x
-- Real.logb_pow
theorem logb_pow {k : ℕ} (hx : 0 < x) : logb b (x ^ k) = k * logb b x 
Arguments: {b x : ℝ} {k : ℕ} (hx : 0 < x)
Goal: Real.logb b (x ^ k) = ↑k * Real.logb b x
-- _private.Mathlib.Analysis.SpecialFunctions.Log.Base.0.Real.log_b_ne_zero
private theorem log_b_ne_zero : log b ≠ 0 
Arguments: {b : ℝ} (b_pos : 0 < b) (b_ne_one : b ≠ 1)
Goal: Real.log b ≠ 0
-- Real.logb_rpow
@[simp]
theorem logb_rpow : logb b (b ^ x) = x 
Arguments: {b x : ℝ} (b_pos : 0 < b) (b_ne_one : b ≠ 1)
Goal: Real.logb b (b ^ x) = x
-- Real.rpow_logb_eq_abs
theorem rpow_logb_eq_abs (hx : x ≠ 0) : b ^ logb b x = |x| 
Arguments: {b x : ℝ} (b_pos : 0 < b) (b_ne_one : b ≠ 1) (hx : x ≠ 0)
Goal: b ^ Real.logb b x = |x|
-- Real.rpow_logb
@[simp]
theorem rpow_logb (hx : 0 < x) : b ^ logb b x = x 
Arguments: {b x : ℝ} (b_pos : 0 < b) (b_ne_one : b ≠ 1) (hx : 0 < x)
Goal: b ^ Real.logb b x = x
-- Real.rpow_logb_of_neg
theorem rpow_logb_of_neg (hx : x < 0) : b ^ logb b x = -x 
Arguments: {b x : ℝ} (b_pos : 0 < b) (b_ne_one : b ≠ 1) (hx : x < 0)
Goal: b ^ Real.logb b x = -x
-- Real.logb_eq_iff_rpow_eq
theorem logb_eq_iff_rpow_eq (hy : 0 < y) : logb b y = x ↔ b ^ x = y 
Arguments: {b x y : ℝ} (b_pos : 0 < b) (b_ne_one : b ≠ 1) (hy : 0 < y)
Goal: Real.logb b y = x ↔ b ^ x = y
-- Real.surjOn_logb
theorem surjOn_logb : SurjOn (logb b) (Ioi 0) univ 
Arguments: {b : ℝ} (b_pos : 0 < b) (b_ne_one : b ≠ 1)
Goal: Set.SurjOn (Real.logb b) (Set.Ioi 0) Set.univ
-- Real.logb_surjective
theorem logb_surjective : Surjective (logb b) 
Arguments: {b : ℝ} (b_pos : 0 < b) (b_ne_one : b ≠ 1)
Goal: Function.Surjective (Real.logb b)
-- Real.range_logb
@[simp]
theorem range_logb : range (logb b) = univ 
Arguments: {b : ℝ} (b_pos : 0 < b) (b_ne_one : b ≠ 1)
Goal: Set.range (Real.logb b) = Set.univ
-- Real.surjOn_logb'
theorem surjOn_logb' : SurjOn (logb b) (Iio 0) univ 
Arguments: {b : ℝ} (b_pos : 0 < b) (b_ne_one : b ≠ 1)
Goal: Set.SurjOn (Real.logb b) (Set.Iio 0) Set.univ
-- _private.Mathlib.Analysis.SpecialFunctions.Log.Base.0.Real.b_pos
private theorem b_pos : 0 < b 
Arguments: {b : ℝ} (hb : 1 < b)
Goal: 0 < b
-- _private.Mathlib.Analysis.SpecialFunctions.Log.Base.0.Real.b_ne_one'
private theorem b_ne_one' : b ≠ 1 
Arguments: {b : ℝ} (hb : 1 < b)
Goal: b ≠ 1
-- Real.logb_le_logb
@[simp]
theorem logb_le_logb (h : 0 < x) (h₁ : 0 < y) : logb b x ≤ logb b y ↔ x ≤ y 
Arguments: {b x y : ℝ} (hb : 1 < b) (h : 0 < x) (h₁ : 0 < y)
Goal: Real.logb b x ≤ Real.logb b y ↔ x ≤ y
-- Real.logb_le_logb_of_le
@[gcongr]
theorem logb_le_logb_of_le (h : 0 < x) (hxy : x ≤ y) : logb b x ≤ logb b y 
Arguments: {b x y : ℝ} (hb : 1 < b) (h : 0 < x) (hxy : x ≤ y)
Goal: Real.logb b x ≤ Real.logb b y
-- Real.logb_lt_logb
@[gcongr]
theorem logb_lt_logb (hx : 0 < x) (hxy : x < y) : logb b x < logb b y 
Arguments: {b x y : ℝ} (hb : 1 < b) (hx : 0 < x) (hxy : x < y)
Goal: Real.logb b x < Real.logb b y
-- Real.logb_lt_logb_iff
@[simp]
theorem logb_lt_logb_iff (hx : 0 < x) (hy : 0 < y) : logb b x < logb b y ↔ x < y 
Arguments: {b x y : ℝ} (hb : 1 < b) (hx : 0 < x) (hy : 0 < y)
Goal: Real.logb b x < Real.logb b y ↔ x < y
-- Real.logb_le_iff_le_rpow
theorem logb_le_iff_le_rpow (hx : 0 < x) : logb b x ≤ y ↔ x ≤ b ^ y 
Arguments: {b x y : ℝ} (hb : 1 < b) (hx : 0 < x)
Goal: Real.logb b x ≤ y ↔ x ≤ b ^ y
-- Real.logb_lt_iff_lt_rpow
theorem logb_lt_iff_lt_rpow (hx : 0 < x) : logb b x < y ↔ x < b ^ y 
Arguments: {b x y : ℝ} (hb : 1 < b) (hx : 0 < x)
Goal: Real.logb b x < y ↔ x < b ^ y
-- Real.le_logb_iff_rpow_le
theorem le_logb_iff_rpow_le (hy : 0 < y) : x ≤ logb b y ↔ b ^ x ≤ y 
Arguments: {b x y : ℝ} (hb : 1 < b) (hy : 0 < y)
Goal: x ≤ Real.logb b y ↔ b ^ x ≤ y
-- Real.lt_logb_iff_rpow_lt
theorem lt_logb_iff_rpow_lt (hy : 0 < y) : x < logb b y ↔ b ^ x < y 
Arguments: {b x y : ℝ} (hb : 1 < b) (hy : 0 < y)
Goal: x < Real.logb b y ↔ b ^ x < y
-- Real.logb_pos_iff
theorem logb_pos_iff (hx : 0 < x) : 0 < logb b x ↔ 1 < x 
Arguments: {b x : ℝ} (hb : 1 < b) (hx : 0 < x)
Goal: 0 < Real.logb b x ↔ 1 < x
-- Real.logb_pos
theorem logb_pos (hx : 1 < x) : 0 < logb b x 
Arguments: {b x : ℝ} (hb : 1 < b) (hx : 1 < x)
Goal: 0 < Real.logb b x
-- Real.logb_neg_iff
theorem logb_neg_iff (h : 0 < x) : logb b x < 0 ↔ x < 1 
Arguments: {b x : ℝ} (hb : 1 < b) (h : 0 < x)
Goal: Real.logb b x < 0 ↔ x < 1
-- Real.logb_neg
theorem logb_neg (h0 : 0 < x) (h1 : x < 1) : logb b x < 0 
Arguments: {b x : ℝ} (hb : 1 < b) (h0 : 0 < x) (h1 : x < 1)
Goal: Real.logb b x < 0
-- Real.logb_nonneg_iff
theorem logb_nonneg_iff (hx : 0 < x) : 0 ≤ logb b x ↔ 1 ≤ x 
Arguments: {b x : ℝ} (hb : 1 < b) (hx : 0 < x)
Goal: 0 ≤ Real.logb b x ↔ 1 ≤ x
-- Real.logb_nonneg
theorem logb_nonneg (hx : 1 ≤ x) : 0 ≤ logb b x 
Arguments: {b x : ℝ} (hb : 1 < b) (hx : 1 ≤ x)
Goal: 0 ≤ Real.logb b x
-- Real.logb_nonpos_iff
theorem logb_nonpos_iff (hx : 0 < x) : logb b x ≤ 0 ↔ x ≤ 1 
Arguments: {b x : ℝ} (hb : 1 < b) (hx : 0 < x)
Goal: Real.logb b x ≤ 0 ↔ x ≤ 1
-- Real.logb_nonpos_iff'
theorem logb_nonpos_iff' (hx : 0 ≤ x) : logb b x ≤ 0 ↔ x ≤ 1 
Arguments: {b x : ℝ} (hb : 1 < b) (hx : 0 ≤ x)
Goal: Real.logb b x ≤ 0 ↔ x ≤ 1
-- Real.logb_nonpos
theorem logb_nonpos (hx : 0 ≤ x) (h'x : x ≤ 1) : logb b x ≤ 0 
Arguments: {b x : ℝ} (hb : 1 < b) (hx : 0 ≤ x) (h'x : x ≤ 1)
Goal: Real.logb b x ≤ 0
-- Real.strictMonoOn_logb
theorem strictMonoOn_logb : StrictMonoOn (logb b) (Set.Ioi 0) 
Arguments: {b : ℝ} (hb : 1 < b)
Goal: StrictMonoOn (Real.logb b) (Set.Ioi 0)
-- Real.strictAntiOn_logb
theorem strictAntiOn_logb : StrictAntiOn (logb b) (Set.Iio 0) 
Arguments: {b : ℝ} (hb : 1 < b)
Goal: StrictAntiOn (Real.logb b) (Set.Iio 0)
-- Real.logb_injOn_pos
theorem logb_injOn_pos : Set.InjOn (logb b) (Set.Ioi 0) 
Arguments: {b : ℝ} (hb : 1 < b)
Goal: Set.InjOn (Real.logb b) (Set.Ioi 0)
-- Real.eq_one_of_pos_of_logb_eq_zero
theorem eq_one_of_pos_of_logb_eq_zero (h₁ : 0 < x) (h₂ : logb b x = 0) : x = 1 
Arguments: {b x : ℝ} (hb : 1 < b) (h₁ : 0 < x) (h₂ : Real.logb b x = 0)
Goal: x = 1
-- Real.logb_ne_zero_of_pos_of_ne_one
theorem logb_ne_zero_of_pos_of_ne_one (hx_pos : 0 < x) (hx : x ≠ 1) : logb b x ≠ 0 
Arguments: {b x : ℝ} (hb : 1 < b) (hx_pos : 0 < x) (hx : x ≠ 1)
Goal: Real.logb b x ≠ 0
-- Real.tendsto_logb_atTop
theorem tendsto_logb_atTop : Tendsto (logb b) atTop atTop 
Arguments: {b : ℝ} (hb : 1 < b)
Goal: Filter.Tendsto (Real.logb b) Filter.atTop Filter.atTop
-- _private.Mathlib.Analysis.SpecialFunctions.Log.Base.0.Real.b_ne_one
private theorem b_ne_one : b ≠ 1 
Arguments: {b : ℝ} (b_lt_one : b < 1)
Goal: b ≠ 1
-- Real.logb_le_logb_of_base_lt_one
@[simp]
theorem logb_le_logb_of_base_lt_one (h : 0 < x) (h₁ : 0 < y) : logb b x ≤ logb b y ↔ y ≤ x 
Arguments: {b x y : ℝ} (b_pos : 0 < b) (b_lt_one : b < 1) (h : 0 < x) (h₁ : 0 < y)
Goal: Real.logb b x ≤ Real.logb b y ↔ y ≤ x
-- Real.logb_lt_logb_of_base_lt_one
theorem logb_lt_logb_of_base_lt_one (hx : 0 < x) (hxy : x < y) : logb b y < logb b x 
Arguments: {b x y : ℝ} (b_pos : 0 < b) (b_lt_one : b < 1) (hx : 0 < x) (hxy : x < y)
Goal: Real.logb b y < Real.logb b x
-- Real.logb_lt_logb_iff_of_base_lt_one
@[simp]
theorem logb_lt_logb_iff_of_base_lt_one (hx : 0 < x) (hy : 0 < y) :
    logb b x < logb b y ↔ y < x 
Arguments: {b x y : ℝ} (b_pos : 0 < b) (b_lt_one : b < 1) (hx : 0 < x) (hy : 0 < y)
Goal: Real.logb b x < Real.logb b y ↔ y < x
-- Real.logb_le_iff_le_rpow_of_base_lt_one
theorem logb_le_iff_le_rpow_of_base_lt_one (hx : 0 < x) : logb b x ≤ y ↔ b ^ y ≤ x 
Arguments: {b x y : ℝ} (b_pos : 0 < b) (b_lt_one : b < 1) (hx : 0 < x)
Goal: Real.logb b x ≤ y ↔ b ^ y ≤ x
-- Real.logb_lt_iff_lt_rpow_of_base_lt_one
theorem logb_lt_iff_lt_rpow_of_base_lt_one (hx : 0 < x) : logb b x < y ↔ b ^ y < x 
Arguments: {b x y : ℝ} (b_pos : 0 < b) (b_lt_one : b < 1) (hx : 0 < x)
Goal: Real.logb b x < y ↔ b ^ y < x
-- Real.le_logb_iff_rpow_le_of_base_lt_one
theorem le_logb_iff_rpow_le_of_base_lt_one (hy : 0 < y) : x ≤ logb b y ↔ y ≤ b ^ x 
Arguments: {b x y : ℝ} (b_pos : 0 < b) (b_lt_one : b < 1) (hy : 0 < y)
Goal: x ≤ Real.logb b y ↔ y ≤ b ^ x
-- Real.lt_logb_iff_rpow_lt_of_base_lt_one
theorem lt_logb_iff_rpow_lt_of_base_lt_one (hy : 0 < y) : x < logb b y ↔ y < b ^ x 
Arguments: {b x y : ℝ} (b_pos : 0 < b) (b_lt_one : b < 1) (hy : 0 < y)
Goal: x < Real.logb b y ↔ y < b ^ x
-- Real.logb_pos_iff_of_base_lt_one
theorem logb_pos_iff_of_base_lt_one (hx : 0 < x) : 0 < logb b x ↔ x < 1 
Arguments: {b x : ℝ} (b_pos : 0 < b) (b_lt_one : b < 1) (hx : 0 < x)
Goal: 0 < Real.logb b x ↔ x < 1
-- Real.logb_pos_of_base_lt_one
theorem logb_pos_of_base_lt_one (hx : 0 < x) (hx' : x < 1) : 0 < logb b x 
Arguments: {b x : ℝ} (b_pos : 0 < b) (b_lt_one : b < 1) (hx : 0 < x) (hx' : x < 1)
Goal: 0 < Real.logb b x
-- Real.logb_neg_iff_of_base_lt_one
theorem logb_neg_iff_of_base_lt_one (h : 0 < x) : logb b x < 0 ↔ 1 < x 
Arguments: {b x : ℝ} (b_pos : 0 < b) (b_lt_one : b < 1) (h : 0 < x)
Goal: Real.logb b x < 0 ↔ 1 < x
-- Real.logb_neg_of_base_lt_one
theorem logb_neg_of_base_lt_one (h1 : 1 < x) : logb b x < 0 
Arguments: {b x : ℝ} (b_pos : 0 < b) (b_lt_one : b < 1) (h1 : 1 < x)
Goal: Real.logb b x < 0
-- Real.logb_nonneg_iff_of_base_lt_one
theorem logb_nonneg_iff_of_base_lt_one (hx : 0 < x) : 0 ≤ logb b x ↔ x ≤ 1 
Arguments: {b x : ℝ} (b_pos : 0 < b) (b_lt_one : b < 1) (hx : 0 < x)
Goal: 0 ≤ Real.logb b x ↔ x ≤ 1
-- Real.logb_nonneg_of_base_lt_one
theorem logb_nonneg_of_base_lt_one (hx : 0 < x) (hx' : x ≤ 1) : 0 ≤ logb b x 
Arguments: {b x : ℝ} (b_pos : 0 < b) (b_lt_one : b < 1) (hx : 0 < x) (hx' : x ≤ 1)
Goal: 0 ≤ Real.logb b x
-- Real.logb_nonpos_iff_of_base_lt_one
theorem logb_nonpos_iff_of_base_lt_one (hx : 0 < x) : logb b x ≤ 0 ↔ 1 ≤ x 
Arguments: {b x : ℝ} (b_pos : 0 < b) (b_lt_one : b < 1) (hx : 0 < x)
Goal: Real.logb b x ≤ 0 ↔ 1 ≤ x
-- Real.strictAntiOn_logb_of_base_lt_one
theorem strictAntiOn_logb_of_base_lt_one : StrictAntiOn (logb b) (Set.Ioi 0) 
Arguments: {b : ℝ} (b_pos : 0 < b) (b_lt_one : b < 1)
Goal: StrictAntiOn (Real.logb b) (Set.Ioi 0)
-- Real.strictMonoOn_logb_of_base_lt_one
theorem strictMonoOn_logb_of_base_lt_one : StrictMonoOn (logb b) (Set.Iio 0) 
Arguments: {b : ℝ} (b_pos : 0 < b) (b_lt_one : b < 1)
Goal: StrictMonoOn (Real.logb b) (Set.Iio 0)
-- Real.logb_injOn_pos_of_base_lt_one
theorem logb_injOn_pos_of_base_lt_one : Set.InjOn (logb b) (Set.Ioi 0) 
Arguments: {b : ℝ} (b_pos : 0 < b) (b_lt_one : b < 1)
Goal: Set.InjOn (Real.logb b) (Set.Ioi 0)
-- Real.eq_one_of_pos_of_logb_eq_zero_of_base_lt_one
theorem eq_one_of_pos_of_logb_eq_zero_of_base_lt_one (h₁ : 0 < x) (h₂ : logb b x = 0) : x = 1 
Arguments: {b x : ℝ} (b_pos : 0 < b) (b_lt_one : b < 1) (h₁ : 0 < x) (h₂ : Real.logb b x = 0)
Goal: x = 1
-- Real.logb_ne_zero_of_pos_of_ne_one_of_base_lt_one
theorem logb_ne_zero_of_pos_of_ne_one_of_base_lt_one (hx_pos : 0 < x) (hx : x ≠ 1) : logb b x ≠ 0 
Arguments: {b x : ℝ} (b_pos : 0 < b) (b_lt_one : b < 1) (hx_pos : 0 < x) (hx : x ≠ 1)
Goal: Real.logb b x ≠ 0
-- Real.tendsto_logb_atTop_of_base_lt_one
theorem tendsto_logb_atTop_of_base_lt_one : Tendsto (logb b) atTop atBot 
Arguments: {b : ℝ} (b_pos : 0 < b) (b_lt_one : b < 1)
Goal: Filter.Tendsto (Real.logb b) Filter.atTop Filter.atBot
-- Real.floor_logb_natCast
theorem floor_logb_natCast {b : ℕ} {r : ℝ} (hb : 1 < b) (hr : 0 ≤ r) :
    ⌊logb b r⌋ = Int.log b r 
Arguments: {b : ℕ} {r : ℝ} (hb : 1 < b) (hr : 0 ≤ r)
Goal: ⌊Real.logb (↑b) r⌋ = Int.log b r
-- Real.ceil_logb_natCast
theorem ceil_logb_natCast {b : ℕ} {r : ℝ} (hb : 1 < b) (hr : 0 ≤ r) :
    ⌈logb b r⌉ = Int.clog b r 
Arguments: {b : ℕ} {r : ℝ} (hb : 1 < b) (hr : 0 ≤ r)
Goal: ⌈Real.logb (↑b) r⌉ = Int.clog b r
-- Real.logb_eq_zero
@[simp]
theorem logb_eq_zero : logb b x = 0 ↔ b = 0 ∨ b = 1 ∨ b = -1 ∨ x = 0 ∨ x = 1 ∨ x = -1 
Arguments: {b x : ℝ}
Goal: Real.logb b x = 0 ↔ b = 0 ∨ b = 1 ∨ b = -1 ∨ x = 0 ∨ x = 1 ∨ x = -1
-- Real.logb_prod
theorem logb_prod {α : Type*} (s : Finset α) (f : α → ℝ) (hf : ∀ x ∈ s, f x ≠ 0) :
    logb b (∏ i ∈ s, f i) = ∑ i ∈ s, logb b (f i) 
Arguments: {b : ℝ} {α : Type u_1} (s : Finset α) (f : α → ℝ) (hf : ∀ x ∈ s, f x ≠ 0)
Goal: Real.logb b (∏ i ∈ s, f i) = ∑ i ∈ s, Real.logb b (f i)