Derivatives of General Logarithms

Learning Objectives

By the end of this section you will be able to:

1. Derive the formula $\frac{d}{dx}\!\bigl[\log_a x\bigr] = \dfrac{1}{x\,\ln a}$ from scratch using the change-of-base identity — no memorization required.
2. See visually why a bigger base gives a flatter curve, and why the slope formula has $\ln a$ in the denominator.
3. Apply the chain rule to differentiate $\log_a(u(x))$ for any inner function $u(x)$.
4. Confirm the formula in two ways: a hand-traced Python finite-difference, then PyTorch autograd.
5. Recognize why $\ln x$ is the single base that calculus prefers, and how it connects to information theory and machine learning.

The Question We Are Answering

We already know two important derivatives. The exponential $e^x$ is its own derivative, and the natural logarithm satisfies $\dfrac{d}{dx}\ln x = \dfrac{1}{x}$. Both formulas are beautiful precisely because the base is $e$. But the real world does not always speak in base $e$:

• Engineers reason about decibels and the Richter scale in base 10.
• Computer scientists count bits in base 2 — one binary digit per factor of 2.
• Chemists measure pH as $-\log_{10}[\text{H}^+]$.
• Statisticians compute log-likelihoods in whichever base is convenient for the experiment.

So we want a derivative formula that works for $\log_a x$ — the logarithm to any positive base $a \ne 1$. The intuition we will build is short and physical: changing the base just rescales the y-axis of the natural log, and that vertical rescaling rides through the derivative as a constant factor.

The one-sentence goal: express $\log_a x$ in terms of $\ln x$, then borrow the natural-log derivative we already know.

The Change-of-Base Trick

From any base back to the natural log

The change-of-base identity is the bridge we need. Starting from the definition $y = \log_a x$ meaning $a^y = x$, take the natural log of both sides:

That is the identity we will use everywhere from now on:

Look closely at the right-hand side. The variable $x$ lives only inside $\ln x$. The factor $1/\ln a$ is a constant — it does not depend on $x$ at all. So $\log_a x$ is literally a constant times $\ln x$.

The Formula and Its Picture

Differentiating both sides of $\log_a x = \dfrac{1}{\ln a}\,\ln x$:

That collapses to the clean answer:

Three quick sanity checks confirm this is the right formula:

The four numbers you should always be able to recall

Interactive: Drag the Slope

The picture is the best argument. In the visualization below, the orange dot is the point where you want the slope. The cyan dashed line is the actual tangent. The readouts confirm that the slope you see is exactly $1/(x\,\ln a)$. Play with three things:

• Drag the dot rightward. Watch the tangent flatten out: the slope shrinks like $1/x$.
• Crank up the base with the slider. The whole curve gets squashed and the slope number drops accordingly.
• Turn on "compare bases." The three classical curves all pass through $(1, 0)$ but separate immediately because each one is stretched by its own factor $1/\ln a$.

Worked Example (Do-It-By-Hand)

Open the box and work through this example with a pencil before you peek at the steps. Pick simple numbers so you can see the formula in motion.

The Chain Rule Version

In practice you rarely meet a bare $\log_a x$. You usually meet $\log_a$ of something more complicated — a polynomial, a ratio, a trig function. The chain rule combines with our formula in the cleanest possible way:

The recipe: divide $u'$ by $u$, then divide once more by $\ln a$. That extra denominator $\ln a$ is the only thing that changes when you switch bases.

Three worked applications of the chain rule

Why ln Is the "Natural" Base for Calculus

Looking at the formula $\dfrac{d}{dx}\log_a x = \dfrac{1}{x\,\ln a}$, you can immediately see why the natural logarithm gets the adjective "natural":

Among all bases $a > 0, a \ne 1$, the base $a = e$ is the unique one whose derivative formula does not contain an extra constant. Every other base pays a $1/\ln a$ tax.

This is not a coincidence; it is the definition of $e$. The number $e$ was chosen precisely so that $\ln e = 1$, killing the constant factor. Calculus rewards the choice with the cleanest possible derivative.

