Derivative of ln(x)

Learning Objectives

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

1. State and use the identity $\dfrac{d}{dx}\left[\ln x\right] = \dfrac{1}{x}$ for every $x > 0$.
2. Explain why the slope of the log curve is the reciprocal of the input, both geometrically (area under $1/x$) and algebraically (inverse of $e^x$).
3. Combine the rule with the chain rule to differentiate $\ln(u(x))$ for any positive function $u$.
4. Avoid the classic mistakes — sign errors with $\ln|x|$, undefined values at $x \le 0$, and treating $\ln$ as a linear function.
5. Verify the formula numerically with finite differences and symbolically with PyTorch's autograd.

The Question Behind the Section

We already know how steep the curve $y = e^{x}$ is at every point. Question: how steep is its mirror image — the curve $y = \ln x$ — at every point?

Section 5.1 gave us our first transcendental derivative: $\dfrac{d}{dx}\bigl[e^{x}\bigr] = e^{x}$. The exponential is the unique function whose slope equals its own value. That is a deep statement, but it leaves a sibling question hanging.

Pull the graph of $e^{x}$ in front of you and rotate it across the line $y = x$. The mirror image is the natural logarithm, $\ln x$. Wherever the exponential was steep, the log is shallow. Where the exponential was shallow (near $x = 0$), the log is steep (near $x = 1$). Slopes get exchanged with their reciprocals — that is what happens when you flip a curve across $y = x$.

So we already suspect the answer. The rest of the section makes it precise, explains why from two independent angles (an area picture and an algebra proof), gives you a 3Blue1Brown-style playground to feel it, walks a worked example by hand, and finally checks the formula in Python and PyTorch.

Geometric Definition: ln Is an Area

Many textbooks define $\ln x$ as “the inverse of $e^{x}$”. That is fine for computation but it hides what the log really is. There is a more honest definition — a definition that makes the derivative formula obvious:

In plain English: the natural logarithm of a positive number $a$ is the area trapped between the curve $y = 1/t$ and the $t$-axis, from$\;t = 1\;$up to $\;t = a$. If $a > 1$, we are accumulating area going to the right and the result is positive. If $0 < a < 1$, we are travelling backwards along the axis, so the area picks up a minus sign — and $\ln a$ comes out negative, exactly as you remember.

The picture in three sentences

• Draw the hyperbola $y = 1/t$ on the positive $t$-axis.
• Anchor the left edge at $t = 1$; this is where the area starts counting (and where $\ln 1 = 0$).
• Slide the right edge to $t = a$. The shaded region between 1 and $a$ is exactly $\ln a$.

Interactive: Slide a, Watch ln(a) Grow

The interactive below makes the definition tangible. Drag the slider for $a$ and watch the shaded area change in real time. The number underneath the picture is the value of $\ln a$ computed by the area definition — it agrees with your calculator to the last decimal place.

Three things to try, in order:

1. Slide $a$ right until the “Snap a = e” button rounds you to $a = 2.718\ldots$. The shaded area should read $1.00000$. That is the area-based definition of $e$: the number whose log is one.
2. Slide $a$ below $1$. The shaded region turns red, because area travelled right-to-left counts negative, and the printed value of $\ln a$ turns negative.
3. Turn on the orange differential strip and look at the three numbers under the picture. The strip's area (shown in amber) is almost identical to $(1/a)\cdot h$ (in magenta). That tiny mismatch shrinks to zero as $h$ shrinks — and that is literally the derivative.

From Area to Derivative: The Rate of Growth

We now turn the picture into a one-line proof. Start with the definition:

The right-hand side is a function defined by an integral with a moving upper limit. The Fundamental Theorem of Calculus, Part 1 (from $\S 14$ of this book), says exactly how its derivative behaves:

FTC Part 1. If $F(x) = \int_{a}^{\,x} f(t)\,dt$ for a continuous integrand $f$, then $F'(x) = f(x)$.

Apply that with $f(t) = 1/t$ and $a = 1$:

That is the whole proof. One line, because the definition was the right one.

The same argument in plain words

Let the shaded area equal $L(x) = \ln x$. Now nudge the right edge from $x$ to $x + h$. The added strip is so thin that its top is essentially a horizontal segment of height $1/x$. So the strip's area is approximately:

