Brownian Motion and Random Walk Models › Geometric Brownian Motion
Quantitative FinanceAll chapters Brownian Motion and Random Walk Models › Geometric Brownian MotionOne section · Sections in this chapter5 / 10 ↓
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
Standard Brownian motion can go negative, which makes it unsuitable for modeling asset prices directly. A stock price of negative $50 is meaningless. We need a modification that ensures prices stay positive and captures the multiplicative nature of returns, where a 10% gain followed by a 10% loss doesn't return you to the starting point. If you start with $100, gain 10% to reach $110, then lose 10%, you end at $99, not $100.
Geometric Brownian Motion (GBM) solves both problems by modeling the logarithm of the price as Brownian motion with drift. By taking the exponential of a process that can range from negative infinity to positive infinity, we obtain a process that ranges from zero to positive infinity, which is exactly the domain of asset prices. The multiplicative structure of percentage returns emerges naturally from this construction.
A stochastic process follows Geometric Brownian Motion if it satisfies the stochastic differential equation:
where:
- : asset price at time
- : drift rate (expected return)
- : volatility (standard deviation of returns)
- : standard Brownian motion
Equivalently, follows Brownian motion with drift.
The stochastic differential equation above deserves careful interpretation. The term represents the deterministic drift: if there were no randomness, the price would grow exponentially at rate . The term represents the random fluctuations: the price is continuously perturbed by Brownian shocks, with the magnitude of these shocks proportional to the current price level. This proportionality means that a $100 stock and a $1000 stock experiencing the same percentage volatility will have different dollar volatilities.
The solution to this SDE is:
where:
- : asset price at time
- : initial asset price
- : drift parameter
- : volatility parameter
- : value of Brownian motion at time
We'll derive this solution rigorously using Itô's lemma in the next chapter. For now, let's understand why this form makes sense and explore its properties.
Why the Drift Adjustment?
You might expect the exponent to simply be , but there's an additional term. This correction arises from the convexity of the exponential function and the non-zero quadratic variation of Brownian motion. It is perhaps the most important example of how stochastic calculus differs from ordinary calculus.
Consider the logarithm of the price process:
where:
- : log-price at time
- : price at time
- : drift of the log-price process
- : standard Brownian motion source of noise
This is an arithmetic Brownian motion with drift and volatility . The term is sometimes called the "Itô correction" or "convexity adjustment."
The drift represents the expected instantaneous return , but because of Jensen's inequality, the expected log return is lower:
where:
- : expected value operator
- : return ratio over time
- : arithmetic drift rate
- : convexity adjustment
To understand this intuitively, consider what happens to the average of $100 invested in two equally likely scenarios: either the price doubles to $200 or it halves to $50. The arithmetic average outcome is (200 + 50)/2 = $125, representing a 25% gain. But the geometric average (or equivalently, the average of log returns) is = $100, representing a 0% gain. The arithmetic mean exceeds the geometric mean whenever there is volatility, and the gap is approximately .
For typical equity parameters (, ), the difference is or 2% per year, which is economically significant. An expected arithmetic return of 10% per year corresponds to an expected log return of only 8% per year. Over long horizons, this difference compounds substantially.