In practice this means: if you have a choice, work in $\ln$. Convert to base 2 or base 10 only at the very end, when reporting the answer in "bits" or "decibels." Inside derivatives, gradients, optimizers, and ML training loops, $\ln$ is the right currency.

Plain Python: Verify the Formula Numerically

Mathematics tells us $f'(x) = 1/(x\,\ln a)$. The computer is happy to check that, but it does not know about derivatives directly — it knows about finite differences. So we are going to compute thetrue slope two ways:

1. Analytic: the closed-form formula we just derived, evaluated at our test points.
2. Numeric: a tiny Δx → 0 approximation of the difference quotient. If both numbers agree to many decimal places, the formula is right.

We will do this for three bases at three test points — nine comparisons total — in plain Python with no external libraries.

log_a(8, 2) → 3.0   because 2^3 = 8

h = 1e-6 → error ≈ 10⁻¹², far below the printout precision.

a == math.e is dangerous — use abs(a - math.e) < 1e-9.

1import math
2
3def log_a(x, a):
4    """log base a, expressed via the change-of-base identity."""
5    return math.log(x) / math.log(a)
6
7def analytic_derivative(x, a):
8    """The formula we derived: 1 / (x * ln a)."""
9    return 1.0 / (x * math.log(a))
10
11def numeric_derivative(x, a, h=1e-6):
12    """Central difference: (f(x+h) - f(x-h)) / (2h)."""
13    return (log_a(x + h, a) - log_a(x - h, a)) / (2 * h)
14
15# Three bases x three test points = nine checks.
16bases  = [2, math.e, 10]
17points = [0.5, 4.0, 100.0]
18
19print(f"{'base':>6} {'x':>8} {'analytic':>14} {'numeric':>14} {'|diff|':>10}")
20for a in bases:
21    for x in points:
22        ana = analytic_derivative(x, a)
23        num = numeric_derivative(x, a)
24        diff = abs(ana - num)
25        a_str = "e" if abs(a - math.e) < 1e-9 else str(int(a))
26        print(f"{a_str:>6} {x:>8.2f} {ana:>14.8f} {num:>14.8f} {diff:>10.2e}")

Expected output, copy-pasteable:

  base        x       analytic        numeric     |diff|
     2     0.50     2.88539008     2.88539008   4.84e-11
     2     4.00     0.36067376     0.36067376   6.04e-12
     2   100.00     0.01442695     0.01442695   2.39e-13
     e     0.50     2.00000000     2.00000000   3.33e-11
     e     4.00     0.25000000     0.25000000   4.16e-12
     e   100.00     0.01000000     0.01000000   1.67e-13
    10     0.50     0.86858896     0.86858896   1.45e-11
    10     4.00     0.10857362     0.10857362   1.85e-12
    10   100.00     0.00434294     0.00434294   7.20e-14

PyTorch: Autograd Confirms the Same Number

For machine-learning workflows, we never write the derivative by hand. PyTorch's autograd engine records every operation as we go and applies the chain rule in reverse. If we compute $y = \log_2(x)$ and call $y\text{.backward}()$, PyTorch will fill $x\text{.grad}$ with $1/(x\,\ln 2)$. Let's verify.

y2 ≈ tensor([-1.0000,  2.0000,  6.6439])

Without zero_(), xs.grad would become 2× the correct slopes on the next call.

6 / (8 * 2.302585) = 0.325790760...