Divide both sides by $h$ and send $h \to 0$. The left-hand side becomes the derivative; the right-hand side becomes $1/x$. Done.

Two Rigorous Proofs (Inverse Function & Limit)

The FTC proof above is the cleanest, but it assumes you accept the area definition. If instead you take $\ln$ to be defined as the inverse of $e^{x}$, you can still recover $d/dx[\ln x] = 1/x$ by two short arguments. Both are worth knowing.

Proof 1 — Inverse-function rule (the algebra route)

Let $y = \ln x$. Then by the definition of inverse, $x = e^{y}$. Differentiate both sides of $x = e^{y}$ with respect to $x$ and use the chain rule on the right-hand side:

Solve for $dy/dx$:

The last equality used $e^{y} = x$. That is the full proof. Notice how every step is a single rule of algebra — no limits, no areas.

Proof 2 — Straight from the limit definition

For readers who want the bare-metal version, compute the derivative directly from $f'(x) = \lim_{h \to 0}\dfrac{f(x+h)-f(x)}{h}$:

Use $(x+h)/x = 1 + h/x$, set $u = h/x$ (so $h = ux$ and $u \to 0$ as $h \to 0$):

The remaining limit is a famous one (proved in §4): $\displaystyle \lim_{u\to 0}\frac{\ln(1+u)}{u} = 1$. Plug it in:

Interactive: Tangent Slope vs. 1/x

Time to see the formula. The left panel shows the curve $y = \ln x$ with two superimposed lines:

• A dashed orange secant connecting $(x, \ln x)$ and $(x+h, \ln(x+h))$.
• A solid green tangent at $(x, \ln x)$, drawn with slope $1/x$.

The right panel plots $y' = 1/x$. A green dot marks the current slope and you can see it ride along the magenta hyperbola as you drag $x$. Hit “Animate h → 0” and watch the orange secant collapse onto the green tangent — the difference quotient becoming the derivative.

Worked Example by Hand

Below is a single example chosen because it exercises the identity at three different levels: numerical (a difference quotient at $x = 2$), the Taylor approximation that explains the residual, and a chain-rule composition. Pop the details open and try it before reading the solution — five minutes with paper will pay back the rest of the chapter.

Combining With the Chain Rule

Most logs you meet in practice are not bare $\ln x$. They wrap something more complicated: $\ln(x^{2}+1)$, $\ln(\sin x + 2)$, $\ln(\sqrt{x})$. All of these reduce to one pattern.

The way to read this: differentiate the inside, divide by the inside. Three worked instances:

Common Mistakes and Edge Cases

Pitfall 1 — Forgetting the domain

$\ln x$ is undefined for $x \le 0$, so its derivative is undefined there too. Writing $d/dx[\ln x] = 1/x$ at, say, $x = -2$ is meaningless — the formula gives $-1/2$ but the function does not exist at $-2$.

Pitfall 2 — ln|x| vs. ln(x)

For $x \neq 0$ the absolute-value version $\ln|x|$ is defined everywhere except zero, and a small calculation shows:

Same formula, broader domain. The proof: for $x > 0$ we already have it. For $x < 0$, write $\ln|x| = \ln(-x)$ and apply the chain rule: $(1/(-x))\cdot (-1) = 1/x$. That is why the formula on the antiderivative side reads $\int \tfrac{1}{x}\,dx = \ln|x| + C$ — the absolute value is the right object once you let $x$ be either sign.

Pitfall 3 — Treating ln as if it were linear

It is very common to see students write $\ln(a + b) = \ln a + \ln b$. This is false. The genuine rules are:

Pitfall 4 — Confusing log bases

In a math context $\ln$ always means natural log (base $e$). In some engineering or programming contexts $\log$ alone is used to mean base 10. If you write $d/dx[\log x] = 1/x$ when the textbook meant base 10, you will be off by a factor of $\ln 10 \approx 2.3026$. The next section (§5.4) handles the general-base case carefully.

Plain Python: Numerical Verification

Now we leave paper and go to a screen. The first script does the thing you would do with a calculator if you wanted to convince a skeptic: it computes a numerical derivative of $\ln x$ at several points and prints it next to the analytic value $1/x$. They should agree to 10 decimal places.

