File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

full_name: Real.logb
code: /-- The real logarithm in a given base. As with the natural logarithm, we define `logb b x` to
be `logb b |x|` for `x < 0`, and `0` for `x = 0`. -/
@[pp_nodot]
noncomputable def logb (b x : ℝ) : ℝ 
goal: ℝ

full_name: Real.log_div_log
code: theorem log_div_log : log x / log b = logb b x 
goal: Real.log x / Real.log b = Real.logb b x

full_name: Real.logb_zero
code: @[simp]
theorem logb_zero : logb b 0 = 0 
goal: Real.logb b 0 = 0

full_name: Real.logb_one
code: @[simp]
theorem logb_one : logb b 1 = 0 
goal: Real.logb b 1 = 0

full_name: Real.logb_self_eq_one
code: @[simp]
lemma logb_self_eq_one (hb : 1 < b) : logb b b = 1 
goal: Real.logb b b = 1

full_name: Real.logb_self_eq_one_iff
code: lemma logb_self_eq_one_iff : logb b b = 1 ↔ b ≠ 0 ∧ b ≠ 1 ∧ b ≠ -1 
goal: Real.logb b b = 1 ↔ b ≠ 0 ∧ b ≠ 1 ∧ b ≠ -1

full_name: Real.logb_abs
code: @[simp]
theorem logb_abs (x : ℝ) : logb b |x| = logb b x 
goal: Real.logb b |x| = Real.logb b x

full_name: Real.logb_neg_eq_logb
code: @[simp]
theorem logb_neg_eq_logb (x : ℝ) : logb b (-x) = logb b x 
goal: Real.logb b (-x) = Real.logb b x

full_name: Real.logb_mul
code: theorem logb_mul (hx : x ≠ 0) (hy : y ≠ 0) : logb b (x * y) = logb b x + logb b y 
goal: Real.logb b (x * y) = Real.logb b x + Real.logb b y

full_name: Real.logb_div
code: theorem logb_div (hx : x ≠ 0) (hy : y ≠ 0) : logb b (x / y) = logb b x - logb b y 
goal: Real.logb b (x / y) = Real.logb b x - Real.logb b y

full_name: Real.logb_inv
code: @[simp]
theorem logb_inv (x : ℝ) : logb b x⁻¹ = -logb b x 
goal: Real.logb b x⁻¹ = -Real.logb b x

full_name: Real.inv_logb
code: theorem inv_logb (a b : ℝ) : (logb a b)⁻¹ = logb b a 
goal: (Real.logb a b)⁻¹ = Real.logb b a

full_name: Real.inv_logb_mul_base
code: theorem inv_logb_mul_base {a b : ℝ} (h₁ : a ≠ 0) (h₂ : b ≠ 0) (c : ℝ) :
    (logb (a * b) c)⁻¹ = (logb a c)⁻¹ + (logb b c)⁻¹ 
goal: (Real.logb (a * b) c)⁻¹ = (Real.logb a c)⁻¹ + (Real.logb b c)⁻¹

full_name: Real.inv_logb_div_base
code: theorem inv_logb_div_base {a b : ℝ} (h₁ : a ≠ 0) (h₂ : b ≠ 0) (c : ℝ) :
    (logb (a / b) c)⁻¹ = (logb a c)⁻¹ - (logb b c)⁻¹ 
goal: (Real.logb (a / b) c)⁻¹ = (Real.logb a c)⁻¹ - (Real.logb b c)⁻¹

full_name: Real.logb_mul_base
code: theorem logb_mul_base {a b : ℝ} (h₁ : a ≠ 0) (h₂ : b ≠ 0) (c : ℝ) :
    logb (a * b) c = ((logb a c)⁻¹ + (logb b c)⁻¹)⁻¹ 
goal: Real.logb (a * b) c = ((Real.logb a c)⁻¹ + (Real.logb b c)⁻¹)⁻¹

full_name: Real.logb_div_base
code: theorem logb_div_base {a b : ℝ} (h₁ : a ≠ 0) (h₂ : b ≠ 0) (c : ℝ) :
    logb (a / b) c = ((logb a c)⁻¹ - (logb b c)⁻¹)⁻¹ 