1import torch
2import math
3
4# --- Part A: derivative of plain log_a(x) at three bases ------------
5xs = torch.tensor([0.5, 4.0, 100.0], requires_grad=True)
6
7# log_2(x) = ln(x) / ln(2)
8y2 = torch.log(xs) / math.log(2)
9# We need the gradient of the SUM so PyTorch returns a vector of slopes.
10y2.sum().backward()
11print("d/dx log_2 at [0.5, 4, 100]:", xs.grad)
12print("formula 1/(x*ln 2):          ", 1.0 / (xs.detach() * math.log(2)))
13
14# Reset gradients before the next test
15xs.grad.zero_()
16
17# log_10(x) = ln(x) / ln(10)
18y10 = torch.log(xs) / math.log(10)
19y10.sum().backward()
20print("\nd/dx log_10 at [0.5, 4, 100]:", xs.grad)
21print("formula 1/(x*ln 10):           ", 1.0 / (xs.detach() * math.log(10)))
22
23# --- Part B: chain rule on u(x) = 3x^2 + 5, base 10 -----------------
24x = torch.tensor(1.0, requires_grad=True)
25u = 3 * x**2 + 5            # u(1) = 8
26y = torch.log(u) / math.log(10)
27y.backward()
28print("\nd/dx log_10(3x^2 + 5) at x=1:")
29print("  autograd:", x.grad.item())
30print("  formula :", (6 * 1.0) / (8.0 * math.log(10)))

Application: Information Theory and log₂

A satisfying place to land is in the place where $\log_2$ is the unquestioned king: information theory. Encoding one out of $N$ equally likely outcomes costs exactly $\log_2 N$ bits. The derivative we just derived tells you the marginal cost of making N a little larger:

Two things to feel here. First, doubling $N$ always adds exactly one bit — a discrete jump that the derivative averages out into a continuous slope. Second, that slope shrinks like $1/N$, so growing a code from $N = 1\,000$ to $N = 1\,001$ costs almost nothing, but growing from 2 to 3 costs nearly half a bit.

The same idea appears every time machine learning measures "perplexity" $= 2^{\text{cross-entropy}}$: the cross-entropy is a sum of log₂ terms, and the gradient with respect to any predicted probability inherits a $1/(p\,\ln 2)$ factor — the very formula of this section.

Summary

• One identity unlocks everything: $\log_a x = \dfrac{\ln x}{\ln a}$. The right side is just a constant times $\ln x$.
• Plain derivative: $\dfrac{d}{dx}\log_a x = \dfrac{1}{x\,\ln a}$.
• Chain-rule version: $\dfrac{d}{dx}\log_a u(x) = \dfrac{u'(x)}{u(x)\,\ln a}$.
• Geometric meaning: bigger base $a$ ⇒ flatter curve ⇒ smaller slope, because $\ln a$ sits in the denominator.
• Calculus prefers $\ln$: base $e$ is the unique base whose derivative carries no extra constant. Convert to base 2 or base 10 only at the reporting stage.
• Verified twice: finite differences in plain Python and PyTorch autograd both produce the same numbers to $\sim 10^{-11}$.

Exercises

1. Differentiate $f(x) = \log_7(x)$ and evaluate $f'(49)$. Sanity-check against the formula $1/(x\,\ln a)$. (Answer: $1/(49\,\ln 7) \approx 0.01049$.)
2. Differentiate $g(x) = \log_2(x^2 + 1)$ and evaluate at $x = 1$. (Hint: $u = x^2 + 1$, $u' = 2x$. Answer: $2/(2\,\ln 2) = 1/\ln 2 \approx 1.4427$.)
3. Find the x-coordinate where the tangent to $y = \log_{10} x$ has slope $1/10$. (Answer: set $1/(x\,\ln 10) = 1/10$ ⇒ $x = 10/\ln 10 \approx 4.343$.)
4. Show that $\dfrac{d}{dx}\log_a(kx) = \dfrac{d}{dx}\log_a(x)$ for any positive constant $k$. (Hint: use $\log_a(kx) = \log_a k + \log_a x$; the constant differentiates to zero.)
5. Open the interactive slope explorer. Set base $a = e^2$ using the custom slider. Read off the slope at $x = 5$. Does it match the formula prediction $1/(5 \cdot 2) = 0.1$? (It should.)
6. A 256-symbol alphabet (ASCII) costs $\log_2 256 = 8$ bits per symbol. Use the derivative $1/(N \ln 2)$ to estimate the cost per symbol if the alphabet grew to 260 symbols. Compare against the exact answer $\log_2 260 - 8$. (Linear approximation: $\approx 4/(256 \ln 2) \approx 0.0225$ extra bits. Exact: $\approx 0.0224$.)