Derivatives of Inverse Hyperbolic Functions

Learning Objectives

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

1. Derive every inverse hyperbolic derivative from one tool — the inverse function theorem $(f^{-1})'(y) \;=\; 1 / f'(f^{-1}(y))$ — applied to $\sinh$, $\cosh$, and $\tanh$.
2. Recognize why each formula has the shape it does: a square-root in the denominator for $\operatorname{arsinh}, \operatorname{arcosh}$ (they come from $\cosh^2 - \sinh^2 = 1$), a quadratic for $\operatorname{artanh}$ (it comes from $1 - \tanh^2$).
3. Cross-check the formulas by differentiating the logarithmic forms $\operatorname{arsinh}(x) = \ln(x + \sqrt{x^2+1})$ directly with the chain rule.
4. Apply the chain rule to compose these derivatives with other functions $\frac{d}{dx}\operatorname{artanh}(g(x)) = \frac{g'(x)}{1 - g(x)^2}$.
5. Verify any answer numerically (Python central difference) and symbolically (PyTorch autograd).
6. Connect $\operatorname{artanh}$ to the logit transform used in classification heads, and $\operatorname{arsinh}$ to the asinh-scaled loss used in regression on heavy-tailed data.

The Question Behind the Formulas

In the last section you learned that $\sinh, \cosh, \tanh$ have unusually tidy derivatives. $\sinh' = \cosh$. $\cosh' = \sinh$. $\tanh' = 1 - \tanh^2$. The pair $(\sinh, \cosh)$ behaves like a hyperbolic version of $(\sin, \cos)$ — same algebraic rhythm, no minus sign.

But just like the trig functions, hyperbolic functions are sometimes given to us backwards. A hanging cable has a shape $y = a \cosh(x/a)$. If you measure the height $y$ and want to recover the horizontal position $x$, you need $x = a\,\operatorname{arcosh}(y/a)$. A neural network outputs a number $u \in (-1, 1)$ through a $\tanh$ head. If you want the pre-activation that produced it you need $\operatorname{artanh}(u)$. Special relativity gives a rapidity $\phi = \operatorname{artanh}(v/c)$. Statistics gives Fisher's $z = \operatorname{artanh}(r)$ transform on correlation coefficients.

The single question of this section: given that $(\sinh, \cosh, \tanh)$ have such clean derivatives, what are the derivatives of their inverses? And why do those derivatives have square-roots and quadratics glued to them?

The answer is one mechanical idea — the inverse function theorem — applied three times. Once you see the picture (curves reflecting across $y = x$, slopes reciprocating), the formulas are inevitable.

Intuition: Inverses Mirror, Slopes Reciprocate

Inverting a function geometrically means reflecting its graph across the line $y = x$. Every point $(a, b)$ on $f$ becomes the point $(b, a)$ on $f^{-1}$. The two graphs are mirror images.

Now follow what happens to a tangent. Pick a point on $f$ where the tangent rises with slope $m = f'(a)$ — “up $m$ for every right 1”. Reflect that little arrow across $y = x$. Up and right swap. The reflected arrow is “right $m$ for every up 1” — which is exactly the same as “up $1/m$ for every right 1”.

One sentence to keep: reflection across $y = x$ swaps rise and run, which is exactly the operation that inverts a slope. So the derivative of the inverse at a point is the reciprocal of the original derivative at the matching point.

Algebraically, if $y = f(x)$ and $x = f^{-1}(y)$, then taking $\frac{d}{dy}$ of the second equation — viewing $x$ as a function of $y$, then applying the chain rule from the first — gives

That is the entire toolkit. The rest of this section is just plugging in three different $f$s.

Mirror Across $y = x$ — Live Viewer

Drag the slider. Two things to watch:

• The blue point on $f$ and the purple point on $f^{-1}$ are exact mirror images across the dashed line — they have swapped coordinates.
• The green tangent (on $f$) and the orange tangent (on $f^{-1}$) are mirror images too. Their slopes multiply to $1$: that is the inverse function theorem, drawn.

The Machine: Inverse Function Theorem

Concretely, here is the three-step recipe we will run three times.

1. Set $y = f(x)$, so $x = f^{-1}(y)$.
2. Differentiate $y = f(x)$ with respect to $y$ on both sides: $1 = f'(x)\,\frac{dx}{dy}$, so $\frac{dx}{dy} = \frac{1}{f'(x)}$.
3. Re-express $f'(x)$ in terms of $y$ using the relation $y = f(x)$. This is the step that produces the square root.

