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

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

Book contents

Section 4 of 14 · 9 min read

Finite Difference Methods for Option Pricing › The Implicit Finite Difference SchemeOne section · Sections in this chapter4 / 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 implicit scheme overcomes the stability limitation by evaluating the spatial derivatives at the current time step tnt_n rather than the future time step tn+1t_{n+1}. This small change significantly improves numerical stability. Rather than computing values at time tnt_n directly from known values at tn+1t_{n+1}, the implicit scheme requires solving for all values at tnt_n simultaneously, since the update formula for each point involves unknown values at neighboring points at the same time level.

Derivative Approximations

The implicit scheme uses the same time derivative approximation as the explicit scheme but evaluates the spatial derivatives at a different time level. The implicit scheme uses:

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

Spatial derivatives at time tnt_n:

∂V∂S≈Vj+1n−Vj−1n2ΔS∂2V∂S2≈Vj+1n−2Vjn+Vj−1n(ΔS)2\begin{aligned} \frac{\partial V}{\partial S} &\approx \frac{V_{j+1}^n - V_{j-1}^n}{2\Delta S} \\[1em] \frac{\partial^2 V}{\partial S^2} &\approx \frac{V_{j+1}^n - 2V_j^n + V_{j-1}^n}{(\Delta S)^2} \end{aligned}

where:

  • Vj⋅nV_{j\cdot}^n: option values at current time tnt_n (unknowns)
  • ΔS\Delta S: price step size

The distinction from the explicit scheme is that these spatial derivatives use values at time tnt_n, which are the unknowns we seek to determine. This creates a coupling between neighboring grid points at the same time level: to find VjnV_j^n, we need Vj−1nV_{j-1}^n and Vj+1nV_{j+1}^n, but these values are also unknown.

The Tridiagonal System

Because all values at time tnt_n are coupled together, we cannot compute them one at a time. Instead, we must solve a system of linear equations simultaneously. Substituting the approximations into the Black-Scholes PDE:

Vjn+1−VjnΔt+12σ2Sj2Vj+1n−2Vjn+Vj−1n(ΔS)2+rSjVj+1n−Vj−1n2ΔS−rVjn=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 - 2V_j^n + V_{j-1}^n}{(\Delta S)^2} \\ &+ rS_j\frac{V_{j+1}^n - V_{j-1}^n}{2\Delta S} - rV_j^n = 0 \end{aligned}

where:

  • V⋅nV_{\cdot}^n: unknown option values at current time tnt_n
  • Vjn+1V_j^{n+1}: known option value at next time tn+1t_{n+1}

We multiply by Δt\Delta t and isolate Vjn+1V_j^{n+1}:

Vjn+1=Vjn−Δt[12σ2Sj2Vj+1n−2Vjn+Vj−1n(ΔS)2+rSjVj+1n−Vj−1n2ΔS−rVjn]V_j^{n+1} = V_j^n - \Delta t \left[ \frac{1}{2}\sigma^2 S_j^2 \frac{V_{j+1}^n - 2V_j^n + V_{j-1}^n}{(\Delta S)^2} + rS_j\frac{V_{j+1}^n - V_{j-1}^n}{2\Delta S} - rV_j^n \right]

Grouping the unknown terms at tnt_n by spatial index:

Vjn+1=[−Δt2(ΔS)2σ2Sj2+Δt2ΔSrSj]Vj−1n+[1+Δt(ΔS)2σ2Sj2+Δtr]Vjn+[−Δt2(ΔS)2σ2Sj2−Δt2ΔSrSj]Vj+1n\begin{aligned} V_j^{n+1} &= \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 \\ &\quad + \left[ 1 + \frac{\Delta t}{(\Delta S)^2}\sigma^2 S_j^2 + \Delta t r \right] V_j^n \\ &\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 \end{aligned}

Defining coefficients αj,βj,γj\alpha_j, \beta_j, \gamma_j to simplify notation, we obtain the linear system:

