path-integral-default-intensity-pricing

name	path-integral-default-intensity-pricing
category	finance
description	Path-integral formalism for semi-analytical pricing of default intensity models in quantitative finance. Enables accurate derivatives pricing (CDS, XVA) under stochastic default intensity without full numerical simulation.
tags	["quantitative-finance","path-integral","credit-risk","derivatives-pricing","stochastic-calculus","quantum-mechanics"]
activation	path integral pricing, default intensity model, credit default swap pricing, semi-analytical pricing, XVA computation, stochastic intensity, quantum finance, Black-Karasinski pricing, quanto CDS

Path-Integral Default Intensity Pricing

Overview

This skill implements semi-analytical pricing for general default intensity models using path-integral formalism. Based on the paper "Semi-Analytical Pricing for General Default Intensity Models" (arXiv:2606.21800), this approach provides remarkably accurate results for credit derivatives pricing, even under high volatility and multi-year time horizons.

Key insight: The path-integral formalism from quantum mechanics can be adapted to financial default intensity modeling, providing computationally efficient alternatives to fully numerical schemes for XVA and credit product pricing.

Core Methodology

1. Default Intensity Framework

Default intensity (hazard rate) models describe the instantaneous probability of default conditional on survival. The survival probability over time T is:

S(T) = E[exp(-∫₀ᵀ λ(t) dt)]

where λ(t) is the stochastic default intensity process.

2. Path-Integral Formulation

The path-integral approach computes expectations over all possible paths of the intensity process:

S(T) = ∫ D[λ] exp(-S[λ])

where S[λ] is the action functional of the intensity process, analogous to quantum mechanical path integrals.

3. Semi-Analytical Approximation

The key contribution is an accurate, easy-to-compute approximation that:

• Handles general default intensity dynamics (not limited to specific models)
• Maintains accuracy under high volatility regimes
• Scales efficiently to multi-year time horizons
• Provides closed-form or semi-closed-form expressions

4. Black-Karasinski Model Application

For the Black-Karasinski model where:

d ln(λ(t)) = κ(θ - ln(λ(t))) dt + σ dW(t)

The path-integral approximation provides remarkably accurate CDS spread and survival probability calculations.

Implementation

Python Implementation

import numpy as np
from scipy.integrate import quad
from scipy.optimize import minimize_scalar

class PathIntegralDefaultPricing:
    """Semi-analytical pricing using path-integral formalism."""
    
    def __init__(self, model_params):
        """
        Initialize with model parameters.
        
        Args:
            model_params: dict with model-specific parameters
                For Black-Karasinski:
                - kappa: mean reversion speed
                - theta: long-term mean of log intensity
                - sigma: volatility of log intensity
                - lambda_0: initial intensity
        """
        self.params = model_params
    
    def survival_probability(self, T, n_steps=100):
        """
        Compute survival probability using path-integral approximation.
        
        Args:
            T: Time horizon
            n_steps: Number of discretization steps
        
        Returns:
            Survival probability S(T)
        """
        kappa = self.params['kappa']
        theta = self.params['theta']
        sigma = self.params['sigma']
        lam0 = self.params['lambda_0']
        
        # Path-integral approximation for BK model
        # Effective action for the intensity process
        dt = T / n_steps
        t = np.linspace(0, T, n_steps)
        
        # Mean path (classical trajectory)
        ln_lam_mean = theta + (np.log(lam0) - theta) * np.exp(-kappa * t)
        
        # Variance of the path integral
        var_path = sigma**2 / ( * kappa) * ( - np.exp(- * kappa * T))
        
        
        
        expected_integral = np.trapz(np.exp(ln_lam_mean + var_path / ), t)
        
         np.exp(-expected_integral)
    
     ():
        
        
        
        
        protection_leg = ( - recovery_rate) * ( - .survival_probability(T_maturity, n_steps))
        
        
        dt = T_maturity / n_steps
        t = np.linspace(dt, T_maturity, n_steps)
        survival = np.array([.survival_probability(ti, n_steps)  ti  t])
        
        
        r = .params.get(, )
        discount = np.exp(-r * t)
        
        premium_leg = np.trapz(discount * survival, t)
        
        
        spread = protection_leg / (premium_leg + )
         spread *   
    
     ():
        
        
        
        
        
        
        sigma = .params[]
        base_spread = .cds_spread(T_maturity, recovery_rate, n_steps)
        
        
        quanto_adj = np.exp(fx_correlation * sigma * fx_vol * T_maturity)
        
         base_spread * quanto_adj

Usage Example