goal: Real.logb (a / b) c = ((Real.logb a c)⁻¹ - (Real.logb b c)⁻¹)⁻¹

full_name: Real.mul_logb
code: theorem mul_logb {a b c : ℝ} (h₁ : b ≠ 0) (h₂ : b ≠ 1) (h₃ : b ≠ -1) :
    logb a b * logb b c = logb a c 
goal: Real.logb a b * Real.logb b c = Real.logb a c

full_name: Real.div_logb
code: theorem div_logb {a b c : ℝ} (h₁ : c ≠ 0) (h₂ : c ≠ 1) (h₃ : c ≠ -1) :
    logb a c / logb b c = logb a b 
goal: Real.logb a c / Real.logb b c = Real.logb a b

full_name: Real.logb_rpow_eq_mul_logb_of_pos
code: theorem logb_rpow_eq_mul_logb_of_pos (hx : 0 < x) : logb b (x ^ y) = y * logb b x 
goal: Real.logb b (x ^ y) = y * Real.logb b x

full_name: Real.logb_pow
code: theorem logb_pow {k : ℕ} (hx : 0 < x) : logb b (x ^ k) = k * logb b x 
goal: Real.logb b (x ^ k) = ↑k * Real.logb b x

full_name: _private.Mathlib.Analysis.SpecialFunctions.Log.Base.0.Real.log_b_ne_zero
code: private theorem log_b_ne_zero : log b ≠ 0 
goal: Real.log b ≠ 0

full_name: Real.logb_rpow
code: @[simp]
theorem logb_rpow : logb b (b ^ x) = x 
goal: Real.logb b (b ^ x) = x

full_name: Real.rpow_logb_eq_abs
code: theorem rpow_logb_eq_abs (hx : x ≠ 0) : b ^ logb b x = |x| 
goal: b ^ Real.logb b x = |x|

full_name: Real.rpow_logb
code: @[simp]
theorem rpow_logb (hx : 0 < x) : b ^ logb b x = x 
goal: b ^ Real.logb b x = x

full_name: Real.rpow_logb_of_neg
code: theorem rpow_logb_of_neg (hx : x < 0) : b ^ logb b x = -x 
goal: b ^ Real.logb b x = -x

full_name: Real.logb_eq_iff_rpow_eq
code: theorem logb_eq_iff_rpow_eq (hy : 0 < y) : logb b y = x ↔ b ^ x = y 
goal: Real.logb b y = x ↔ b ^ x = y

full_name: Real.surjOn_logb
code: theorem surjOn_logb : SurjOn (logb b) (Ioi 0) univ 
goal: Set.SurjOn (Real.logb b) (Set.Ioi 0) Set.univ

full_name: Real.logb_surjective
code: theorem logb_surjective : Surjective (logb b) 
goal: Function.Surjective (Real.logb b)

full_name: Real.range_logb
code: @[simp]
theorem range_logb : range (logb b) = univ 
goal: Set.range (Real.logb b) = Set.univ

full_name: Real.surjOn_logb'
code: theorem surjOn_logb' : SurjOn (logb b) (Iio 0) univ 
goal: Set.SurjOn (Real.logb b) (Set.Iio 0) Set.univ

full_name: _private.Mathlib.Analysis.SpecialFunctions.Log.Base.0.Real.b_pos
code: private theorem b_pos : 0 < b 
goal: 0 < b

full_name: _private.Mathlib.Analysis.SpecialFunctions.Log.Base.0.Real.b_ne_one'
code: private theorem b_ne_one' : b ≠ 1 
goal: b ≠ 1

full_name: Real.logb_le_logb
code: @[simp]
theorem logb_le_logb (h : 0 < x) (h₁ : 0 < y) : logb b x ≤ logb b y ↔ x ≤ y 
goal: Real.logb b x ≤ Real.logb b y ↔ x ≤ y

full_name: Real.logb_le_logb_of_le
code: @[gcongr]
theorem logb_le_logb_of_le (h : 0 < x) (hxy : x ≤ y) : logb b x ≤ logb b y 
goal: Real.logb b x ≤ Real.logb b y