−αjVj−1n+(1+βj)Vjn−γjVj+1n=Vjn+1-\alpha_j V_{j-1}^n + (1 + \beta_j) V_j^n - \gamma_j V_{j+1}^n = V_j^{n+1}

where:

  • V⋅nV_{\cdot}^n: unknown values at current time tnt_n
  • Vjn+1V_j^{n+1}: known value at next time tn+1t_{n+1}
  • αj,βj,γj\alpha_j, \beta_j, \gamma_j: coefficients for the implicit system

The coefficients are:

αj=Δt2(σ2j2−rj)βj=Δt(σ2j2+r)γj=Δt2(σ2j2+rj)\begin{aligned} \alpha_j &= \frac{\Delta t}{2}\left(\sigma^2 j^2 - rj\right) \\ \beta_j &= \Delta t\left(\sigma^2 j^2 + r\right) \\ \gamma_j &= \frac{\Delta t}{2}\left(\sigma^2 j^2 + rj\right) \end{aligned}

where:

  • Δt\Delta t: time step
  • σ\sigma: volatility
  • rr: risk-free rate
  • jj: spatial index corresponding to SjS_j

Unlike the explicit scheme, we cannot directly calculate VjnV_j^n from Vjn+1V_j^{n+1}. Instead, we must solve a system of linear equations at each time step. For the M−1M-1 interior points, this forms a tridiagonal matrix equation:

AVn=Vn+1+b\mathbf{A}\mathbf{V}^n = \mathbf{V}^{n+1} + \mathbf{b}

where:

  • A\mathbf{A}: tridiagonal coefficient matrix
  • Vn\mathbf{V}^n: vector of option values at time tnt_n (unknowns)
  • Vn+1\mathbf{V}^{n+1}: vector of known option values at time tn+1t_{n+1}
  • b\mathbf{b}: vector incorporating boundary conditions

The Tridiagonal Matrix Structure

The matrix A\mathbf{A} has the form:

A=(1+β1−γ10⋯0−α21+β2−γ2⋯00−α31+β3⋯0⋮⋱⋱⋱⋮00⋯−αM−11+βM−1)\mathbf{A} = \begin{pmatrix} 1 + \beta_1 & -\gamma_1 & 0 & \cdots & 0 \\ -\alpha_2 & 1 + \beta_2 & -\gamma_2 & \cdots & 0 \\ 0 & -\alpha_3 & 1 + \beta_3 & \cdots & 0 \\ \vdots & \ddots & \ddots & \ddots & \vdots \\ 0 & 0 & \cdots & -\alpha_{M-1} & 1 + \beta_{M-1} \end{pmatrix}

where:

  • αj,βj,γj\alpha_j, \beta_j, \gamma_j: coefficients defined previously
  • MM: number of spatial grid intervals

The tridiagonal structure arises because each interior equation involves only three unknowns: the value at the current grid point and its two immediate neighbors. This sparse structure is extremely important computationally because it allows efficient solution algorithms. By coupling all VjnV_j^n values in a single system, the implicit method allows information to propagate across the entire grid instantaneously, mirroring the infinite propagation speed of the diffusion equation. In contrast, the explicit scheme propagates information only one grid point per time step, which is why it requires the stability constraint. This global dependency ensures errors are damped rather than amplified, and gives unconditional stability. Tridiagonal systems can be solved very efficiently using the Thomas algorithm (a specialized form of Gaussian elimination), requiring only O(M)O(M) operations per time step, making the implicit scheme practical even though it requires solving a linear system.

Out[12]:
Visualization
Heatmap showing the sparsity pattern of a tridiagonal matrix with non-zero values only on three diagonals.
Structure of the tridiagonal matrix in the implicit finite difference scheme. Non-zero entries appear only on the main diagonal and the two adjacent diagonals, enabling efficient O(M) solution using the Thomas algorithm.

Implementation

