Common Probability Distributions in Finance › The Lognormal Distribution

Michael BrenndoerferOctober 21, 202512 min read
Quantitative FinanceAll chapters
Part 1 of 15Mathematical Foundations
Chapter 3Common Probability Distributions in Finance › The Lognormal Distribution
Reading section 3 of 8 · The Lognormal Distribution · 12 minSection 3 of 8 · 12 min

Book contents

Section 3 of 8 · 12 min read

Common Probability Distributions in Finance › The Lognormal DistributionOne section · Sections in this chapter3 / 8 ↓
Reading tools Definitions & inline links

Choose your expertise level to adjust how many terms are explained. Beginners see more tooltips, experts see fewer to maintain reading flow. Hover over underlined terms for instant definitions.

Article links

Make inline references clickable

Returns may be approximately normal, but a nonnegative stock-price level cannot follow an exact nondegenerate normal law because that law assigns some probability below zero. A local normal approximation may still be useful. A stock price can rise 50% but cannot fall more than 100%. This asymmetry is captured by the lognormal distribution, which constrains values to be positive. The lognormal distribution arises when multiplicative returns produce an accumulated log return that is normally distributed: exponentiating that normal log return gives a positive, lognormally distributed price. Multiplicative compounding by itself does not determine the distribution.

Lognormal Distribution

A probability distribution of a random variable whose logarithm is normally distributed. If ln⁡(X)∼N(μ,σ2)\ln(X) \sim N(\mu, \sigma^2) with σ>0\sigma>0, then XX follows a lognormal distribution. The constant-parameter GBM model below gives lognormal stock prices at each positive horizon.

From Returns to Prices

The connection between normal returns and lognormal prices is one of the most important relationships in quantitative finance. If log-returns are normally distributed, then prices are lognormally distributed. Consider a stock with initial price S0S_0 and continuously compounded return rr over some period:

ST=S0erS_T = S_0 e^r

This equation captures a key relationship in how prices evolve. The exponential function ere^r converts the additive world of log-returns into the multiplicative world of price changes. When r=0.10r = 0.10, the stock has grown by a factor of e0.10≈1.105e^{0.10} \approx 1.105, or about 10.5%. The slight difference between the log-return and the percentage return becomes more pronounced for larger moves.

The components of this price equation are:

  • STS_T: stock price at time TT
  • S0S_0: initial stock price
  • rr: continuously compounded return over the period
  • ere^r: the growth factor, converting log-return to price ratio

If r∼N(μ,σ2)r \sim N(\mu, \sigma^2), then STS_T follows a lognormal distribution. This relationship is fundamental: the exponential function turns the symmetric, unbounded normal distribution into a right-skewed distribution bounded below by zero, which matches the behavior of asset prices that can rise without limit but cannot fall below zero. The step preserves the elegant properties of the normal distribution while mapping them onto the economically sensible domain of positive prices.

For σ>0\sigma>0, the probability density function of the lognormal distribution reveals its connection to the normal:

f(x)=1xσ2πexp⁡(−(ln⁡x−μ)22σ2),x>0f(x) = \frac{1}{x\sigma\sqrt{2\pi}} \exp\left(-\frac{(\ln x - \mu)^2}{2\sigma^2}\right), \quad x > 0

Compare this to the normal density to see the main differences. The argument of the exponential now involves ln⁡x\ln x rather than xx, which reflects that we are measuring distance in the log-space. The presence of 1/x1/x in front of the exponential arises from the chain rule when transforming from the normal to the lognormal through the change of variables.

Each element of this formula serves a distinct purpose:

  • xx: the value at which we evaluate the density (must be positive)
  • μ\mu: the mean of ln⁡(X)\ln(X), not the mean of XX itself
  • σ\sigma: the standard deviation of ln⁡(X)\ln(X), not of XX itself
  • 1/x1/x: this factor (compared to the normal PDF) accounts for the change of variables from ln⁡(x)\ln(x) to xx

The key distinction is that μ\mu and σ\sigma describe the underlying normal log-values, not the lognormal variable itself. A log-return standard deviation of 20% must refer to a specified horizon; it is not the standard deviation of price levels or simple returns. In GBM, the annualized diffusion coefficient σ\sigma instead gives log-return standard deviation σT\sigma\sqrt{T} over TT years. The actual mean and variance of a lognormal variable are:

E[X]=eμ+σ2/2E[X] = e^{\mu + \sigma^2/2} Var(X)=(eσ2−1)e2μ+σ2\text{Var}(X) = (e^{\sigma^2} - 1)e^{2\mu + \sigma^2}

These formulas reveal how the parameters of the underlying normal distribution translate into the moments of the lognormal:

  • E[X]E[X]: the expected value (mean) of the lognormal variable XX
  • Var(X)\text{Var}(X): the variance of XX
  • μ\mu: the mean of ln⁡(X)\ln(X), the underlying normal distribution
  • σ2\sigma^2: the variance of ln⁡(X)\ln(X)
  • eμ+σ2/2e^{\mu + \sigma^2/2}: the mean is greater than eμe^\mu when σ>0\sigma > 0, and equal to it in the degenerate case σ=0\sigma = 0