Derivation 1: $\dfrac{d}{dx}\operatorname{arsinh}(x)$

Let $y = \operatorname{arsinh}(x)$, so $x = \sinh(y)$. We want $dy/dx$.

Step 1. Differentiate the relation $x = \sinh(y)$ with respect to $x$, treating $y$ as a function of $x$:

Step 2. Re-express $\cosh(y)$ in terms of $x$. Use the fundamental identity $\cosh^2(y) - \sinh^2(y) = 1$:

We take the positive square root because $\cosh \ge 1 > 0$ everywhere.

Step 3. Plug back in:

The square root in the denominator is the geometric signature of the identity $\cosh^2 - \sinh^2 = 1$. Anytime you see $1/\sqrt{1+x^2}$ in a calculation, you are looking at an arsinh in disguise.

Derivation 2: $\dfrac{d}{dx}\operatorname{arcosh}(x)$

Let $y = \operatorname{arcosh}(x)$, with $x \ge 1$ and $y \ge 0$ (the principal branch — see the pitfall section).

Step 1. From $x = \cosh(y)$, differentiate:

Step 2. Re-express $\sinh(y)$ in terms of $x$:

The positive sign comes from $y \ge 0 \Rightarrow \sinh(y) \ge 0$.

Step 3. Plug back in:

As $x \to 1^+$, the slope blows up. Geometrically this is the moment $\cosh$'s tangent at the bottom of its U-shape passes through horizontal (slope 0). Inverting it means the tangent of $\operatorname{arcosh}$ becomes vertical there. Reciprocal of zero is infinity.

Derivation 3: $\dfrac{d}{dx}\operatorname{artanh}(x)$

Let $y = \operatorname{artanh}(x)$, with $-1 < x < 1$.

Step 1. From $x = \tanh(y)$, differentiate using $\tanh'(y) = 1 - \tanh^2(y)$ (the derivative you proved in the previous section):

Step 2. Substitute $\tanh(y) = x$ directly — no square roots this time, because the identity $1 - \tanh^2 = \operatorname{sech}^2$ is already a clean quadratic in $\tanh$:

At the endpoints $x = \pm 1$ the formula produces $1/0$; the slope is genuinely infinite there because $\operatorname{artanh}$ has vertical asymptotes at $\pm 1$. The infinite slope is not a bug — it is the price of squeezing all of $\mathbb R$ into the open interval $(-1, 1)$.

The Remaining Three: $\operatorname{arcsch}, \operatorname{arsech}, \operatorname{arcoth}$

The same machine handles the reciprocal trio. The derivations are short — they follow $\frac{d}{dx}\operatorname{arcsch}(x) = -\frac{1}{|x|\sqrt{1+x^2}}$ from $\operatorname{csch} = 1/\sinh$ by applying the chain rule plus our arsinh result — and the answers are:

Master Reference Table

Print this. Tape it to your wall. Every inverse-hyperbolic problem reduces to one of these rows, perhaps composed with the chain rule.

Sanity Check: The Logarithm Route

Each inverse hyperbolic function also has a closed-form logarithmic expression. Differentiating those expressions directly with the chain rule gives a second route to the same answers — a perfect cross-check for the inverse-function-theorem route.

Where does $\operatorname{arsinh}(x) = \ln(x + \sqrt{x^2+1})$ come from? Solve $x = \sinh(y) = (e^y - e^{-y})/2$ for $y$. Multiply by $2e^y$: $e^{2y} - 2xe^y - 1 = 0$. This is a quadratic in $u = e^y$ with positive root $u = x + \sqrt{x^2+1}$. Take $\ln$ of both sides and you get the formula.

