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

full_name: Real.hasStrictDerivAt_log_of_pos
code: theorem hasStrictDerivAt_log_of_pos (hx : 0 < x) : HasStrictDerivAt log x⁻¹ x 
goal: HasStrictDerivAt Real.log x⁻¹ x

full_name: Real.hasStrictDerivAt_log
code: theorem hasStrictDerivAt_log (hx : x ≠ 0) : HasStrictDerivAt log x⁻¹ x 
goal: HasStrictDerivAt Real.log x⁻¹ x

full_name: Real.hasDerivAt_log
code: theorem hasDerivAt_log (hx : x ≠ 0) : HasDerivAt log x⁻¹ x 
goal: HasDerivAt Real.log x⁻¹ x

full_name: Real.differentiableAt_log
code: theorem differentiableAt_log (hx : x ≠ 0) : DifferentiableAt ℝ log x 
goal: DifferentiableAt ℝ Real.log x

full_name: Real.differentiableOn_log
code: theorem differentiableOn_log : DifferentiableOn ℝ log {0}ᶜ 
goal: DifferentiableOn ℝ Real.log {0}ᶜ

full_name: Real.differentiableAt_log_iff
code: @[simp]
theorem differentiableAt_log_iff : DifferentiableAt ℝ log x ↔ x ≠ 0 
goal: DifferentiableAt ℝ Real.log x ↔ x ≠ 0

full_name: Real.deriv_log
code: theorem deriv_log (x : ℝ) : deriv log x = x⁻¹ 
goal: deriv Real.log x = x⁻¹

full_name: Real.deriv_log'
code: @[simp]
theorem deriv_log' : deriv log = Inv.inv 
goal: deriv Real.log = Inv.inv

full_name: Real.contDiffOn_log
code: theorem contDiffOn_log {n : ℕ∞} : ContDiffOn ℝ n log {0}ᶜ 
goal: ContDiffOn ℝ n Real.log {0}ᶜ

full_name: Real.contDiffAt_log
code: theorem contDiffAt_log {n : ℕ∞} : ContDiffAt ℝ n log x ↔ x ≠ 0 
goal: ContDiffAt ℝ n Real.log x ↔ x ≠ 0