The σ2/2\sigma^2/2 term is a convexity adjustment: for a nondegenerate normal YY, Jensen's inequality gives E[eY]>eE[Y]E[e^Y]>e^{E[Y]}, and both expectations are finite. High values of YY contribute disproportionately to the mean of eYe^Y. Holding the mean log-return μ\mu fixed, greater σ\sigma therefore raises E[X]E[X]. In the GBM notation below, however, μ\mu denotes arithmetic drift: holding that drift fixed, the log-mean falls by σ2T/2\sigma^2T/2 as variance rises, and E[ST]=S0eμTE[S_T]=S_0e^{\mu T} does not depend on σ\sigma.

Geometric Brownian Motion

A standard baseline model for stock price dynamics is geometric Brownian motion (GBM), which produces lognormally distributed prices at a fixed positive horizon. Its constant-volatility stock model underlies the Black-Scholes option pricing formula. A formal derivation uses stochastic calculus, but the explicit solution and simulation can be understood through normal log-return increments. Modeled prices evolve continuously with both a deterministic trend and random fluctuations proportional to the current price.

Under GBM, the stock price evolves according to:

dS=μS dt+σS dWdS = \mu S \, dt + \sigma S \, dW

This is Itô differential notation: finite price changes are defined through drift and stochastic integrals, not ordinary infinitesimal derivatives. Over a finite interval Δt\Delta t, a Brownian increment satisfies ΔW∼N(0,Δt)\Delta W\sim N(0,\Delta t). Each term has a clear interpretation:

  • dSdS: stochastic differential of the stock-price process
  • SS: current stock price
  • μ\mu: drift rate (expected return per unit time)
  • σ\sigma: diffusion volatility (annualized when time is measured in years); over an interval Δt\Delta t, the log-return standard deviation is σΔt\sigma\sqrt{\Delta t}
  • dtdt: infinitesimal time increment
  • dWdW: Brownian stochastic differential; its finite increments have variance equal to elapsed time

The first term μS dt\mu S\,dt represents the drift, while σS dW\sigma S\,dW captures random fluctuations proportional to the current price. A $100 stock and a $10 stock with the same parameters have the same percentage return distribution, but the absolute dollar changes are ten times larger for the more expensive stock. This makes GBM a scale-consistent baseline. Whether its continuous-path, constant-volatility assumptions fit a particular market and horizon still requires evidence.

Solving this stochastic differential equation yields:

ST=S0exp⁡[(μ−σ22)T+σWT]S_T = S_0 \exp\left[\left(\mu - \frac{\sigma^2}{2}\right)T + \sigma W_T\right]

This solution tells us exactly where the stock price will be at any future time, given the realized path of the Brownian motion. The formula has a clear structure:

  • STS_T: stock price at time TT
  • S0S_0: initial stock price at time 0
  • μ\mu: annualized instantaneous proportional-return drift; expected simple return over TT years is eμT−1e^{\mu T}-1
  • σ\sigma: volatility (annualized standard deviation)
  • TT: time horizon in years
  • WTW_T: value of the Wiener process at time TT, with WT∼N(0,T)W_T \sim N(0, T)
  • σ2/2\sigma^2/2: Itô correction term arising from the quadratic variation of Brownian motion

The Itô correction σ2/2\sigma^2/2 appears because we apply Itô's lemma to ln⁡(S)\ln(S): the second derivative term 12∂2ln⁡S∂S2(σS)2=−σ22\frac{1}{2}\frac{\partial^2 \ln S}{\partial S^2}(\sigma S)^2 = -\frac{\sigma^2}{2} contributes to the drift. This correction is one of the key differences between ordinary calculus and stochastic calculus. In ordinary calculus, if we know dS/SdS/S, we would conclude that d(ln⁡S)=dS/Sd(\ln S) = dS/S. However, when SS follows a diffusion process, the additional −σ2/2-\sigma^2/2 term arises from the non-zero quadratic variation of Brownian motion. For σ>0\sigma>0, the expected GBM log-growth rate μ−σ2/2\mu-\sigma^2/2 is below its arithmetic drift μ\mu; at σ=0\sigma=0, the two are equal.

This model forms the foundation of the Black-Scholes option pricing formula.

Out[8]:
Visualization
Line plot of a normal probability density over daily returns with a vertical line at zero.
Normal distribution of returns, centered near zero and symmetric.
Line plot of a lognormal probability density over stock prices with a vertical line at the initial price.
Lognormal distribution of prices, bounded below by zero and positively skewed.

Simulating Price Paths

Monte Carlo simulation of stock prices under GBM is simple. The approach below draws exact GBM transition increments at each point on the chosen time grid and cumulatively sums them. Unlike an Euler approximation, this produces the exact GBM distribution at the grid points for constant parameters; it does not simulate between-grid extrema.

In[9]:
Code
import numpy as np