Now differentiate directly. Let $u(x) = x + \sqrt{x^2+1}$. Then:

By the chain rule,

Same answer. The little cancellation $u(x)/u(x) = 1$ is where the algebra rewards us. The same trick works for $\operatorname{arcosh}$ and $\operatorname{artanh}$; try it as an exercise.

Worked Example (Collapsible): Mass on a Falling Cable

A heavy chain hangs in the shape $y(x) = a\cosh(x/a)$ (the catenary; see ch07/s01 if you want the physics derivation). We measure the height of a bead on the chain and want to know how its horizontal coordinate moves when the height changes. That is $dx/dy$, and the answer is an application of the arcosh derivative.

Try the problem yourself first. Then expand the panel below to check.

Interactive Derivative Explorer

Pick one of the six inverse hyperbolic functions, drag the slider, and watch:

• the green tangent line rotate on the blue curve;
• the orange dashed curve show $f'(x)$; the dashed curve's height at $x$ equals the slope of the blue curve at the same $x$;
• the readouts — value, slope, and tangent angle in degrees — update live.

Python: Numerical Verification by Central Difference

Three formulas, eight test points, one diagnostic table. We compare each hand-derived derivative against a central-difference estimate. If the algebra is right, the error column should be $\sim 10^{-10}$ on smooth regions.

arsinh(0)   = ln(0 + 1)   = 0
arsinh(1)   = ln(1 + √2)  ≈ 0.88137
arsinh(2.5) = ln(2.5 + √7.25) ≈ 1.6472

arcosh(1)   = ln(1 + 0) = 0
arcosh(1.5) = ln(1.5 + √1.25) ≈ 0.9624
arcosh(3)   = ln(3 + √8)  ≈ 1.7627

artanh(0)   = 0
artanh(0.5) = ½ ln(1.5/0.5) = ½ ln 3 ≈ 0.5493
artanh(0.9) = ½ ln(1.9/0.1) ≈ 1.4722

d_arsinh(0)   = 1
d_arsinh(1)   = 1/√2 ≈ 0.7071
d_arsinh(2.5) ≈ 0.3714

d_arcosh(1.5) = 1/√1.25 ≈ 0.8944
d_arcosh(3)   = 1/√8     ≈ 0.3536

d_artanh(0)   = 1
d_artanh(0.5) = 1/0.75 ≈ 1.3333
d_artanh(0.9) = 1/0.19 ≈ 5.2632

Sample output line:
arsinh  x=  1.0  analytic=  0.707107  numeric=  0.707107  err=1.27e-11

1import math
2from typing import Callable, Tuple
3
4# ---- the six inverse hyperbolic functions, in closed form ----------------
5
6def arsinh(x: float) -> float:
7    # defined for all real x
8    return math.log(x + math.sqrt(x * x + 1.0))
9
10def arcosh(x: float) -> float:
11    # only defined for x >= 1
12    if x < 1.0:
13        raise ValueError("arcosh requires x >= 1")
14    return math.log(x + math.sqrt(x * x - 1.0))
15
16def artanh(x: float) -> float:
17    # only defined for -1 < x < 1
18    if not -1.0 < x < 1.0:
19        raise ValueError("artanh requires -1 < x < 1")
20    return 0.5 * math.log((1.0 + x) / (1.0 - x))
21
22
23# ---- their derivatives, in closed form (from the inverse function theorem) -
24
25def d_arsinh(x: float) -> float:
26    return 1.0 / math.sqrt(1.0 + x * x)
27
28def d_arcosh(x: float) -> float:
29    return 1.0 / math.sqrt(x * x - 1.0)
30
31def d_artanh(x: float) -> float:
32    return 1.0 / (1.0 - x * x)
33
34
35# ---- numerical derivative via symmetric difference -----------------------
36
37def numerical_derivative(f: Callable[[float], float], x: float,
38                          h: float = 1e-5) -> float:
39    """Central difference: O(h^2) accurate for smooth f."""
40    return (f(x + h) - f(x - h)) / (2.0 * h)
41
42
43def check(name: str, x: float, f: Callable[[float], float],
44          fprime: Callable[[float], float]) -> Tuple[float, float, float]:
45    analytic = fprime(x)
46    numeric = numerical_derivative(f, x)
47    err = abs(analytic - numeric)
48    print(f"{name}  x={x:>5}  analytic={analytic:10.6f}  "
49          f"numeric={numeric:10.6f}  err={err:.2e}")
50    return analytic, numeric, err
51
52
53if __name__ == "__main__":
54    # Pick points safely inside each function's domain.
55    check("arsinh", 0.0, arsinh, d_arsinh)
56    check("arsinh", 1.0, arsinh, d_arsinh)
57    check("arsinh", 2.5, arsinh, d_arsinh)
58
59    check("arcosh", 1.5, arcosh, d_arcosh)
60    check("arcosh", 3.0, arcosh, d_arcosh)
61
62    check("artanh", -0.5, artanh, d_artanh)
63    check("artanh",  0.5, artanh, d_artanh)
64    check("artanh",  0.9, artanh, d_artanh)