In[13]:
Code
def thomas_algorithm(a, b, c, d):
    """
    Solve tridiagonal system using the Thomas algorithm.

    Solves Ax = d where A has:
        - a: sub-diagonal (length n-1)
        - b: main diagonal (length n)
        - c: super-diagonal (length n-1)
    """
    n = len(b)
    c_prime = np.zeros(n - 1)
    d_prime = np.zeros(n)

    # Forward sweep
    c_prime[0] = c[0] / b[0]
    d_prime[0] = d[0] / b[0]

    for i in range(1, n - 1):
        denom = b[i] - a[i - 1] * c_prime[i - 1]
        c_prime[i] = c[i] / denom
        d_prime[i] = (d[i] - a[i - 1] * d_prime[i - 1]) / denom

    d_prime[n - 1] = (d[n - 1] - a[n - 2] * d_prime[n - 2]) / (
        b[n - 1] - a[n - 2] * c_prime[n - 2]
    )

    # Back substitution
    x = np.zeros(n)
    x[n - 1] = d_prime[n - 1]
    for i in range(n - 2, -1, -1):
        x[i] = d_prime[i] - c_prime[i] * x[i + 1]

    return x


def implicit_european_call(S_max, K, T, r, sigma, M, N):
    """
    Price a European call option using the implicit finite difference method.
    """
    dS = S_max / M
    dt = T / N

    # Grid of stock prices
    S = np.linspace(0, S_max, M + 1)

    # Initialize option values at expiration
    V = np.maximum(S - K, 0)

    # Precompute coefficients for interior points
    j = np.arange(1, M)
    alpha = 0.5 * dt * (sigma**2 * j**2 - r * j)
    beta = dt * (sigma**2 * j**2 + r)
    gamma = 0.5 * dt * (sigma**2 * j**2 + r * j)

    # Build tridiagonal matrix coefficients
    a = -alpha[1:]  # Sub-diagonal (length M-2)
    b = 1 + beta  # Main diagonal (length M-1)
    c = -gamma[:-1]  # Super-diagonal (length M-2)

    # Time stepping
    for n in range(N - 1, -1, -1):
        # Right-hand side
        d = V[1:M].copy()

        # Boundary condition adjustments
        d[0] += alpha[0] * 0  # V[0] = 0 for call
        boundary_M = S_max - K * np.exp(-r * (N - n) * dt)
        d[-1] += gamma[-1] * boundary_M

        # Solve tridiagonal system
        V[1:M] = thomas_algorithm(a, b, c, d)

        # Update boundaries
        V[0] = 0
        V[M] = boundary_M

    return S, V
In[14]:
Code
# Price with implicit method (can use fewer time steps due to unconditional stability)
S_grid, V_implicit = implicit_european_call(S_max, K, T, r, sigma, M, N=500)

idx = np.argmin(np.abs(S_grid - S_0))
price_implicit = V_implicit[idx]
Out[15]:
Console
Implicit FD price at S = 100: $10.4386
Time steps used: 500 (vs 5000 for explicit)

The implicit method yields a price very close to the explicit method but achieves this using only 500 time steps, one-tenth of the effort required for the explicit scheme. This efficiency demonstrates the practical benefit of unconditional stability.

Unconditional Stability

The implicit scheme is unconditionally stable, meaning it produces bounded solutions for any choice of Δt\Delta t and ΔS\Delta S. This property allows you to use much larger time steps, dramatically reducing computation. Although each time step requires solving a linear system, the overall efficiency often surpasses the explicit scheme because far fewer time steps are needed.

The stability comes from the implicit treatment of the spatial derivatives. Mathematically, when we analyze the amplification factor of the numerical scheme, the implicit treatment ensures that errors decay rather than grow over time. Any errors introduced in one time step are damped rather than amplified in subsequent steps. The price we pay for this stability is the need to solve a linear system at each time step, but for tridiagonal systems this cost is minimal.