def _scaled_product(left, right, divisor=1):
    """Multiply then divide through binary mantissas when intermediates fail."""
    import math

    lm, le = math.frexp(float(left))
    rm, re = math.frexp(float(right))
    dm, de = math.frexp(float(divisor))
    try:
        result = math.ldexp(lm * rm / dm, le + re - de)
    except OverflowError as error:
        raise FloatingPointError(
            "Scaled coefficient exceeds floating-point range"
        ) from error
    if not math.isfinite(result):
        raise FloatingPointError("Scaled coefficient exceeds floating-point range")
    return result


def simulate_gbm_paths(S0, mu, sigma, T, n_steps, n_paths, rng=None):
    """
    Simulate geometric Brownian motion paths.

    Parameters:
        S0: Initial stock price
        mu: Annualized instantaneous proportional-return drift
        sigma: Annualized volatility
        T: Time horizon in years
        n_steps: Number of time steps
        n_paths: Number of simulation paths
        rng: Optional local NumPy RandomState; defaults to a fresh seed-42 stream

    Returns:
        Array of shape (n_paths, n_steps + 1) containing price paths

    Finite model inputs do not guarantee representable transition coefficients
    or prices. Range failures raise FloatingPointError; ordinary floating-point
    rounding remains. The time-zero column directly preserves the floating-point
    representation of S0, not an arbitrary integer's exact precision.
    """
    if not all(np.isfinite(value) for value in (S0, mu, sigma, T)):
        raise ValueError("Simulation parameters must be finite")
    if S0 <= 0 or sigma < 0 or T < 0:
        raise ValueError("Require S0>0, sigma>=0 and T>=0")
    if any(
        isinstance(value, (bool, np.bool_))
        or not isinstance(value, (int, np.integer))
        or value <= 0
        for value in (n_steps, n_paths)
    ):
        raise ValueError("n_steps and n_paths must be positive integers")
    dt = T / n_steps

    # Generate random increments
    rng = np.random.RandomState(42) if rng is None else rng
    Z = rng.standard_normal((n_paths, n_steps))

    # Calculate log returns for each step
    if T == 0:
        # Draws above still advance a supplied stream in the usual order.
        return np.full((n_paths, n_steps + 1), S0, dtype=float)
    ordinary_step = dt > 0 and sigma <= np.sqrt(np.finfo(float).max)
    if ordinary_step:
        with np.errstate(over="ignore", invalid="ignore"):
            log_returns = (mu - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z
        ordinary_step = np.all(np.isfinite(log_returns))
    if not ordinary_step:
        # Scale time before squaring volatility or rounding T/n to zero.
        volatility_step = _scaled_product(sigma, np.sqrt(T), np.sqrt(n_steps))
        drift_step = _scaled_product(mu, T, n_steps)
        variance_step = _scaled_product(volatility_step, volatility_step, 2)
        log_returns = drift_step - variance_step + volatility_step * Z

    # Cumulative sum to get log prices relative to initial
    log_prices = np.zeros((n_paths, n_steps + 1))
    log_prices[:, 0] = np.log(S0)
    log_prices[:, 1:] = np.log(S0) + np.cumsum(log_returns, axis=1)

    # Convert to prices
    with np.errstate(over="raise", under="ignore", invalid="raise"):
        prices = np.exp(log_prices)
    prices[:, 0] = S0
    if not np.all(np.isfinite(prices) & (prices > 0)):
        raise FloatingPointError("Price paths exceed floating-point representability")
    return prices


# Simulate 1 year of daily prices
S0 = 100
mu = 0.10  # 10% instantaneous annualized drift; expected one-year simple return ≈10.52%
sigma = 0.25  # 25% annual volatility
T = 1.0
n_steps = 252  # Trading days
n_paths = 1000

paths = simulate_gbm_paths(S0, mu, sigma, T, n_steps, n_paths)
final_prices = paths[:, -1]
Out[10]:
Console
Initial price: $100.00
Expected final price (theoretical): $110.52
Mean simulated final price: $110.44
Median simulated final price: $108.19
5th percentile: $71.15
95th percentile: $160.84

Notice that the mean simulated price is close to the theoretical expected value of S0eμTS_0 e^{\mu T}, but the median is lower. This is typical of a non-degenerate lognormal distribution: its mean exceeds its median, and its mode is lower still. These quantities answer different questions. The median describes the middle terminal outcome across simulated paths, the mean describes ensemble expected terminal wealth, and long-run performance of repeatedly compounded wealth is governed by average log growth rather than by the arithmetic mean terminal price alone.

Out[11]:
Visualization
Spaghetti plot of simulated GBM price paths with an overlaid expected path.
Fifty sample paths from a Monte Carlo simulation of 1,000 stock-price paths under geometric Brownian motion. The fan-like shape illustrates how uncertainty increases with time.
Histogram of simulated final stock prices with vertical lines marking the mean and median.
Distribution of final simulated prices under geometric Brownian motion after one year, illustrating the right-skewed outcomes of a lognormal model.