PyTorch: Autograd Recovers Every Formula

Now the third independent route. We compute the same derivatives with $\texttt{torch.autograd.grad}$ and compare against the analytic formulas. Internally, PyTorch's C++ backward kernels for $\texttt{asinh}, \texttt{acosh}, \texttt{atanh}$ implement exactly the closed forms we proved. If our derivation is correct the two columns must match to $\sim 10^{-15}$ on float64.

torch.asinh(torch.tensor(1.0))   → tensor(0.8814)
torch.atanh(torch.tensor(0.5))   → tensor(0.5493)

name='arsinh', x=1.0
  y = torch.asinh(xt)
  y.item() ≈ 0.8813735870195429

1import math
2import torch
3
4# ----- the six inverse hyperbolic functions via torch -----------------------
5# torch.asinh / acosh / atanh exist natively. We use them so autograd can do
6# its job, then cross-check against our hand-derived formulas.
7
8def f_arsinh(x: torch.Tensor) -> torch.Tensor:
9    return torch.asinh(x)
10
11def f_arcosh(x: torch.Tensor) -> torch.Tensor:
12    return torch.acosh(x)
13
14def f_artanh(x: torch.Tensor) -> torch.Tensor:
15    return torch.atanh(x)
16
17
18def analytic_derivative(name: str, x: float) -> float:
19    if name == "arsinh":
20        return 1.0 / math.sqrt(1.0 + x * x)
21    if name == "arcosh":
22        return 1.0 / math.sqrt(x * x - 1.0)
23    if name == "artanh":
24        return 1.0 / (1.0 - x * x)
25    raise ValueError(name)
26
27
28def autograd_derivative(name: str, x: float) -> float:
29    """Ask PyTorch for f'(x) at a single point using torch.autograd.grad."""
30    xt = torch.tensor(x, dtype=torch.float64, requires_grad=True)
31    if name == "arsinh":
32        y = f_arsinh(xt)
33    elif name == "arcosh":
34        y = f_arcosh(xt)
35    elif name == "artanh":
36        y = f_artanh(xt)
37    else:
38        raise ValueError(name)
39
40    (grad,) = torch.autograd.grad(
41        outputs=y,
42        inputs=xt,
43        create_graph=False,
44    )
45    return grad.item()
46
47
48if __name__ == "__main__":
49    tests = [
50        ("arsinh",  0.0),
51        ("arsinh",  1.0),
52        ("arsinh", -2.5),
53        ("arcosh",  1.5),
54        ("arcosh",  3.0),
55        ("artanh", -0.5),
56        ("artanh",  0.5),
57        ("artanh",  0.9),
58    ]
59    for name, x in tests:
60        ana = analytic_derivative(name, x)
61        ag  = autograd_derivative(name, x)
62        print(f"{name:>7}  x={x:>5}  analytic={ana:10.6f}  "
63              f"autograd={ag:10.6f}  match={math.isclose(ana, ag, rel_tol=1e-9)}")