full_name: HasDerivWithinAt.log
code: theorem HasDerivWithinAt.log (hf : HasDerivWithinAt f f' s x) (hx : f x ≠ 0) :
    HasDerivWithinAt (fun y => log (f y)) (f' / f x) s x 
goal: HasDerivWithinAt (fun y => Real.log (f y)) (f' / f x) s x

full_name: HasDerivAt.log
code: theorem HasDerivAt.log (hf : HasDerivAt f f' x) (hx : f x ≠ 0) :
    HasDerivAt (fun y => log (f y)) (f' / f x) x 
goal: HasDerivAt (fun y => Real.log (f y)) (f' / f x) x

full_name: HasStrictDerivAt.log
code: theorem HasStrictDerivAt.log (hf : HasStrictDerivAt f f' x) (hx : f x ≠ 0) :
    HasStrictDerivAt (fun y => log (f y)) (f' / f x) x 
goal: HasStrictDerivAt (fun y => Real.log (f y)) (f' / f x) x

full_name: derivWithin.log
code: theorem derivWithin.log (hf : DifferentiableWithinAt ℝ f s x) (hx : f x ≠ 0)
    (hxs : UniqueDiffWithinAt ℝ s x) :
    derivWithin (fun x => log (f x)) s x = derivWithin f s x / f x 
goal: derivWithin (fun x => Real.log (f x)) s x = derivWithin f s x / f x

full_name: deriv.log
code: @[simp]
theorem deriv.log (hf : DifferentiableAt ℝ f x) (hx : f x ≠ 0) :
    deriv (fun x => log (f x)) x = deriv f x / f x 
goal: deriv (fun x => Real.log (f x)) x = deriv f x / f x

full_name: Real.deriv_log_comp_eq_logDeriv
code: /-- The derivative of `log ∘ f` is the logarithmic derivative provided `f` is differentiable and
`f x  ≠ 0`. -/
lemma Real.deriv_log_comp_eq_logDeriv {f : ℝ → ℝ} {x : ℝ} (h₁ : DifferentiableAt ℝ f x)
    (h₂ : f x ≠ 0) : deriv (log ∘ f) x = logDeriv f x 
goal: deriv (Real.log ∘ f) x = logDeriv f x

full_name: HasFDerivWithinAt.log
code: theorem HasFDerivWithinAt.log (hf : HasFDerivWithinAt f f' s x) (hx : f x ≠ 0) :
    HasFDerivWithinAt (fun x => log (f x)) ((f x)⁻¹ • f') s x 
goal: HasFDerivWithinAt (fun x => Real.log (f x)) ((f x)⁻¹ • f') s x

full_name: HasFDerivAt.log
code: theorem HasFDerivAt.log (hf : HasFDerivAt f f' x) (hx : f x ≠ 0) :
    HasFDerivAt (fun x => log (f x)) ((f x)⁻¹ • f') x 
goal: HasFDerivAt (fun x => Real.log (f x)) ((f x)⁻¹ • f') x

full_name: HasStrictFDerivAt.log
code: theorem HasStrictFDerivAt.log (hf : HasStrictFDerivAt f f' x) (hx : f x ≠ 0) :
    HasStrictFDerivAt (fun x => log (f x)) ((f x)⁻¹ • f') x 
goal: HasStrictFDerivAt (fun x => Real.log (f x)) ((f x)⁻¹ • f') x

full_name: DifferentiableWithinAt.log
code: theorem DifferentiableWithinAt.log (hf : DifferentiableWithinAt ℝ f s x) (hx : f x ≠ 0) :
    DifferentiableWithinAt ℝ (fun x => log (f x)) s x 
goal: DifferentiableWithinAt ℝ (fun x => Real.log (f x)) s x

full_name: DifferentiableAt.log
code: @[simp]
theorem DifferentiableAt.log (hf : DifferentiableAt ℝ f x) (hx : f x ≠ 0) :
    DifferentiableAt ℝ (fun x => log (f x)) x 
goal: DifferentiableAt ℝ (fun x => Real.log (f x)) x

full_name: ContDiffAt.log
code: theorem ContDiffAt.log {n} (hf : ContDiffAt ℝ n f x) (hx : f x ≠ 0) :
    ContDiffAt ℝ n (fun x => log (f x)) x 
goal: ContDiffAt ℝ n (fun x => Real.log (f x)) x

full_name: ContDiffWithinAt.log
code: theorem ContDiffWithinAt.log {n} (hf : ContDiffWithinAt ℝ n f s x) (hx : f x ≠ 0) :
    ContDiffWithinAt ℝ n (fun x => log (f x)) s x 
goal: ContDiffWithinAt ℝ n (fun x => Real.log (f x)) s x

full_name: ContDiffOn.log
code: theorem ContDiffOn.log {n} (hf : ContDiffOn ℝ n f s) (hs : ∀ x ∈ s, f x ≠ 0) :
    ContDiffOn ℝ n (fun x => log (f x)) s 
goal: ContDiffOn ℝ n (fun x => Real.log (f x)) s

full_name: ContDiff.log
code: theorem ContDiff.log {n} (hf : ContDiff ℝ n f) (h : ∀ x, f x ≠ 0) :
    ContDiff ℝ n fun x => log (f x) 
goal: ContDiff ℝ n fun x => Real.log (f x)

full_name: DifferentiableOn.log
code: theorem DifferentiableOn.log (hf : DifferentiableOn ℝ f s) (hx : ∀ x ∈ s, f x ≠ 0) :
    DifferentiableOn ℝ (fun x => log (f x)) s 
goal: DifferentiableOn ℝ (fun x => Real.log (f x)) s

full_name: Differentiable.log
code: @[simp]
theorem Differentiable.log (hf : Differentiable ℝ f) (hx : ∀ x, f x ≠ 0) :
    Differentiable ℝ fun x => log (f x) 
goal: Differentiable ℝ fun x => Real.log (f x)

full_name: fderivWithin.log
code: theorem fderivWithin.log (hf : DifferentiableWithinAt ℝ f s x) (hx : f x ≠ 0)
    (hxs : UniqueDiffWithinAt ℝ s x) :
    fderivWithin ℝ (fun x => log (f x)) s x = (f x)⁻¹ • fderivWithin ℝ f s x 
goal: fderivWithin ℝ (fun x => Real.log (f x)) s x = (f x)⁻¹ • fderivWithin ℝ f s x

full_name: fderiv.log
code: @[simp]
theorem fderiv.log (hf : DifferentiableAt ℝ f x) (hx : f x ≠ 0) :
    fderiv ℝ (fun x => log (f x)) x = (f x)⁻¹ • fderiv ℝ f x 
goal: fderiv ℝ (fun x => Real.log (f x)) x = (f x)⁻¹ • fderiv ℝ f x

full_name: Real.tendsto_mul_log_one_plus_div_atTop
code: /-- The function `x * log (1 + t / x)` tends to `t` at `+∞`. -/
theorem tendsto_mul_log_one_plus_div_atTop (t : ℝ) :
    Tendsto (fun x => x * log (1 + t / x)) atTop (𝓝 t) 
goal: Filter.Tendsto (fun x => x * Real.log (1 + t / x)) Filter.atTop (𝓝 t)

full_name: Real.abs_log_sub_add_sum_range_le
code: /-- A crude lemma estimating the difference between `log (1-x)` and its Taylor series at `0`,
where the main point of the bound is that it tends to `0`. The goal is to deduce the series
expansion of the logarithm, in `hasSum_pow_div_log_of_abs_lt_1`.

Porting note (#11215): TODO: use one of generic theorems about Taylor's series
to prove this estimate.
-/
theorem abs_log_sub_add_sum_range_le {x : ℝ} (h : |x| < 1) (n : ℕ) :
    |(∑ i ∈ range n, x ^ (i + 1) / (i + 1)) + log (1 - x)| ≤ |x| ^ (n + 1) / (1 - |x|) 
goal: |∑ i ∈ Finset.range n, x ^ (i + 1) / (↑i + 1) + Real.log (1 - x)| ≤ |x| ^ (n + 1) / (1 - |x|)

full_name: Real.hasSum_pow_div_log_of_abs_lt_one
code: /-- Power series expansion of the logarithm around `1`. -/
theorem hasSum_pow_div_log_of_abs_lt_one {x : ℝ} (h : |x| < 1) :
    HasSum (fun n : ℕ => x ^ (n + 1) / (n + 1)) (-log (1 - x)) 
goal: HasSum (fun n => x ^ (n + 1) / (↑n + 1)) (-Real.log (1 - x))

full_name: Real.hasSum_log_sub_log_of_abs_lt_one
code: /-- Power series expansion of `log(1 + x) - log(1 - x)` for `|x| < 1`. -/
theorem hasSum_log_sub_log_of_abs_lt_one {x : ℝ} (h : |x| < 1) :
    HasSum (fun k : ℕ => (2 : ℝ) * (1 / (2 * k + 1)) * x ^ (2 * k + 1))
      (log (1 + x) - log (1 - x)) 
goal: HasSum (fun k => 2 * (1 / (2 * ↑k + 1)) * x ^ (2 * k + 1)) (Real.log (1 + x) - Real.log (1 - x))

full_name: Real.hasSum_log_one_add_inv
code: /-- Expansion of `log (1 + a⁻¹)` as a series in powers of `1 / (2 * a + 1)`. -/
theorem hasSum_log_one_add_inv {a : ℝ} (h : 0 < a) :
    HasSum (fun k : ℕ => (2 : ℝ) * (1 / (2 * k + 1)) * (1 / (2 * a + 1)) ^ (2 * k + 1))
      (log (1 + a⁻¹)) 
goal: HasSum (fun k => 2 * (1 / (2 * ↑k + 1)) * (1 / (2 * a + 1)) ^ (2 * k + 1)) (Real.log (1 + a⁻¹))