full_name: Real.logb_lt_logb
code: @[gcongr]
theorem logb_lt_logb (hx : 0 < x) (hxy : x < y) : logb b x < logb b y 
goal: Real.logb b x < Real.logb b y

full_name: Real.logb_lt_logb_iff
code: @[simp]
theorem logb_lt_logb_iff (hx : 0 < x) (hy : 0 < y) : logb b x < logb b y ↔ x < y 
goal: Real.logb b x < Real.logb b y ↔ x < y

full_name: Real.logb_le_iff_le_rpow
code: theorem logb_le_iff_le_rpow (hx : 0 < x) : logb b x ≤ y ↔ x ≤ b ^ y 
goal: Real.logb b x ≤ y ↔ x ≤ b ^ y

full_name: Real.logb_lt_iff_lt_rpow
code: theorem logb_lt_iff_lt_rpow (hx : 0 < x) : logb b x < y ↔ x < b ^ y 
goal: Real.logb b x < y ↔ x < b ^ y

full_name: Real.le_logb_iff_rpow_le
code: theorem le_logb_iff_rpow_le (hy : 0 < y) : x ≤ logb b y ↔ b ^ x ≤ y 
goal: x ≤ Real.logb b y ↔ b ^ x ≤ y

full_name: Real.lt_logb_iff_rpow_lt
code: theorem lt_logb_iff_rpow_lt (hy : 0 < y) : x < logb b y ↔ b ^ x < y 
goal: x < Real.logb b y ↔ b ^ x < y

full_name: Real.logb_pos_iff
code: theorem logb_pos_iff (hx : 0 < x) : 0 < logb b x ↔ 1 < x 
goal: 0 < Real.logb b x ↔ 1 < x

full_name: Real.logb_pos
code: theorem logb_pos (hx : 1 < x) : 0 < logb b x 
goal: 0 < Real.logb b x

full_name: Real.logb_neg_iff
code: theorem logb_neg_iff (h : 0 < x) : logb b x < 0 ↔ x < 1 
goal: Real.logb b x < 0 ↔ x < 1

full_name: Real.logb_neg
code: theorem logb_neg (h0 : 0 < x) (h1 : x < 1) : logb b x < 0 
goal: Real.logb b x < 0

full_name: Real.logb_nonneg_iff
code: theorem logb_nonneg_iff (hx : 0 < x) : 0 ≤ logb b x ↔ 1 ≤ x 
goal: 0 ≤ Real.logb b x ↔ 1 ≤ x

full_name: Real.logb_nonneg
code: theorem logb_nonneg (hx : 1 ≤ x) : 0 ≤ logb b x 
goal: 0 ≤ Real.logb b x

full_name: Real.logb_nonpos_iff
code: theorem logb_nonpos_iff (hx : 0 < x) : logb b x ≤ 0 ↔ x ≤ 1 
goal: Real.logb b x ≤ 0 ↔ x ≤ 1

full_name: Real.logb_nonpos_iff'
code: theorem logb_nonpos_iff' (hx : 0 ≤ x) : logb b x ≤ 0 ↔ x ≤ 1 
goal: Real.logb b x ≤ 0 ↔ x ≤ 1

