Quant Pricing - Options Pricing Analysis

1. Black-Scholes-Merton Model

The Black-Scholes-Merton model (1973) provides closed-form analytical solutions for European options. Under the assumption of geometric Brownian motion for the underlying asset, the option prices are given by:

European Call Option Price:

C(S_0, t) = S_0 \mathcal{N}(d_1) - K e^{-rT} \mathcal{N}(d_2)

European Put Option Price:

P(S_0, t) = K e^{-rT} \mathcal{N}(-d_2) - S_0 \mathcal{N}(-d_1)

Where the auxiliary variables are:

d_1 = \frac{\ln(S_0/K) + (r + \sigma^2/2)T}{\sigma\sqrt{T}}

d_2 = d_1 - \sigma\sqrt{T} = \frac{\ln(S_0/K) + (r - \sigma^2/2)T}{\sigma\sqrt{T}}

Parameters:

S_0

:Current stock price

K

:Strike price

T

:Time to maturity (years)

r

:Risk-free interest rate

\sigma

:Volatility (annualized)

\mathcal{N}(\cdot)

:Cumulative standard normal distribution function

Note: The Black-Scholes model assumes continuous trading, no transaction costs, constant volatility, and log-normal distribution of stock prices. It is exact only for European options.

2. The Greeks - Risk Sensitivities

The Greeks quantify how option prices change with respect to various market parameters. These are partial derivatives of the option price and are essential for risk management and hedging strategies.

Delta (Δ) - Rate of Change w.r.t. Underlying Price

\Delta = \frac{\partial V}{\partial S} = \mathcal{N}(d_1) \quad \text{(for calls)}

Delta represents the sensitivity of the option price to changes in the underlying asset price. It ranges from 0 to 1 for calls and -1 to 0 for puts. Delta is also the hedge ratio.

Gamma (Γ) - Rate of Change of Delta

\Gamma = \frac{\partial^2 V}{\partial S^2} = \frac{n(d_1)}{S_0 \sigma \sqrt{T}}

Where $n(\cdot)$ is the standard normal probability density function:

n(x) = \frac{1}{\sqrt{2\pi}} e^{-x^2/2}

Gamma measures the convexity of the option's value. High gamma means delta changes rapidly, requiring frequent rehedging.

Theta (Θ) - Time Decay

\Theta = \frac{\partial V}{\partial t} = -\frac{S_0 n(d_1) \sigma}{2\sqrt{T}} - rKe^{-rT}\mathcal{N}(d_2)

Theta measures the rate of decline in option value as time passes (time decay). Expressed per day by dividing by 365. Most options experience negative theta, especially near expiration.

Vega (ν) - Volatility Sensitivity

\nu = \frac{\partial V}{\partial \sigma} = S_0 n(d_1) \sqrt{T}

Vega measures sensitivity to changes in implied volatility. Expressed per 1% change in volatility (divided by 100). Options are most sensitive to volatility when at-the-money.

Rho (ρ) - Interest Rate Sensitivity

\rho = \frac{\partial V}{\partial r} = KT e^{-rT} \mathcal{N}(d_2)

Rho measures sensitivity to changes in the risk-free interest rate. Expressed per 1% change in rates (divided by 100). Less significant for short-dated options.

3. Binomial Tree Model (Cox-Ross-Rubinstein)

The Cox-Ross-Rubinstein (CRR) binomial tree model (1979) is a discrete-time method that models stock price evolution as a recombining tree. It can price both European and American options and converges to the Black-Scholes price as the number of steps increases.

Model Parameters:

Time step:

\Delta t = \frac{T}{N}

Up factor:

u = e^{\sigma\sqrt{\Delta t}}

Down factor:

d = \frac{1}{u} = e^{-\sigma\sqrt{\Delta t}}

Risk-neutral probability:

p = \frac{e^{r\Delta t} - d}{u - d}

Discount factor:

\text{disc} = e^{-r\Delta t}

Algorithm: Backward Induction