# Black-Karasinski model parameters
params = {
    'kappa': 0.5,        # Mean reversion speed
    'theta': -3.0,       # Long-term mean of log intensity
    'sigma': 0.3,        # Volatility
    'lambda_0': 0.01,    # Initial default intensity (1%)
    'risk_free_rate': 0.03,
}

pricer = PathIntegralDefaultPricing(params)

# 5-year survival probability
S_5y = pricer.survival_probability(5.0)
print(f"5Y Survival Probability: {S_5y:.4f}")

# 5Y CDS spread
spread = pricer.cds_spread(5.0)
print(f"5Y CDS Spread: {spread:.1f} bps")

# Quanto CDS with FX risk
quanto_spread = pricer.quanto_cds_price(5.0, fx_vol=0.15, fx_correlation=-0.3)
print(f"5Y Quanto CDS Spread: {quanto_spread:.1f} bps")

Key Applications

1. Credit Default Swap (CDS) Pricing: Fast and accurate CDS spread computation under stochastic intensity
2. XVA Computation: CVA, DVA, FVA calculations for credit portfolios
3. Quanto CDS Pricing: Joint modeling of credit and FX risk
4. Bond Pricing: Defaultable bond valuation under stochastic default
5. Credit Portfolio Risk: Portfolio-level credit risk metrics

Advantages Over Numerical Methods

Feature	Path-Integral	Monte Carlo	PDE Methods
Speed	✓✓✓ (semi-analytical)	✗ (slow)	✓ (moderate)
High Volatility	✓✓ (stable)	✓ (converges)	✗ (unstable)
Multi-year Horizon	✓✓ (accurate)	✓ (slow)	✗ (dimensional curse)
General Models	✓ (flexible)	✓ (flexible)	✗ (model-specific)

Model Extensions

Multi-Factor Intensity Models

class MultiFactorPathIntegralPricing:
    """Extension to multi-factor default intensity models."""
    
    def __init__(self, factors):
        """
        Args:
            factors: list of (kappa, theta, sigma, weight) tuples
        """
        self.factors = factors
    
    def combined_intensity(self, t):
        """Compute combined intensity from all factors."""
        lam = 0
        for kappa, theta, sigma, weight in self.factors:
            lam += weight * np.exp(theta)  # Simplified
        return lam

Stochastic Recovery

def cds_with_stochastic_recovery(self, T, recovery_mean=0.4, recovery_vol=0.1):
    """CDS pricing with stochastic recovery rate."""
    # Joint path integral over intensity and recovery
    base_spread = self.cds_spread(T)
    recovery_adj = 1 + recovery_vol**2 * T  # Second-order correction
    return base_spread * recovery_adj

Validation & Testing

def validate_against_monte_carlo(n_sims=10000):
    """Validate path-integral approximation against Monte Carlo."""
    params = {'kappa': 0.5, 'theta': -3.0, 'sigma': 0.3, 'lambda_0': 0.01}
    pricer = PathIntegralDefaultPricing(params)
    
    # Monte Carlo simulation
    T = 5.0
    dt = T / 252
    n_steps = int(T / dt)
    
    survivals = []
    for _ in range(n_sims):
        ln_lam = np.log(params['lambda_0'])
        integral = 0
        for _ in range(n_steps):
            dW = np.random.randn() * np.sqrt(dt)
            ln_lam += params['kappa'] * (params['theta'] - ln_lam) * dt + params['sigma'] * dW
            integral += np.exp(ln_lam) * dt
        survivals.append(np.exp(-integral))
    
    mc_survival = np.mean(survivals)
    pi_survival = pricer.survival_probability(T)
    
    print(f"MC Survival:     {mc_survival:.6f}")
    print(f"PI Survival:     {pi_survival:.6f}")
    print(f"Relative Error:  {abs(mc_survival - pi_survival)/mc_survival*100:.4f}%")

validate_against_monte_carlo()

References

• Parker, R., Stedman, M., & Capriotti, L. (2026). "Semi-Analytical Pricing for General Default Intensity Models." arXiv:2606.21800. Published in Risk Magazine, July 2025.
• Path-integral methods in finance: Baaquie (2007) "Interest Rates and Coupon Bond in Quantum Finance"
• Black-Karasinski model: Black & Karasinski (1991) "Bond and Option Pricing when Short Rates are Lognormal"

Activation Keywords

path integral pricing, default intensity model, credit default swap pricing, semi-analytical pricing, XVA computation, stochastic intensity, quantum finance, Black-Karasinski pricing, quanto CDS, credit risk modeling, hazard rate model, survival probability