Finite Difference Methods for Option Pricing › The Explicit Finite Difference Scheme

Michael BrenndoerferDecember 4, 202511 min read
Quantitative FinanceAll chapters
Part 6 of 15Numerical Methods for Derivative Pricing
Chapter 36Finite Difference Methods for Option Pricing › The Explicit Finite Difference Scheme
Reading section 3 of 14 · The Explicit Finite Difference Scheme · 11 minSection 3 of 14 · 11 min

Book contents

Section 3 of 14 · 11 min read

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 (Sj,tn+1)(S_j, t_{n+1}), the approximations are:

Time derivative (backward difference):

∂V∂t≈Vjn+1−VjnΔt\frac{\partial V}{\partial t} \approx \frac{V_j^{n+1} - V_j^n}{\Delta t}

where:

  • VjnV_j^n: option value at grid point jj and current time step nn
  • Vjn+1V_j^{n+1}: option value at grid point jj and next time step n+1n+1
  • Δt\Delta t: 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 Δt\Delta t instead. The error in this approximation is proportional to Δt\Delta t, meaning we achieve first-order accuracy in time.

First spatial derivative (central difference):

∂V∂S≈Vj+1n+1−Vj−1n+12ΔS\frac{\partial V}{\partial S} \approx \frac{V_{j+1}^{n+1} - V_{j-1}^{n+1}}{2\Delta S}

where:

  • Vj±1n+1V_{j\pm 1}^{n+1}: option values at adjacent spatial points at time tn+1t_{n+1}
  • ΔS\Delta S: 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):

∂2V∂S2≈Vj+1n+1−2Vjn+1+Vj−1n+1(ΔS)2\frac{\partial^2 V}{\partial S^2} \approx \frac{V_{j+1}^{n+1} - 2V_j^{n+1} + V_{j-1}^{n+1}}{(\Delta S)^2}

where:

  • Vj±1n+1V_{j\pm 1}^{n+1}: option values at adjacent spatial points
  • ΔS\Delta S: 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 tn+1t_{n+1}. This makes the scheme "explicit" because we can directly calculate VjnV_j^n from known values at tn+1t_{n+1} 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 VjnV_j^n:

Vjn+1−VjnΔt+12σ2Sj2Vj+1n+1−2Vjn+1+Vj−1n+1(ΔS)2+rSjVj+1n+1−Vj−1n+12ΔS−rVjn+1=0\begin{aligned} \frac{V_j^{n+1} - V_j^n}{\Delta t} &+ \frac{1}{2}\sigma^2 S_j^2 \frac{V_{j+1}^{n+1} - 2V_j^{n+1} + V_{j-1}^{n+1}}{(\Delta S)^2} \\ &+ rS_j\frac{V_{j+1}^{n+1} - V_{j-1}^{n+1}}{2\Delta S} - rV_j^{n+1} = 0 \end{aligned}

where:

  • VjnV_j^n: unknown option value at current time step nn
  • V⋅n+1V_{\cdot}^{n+1}: known option values at next time step n+1n+1
  • SjS_j: asset price at grid point jj
  • Δt,ΔS\Delta t, \Delta S: time and price step sizes
  • r,σr, \sigma: risk-free rate and volatility

Our objective is to isolate VjnV_j^n on one side of the equation, expressing it in terms of known quantities. Multiplying by Δt\Delta t and rearranging to isolate VjnV_j^n:

Vjn=Vjn+1+Δt(12σ2Sj2Vj+1n+1−2Vjn+1+Vj−1n+1(ΔS)2+rSjVj+1n+1−Vj−1n+12ΔS−rVjn+1)\begin{aligned} V_j^n = V_j^{n+1} + \Delta t \bigg( &\frac{1}{2}\sigma^2 S_j^2 \frac{V_{j+1}^{n+1} - 2V_j^{n+1} + V_{j-1}^{n+1}}{(\Delta S)^2} \\ &+ rS_j\frac{V_{j+1}^{n+1} - V_{j-1}^{n+1}}{2\Delta S} - rV_j^{n+1} \bigg) \end{aligned}

where:

  • VjnV_j^n: option value at the current time step
  • Δt\Delta t: 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 Vj−1n+1V_{j-1}^{n+1}, Vjn+1V_j^{n+1}, and Vj+1n+1V_{j+1}^{n+1}:

Vjn=[Δt2(ΔS)2σ2Sj2−Δt2ΔSrSj]Vj−1n+1+[1−Δt(ΔS)2σ2Sj2−Δtr]Vjn+1+[Δt2(ΔS)2σ2Sj2+Δt2ΔSrSj]Vj+1n+1\begin{aligned} V_j^n &= \left[ \frac{\Delta t}{2(\Delta S)^2}\sigma^2 S_j^2 - \frac{\Delta t}{2\Delta S}rS_j \right] V_{j-1}^{n+1} \\ &\quad + \left[ 1 - \frac{\Delta t}{(\Delta S)^2}\sigma^2 S_j^2 - \Delta t r \right] V_j^{n+1} \\ &\quad + \left[ \frac{\Delta t}{2(\Delta S)^2}\sigma^2 S_j^2 + \frac{\Delta t}{2\Delta S}rS_j \right] V_{j+1}^{n+1} \end{aligned}

where:

  • VjnV_j^n: option value at the current time step
  • Δt\Delta t: time step size
  • ΔS\Delta S: price step size
  • σ\sigma: volatility
  • rr: risk-free rate
  • SjS_j: asset price at grid point jj
  • V⋅n+1V_{\cdot}^{n+1}: 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 Sj=jΔSS_j = j\Delta S, these bracketed terms simplify to a more compact form:

Vjn=ajVj−1n+1+bjVjn+1+cjVj+1n+1V_j^n = a_j V_{j-1}^{n+1} + b_j V_j^{n+1} + c_j V_{j+1}^{n+1}

where:

  • VjnV_j^n: option value at the current time step nn
  • Vj−1n+1,Vjn+1,Vj+1n+1V_{j-1}^{n+1}, V_j^{n+1}, V_{j+1}^{n+1}: known option values at the next time step n+1n+1
  • aj,bj,cja_j, b_j, c_j: weighting coefficients for the grid points

The coefficients are:

aj=Δt2(σ2j2−rj)bj=1−Δt(σ2j2+r)cj=Δt2(σ2j2+rj)\begin{aligned} a_j &= \frac{\Delta t}{2}\left(\sigma^2 j^2 - rj\right) \\ b_j &= 1 - \Delta t\left(\sigma^2 j^2 + r\right) \\ c_j &= \frac{\Delta t}{2}\left(\sigma^2 j^2 + rj\right) \end{aligned}

where:

  • Δt\Delta t: time step size
  • σ\sigma: volatility
  • rr: risk-free rate
  • jj: grid index (j=Sj/ΔSj = S_j/\Delta S)

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: aja_j and cjc_j represent the weights (pseudo-probabilities) of the asset price moving down or up, while bjb_j 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:

  1. Initialize the grid with the terminal payoff at expiration
  2. Apply boundary conditions at S=0S = 0 and S=Smax⁡S = S_{\max}
  3. Sweep backward through time, calculating each VjnV_j^n from values at tn+1t_{n+1}
In[5]:
Code
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
In[6]:
Code
# 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]
Out[7]:
Console
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 aj,bj,cja_j, b_j, c_j 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 Δt\Delta t is too large, bjb_j 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:

Δt≤1σ2jmax⁡2+r\Delta t \leq \frac{1}{\sigma^2 j_{\max}^2 + r}

where:

  • Δt\Delta t: maximum allowable time step
  • σ\sigma: volatility
  • rr: risk-free rate
  • jmax⁡j_{\max}: maximum grid index (MM)

In practice, this means:

Δt≤(ΔS)2σ2Smax⁡2\Delta t \leq \frac{(\Delta S)^2}{\sigma^2 S_{\max}^2}

where:

  • Δt\Delta t: maximum stable time step
  • ΔS\Delta S: price grid spacing
  • σ\sigma: volatility
  • Smax⁡S_{\max}: maximum price on the grid

This constraint can be severe because the bound depends on the square of the price grid spacing. Halving ΔS\Delta S to improve spatial resolution requires dividing Δt\Delta t 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.

In[8]:
Code
# 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
In[9]:
Code
# 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))
Out[10]:
Console
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.

Out[11]:
Visualization
Line plot showing smooth option value curve for stable explicit scheme.
Stable explicit finite difference solution. With sufficient time steps ($N=5000$), the solution (blue line) is smooth and matches the payoff and theoretical values.
Line plot showing jagged, oscillating curve for unstable explicit scheme.
Unstable explicit finite difference solution. When the stability condition is violated ($N=200$), the solution (red line) oscillates wildly and diverges from the true option values.