Simulating GBM
We can simulate GBM in two equivalent ways: directly using the exact solution, or by discretizing the SDE.
Exact simulation: Since we have a closed-form solution, we can generate directly:
where:
- : simulated price at time
- : starting price
- : drift and volatility parameters
- : Brownian motion realization
This approach is highly efficient because we only need to simulate the Brownian motion once, then apply the exponential transformation. There is no discretization error because we are using the exact solution at each time point.
Euler discretization: Approximate the SDE over small time steps:
where:
- : price at the next time step
- : current price
- : drift rate
- : volatility
- : time increment
- : standard normal random variable
The Euler method approximates the continuous SDE by treating the drift and diffusion terms as constant over each small time step. This introduces discretization error that shrinks as , but for any finite time step, the approximation is not exact.
The exact method is preferable when possible since it avoids discretization error.
import numpy as np
def gbm_exact(S0, mu, sigma, T, n_steps, n_paths=1):
"""Simulate GBM using the exact solution."""
dt = T / n_steps
times = np.linspace(0, T, n_steps + 1)
# Generate Brownian motion increments
dW = np.sqrt(dt) * np.random.randn(n_paths, n_steps)
W = np.cumsum(dW, axis=1)
W = np.hstack([np.zeros((n_paths, 1)), W])
# Apply GBM formula
drift = (mu - 0.5 * sigma**2) * times
diffusion = sigma * W
S = S0 * np.exp(drift + diffusion)
return times, S
# Typical equity parameters
S0 = 100 # Initial price
mu = 0.10 # 10% annual drift
sigma = 0.20 # 20% annual volatility
T = 1.0 # One year
np.random.seed(42)
times, S = gbm_exact(S0, mu, sigma, T, n_steps=252, n_paths=10)
Lognormal Distribution of Prices
Since is normally distributed, itself follows a lognormal distribution. This is a direct consequence of the GBM solution: the exponential of a normal random variable is lognormal. Specifically:
where:
- : natural logarithm of price at time
- : normal distribution notation
- : initial price
- : drift rate
- : volatility
- : time elapsed
- : mean of the log-price
- : variance of the log-price
From this, we can derive several important quantities:
- Expected price:
- Variance of price:
- Median price:
The mean exceeds the median because the lognormal distribution is right-skewed. There's a small probability of very large price increases, which pulls the mean above the median. This skewness increases with volatility and time, which reflects the asymmetry between percentage gains and losses: a stock can gain 100% or 200%, but it can only lose at most 100%.
Let's verify the distribution:
import numpy as np
# Simulate many paths to check distribution at T=1
np.random.seed(42)
n_paths = 50000
times, S = gbm_exact(S0, mu, sigma, T=1.0, n_steps=252, n_paths=n_paths)
final_prices = S[:, -1]
# Theoretical values
expected_price = S0 * np.exp(mu * T)
median_price = S0 * np.exp((mu - sigma**2 / 2) * T)
log_mean = np.log(S0) + (mu - sigma**2 / 2) * T
log_std = sigma * np.sqrt(T)
# Empirical values
empirical_mean = final_prices.mean()
empirical_median = np.median(final_prices)
empirical_log_mean = np.log(final_prices).mean()
empirical_log_std = np.log(final_prices).std()GBM Distribution at T=1:
==================================================
Theoretical Empirical
--------------------------------------------------
Mean price $ 110.52 $ 110.43
Median price $ 108.33 $ 108.33
Log mean 4.6852 4.6845
Log std: 0.2000 0.1991The simulation results confirm that while the log-prices are normally distributed, the prices themselves are lognormally distributed. The mean price exceeds the median, which reflects the positive skewness of the lognormal distribution.


Returns Under GBM
Under GBM, the log-return over period is:
where:
- : log-return over the interval
- : price ratio
- : length of the time interval
- : Brownian increment over the interval
Since the Brownian increment is normally distributed with mean zero and variance , the log-return is normally distributed with mean and variance . This matches one of the stylized facts we discussed in the previous chapter: returns are approximately symmetric and close to normal for moderate return magnitudes.
For small , the simple return approximates the log-return:
where:
- : simple percentage return
- : logarithmic return
This approximation follows from the Taylor expansion for small . When the percentage return is small (say, under 10%), the difference between simple and log returns is negligible for most practical purposes.
import numpy as np
# Extract daily returns from simulated paths
daily_returns = np.diff(np.log(S), axis=1).flatten()
# Theoretical values for daily returns (dt = 1/252)
dt = 1 / 252
theoretical_mean = (mu - sigma**2 / 2) * dt
theoretical_std = sigma * np.sqrt(dt)
# Empirical values
from scipy import stats
empirical_mean = daily_returns.mean()
empirical_std = daily_returns.std()
empirical_skew = stats.skew(daily_returns)
empirical_kurt = stats.kurtosis(daily_returns)
theoretical_skew = 0.0
theoretical_kurt = 0.0Daily Log-Returns Under GBM:
==================================================
Theoretical Empirical
--------------------------------------------------
Mean 0.000317 0.000315
Std 0.012599 0.012599
Skewness 0.000000 -0.000389
Excess Kurtosis: 0.000000 -0.000632The moments of the simulated log-returns match the theoretical values for a normal distribution: mean close to zero, standard deviation consistent with volatility, and negligible skewness and excess kurtosis.
