Finite Difference Methods for Option Pricing › The Explicit Finite Difference Scheme
Quantitative FinanceAll chapters Finite Difference Methods for Option Pricing › The Explicit Finite Difference SchemeOne section · Sections in this chapter3 / 14 ↓
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
The explicit scheme is the most straightforward approach to solving the Black-Scholes PDE numerically. Its simplicity makes it an excellent starting point for understanding finite difference methods, even though its stability limitations often favor other schemes in practice. The explicit scheme approximates the PDE derivatives using values at the current time step to calculate values at the previous time step (remembering that we work backward from expiration).
Derivative Approximations
The central idea of finite difference methods is to replace derivatives with algebraic approximations involving function values at nearby grid points. These approximations come from Taylor series expansions. We approximate the partial derivatives using finite differences. At grid point , the approximations are:
Time derivative (backward difference):
where:
- : option value at grid point and current time step
- : option value at grid point and next time step
- : time step size
This approximation follows from the definition of a derivative as a limit. When we cannot take an infinitesimal step, we use a small but finite step instead. The error in this approximation is proportional to , meaning we achieve first-order accuracy in time.
First spatial derivative (central difference):
where:
- : option values at adjacent spatial points at time
- : price step size
The central difference uses function values on both sides of the point of interest, which leads to a symmetric approximation with second-order accuracy. Compared to one-sided differences, the central difference cancels the leading error terms, giving a more accurate estimate of the derivative.
Second spatial derivative (central difference):
where:
- : option values at adjacent spatial points
- : price step size
This formula for the second derivative can be derived by applying the first derivative approximation twice, or equivalently by using Taylor expansions and solving for the second derivative. The resulting expression has an intuitive interpretation: it measures the curvature of the option value function by comparing the value at a point to the average of its neighbors. Notice that all spatial derivatives use values at time . This makes the scheme "explicit" because we can directly calculate from known values at without needing to solve a system of equations.
Deriving the Update Formula
With our finite difference approximations in hand, we can now derive the explicit update formula by substituting into the Black-Scholes PDE. Substituting these approximations into the Black-Scholes PDE and rearranging for :
where:
- : unknown option value at current time step
- : known option values at next time step
- : asset price at grid point
- : time and price step sizes
- : risk-free rate and volatility
Our objective is to isolate on one side of the equation, expressing it in terms of known quantities. Multiplying by and rearranging to isolate :
where:
- : option value at the current time step
- : time step size
- Terms in parenthesis: discrete approximation of the Black-Scholes operator
The expression in parentheses represents the spatial part of the Black-Scholes operator, evaluated at the known time step. To make the formula more useful for computation, we collect terms by which grid point they involve. Grouping terms by the grid points , , and :
where:
- : option value at the current time step
- : time step size
- : price step size
- : volatility
- : risk-free rate
- : asset price at grid point
- : option values at the next time step
The structure of this equation reveals that the option value at any interior grid point is a weighted combination of three values at the next time step: the value at the same price level and the values at adjacent price levels. Using , these bracketed terms simplify to a more compact form:
where:
- : option value at the current time step
- : known option values at the next time step
- : weighting coefficients for the grid points
The coefficients are:
where:
- : time step size
- : volatility
- : risk-free rate
- : grid index ()
The option value at each interior point depends only on three values at the next time step, which we already know from either the terminal condition or previous calculations. Intuitively, this weighted sum resembles an expected value calculation: and represent the weights (pseudo-probabilities) of the asset price moving down or up, while is the weight of staying effectively in the same region, all adjusted for the risk-free discounting. This probabilistic interpretation connects finite difference methods to the binomial tree approach, where we also computed option values as discounted expected values under risk-neutral probabilities. The explicit scheme essentially implements the same logic on a finer grid.
Implementation
The explicit scheme proceeds as follows:
- Initialize the grid with the terminal payoff at expiration
- Apply boundary conditions at and
- Sweep backward through time, calculating each from values at
def explicit_european_call(S_max, K, T, r, sigma, M, N):
"""
Price a European call option using the explicit finite difference method.
Parameters:
S_max: Maximum stock price on grid
K: Strike price
T: Time to expiration
r: Risk-free rate
sigma: Volatility
M: Number of price steps
N: Number of time steps
Returns:
S: Array of stock prices
V: Array of option values at t=0
"""
dS = S_max / M
dt = T / N
# Grid of stock prices
S = np.linspace(0, S_max, M + 1)
# Initialize option values at expiration (terminal condition)
V = np.maximum(S - K, 0) # Call payoff
# Precompute coefficients for interior points
j = np.arange(1, M) # Interior indices
a = 0.5 * dt * (sigma**2 * j**2 - r * j)
b = 1 - dt * (sigma**2 * j**2 + r)
c = 0.5 * dt * (sigma**2 * j**2 + r * j)
# Time stepping (backward from T to 0)
for n in range(N - 1, -1, -1):
V_new = np.zeros(M + 1)
# Interior points: explicit update
V_new[1:M] = a * V[0 : M - 1] + b * V[1:M] + c * V[2 : M + 1]
# Boundary conditions
V_new[0] = 0 # Call worth 0 when S = 0
V_new[M] = S_max - K * np.exp(-r * (N - n) * dt) # Linear approximation
V = V_new
return S, V# Parameters
r = 0.05 # Risk-free rate
sigma = 0.2 # Volatility
S_0 = 100 # Current stock price
# Price the option with explicit method
S_grid, V_explicit = explicit_european_call(S_max, K, T, r, sigma, M, N=5000)
# Find the option value at S_0 = 100
idx = np.argmin(np.abs(S_grid - S_0))
price_explicit = V_explicit[idx]Explicit FD price at S = 100: $10.4409
The calculated option price represents the fair value derived from the explicit finite difference grid. Since the grid is relatively fine (5000 time steps), this value closely approximates the theoretical Black-Scholes price, serving as a baseline for verifying the numerical method's accuracy.
Stability Constraint
The explicit scheme has a critical limitation. It becomes unstable if the time step is too large. This instability arises because the coefficients must behave like probabilities to ensure the solution remains bounded. When we interpret these coefficients as weights in an expected value calculation, they should all be non-negative for the scheme to behave sensibly. If is too large, becomes negative, causing errors to oscillate and grow exponentially with each time step. Small numerical errors introduced by rounding or discretization get amplified rather than damped, eventually overwhelming the true solution. The stability condition requires:
where:
- : maximum allowable time step
- : volatility
- : risk-free rate
- : maximum grid index ()
In practice, this means:
where:
- : maximum stable time step
- : price grid spacing
- : volatility
- : maximum price on the grid
This constraint can be severe because the bound depends on the square of the price grid spacing. Halving to improve spatial resolution requires dividing by four to maintain stability. For typical parameters, the explicit scheme may require thousands of time steps to remain stable, making it computationally expensive despite its conceptual simplicity. This stability restriction motivates the development of implicit methods that remove or relax this constraint.
# Check stability condition
def check_explicit_stability(S_max, sigma, r, M, dt):
"""Check if explicit scheme parameters satisfy stability condition."""
j_max = M
dt_max = 1.0 / (sigma**2 * j_max**2 + r)
is_stable = dt <= dt_max
return is_stable, dt_max# Check stability for our parameters
dt_check = T / 5000
is_stable, dt_max = check_explicit_stability(S_max, sigma, r, M, dt_check)
min_steps_required = int(np.ceil(T / dt_max))Time step used: 0.000200 Maximum stable time step: 0.002500 Stability satisfied: True Minimum time steps required: 401
The stability requirement explains why we used 5,000 time steps in our implementation. Using fewer steps would cause the solution to oscillate wildly and diverge from the true option value.