derivative_of_ln(-1) → ValueError('ln(x) is only defined for x > 0'). No NaN, no silent zero — a loud failure is the right behaviour.

1import math
2
3def derivative_of_ln(x: float, h: float = 1e-5) -> float:
4    """
5    Numerically estimate d/dx[ln(x)] at the point x using the symmetric
6    difference quotient:
7
8        f'(x) ~ ( f(x + h) - f(x - h) ) / (2 * h)
9
10    For f(x) = ln(x) the analytic answer is 1/x, so we use this routine
11    only as an independent witness that confirms the formula.
12    """
13    if x <= 0:
14        raise ValueError("ln(x) is only defined for x > 0")
15    return (math.log(x + h) - math.log(x - h)) / (2.0 * h)
16
17
18def main() -> None:
19    sample_points = [0.5, 1.0, 2.0, math.e, 5.0, 10.0]
20
21    print(f"{'x':>10}  {'numerical':>14}  {'1 / x':>14}  {'abs error':>12}")
22    print('-' * 56)
23    for x in sample_points:
24        numeric = derivative_of_ln(x)
25        analytic = 1.0 / x
26        error = abs(numeric - analytic)
27        print(f"{x:>10.4f}  {numeric:>14.10f}  {analytic:>14.10f}  {error:>12.2e}")
28
29
30if __name__ == "__main__":
31    main()

When you run this you should see a table that looks like this (truncated):

         x       numerical            1 / x     abs error
--------------------------------------------------------
    0.5000    2.0000000000   2.0000000000     1.11e-11
    1.0000    1.0000000001   1.0000000000     6.67e-12
    2.0000    0.5000000000   0.5000000000     2.78e-12
    2.7183    0.3678794412   0.3678794412     1.11e-12
    5.0000    0.2000000000   0.2000000000     2.78e-13
   10.0000    0.1000000000   0.1000000000     2.78e-13

Every “abs error” entry sits at the level of double-precision round-off ($\sim 10^{-12}$). That is as close as floating-point arithmetic can get. Empirical evidence does not get cleaner than this.

Now apply the chain rule from Python

The second script reuses the helper $d/dx[\ln u(x)] = u'(x)/u(x)$ to differentiate three compositions at two different inputs. Same identity, more interesting inner functions:

d_ln_of(-1, 2) → ValueError. Better than returning a misleading negative number.

1import math
2
3def d_ln_of(u_value: float, du_dx: float) -> float:
4    """
5    Apply the chain rule for d/dx[ ln( u(x) ) ].
6
7        d/dx[ ln(u) ] = (1 / u) * du/dx
8
9    Parameters
10    ----------
11    u_value : value of u(x) at the point in question (must be > 0).
12    du_dx   : the derivative of u with respect to x at that point.
13    """
14    if u_value <= 0:
15        raise ValueError("u(x) must be positive for ln(u(x)) to be defined")
16    return du_dx / u_value
17
18
19def demo_three_inner_functions(x: float) -> None:
20    """
21    Show how the same outer rule applies to three different inner functions:
22        f1(x) = ln(x^2 + 1)
23        f2(x) = ln(3 * x + 5)
24        f3(x) = ln(sin(x) + 2)     <- always positive for any x
25    """
26    cases = [
27        ("ln(x^2 + 1)",   x * x + 1,         2.0 * x),
28        ("ln(3x + 5)",    3.0 * x + 5.0,     3.0),
29        ("ln(sin x + 2)", math.sin(x) + 2.0, math.cos(x)),
30    ]
31
32    print(f"At x = {x}")
33    print(f"{'expression':<20}  {'u(x)':>10}  {'du/dx':>10}  {'derivative':>14}")
34    print('-' * 60)
35    for label, u, dudx in cases:
36        deriv = d_ln_of(u, dudx)
37        print(f"{label:<20}  {u:>10.4f}  {dudx:>10.4f}  {deriv:>14.6f}")
38
39
40if __name__ == "__main__":
41    demo_three_inner_functions(1.0)
42    print()
43    demo_three_inner_functions(2.0)

PyTorch: Autograd Confirms 1/x