Initialize: Set $\Delta t = T/N$ , compute $u$ , $d$ , and $p$
Build Terminal Nodes: At maturity (step $N$ ), calculate stock prices for all $N+1$ nodes:
$S_{N,j} = S_0 \cdot u^j \cdot d^{N-j}, \quad j = 0, 1, \ldots, N$
Terminal Payoffs: Compute option values at maturity:
$V_{N,j} = \max(S_{N,j} - K, 0) \quad \text{(Call)}$
$V_{N,j} = \max(K - S_{N,j}, 0) \quad \text{(Put)}$
Backward Recursion: For each step $i = N-1, N-2, \ldots, 0$ and node $j$ :
$V_{i,j} = e^{-r\Delta t} \left[ p \cdot V_{i+1,j+1} + (1-p) \cdot V_{i+1,j} \right]$
American Exercise (Optional): For American options, at each node check early exercise:
$S_{i,j} = S_0 \cdot u^j \cdot d^{i-j}$
$V_{i,j}^{\text{American}} = \max\left(V_{i,j}^{\text{European}}, \; \text{Intrinsic Value}\right)$
Result: Option price is $V_{0,0}$ at the root node

Key Properties: The binomial tree is recombining (up-then-down = down-then-up), has $N+1$ nodes at each time step, and converges to Black-Scholes at rate $O(1/\sqrt{N})$ for European options.

4. Trinomial Tree Model (Boyle)

The Boyle (1988) trinomial tree extends the binomial model by adding a middle branch where the stock price remains unchanged. This provides better convergence properties and more flexibility in modeling.

Model Parameters (Boyle Parameterization):

Time step:

\Delta t = \frac{T}{N}

Up factor:

u = e^{\sigma\sqrt{2\Delta t}}

Down factor:

d = \frac{1}{u} = e^{-\sigma\sqrt{2\Delta t}}

Middle factor:

m = 1 \quad \text{(no change)}

Risk-Neutral Probabilities:

Auxiliary variables:

a = e^{r\Delta t / 2}, \quad b = e^{\sigma\sqrt{\Delta t/2}}

Probability of up move:

p_u = \left[\frac{a - b^{-1}}{b - b^{-1}}\right]^2

Probability of down move:

p_d = \left[\frac{b - a}{b - b^{-1}}\right]^2

Probability of middle move:

p_m = 1 - p_u - p_d

Algorithm: Trinomial Backward Induction

Initialize: Set $\Delta t = T/N$ , compute $u$ , $d$ , $p_u$ , $p_d$ , and $p_m$
Build Terminal Nodes: At maturity, trinomial tree has $2N+1$ nodes representing $j \in \{-N, \ldots, N\}$ net up moves:
$S_{N,j} = S_0 \cdot u^{\max(j,0)} \cdot d^{\max(-j,0)}$
Terminal Payoffs:
$V_{N,j} = \max(S_{N,j} - K, 0) \quad \text{(Call)}$
$V_{N,j} = \max(K - S_{N,j}, 0) \quad \text{(Put)}$
Backward Recursion: For each step $i = N-1, \ldots, 0$ with $2i+1$ nodes:
$V_{i,j} = e^{-r\Delta t} \left[ p_u \cdot V_{i+1,j+1} + p_m \cdot V_{i+1,j} + p_d \cdot V_{i+1,j-1} \right]$
American Exercise (Optional): At each node, compare with intrinsic value:
$V_{i,j}^{\text{American}} = \max\left(V_{i,j}^{\text{European}}, \; \text{Intrinsic Value}\right)$
Result: Option price is $V_{0,0}$ at the root

Advantages: Trinomial trees typically exhibit smoother convergence than binomial trees and can better model path-dependent options. The additional middle branch provides more accurate probability matching.

5. Convergence Analysis

As the number of time steps $N$ increases, both tree models converge to the continuous-time Black-Scholes price for European options. Understanding convergence behavior is crucial for selecting appropriate $N$ values.

Convergence Algorithm:

