American Option Pricing Via Least Squares Monte Carlo

Project Goal

This project implements a high-performance pricing engine for American and Bermudan options using the Least Squares Monte Carlo (LSM) approach.

The primary focus is on enhancing the standard Longstaff-Schwartz (2001) method with advanced variance reduction techniques, specifically Control Variates and Leave-One-Out (LOO) regression to reduce pricing error and in-sample bias. The engine can also be applied to other payoff structures, such as multi-asset max American calls, swing options, quantos, etc.

Features

• Core LSM Algorithm: Backward induction with regression-based continuation value estimation.
• Advanced Stochastic Processes: Simulates multi-dimensional correlated assets (GBM), Quanto asset dynamics, and path-dependent stochastic interest rates (Vasicek/Hull-White dynamics for domestic and foreign rates).
• Flexible Payoffs: Vanilla puts/calls, max calls, swing options, and Quanto options (supporting both fixed FX and stochastic rates).
• Variance and Bias Reduction: Antithetic variates, control variates (European options sampled at maturity or exercise times), and Leave-One-Out (LOO) cross-validation to eliminate look-ahead bias.
• Regression Bases: Laguerre polynomials and power polynomials for basis functions.
• Multi-Asset Support: Handles correlated assets via Cholesky decomposition.
• Benchmarks: Comparison against Binomial Trees, Finite Difference Methods (QuantLib), and Black-Scholes.
• Performance: Optimized for speed and accuracy with configurable paths and steps.

Project Structure

├── .github/
│   └── workflows/
│       ├── ci.yml              # GitHub Actions automated testing
│       └── publish.yml         # PyPI publishing pipeline
├── LSM/
│   ├── __init__.py
│   ├── algorithms.py           # Core LeastSquaresMonteCarlo engine (American & Swing)
│   ├── stochastic_processes.py # GBM, QuantoGBM, and Stochastic Rates processes
│   ├── payoffs.py              # Vanilla, MaxCall, Swing, and Quanto payoffs/features
│   ├── regression_bases.py     # Laguerre and Power polynomial bases
│   ├── control_variate.py      # Black-Scholes European prices and CV logic
│   └── binomial_tree.py        # CRR Binomial Tree for benchmarking
├── notebooks/
│   ├── demo.ipynb              # Quick start and Colab demonstration
│   └── tests.ipynb             # Benchmark tests and advanced payoffs
├── tests/
│   ├── test_lsm.py             # Pytest suite for core LSM functionality
│   ├── test_quanto.py          # Pytest suite for Quanto pricing and stochastic rates
│   └── test_swing.py           # Pytest suite for Swing option constraints and pricing
├── pyproject.toml              # Build metadata and dependencies
└── README.md

Installation

You can install the package via pip:

pip install lsm-option-pricing

Quick Start

Import the modules and create an LSM engine:

import numpy as np
from LSM.stochastic_processes import GeometricBrownianMotion
from LSM.payoffs import VanillaPayoff
from LSM.regression_bases import LaguerrePolynomials
from LSM.algorithms import LeastSquaresMonteCarlo

# Set up process, payoff, and basis
gbm = GeometricBrownianMotion(S0=36.0, r=0.06, q=0.0, sigma=0.2)
payoff = VanillaPayoff(strike=40.0, option_type="put")
basis = LaguerrePolynomials(degree=3)

# Create LSM engine and price option
lsm = LeastSquaresMonteCarlo(process=gbm, payoff_function=payoff, basis_function=basis)
price, stderr = lsm.pricer(T=1.0, n_steps=50, n_paths=10000)

print(f"American Put Price: {price:.4f} ± {stderr:.4f}")

API Reference

LeastSquaresMonteCarlo.pricer()

Prices the option using the standard Least Squares Monte Carlo algorithm. Evaluates the option by comparing immediate intrinsic value against the conditional expected continuation value.

LeastSquaresMonteCarlo.swing_pricer()

Prices a natural gas or electricity swing option with specific volume constraints. Assumes every step in the simulation grid is a valid daily exercise opportunity.

Note:

• "Bang-Bang" Exercise: Decisions are strictly all-or-nothing (0 or exactly DCQ). Partial volume exercises are not supported.
• Hard ToP Penalties: Failing to meet ToP_rights invalidates the simulation path (assigns -inf value) rather than applying a proportional cash penalty.
• No Operational Friction: Assumes immediate exercise rights without advance notice periods, resting times, or dynamic capacity limits.

Returns: A tuple (price, std_err) containing the estimated option price and the standard error.

Demo

An interactive demo showing error convergence and basic pricing is available here:

Dependencies

• Python
• NumPy
• SciPy
• Pandas (for data handling)
• Matplotlib (for plotting)
• Jupyter (for notebooks)
• QuantLib (optional, for FDM benchmarks)

License

This project is licensed under the MIT License (see the LICENSE file for details).

References

• Longstaff, F. A., and E. S. Schwartz (2001). "Valuing American Options by Simulation: A Simple Least-Squares Approach.": Seminal LSM paper.
• Broadie, M., and P. Glasserman (2004). "A Stochastic Mesh Method for Pricing High-Dimensional American Options." Journal of Computational Finance.: Multi-asset American max call benchmarks.
• Jaillet, P., Ronn, E. I., and S. Tompaidis (2004). "Valuation of Commodity-Based Swing Options.": American equivalency and European strip bounds for swing options.
• Hanfeld, M., and S. Schlüter (2016). "Operating a swing option on today's gas markets: How least squares Monte Carlo works and why it is beneficial." Working Paper.: Detailed backward induction logic for the $q_{n,t}$ offtake levels and the 2D state grid used in our swing_pricer.
• Glasserman, P. (2004). Monte Carlo Methods in Financial Engineering.: Quantos and other payoff structures, critique about LSM, etc.
• Rasmussen, H. O. (2005). "Control Variates for American Options.": Control variates for American options sampled at exercise.
• Woo, R., et al. (2019). "Leave-one-out Least Squares Monte Carlo.": Leave-one-out LSM.
• GitHub: luphord/longstaff_schwartz. "An implementation of the Longstaff-Schwartz algorithm for American option pricing.": Another LSM implementation.

Acknowledgements

• Inspiration and repository structure: luphord/longstaff_schwartz (see References).