full_name: Real.logb_nonpos
code: theorem logb_nonpos (hx : 0 ≤ x) (h'x : x ≤ 1) : logb b x ≤ 0 
goal: Real.logb b x ≤ 0

full_name: Real.strictMonoOn_logb
code: theorem strictMonoOn_logb : StrictMonoOn (logb b) (Set.Ioi 0) 
goal: StrictMonoOn (Real.logb b) (Set.Ioi 0)

full_name: Real.strictAntiOn_logb
code: theorem strictAntiOn_logb : StrictAntiOn (logb b) (Set.Iio 0) 
goal: StrictAntiOn (Real.logb b) (Set.Iio 0)

full_name: Real.logb_injOn_pos
code: theorem logb_injOn_pos : Set.InjOn (logb b) (Set.Ioi 0) 
goal: Set.InjOn (Real.logb b) (Set.Ioi 0)

full_name: Real.eq_one_of_pos_of_logb_eq_zero
code: theorem eq_one_of_pos_of_logb_eq_zero (h₁ : 0 < x) (h₂ : logb b x = 0) : x = 1 
goal: x = 1

full_name: Real.logb_ne_zero_of_pos_of_ne_one
code: theorem logb_ne_zero_of_pos_of_ne_one (hx_pos : 0 < x) (hx : x ≠ 1) : logb b x ≠ 0 
goal: Real.logb b x ≠ 0

full_name: Real.tendsto_logb_atTop
code: theorem tendsto_logb_atTop : Tendsto (logb b) atTop atTop 
goal: Filter.Tendsto (Real.logb b) Filter.atTop Filter.atTop

full_name: _private.Mathlib.Analysis.SpecialFunctions.Log.Base.0.Real.b_ne_one
code: private theorem b_ne_one : b ≠ 1 
goal: b ≠ 1

full_name: Real.logb_le_logb_of_base_lt_one
code: @[simp]
theorem logb_le_logb_of_base_lt_one (h : 0 < x) (h₁ : 0 < y) : logb b x ≤ logb b y ↔ y ≤ x 
goal: Real.logb b x ≤ Real.logb b y ↔ y ≤ x

full_name: Real.logb_lt_logb_of_base_lt_one
code: theorem logb_lt_logb_of_base_lt_one (hx : 0 < x) (hxy : x < y) : logb b y < logb b x 
goal: Real.logb b y < Real.logb b x

full_name: Real.logb_lt_logb_iff_of_base_lt_one
code: @[simp]
theorem logb_lt_logb_iff_of_base_lt_one (hx : 0 < x) (hy : 0 < y) :
    logb b x < logb b y ↔ y < x 
goal: Real.logb b x < Real.logb b y ↔ y < x

full_name: Real.logb_le_iff_le_rpow_of_base_lt_one
code: theorem logb_le_iff_le_rpow_of_base_lt_one (hx : 0 < x) : logb b x ≤ y ↔ b ^ y ≤ x 
goal: Real.logb b x ≤ y ↔ b ^ y ≤ x

full_name: Real.logb_lt_iff_lt_rpow_of_base_lt_one
code: theorem logb_lt_iff_lt_rpow_of_base_lt_one (hx : 0 < x) : logb b x < y ↔ b ^ y < x 
goal: Real.logb b x < y ↔ b ^ y < x

full_name: Real.le_logb_iff_rpow_le_of_base_lt_one
code: theorem le_logb_iff_rpow_le_of_base_lt_one (hy : 0 < y) : x ≤ logb b y ↔ y ≤ b ^ x 
goal: x ≤ Real.logb b y ↔ y ≤ b ^ x

full_name: Real.lt_logb_iff_rpow_lt_of_base_lt_one
code: theorem lt_logb_iff_rpow_lt_of_base_lt_one (hy : 0 < y) : x < logb b y ↔ y < b ^ x 
goal: x < Real.logb b y ↔ y < b ^ x

full_name: Real.logb_pos_iff_of_base_lt_one
code: theorem logb_pos_iff_of_base_lt_one (hx : 0 < x) : 0 < logb b x ↔ x < 1 
goal: 0 < Real.logb b x ↔ x < 1

full_name: Real.logb_pos_of_base_lt_one
code: theorem logb_pos_of_base_lt_one (hx : 0 < x) (hx' : x < 1) : 0 < logb b x 
goal: 0 < Real.logb b x

full_name: Real.logb_neg_iff_of_base_lt_one
code: theorem logb_neg_iff_of_base_lt_one (h : 0 < x) : logb b x < 0 ↔ 1 < x 
goal: Real.logb b x < 0 ↔ 1 < x

full_name: Real.logb_neg_of_base_lt_one
code: theorem logb_neg_of_base_lt_one (h1 : 1 < x) : logb b x < 0 
goal: Real.logb b x < 0

full_name: Real.logb_nonneg_iff_of_base_lt_one
code: theorem logb_nonneg_iff_of_base_lt_one (hx : 0 < x) : 0 ≤ logb b x ↔ x ≤ 1 
goal: 0 ≤ Real.logb b x ↔ x ≤ 1

full_name: Real.logb_nonneg_of_base_lt_one
code: theorem logb_nonneg_of_base_lt_one (hx : 0 < x) (hx' : x ≤ 1) : 0 ≤ logb b x 
goal: 0 ≤ Real.logb b x

full_name: Real.logb_nonpos_iff_of_base_lt_one
code: theorem logb_nonpos_iff_of_base_lt_one (hx : 0 < x) : logb b x ≤ 0 ↔ 1 ≤ x 
goal: Real.logb b x ≤ 0 ↔ 1 ≤ x

full_name: Real.strictAntiOn_logb_of_base_lt_one
code: theorem strictAntiOn_logb_of_base_lt_one : StrictAntiOn (logb b) (Set.Ioi 0) 
goal: StrictAntiOn (Real.logb b) (Set.Ioi 0)

full_name: Real.strictMonoOn_logb_of_base_lt_one
code: theorem strictMonoOn_logb_of_base_lt_one : StrictMonoOn (logb b) (Set.Iio 0) 
goal: StrictMonoOn (Real.logb b) (Set.Iio 0)

full_name: Real.logb_injOn_pos_of_base_lt_one
code: theorem logb_injOn_pos_of_base_lt_one : Set.InjOn (logb b) (Set.Ioi 0) 
goal: Set.InjOn (Real.logb b) (Set.Ioi 0)

full_name: Real.eq_one_of_pos_of_logb_eq_zero_of_base_lt_one
code: theorem eq_one_of_pos_of_logb_eq_zero_of_base_lt_one (h₁ : 0 < x) (h₂ : logb b x = 0) : x = 1 
goal: x = 1

full_name: Real.logb_ne_zero_of_pos_of_ne_one_of_base_lt_one
code: theorem logb_ne_zero_of_pos_of_ne_one_of_base_lt_one (hx_pos : 0 < x) (hx : x ≠ 1) : logb b x ≠ 0 
goal: Real.logb b x ≠ 0

full_name: Real.tendsto_logb_atTop_of_base_lt_one
code: theorem tendsto_logb_atTop_of_base_lt_one : Tendsto (logb b) atTop atBot 
goal: Filter.Tendsto (Real.logb b) Filter.atTop Filter.atBot

full_name: Real.floor_logb_natCast
code: theorem floor_logb_natCast {b : ℕ} {r : ℝ} (hb : 1 < b) (hr : 0 ≤ r) :
    ⌊logb b r⌋ = Int.log b r 
goal: ⌊Real.logb (↑b) r⌋ = Int.log b r

full_name: Real.ceil_logb_natCast
code: theorem ceil_logb_natCast {b : ℕ} {r : ℝ} (hb : 1 < b) (hr : 0 ≤ r) :
    ⌈logb b r⌉ = Int.clog b r 
goal: ⌈Real.logb (↑b) r⌉ = Int.clog b r

full_name: Real.logb_eq_zero
code: @[simp]
theorem logb_eq_zero : logb b x = 0 ↔ b = 0 ∨ b = 1 ∨ b = -1 ∨ x = 0 ∨ x = 1 ∨ x = -1 
goal: Real.logb b x = 0 ↔ b = 0 ∨ b = 1 ∨ b = -1 ∨ x = 0 ∨ x = 1 ∨ x = -1

full_name: Real.logb_prod
code: 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) 
goal: Real.logb b (∏ i ∈ s, f i) = ∑ i ∈ s, Real.logb b (f i)

full_name: Real.induction_Ico_mul
code: /-- Induction principle for intervals of real numbers: if a proposition `P` is true
on `[x₀, r * x₀)` and if `P` for `[x₀, r^n * x₀)` implies `P` for `[r^n * x₀, r^(n+1) * x₀)`,
then `P` is true for all `x ≥ x₀`. -/
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 
goal: x ≥ x₀ → P x