We have done the algebra, drawn the picture, and verified numerically. There is one more witness worth calling — automatic differentiation. PyTorch's autograd does not estimate the derivative with a finite-difference quotient; it walks the computation graph and applies the analytic chain rule node by node. If autograd and our formula disagree, one of them is wrong.

They do not disagree.

torch.autograd.grad(outputs=y, inputs=x) returns (tensor(0.5),) for x_value = 2. The trailing comma matters: we are unpacking a one-element tuple.

1import torch
2
3def grad_of_ln_at(x_value: float) -> tuple[float, float]:
4    """
5    Confirm d/dx[ln(x)] = 1/x by running PyTorch's autograd at one point.
6
7    Returns
8    -------
9    (autograd_value, closed_form_value)
10        autograd_value     — what PyTorch's reverse-mode AD gives us.
11        closed_form_value  — 1 / x, computed by hand.
12
13    Both numbers must match to within floating-point round-off.
14    """
15    # 1. Build x as a *leaf* tensor with gradient tracking enabled.
16    x = torch.tensor(x_value, requires_grad=True)
17
18    # 2. Forward pass: y = ln(x). The computation graph records "log".
19    y = torch.log(x)
20
21    # 3. Reverse pass: ask autograd for dy/dx at this single point.
22    (grad_x,) = torch.autograd.grad(outputs=y, inputs=x)
23
24    return grad_x.item(), 1.0 / x_value
25
26
27def main() -> None:
28    test_points = [0.5, 1.0, 2.0, torch.e, 5.0, 10.0]
29
30    print(f"{'x':>10}  {'autograd':>14}  {'1 / x':>14}  {'|delta|':>12}")
31    print('-' * 56)
32    for xv in test_points:
33        a, b = grad_of_ln_at(float(xv))
34        print(f"{float(xv):>10.4f}  {a:>14.10f}  {b:>14.10f}  {abs(a - b):>12.2e}")
35
36
37if __name__ == "__main__":
38    main()

Expected output:

         x        autograd            1 / x      |delta|
--------------------------------------------------------
    0.5000    2.0000000000   2.0000000000     0.00e+00
    1.0000    1.0000000000   1.0000000000     0.00e+00
    2.0000    0.5000000000   0.5000000000     0.00e+00
    2.7183    0.3678794503   0.3678794503     0.00e+00
    5.0000    0.2000000000   0.2000000000     0.00e+00
   10.0000    0.1000000015   0.1000000000     1.49e-09

Real-World Applications

$d/dx[\ln x] = 1/x$ shows up the moment a problem has a multiplicative or relative-rate flavour. Three quick instances:

1. Relative growth rate (economics, biology)

For a positive quantity $Q(t)$, the logarithmic derivative $\dfrac{d}{dt}\ln Q(t) = \dfrac{Q'(t)}{Q(t)}$ is the percentage growth rate per unit time. A population doubling in one year has log-derivative $\ln 2 \approx 0.693$ per year — exactly the meaning of an interest rate or doubling-time formula.

2. Information theory — cross-entropy and surprise

The information content of an event with probability $p$ is $I(p) = -\ln p$ (nats). Its derivative with respect to the probability is $-1/p$. When deep-learning libraries differentiate cross-entropy loss, this is the term doing the work. Every gradient step in classifier training is moving along $1/p$.

3. Physics — entropy and the partition function

The Helmholtz free energy of a thermodynamic system is $F = -k_{B}T\ln Z$ where $Z$ is the partition function. Quantities derived from $F$ require derivatives of $\ln Z$ with respect to temperature or volume — every one of them brings a factor of $1/Z$.

4. Calculus itself — the missing antiderivative

The power rule says $\int x^{n}\,dx = x^{n+1}/(n+1) + C$ for every $n \neq -1$. The exception is exactly $n = -1$ — the integral of $1/x$. The formula we proved here is precisely what fills that hole:

Without $\ln$, calculus would be unable to integrate the single function $1/x$. With it, the gap is closed.

Summary

One identity, five proofs, two pictures, three witnesses in code.

Coming next: §5.4 generalises the formula to logarithms of arbitrary base — $\log_{a} x$. We will see exactly how a single constant of $\ln a$ divides into $1/x$ to give $1/(x \ln a)$, and why the natural base is “natural” precisely because it removes that constant.