Why ML Engineers Care: Logits, Tanh, and Stability

1. Logits are arctanhs in disguise. A binary classifier outputs a probability $p \in (0, 1)$ via $p = \sigma(z) = 1/(1 + e^{-z})$. The inverse $\sigma^{-1}(p) = \ln(p/(1-p))$ is the logit. A short algebraic identity says $\operatorname{artanh}(2p - 1) = \tfrac{1}{2}\sigma^{-1}(p)$. That is why the derivative $1/(1 - x^2)$ appears in backward passes through classification heads: it is the gradient of the logit at the rescaled probability.

2. The arsinh-scaled loss. When a regression target spans many orders of magnitude (think satellite radiance, stock returns, ad-revenue, sensor counts), training on raw values lets a single outlier dominate every gradient step. Replacing the loss $(y - \hat y)^2$ with $(\operatorname{arsinh}(y) - \operatorname{arsinh}(\hat y))^2$ compresses large values logarithmically while leaving small values almost linear. The gradient of the inner term picks up an $1/\sqrt{1+y^2}$ factor — the formula from this section — which is why the optimizer's effective step size on huge targets becomes inversely proportional to $|y|$. Outliers can't scream anymore.

3. The artanh-saturation trap. A tanh activation outputs values in $(-1, 1)$. The backward pass through the loss often inverts the activation conceptually (think contrastive losses operating on cosine similarities). The gradient of $\operatorname{artanh}$ is $1/(1 - x^2)$, which is $100$ at $x = 0.995$ and $10000$ at $x = 0.99995$. If a network saturates toward $\pm 1$ you get an exploding gradient through any artanh in the pipeline. Clamping inputs to $[-0.9999, 0.9999]$ before artanh is a standard production fix.

4. Rapidity in physics-aware models. Special relativity replaces velocities with rapidities $\phi = \operatorname{artanh}(v/c)$ because rapidity adds linearly under boosts while velocity does not. Recent ML papers on relativistic dynamics use this trick to keep loss landscapes flat across speeds — every gradient ends up with our $1/(1 - x^2)$ attached.

Common Pitfalls

1. Forgetting the domain. $\operatorname{arcosh}(x)$ requires $x \ge 1$; $\operatorname{artanh}(x)$ requires $|x| < 1$. The derivatives extend across the same domains, and outside them you get a NaN.
2. Sign of the square root. When you compute $\cosh(y)$ from $\cosh^2(y) = 1 + x^2$ you must pick the positive root, because $\cosh \ge 1$. The same is true for the principal-branch choices in $\operatorname{arcosh}$.
3. Confusing arctanh with arccoth. Their derivatives are identical expressions $1/(1-x^2)$, but their domains are disjoint: $|x|<1$ for artanh, $|x|>1$ for arcoth. Pick the wrong one and your answer is in the wrong region of the real line.
4. Float32 near singularities. Both $\operatorname{artanh}'$ and $\operatorname{arcosh}'$ have gradient blow-ups at the edge of their domain. In float32 you will see noisy or infinite gradients well before you reach the mathematical boundary. Use float64 for diagnostic work and clamp inputs before the function call in production.
5. Notation drift. Some books write $\sinh^{-1}$, $\cosh^{-1}$; we prefer the $\operatorname{arsinh}$, $\operatorname{arcosh}$ form to avoid confusion with the reciprocal $1/\sinh$. Both mean the same thing.

Summary

Every inverse hyperbolic derivative is one step away from the identity it lives on:

Three identities. Six formulas. One mechanical procedure (the inverse function theorem) that converts one to the other. Once the picture — graphs reflected across $y = x$, slopes reciprocating — is in your head, the formulas stop being formulas and become consequences of geometry.

One sentence: the derivative of $f^{-1}$ at $y$ is the reciprocal of the derivative of $f$ at the matching $x$ — and for hyperbolic functions the re-expression in terms of $y$ always produces a square-root or a quadratic via $\cosh^2 - \sinh^2 = 1$.