Overview

Implemented a comprehensive trinomial-tree pricing engine for European and American options with early-exercise handling, Greeks computation, and Black–Scholes convergence validation.

Period: Sep 2025 – Dec 2025
Organization: Paris Dauphine University – PSL
Type: Academic Project
Language: Python

Project Goals

Develop a production-quality option pricing engine that:

Trinomial Tree Methodology

Why Trinomial Trees?

Trinomial trees offer advantages over binomial trees:

Tree Construction

At each node, the stock price can move to three possible states:

\[S_u = S \cdot e^{\lambda \sigma \sqrt{\Delta t}}\] \[S_m = S\] \[S_d = S \cdot e^{-\lambda \sigma \sqrt{\Delta t}}\]

Where $\lambda$ is typically set to $\sqrt{3}$ for optimal stability.

Risk-Neutral Probabilities

The transition probabilities are chosen to match the mean and variance:

\[p_u = \frac{1}{2\lambda^2} + \frac{r - q - \frac{1}{2}\sigma^2}{2\lambda\sigma}\sqrt{\Delta t}\] \[p_d = \frac{1}{2\lambda^2} - \frac{r - q - \frac{1}{2}\sigma^2}{2\lambda\sigma}\sqrt{\Delta t}\] \[p_m = 1 - p_u - p_d\]

Key Features

Option Pricing

European Options

American Options

Greeks Computation

Calculated using finite differences from the tree:

Validation Framework

Black-Scholes Convergence

For European options, the trinomial tree should converge to Black-Scholes:

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

Validation includes:

Known Analytical Results

Technical Implementation

Code Structure

class TrinomialTree:
    """
    Trinomial tree pricer for European and American options.
    """
    def __init__(self, S0, K, T, r, sigma, q=0, N=100):
        # Initialize parameters
        
    def build_tree(self):
        # Construct price tree
        
    def price_european(self, option_type='call'):
        # European option pricing
        
    def price_american(self, option_type='call'):
        # American option with early exercise
        
    def compute_greeks(self):
        # Calculate all Greeks
        
    def validate_convergence(self):
        # Compare with Black-Scholes

Key Algorithms

  1. Tree Building: Forward pass to construct price lattice
  2. Backward Induction: Value propagation from maturity to present
  3. Early Exercise Check: American option comparison
  4. Greeks via Perturbation: Finite difference approximation

Technical Stack

Results

Convergence Analysis

Steps (N) Tree Price Black-Scholes Error
50 10.452 10.451 0.001
100 10.451 10.451 <0.001
200 10.451 10.451 <0.001

Greeks Accuracy

Greeks computed via finite differences show good agreement with analytical Greeks from Black-Scholes model.

American Option Early Exercise

Successfully identifies optimal exercise boundary:

Key Features of Implementation

Numerical Stability

Performance Optimization

API Design

# Simple pricing API
pricer = TrinomialTree(S0=100, K=100, T=1.0, r=0.05, sigma=0.2)
european_call = pricer.price_european('call')
american_put = pricer.price_american('put')
greeks = pricer.compute_greeks()

Educational Value

This project demonstrates:

Extensions Implemented

Beyond basic trinomial trees:

Challenges Overcome

  1. Probability Constraints: Ensuring valid probabilities across all parameter ranges
  2. Early Exercise Logic: Correct implementation of American option early exercise
  3. Greeks Accuracy: Choosing appropriate perturbation sizes for finite differences
  4. Convergence Validation: Statistical testing of convergence behavior

Future Enhancements

Applications

Key Learnings

  1. Trees vs. Closed-Form: Trees are flexible but require convergence analysis
  2. American vs. European: Early exercise adds complexity but also value
  3. Greeks from Trees: Finite differences work well with sufficient steps
  4. Validation is Critical: Always compare numerical methods to known benchmarks

Academic Foundation

This implementation is based on:

This project exemplifies the bridge between financial mathematics theory and practical implementation, providing a robust foundation for understanding derivative pricing and numerical methods in quantitative finance.