Finite Difference Methods for Option Pricing › The Implicit Finite Difference Scheme
Quantitative FinanceAll chapters 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 rather than the future time step . This small change significantly improves numerical stability. Rather than computing values at time directly from known values at , the implicit scheme requires solving for all values at 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):
where:
- : option value at grid point and current time step
- : option value at grid point and next time step
- : time step size
Spatial derivatives at time :
where:
- : option values at current time (unknowns)
- : price step size
The distinction from the explicit scheme is that these spatial derivatives use values at time , which are the unknowns we seek to determine. This creates a coupling between neighboring grid points at the same time level: to find , we need and , but these values are also unknown.
The Tridiagonal System
Because all values at time 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:
where:
- : unknown option values at current time
- : known option value at next time
We multiply by and isolate :
Grouping the unknown terms at by spatial index:
Defining coefficients to simplify notation, we obtain the linear system:
where:
- : unknown values at current time
- : known value at next time
- : coefficients for the implicit system
The coefficients are:
where:
- : time step
- : volatility
- : risk-free rate
- : spatial index corresponding to
Unlike the explicit scheme, we cannot directly calculate from . Instead, we must solve a system of linear equations at each time step. For the interior points, this forms a tridiagonal matrix equation:
where:
- : tridiagonal coefficient matrix
- : vector of option values at time (unknowns)
- : vector of known option values at time
- : vector incorporating boundary conditions
The Tridiagonal Matrix Structure
The matrix has the form:
where:
- : coefficients defined previously
- : 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 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 operations per time step, making the implicit scheme practical even though it requires solving a linear system.

Implementation
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# 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]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 and . 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.