Aggregation and Netting

from xvafoundations.xva.netting import NettingSet

# NettingSet takes a list of (num_paths, num_times) MTM tensors, one per
# trade -- the paths-first convention used throughout xvafoundations.
#
#   gross_ee()                 sum_k  mean_i max(V_k(t), 0)
#   netted_ee()                mean_i max(sum_k V_k(t), 0)
#   collateralised_ee(H, mpr)  mean_i max(V_net(t) - C(t), 0)
#
# with C(t) = max(V_net(t - mpr) - H, 0) and mpr counted in GRID STEPS.

from datetime import date

import torch
torch.set_default_dtype(torch.float64)   # the library is float64 throughout

from xvafoundations.calibration import Stripper
from xvafoundations.conventions import DayCount, year_fraction
from xvafoundations.data.sofr import INSTRUMENTS, VALUATION_DATE
from xvafoundations.instruments import (build_instruments,
                                        pillar_maturities, initial_rates)
from xvafoundations.models import HullWhite1F
from xvafoundations.pricing import SwapSpec, reprice_swap_paths
from xvafoundations.xva.netting import NettingSet

t0 = torch.tensor(0.0)

# The SOFR OIS curve of IR-01, rebuilt here so this block runs alone.
pillars = torch.tensor(pillar_maturities(INSTRUMENTS, VALUATION_DATE))
rates = torch.tensor(initial_rates(INSTRUMENTS))
stripper = Stripper(pillars, rates, instrument_factory=lambda c:
                    build_instruments(INSTRUMENTS, VALUATION_DATE, c))
stripper.calibrate()
curve = stripper.get_curve()

# ACT/360 year fractions of an annual 15-January schedule, so 10Y
# matures at 10.144444, not 10.0.
def annual_schedule(years):
    v0 = VALUATION_DATE
    return tuple(year_fraction(v0, date(v0.year + 1 + k, v0.month, v0.day),
                               DayCount.ACT360)
                 for k in range(years))

# a and sigma are ASSERTED, not calibrated: IR-05 and IR-06 are
# unwritten. They are in the range a USD desk would see, and the shapes
# below do not depend on the third decimal of either.
model = HullWhite1F(a=0.05, sigma=0.007, curve=curve)

# Three trades under one ISDA, each struck at its own par rate, so
# V(0) = 0 for every trade and therefore for the netting set:
#   A  10Y payer     10,000,000 USD   c = 4.1200%
#   B   5Y payer     10,000,000 USD   c = 3.9200%
#   C   7Y receiver  12,000,000 USD   c = 4.0200%
definitions = [("A", 10, 1.0e7, True),
               ("B", 5, 1.0e7, True),
               ("C", 7, 1.2e7, False)]

specs = {}
for key, years, notional, pay_fixed in definitions:
    schedule = annual_schedule(years)
    par = curve.par_swap_rate(t0, torch.tensor(schedule)).item()
    specs[key] = SwapSpec(
        notional=notional,
        fixed_rate=par,
        fixed_payment_times=schedule,
        pay_fixed=pay_fixed,
    )

# 41 steps to 10.25y is dt = 0.25 exactly, and 10.25 covers the longest
# maturity. One short-rate simulation drives all three trades.
short_rates, times = model.simulate(5_000, 41, 10.25, seed=42)
mtm = {key: reprice_swap_paths(model, spec, short_rates, times)
       for key, spec in specs.items()}

netting_set = NettingSet([mtm["A"], mtm["B"], mtm["C"]])

# EE profiles: the per-time function EE(t), not the scalar EPE
gross = netting_set.gross_ee()
netted = netting_set.netted_ee()
coll = netting_set.collateralised_ee(threshold=0.0, mpr=2)  # 2 steps = 0.5y

print(f"gross peak       {gross.max():>12,.2f}")          # 656,516.37
print(f"collateralised   {coll.max():>12,.2f}"
      f" at {times[coll.argmax()]:.2f}y")                 # 87,833.51 at 0.50y