Define step range: Select $N_{\min}$ and $N_{\max}$ (e.g., 1 to 100)
Compute Black-Scholes benchmark: Calculate exact European option price $V_{\text{BS}}$
Iterate over steps: For each $N \in [N_{\min}, N_{\max}]$ :
a) Run binomial tree with $N$ steps → $V_{\text{binom}}(N)$
b) Run trinomial tree with $N$ steps → $V_{\text{trinom}}(N)$
Compute errors: Calculate absolute errors:
$\epsilon_{\text{binom}}(N) = |V_{\text{binom}}(N) - V_{\text{BS}}|$
$\epsilon_{\text{trinom}}(N) = |V_{\text{trinom}}(N) - V_{\text{BS}}|$
Visualize: Plot $V(N)$ vs $N$ with Black-Scholes reference line

Convergence Properties:

Rate of Convergence:
• Binomial tree: $O(1/\sqrt{N})$ for European options
• Trinomial tree: Generally $O(1/N)$ , faster convergence
Oscillatory Behavior: Tree prices oscillate around the Black-Scholes value due to discrete time approximation. Oscillations dampen as $N \to \infty$ .
Even/Odd Effect: Some tree models exhibit different convergence patterns for even vs. odd $N$ when $S_0 = K$ (at-the-money).
Practical Considerations:
• $N = 50-100$ : Good balance of accuracy and speed
• $N > 500$ : Diminishing returns, increased computation
• For American options: Higher $N$ often needed near exercise boundary

Richardson Extrapolation: To improve convergence, advanced techniques like Richardson extrapolation can be applied: Combine results from $N$ and $2N$ steps to achieve $O(1/N^2)$ convergence.

6. Model Validation Tests

The application performs comprehensive validation tests to ensure numerical accuracy and theoretical consistency of the implemented models.

1. Put-Call Parity (European Options):

C - P = S_0 - K e^{-rT}

Verifies the fundamental no-arbitrage relationship between European call and put prices with the same strike and maturity. Any deviation indicates pricing errors.

2. American Early Exercise Premium:

V_{\text{American}} \geq V_{\text{European}}

American options must be worth at least as much as their European counterparts due to the early exercise feature. Violations suggest algorithmic errors.

3. Tree-BS Convergence:

\lim_{N \to \infty} V_{\text{tree}}(N) = V_{\text{BS}}

For European options, tree model prices should converge to the Black-Scholes analytical solution as the number of steps increases. Typical tolerance: $< 0.01$ for $N \geq 100$ .

4. Boundary Conditions:

C(S_0, T) \geq \max(S_0 - Ke^{-rT}, 0)

P(S_0, T) \geq \max(Ke^{-rT} - S_0, 0)

Option prices must satisfy lower bounds to prevent arbitrage. Calls and puts must be worth at least their intrinsic values.

5. Probability Validity:

0 \leq p, p_u, p_m, p_d \leq 1 \quad \text{and} \quad p_u + p_m + p_d = 1

Risk-neutral probabilities must be valid (non-negative and sum to 1). Violations may occur for extreme parameter combinations.

7. Implementation & Technology Stack

Backend

• Python 3.10+
• FastAPI for REST API
• NumPy for vectorized computations
• SciPy for statistical functions

Frontend

• Next.js 14 with TypeScript
• Tailwind CSS for styling
• Plotly.js for charts
• KaTeX for LaTeX rendering

Key Assumptions:

• No dividends ( $q = 0$ )
• Constant volatility $\sigma$
• Constant risk-free rate $r$
• Frictionless markets (no transaction costs)
• Continuous trading (for Black-Scholes)
• Log-normal distribution of stock prices

Performance Optimizations:

• NumPy vectorization for terminal payoffs
• Efficient backward induction (no redundant calculations)
• Sparse convergence sampling for large N
• Client-side caching of results

Ready to Apply the Theory?

Use our interactive calculator to price options with your own parameters and visualize convergence behavior

Launch Pricing Calculator →

Theory & Documentation

Option Pricing Theory & Methods