blog https://your-website-url.example.com/ A blog built with Quarto quarto-1.8.27 Wed, 11 Feb 2026 00:00:00 GMT Hedging a book of exotic options with different maturities https://your-website-url.example.com/posts/post-with-code/exotic-book-local-vol.html In this notebook, we continue on the track to study the track of hedging in the world of FX option still from a trader sitting in a exotic desk in a investment bank. As we’ve seen in the previous notebooks (Hedging a book of exotics options) we have cover the basics on how to hedge a book of FX exotics, both in the case where we are hedging under the Black-Scholes model and in the case where we have a volatility smile and hedge options with the same expiration using the VV method (Hedging a book of exotics options using the Vanna-Volga), in this notebook we are going to take a even further step since we are going to leverage the whole IV surface to hedge our portfolio made of different options with different strikes and expirations. In this case, I’ve decided to leverage the local volatility model and price using the Finite Difference method. The assets that we are considering are thus under the following dynamics:

Market Data

Let’s assume that we are an USD based desk and we are dealing with EURUSD exotics. The initial market data at time is the following

With the following Implied Vol surface

ATM
1W 13.50% 12.00% 9.50% 8.50% 9.50%
1M 13.00% 11.50% 9.00% 8.00% 9.00%
3M 12.50% 11.00% 9.50% 8.50% 9.50%
1Y 12.00% 10.50% 10.00% 9.50% 10.50%

For the sake of simplicity we consider that the interest rate term structures for the USD and EUR are both flat

Note in the FX option world, IVs are quoted as a delta-vol pairs for each maturity.

EUR_USD = 1.18
today = ql.Date(12, ql.December, 2025)
ref_date = today
calendar = ql.NullCalendar()
dc = ql.Actual365Fixed()
r_d = 0.0325
r_f = 0.02

ql.Settings.instance().evaluationDate = today
spot_quote = ql.SimpleQuote(EUR_USD)
spot_handle = ql.QuoteHandle(spot_quote)

deltas = [-0.10, -0.25, 0.5, 0.25, 0.10]
option_types = [ql.Option.Put, ql.Option.Put, ql.Option.Call, ql.Option.Call, ql.Option.Call]
maturity_1y = calendar.advance(today, ql.Period(1, ql.Years))
maturity_3m = calendar.advance(today, ql.Period(3, ql.Months))
maturity_6m = calendar.advance(today, ql.Period(6, ql.Months))
maturity_1m = calendar.advance(today, ql.Period(1, ql.Months))
maturity_1w = calendar.advance(today, ql.Period(1, ql.Weeks))
maturities = [
    maturity_1w,
    maturity_1m,
    maturity_3m,
    maturity_1y
]
times = [dc.yearFraction(today, m) for m in maturities]
# Vol surface
ivs = np.array([
    # 0.10P, 0.25P, ATM,  0.25C, 0.10C
    [0.135, 0.12,  0.095, 0.090, 0.095],  # 1W 
    [0.130, 0.115, 0.090, 0.080, 0.090],  # 1M
    [0.125, 0.110, 0.095, 0.085, 0.095],  # 3M
    [0.120, 0.105, 0.100, 0.095, 0.105],  # 1Y
])
# Rates TS
domestic_ts = ql.YieldTermStructureHandle(ql.FlatForward(today, r_d, dc))
foreign_ts = ql.YieldTermStructureHandle(ql.FlatForward(today, r_f, dc))
# Discount curves
eur_dates = [ql.Date(27, ql.August, 2025), ql.Date(27, ql.August, 2026), ql.Date(27, ql.August, 2027)]
eur_dfs = [1.0, 0.98, 0.95]
eur_curve = ql.DiscountCurve(eur_dates, eur_dfs, dc)
eur_curve.enableExtrapolation()
eur_disc_ts = ql.YieldTermStructureHandle(eur_curve)

usd_dates = [ql.Date(27, ql.August, 2025), ql.Date(27, ql.August, 2026), ql.Date(27, ql.August, 2027)]
usd_dfs = [1.0, 0.985, 0.96]
usd_curve = ql.DiscountCurve(usd_dates, usd_dfs, dc)
usd_curve.enableExtrapolation()
usd_disc_ts = ql.YieldTermStructureHandle(usd_curve)

Let’s also suppose that the following discount curve:

Since we have a sticky delta volatility surface, we need to turn the surface into a sticky strike volatility surface in order to make QuantLib make use of those IVs when pricing the exotics. To do that let’s use the create_strike_iv_surf helper function defined above. create_strike_iv_surf uses the ql.BlackDeltaCalculator class which allows us to get the strike from the delta-vol quote according the specific delta quote convetion that we are using.

strikes = create_strike_iv_surf(EUR_USD, usd_curve, eur_curve, deltas, option_types, times, ivs)

The corresponding strikes for each tuple are:

10D P 25D P ATM 25D C 10D C
1W 1.152382 1.167127 1.180212 1.190167 1.200282
1M 1.125401 1.154811 1.180866 1.199518 1.221262
3M 1.093388 1.140628 1.182536 1.216533 1.256383
1Y 1.025369 1.112431 1.189692 1.268784 1.363115

Since, now we have a set of IV with different strikes for each expiration, we need to find a way to build the IV surface using this data. One efficient and common way to do that is using the Andersen-Huge interpolation (see Andreasen and Huge 2010) method, which allows us to achieve this goal. In a nuthsell, the Andreasen and Huge have introduced an efficient and arbitrage free volatility interpolation method based on a one step finite difference implicit Euler scheme applied to a local volatility parametrization. Probably the most notable use case is the generation of a local volatility surface from a set of option quotes.

QuantLib provides us with a series of classes that can help us to build both the IV and the local surface from the IV data, using the Andersen-Huge method. First and foremost, we need to build a calibration set, which is basically a list of Tuple made by the option and the iv relative to that option (option, ivs_quote), and then we can create an instance of the ql.AndersenHugeVolatilityInterpl with the calibration set created, that is the class that is going to handle the interpolation. Then we need to create the relative Implied vol and Local vol adapter the ql.AndersenHugeVolatilityAdapter and the ql.AndersenHugeLocalAdapter respectively. Those are the instances that resprents the BlackVarianceTermStructure and the LocalVolTermStructure that we need to further wrap into a RelinkableHandle.

Why a RenilableHandle you might ask? Well it’s because it will come in handyh to us when calculating the sensitivities, rembember a RelinkableHandle can be link to another term structure after it is first created, unlike a plain handle.

# Calibration of vol surfaces
def calibrate_vol_surface(strikes: Union[List[List[float]], np.ndarray], 
                          options: List[ql.Option],
                          maturities: List[float], 
                          ivs: np.array
                        ) -> Tuple[ql.BlackVolTermStructure, ql.LocalVolTermStructure]:
    """
    Calibrate the given ivs quotes and build a BlackVolTermStructure and a LocalVolTermStructure
    
    Parameters:
        strikes (Union[List[List[float]], np.ndarray]): the strikes of the volatility surface
        options (List[ql.Option]): the types of option a specific strike is referring to
        maturities (List[float]): list of maturieties of the vol surface
        ivs (np.ndarray): the iv surface data
    
    Return:
        ql.Tuple[ql.BlackVolTermStructure, ql.LocalVolTermStructure]: tuple contaning the calibrate black vol term structure 
                                                                    and the local vol term structure
    """
    calibration_set = ql.CalibrationSet()

    n, m = len(maturities), len(options)

    for i in range(n):
        for j in range(m):
            payoff = ql.PlainVanillaPayoff(options[i], strikes[i][j])
            maturity = ql.EuropeanExercise(maturities[i])

            calibration_set.push_back((ql.VanillaOption(payoff, maturity), ql.SimpleQuote(ivs[i][j])))

    ah_interpolation = ql.AndreasenHugeVolatilityInterpl(calibration_set, \
                            spot_handle, domestic_ts, foreign_ts)
    ah_vol_surf = ql.AndreasenHugeVolatilityAdapter(ah_interpolation) # IV surface
    ah_local_vol = ql.AndreasenHugeLocalVolAdapter(ah_interpolation) # LV surface

    return ah_vol_surf, ah_local_vol

ah_vol_surf, ah_local_vol = calibrate_vol_surface(strikes, option_types, maturities, ivs)
black_vol_surf_handle = ql.RelinkableBlackVolTermStructureHandle(ah_vol_surf)
local_vol_surf_handle = ql.RelinkableLocalVolTermStructureHandle(ah_local_vol)

Now that we have constructed the vol surfaces, let’s now visualized how they look:

Just a reminder , they are related but they are not the same thing. IVs represent a sort of estimate of the average future volatility of the underlying during the option’s lifetime. In a way, IVs is a “global” measure of volatility, in contrast to the local volatility at any spot price and time.

Since we are using the local vol model, one way to price option is by using the Finite Difference method. QuantLib provides us with the FdBlackScholesBarrierEngine class to achieve that, keep in mind that we need to set useLocalVol=True, thus we can use the local volatility function when running the pricing engine.

engine = ql.FdBlackScholesBarrierEngine(
    process,
    200,
    400,
    0,
    ql.FdmSchemeDesc.Douglas(),
    True, # localVol has to be True
    0.1)

Exotics Book

Here’s how the trader book is composed of:

1st Barrier

# Barrier 1
notional = 1_000_000
barrier = 1.30
barrier_type = ql.Barrier.UpOut
exercise = ql.EuropeanExercise(maturity_1y)
strike = strike_from_delta(
    EUR_USD,
    0.25,
    times[-1],
    ql.Option.Call,
    ivs[-1, -2],
    usd_curve,
    eur_curve
)

barrier_25d_130b = call_barrier_factory.get_option(strike, exercise, barrier, barrier_type)
barrier_1 = BarrierPosition(barrier_25d_130b, notional, NullInstrument())

2nd Barrier

# Barrier 2
notional = 2_000_000
barrier = 1.08
barrier_type = ql.Barrier.DownOut
exercise = ql.EuropeanExercise(maturity_6m)
strike = strike_from_delta(
    EUR_USD,
    0.25,
    dc.yearFraction(today, maturity_6m),
    ql.Option.Call,
    0.09, # Interpolated value
    usd_curve,
    eur_curve
)

barrier_25d_108b = call_barrier_factory.get_option(strike, exercise, barrier, barrier_type)
barrier_2 = BarrierPosition(barrier_25d_108b, notional, NullInstrument())

3rd Barrier

# Barrier 3
notional = 1_000_000
barrier = 1.20
barrier_type = ql.Barrier.UpIn
exercise = ql.EuropeanExercise(maturity_3m)
strike = strike_from_delta(
    EUR_USD,
    0.25,
    dc.yearFraction(today, maturity_3m),
    ql.Option.Call,
    ivs[-2, -2],
    usd_curve,
    eur_curve
)
call_vanilla_factory = FxVanillaOptionFactory(spot_handle, maturity_1y, ql.Option.Call)

barrier_25d_120b = call_barrier_factory.get_option(strike, exercise, barrier, barrier_type)
backup_vanilla = call_vanilla_factory.get_option(strike)
FxVanillaOptionFactory.assign_analyitcal_price_engine(backup_vanilla, process_25c)
barrier_3 = BarrierPosition(barrier_25d_120b, notional, backup_vanilla)

4th Barrier

# Barrier 4
notional = 1_000_000
barrier = 1.05
barrier_type = ql.Barrier.DownOut
exercise = ql.EuropeanExercise(maturity_3m)
strike = strike_from_delta(
    EUR_USD,
    -0.25,
    dc.yearFraction(today, maturity_3m),
    ql.Option.Put,
    ivs[-2, 2],
    usd_curve,
    eur_curve
)

barrier_25d_105b = put_barrier_factory.get_option(strike, exercise, barrier, barrier_type)
barrier_4 = BarrierPosition(barrier_25d_105b, notional, NullInstrument())

5th Barrier

# Barrier 5
notional = 2_000_000
barrier = 1.25
barrier_type = ql.Barrier.UpOut
exercise = ql.EuropeanExercise(maturity_1m)
strike = strike_from_delta(
    EUR_USD,
    -0.25,
    dc.yearFraction(today, maturity_1m),
    ql.Option.Put,
    ivs[1, 2],
    usd_curve,
    eur_curve
)

barrier_25d_105b = put_barrier_factory.get_option(strike, exercise, barrier, barrier_type)
barrier_5 = BarrierPosition(barrier_25d_105b, notional, NullInstrument())
book: List[BarrierPosition] = [barrier_1, barrier_2, barrier_3, barrier_4, barrier_5]

for ins in book:
    FxBarrierOptionFactory.assign_price_engine(ins.instrument, engine)

Now we have setup our book, let’s see what’s the premium on those options.

Barrier 1, price $260.39
Barrier 2, price $26721.44
Barrier 3, price $7822.55
Barrier 4, price $4510.61
Barrier 5, price $13603.77
The total book value is ${book_value}

Bucketed sensitivities

When dealing with vol surfaces or smiles, to calculate the sensitivity w.r.t. the volatility does not result trival as when we are dealing with a single vol like in BS model. As shown in the Hedging a book of exotic options with VV method, in case we have a smile we can calculate the sensitivities to the various movements of the volatility smile (paralallel shift, varying the skew, and the curvature), and those ideas can be also applied to the whole vol surface.

Another possible way, to get those vega sensitivities is to calculate how the prices are sensible to each single IV variation, in this way we get the so called bucket sensitivites.

For example we want to know how the price of an exotic is sensible to the variation to the . To the get that we can use the forward finte difference formula:

By repeating this process for all vols of the IV surface we get a matrix of the bucket sensitivities:

The methodology to use to calculate the sensitivities w.r.t. the volatility surface is up the trader/trading desk, on how they want those sensitivities …

TODO: add risk surface explanation

To visualized the effect of those single bumps of the single IVs, let’s for example bump by the ATM vol with maturity 1 year, and visualized how the IV and LV surfaces are changing.

The IV surface does change a bit, but where we can see a big changment is in LV surface where a new hump appears at the end of the surface. Let’s now see how the prices of the exotics have changed with this new vol surfaces.

new_premiums = [opt.NPV() for opt in book]
new_premiums
[555.7614339685688,
 31789.433532155144,
 7822.54562563613,
 4510.6110117102935,
 13603.771705059622]
np.array(premiums) - np.array(new_premiums)
array([ -295.3701985 , -5067.99548249,     0.        ,     0.        ,
           0.        ])

As we can see the only options where the price has varied is the 1st barrier, which is the only barrier that has expiration time 1Y. … You might wonder what does bump another vol with shorted maturity, will that affect also the exotics with maturities greater than that maturity? Let’s bump for example by 1bp the ATM, 1M implied vol and see the effects on the other exotics prices.

Barrier 1, ATM 1M IV bump sensitivity: $ -0.10
Barrier 2, ATM 1M IV bump sensitivity: $ 17.19
Barrier 3, ATM 1M IV bump sensitivity: $ 4.48
Barrier 4, ATM 1M IV bump sensitivity: $ -22.66
Barrier 5, ATM 1M IV bump sensitivity: $ -565.39

Now we see how all options in the book have been impacted by this vol bump, that’s because all the options in the book have an expiration after 1Y, thus this will impact their price. Of course Barrier 5 will be the one with more price impact, since it expires in 1 month, but we can see that also in options expirying in 3 months and 6 months there is a price impact.

Let’s apply the process above for all the IVs in the original IV surface and calculate those bucket sensitivities.

bucket_sens = np.zeros_like(ivs)
delta_vol = 1.0e-08

for i in range(len(ivs)):
    for j in range(len(ivs[0])):
        ivs[i, j] += delta_vol

        tmp_strikes = create_strike_iv_surf(EUR_USD, usd_curve, eur_curve, deltas, option_types, times, ivs)

        new_ah_vol_surf, new_ah_local_vol = calibrate_vol_surface(tmp_strikes, option_types, maturities, ivs)
        black_vol_surf_handle.linkTo(new_ah_vol_surf)
        local_vol_surf_handle.linkTo(new_ah_local_vol)

        new_book_value = sum([opt.NPV() for opt in book])

        bucket_sens[i, j] = (new_book_value - book_value) / delta_vol

        ivs[i, j] -= delta_vol
10D P 25D P ATM 25D C 10D C
1W -1878.530020 5996.552500 -7096.302579 3011.398803 974.274008
1M -11133.617227 168080.302683 41107.244760 -11645.406630 1430.459088
3M -153599.417536 173253.199318 40819.460264 250610.804505 49760.293768
1Y 15323.454136 -176753.786945 341937.783378 346704.848926 -71231.295442

How do we hedge those bucketed sensitivities? Well, we can do it with plain vanilla options, …

vanilla_options = np.zeros_like(bucket_sens).tolist()

for i in range(len(vanilla_options)):
    for j in range(len(vanilla_options[0])):
        maturity = maturities[i]
        option_type = option_types[j]
        strike = strikes[i, j]
        process = ql.GarmanKohlagenProcess(
            spot_handle,
            foreign_ts,
            domestic_ts,
            ql.BlackVolTermStructureHandle(
                ql.BlackConstantVol(ref_date, calendar, ivs[i, j], dc)
            )
        )

        payoff = ql.PlainVanillaPayoff(option_type, strike)
        vanilla_options[i][j] = ql.VanillaOption(payoff, ql.EuropeanExercise(maturity))
        vanilla_options[i][j].setPricingEngine(ql.AnalyticEuropeanEngine(process))
vegas = np.array([[opt.vega() * notional for opt in row] for row in vanilla_options])
vega_weights = bucket_sens / vegas
with np.printoptions(precision=3):
    print(vega_weights)
[[-0.033  0.058 -0.054  0.029  0.017]
 [-0.094  0.78   0.15  -0.052  0.012]
 [-0.778  0.477  0.088  0.656  0.231]
 [ 0.04  -0.251  0.372  0.446 -0.159]]

Now that we have found the weight for all the vanillas, let’s now reduce the total exposure of our portfolio. The weight for the spot position hedge is given by

spot_change = 0.01 * spot_quote.value() / 2

delta_book = sum([pos.sensitivity(delta, h=spot_change) for pos in book])
delta_vanillas = sum([sum([opt.delta() * v_w * notional for opt, v_w in zip(row, v_row)]) for row, v_row in zip(vanilla_options, vega_weights)])
hedging_delta_weight = delta_book / delta_vanillas
hedging_delta_weight
np.float64(-0.23937887076554554)
vanillas_premiums = [[opt.NPV() * v_w * notional for opt, v_w in zip(row, v_row)] for row, v_row in zip(vanilla_options, vega_weights)]
spot_hedge_usd = hedging_delta_weight * notional * spot_handle.value()
hedging_str_premium = np.sum(vanillas_premiums) + spot_hedge_usd
bank_account_value = - hedging_str_premium + np.sum(premiums)
port_value = [hedging_str_premium - np.sum(premiums) + bank_account_value]

print(f"The portfolio value at time t = 0 is {port_value[0]}")
The portfolio value at time t = 0 is 0.0

Changes of the hedging portfolio with the changes of the market conditions

Now that we have setup our hedging portfolio see verify how its will change as the spot and vol surface change. Let’s assume that in a 2-day period the spot went go down by 200 pips, the ATM vol went up by while the the 25 Put vol went up (since the price to hedge from downside has went up because of the underlying so there is more demand for puts).

With the following Implied Vol surface

ATM
3D 14.00% 13.00% 12.00% 11.50% 10.50%
1M 14.00% 13.50% 10.00% 9.00% 9.75%
3M 12.75% 11.50% 10.00% 9.00% 9.50%
1Y 12.50% 10.75% 10.25% 9.75% 9.50%

We are now interested to see what’s the new exposure of our hedging portfolio.

ref_date = today + ql.Period(2, ql.Days)

spot_quote.setValue(1.16)

new_times = [dc.yearFraction(ref_date, m) for m in maturities]
# Vol surface
new_ivs = np.array([
    # 0.10P, 0.25P, ATM,  0.25C, 0.10C
    [0.140, 0.13,  0.12, 0.115, 0.105],  # 1W 
    [0.140, 0.135, 0.110, 0.105, 0.10],  # 1M
    [0.1275, 0.115, 0.100, 0.090, 0.095],  # 3M
    [0.125, 0.1075, 0.1025, 0.0975, 0.105],  # 1Y
])

# Move vols and expiry time
ql.Settings.instance().evaluationDate = ref_date

Let’s calculate the new strikes needed to build the new calibrated local vol surface.

new_strikes = create_strike_iv_surf(spot_quote.value(), usd_curve, eur_curve, deltas, option_types, new_times, new_ivs)
array([[1.13612881, 1.14837208, 1.16019107, 1.17076404, 1.17858337],
       [1.10412947, 1.13192316, 1.16097287, 1.18435339, 1.20361041],
       [1.07412444, 1.11998689, 1.16256386, 1.19758045, 1.23419363],
       [1.00256954, 1.09219685, 1.16972097, 1.24936665, 1.33944933]])
ah_vol_surf, ah_local_vol = calibrate_vol_surface(new_strikes, option_types, maturities, new_ivs)
black_vol_surf_handle.linkTo(ah_vol_surf)
local_vol_surf_handle.linkTo(ah_local_vol)

We now have to recalculate the price of the hedging vanillas and the value of the new exotics to calculate the from time to time 

for i in range(len(vanilla_options)):
    for j in range(len(vanilla_options[0])):
        process = ql.GarmanKohlagenProcess(
            spot_handle,
            foreign_ts,
            domestic_ts,
            ql.BlackVolTermStructureHandle(
                ql.BlackConstantVol(ref_date, calendar, new_ivs[i, j], dc)
            )
        )
        vanilla_options[i][j].setPricingEngine(ql.AnalyticEuropeanEngine(process))
new_premiums = [opt.NPV() for opt in book]
new_book_value = sum(new_premiums)
new_vanilla_premiums = [[opt.NPV() * v_w * notional for opt, v_w in zip(row, v_row)] for row, v_row in zip(vanilla_options, vega_weights)]
spot_premium_eur = hedging_delta_weight * notional 
new_spot_hedge_usd = hedging_delta_weight * notional * spot_handle.value()
new_hedging_str_premium = np.sum(new_vanilla_premiums) + new_spot_hedge_usd
dt = dc.yearFraction(today, ref_date)
usd_interest_cost = hedging_str_premium * r_d * dt
eur_interest_accr = spot_premium_eur * r_f * dt
new_total_portfolio_value = new_hedging_str_premium - np.sum(new_premiums) + bank_account_value - usd_interest_cost + eur_interest_accr * spot_quote.value()

print(f"Portfolio value at time t = 1 is: ${new_total_portfolio_value}")
Portfolio value at time t = 1 is: $202.86605298389892

Thus the variation from time 0 to time 1 is just about , this confirms that our hedge worked by limiting the variation of the whole portfolio value.

References

Andreasen, Jesper, and Brian Huge. 2010. “Volatility Interpolation.” Risk Magazine, March. https://doi.org/10.2139/ssrn.1694972.
]]> Quantitative finance Hedging Exotic options https://your-website-url.example.com/posts/post-with-code/exotic-book-local-vol.html Wed, 11 Feb 2026 00:00:00 GMT Hedging a book of exotic options using the Vanna-Volga method https://your-website-url.example.com/posts/post-with-code/exotic-book-vanna-volga.html In this notebook, we continue to study the track of hedging in the world of FX options still from a trader sitting in a exotic desk in the S&T branch of a bank. As we’ve seen in the previous notebook (Hedging a book of exotics options) we have cover the basics on how to hedge a book of FX exotics, in this notebook we are going to take a further step to what is used in practice since, as you might know volatilities in practice are not flat across different strikes and across different time to expirations. Thus we are going to introduce a method that is going to take into account also for those volatilities as well to produce market consistent prices. This method is called the Vanna-Volga method.

Again as a library we are going to use QuantLib, because, well why not, right?

Market Data

Let’s assume that we are an USD based desk and we are dealing with EURUSD exotics. The initial market data at time is the following

Let’s further assume that in our book we have all options expirying in 6 months (thus ).

EUR_USD = 1.18
spot_quote = ql.SimpleQuote(EUR_USD)
today = ql.Date(16, ql.September, 2025)
ref_date = today
r_d = 0.045
r_f = 0.02
vol_quote = ql.SimpleQuote(0.13)
spot_handle = ql.QuoteHandle(spot_quote)
vol_handle = ql.QuoteHandle(vol_quote)

dc = ql.Actual365Fixed()
calendar = ql.JointCalendar(ql.Italy(), ql.UnitedStates(ql.UnitedStates.NYSE))

expiration_date = ref_date + ql.Period(6, ql.Months)
expiration_time = dc.yearFraction(ref_date, expiration_date)
domestic_rf_handle = ql.YieldTermStructureHandle(ql.FlatForward(today, r_d, dc))
foreign_rf_handle = ql.YieldTermStructureHandle(ql.FlatForward(today, r_f, dc))
black_vol = ql.BlackConstantVol(today, ql.NullCalendar(), vol_handle, dc)
vol_ts_handle = ql.BlackVolTermStructureHandle(black_vol)

exp_time_quote = ql.SimpleQuote(expiration_time)
exp_time_handle = ql.QuoteHandle(exp_time_quote)
exp_time_sqrt_quote = ql.DerivedQuote(exp_time_handle, function=lambda x: np.sqrt(x))
exp_time_sqrt_handle = ql.QuoteHandle(exp_time_sqrt_quote)

delta_type = ql.DeltaVolQuote.Spot
atm_type = ql.DeltaVolQuote.AtmSpot
atm_vol, delta25_call_vol, delta25_put_vol = 0.11, 0.125, 0.14
atm_vol_quote = ql.SimpleQuote(atm_vol)
delta25_call_vol_quote = ql.SimpleQuote(delta25_call_vol)
delta25_put_vol_quote = ql.SimpleQuote(delta25_put_vol)


# Handle creations
spot_handle = ql.QuoteHandle(spot_quote)
atm_vol_handle = ql.QuoteHandle(atm_vol_quote)
delta25_c_vol_handle = ql.QuoteHandle(delta25_call_vol_quote)
delta25_p_vol_handle = ql.QuoteHandle(delta25_put_vol_quote)

atm_dvol_quote = ql.DeltaVolQuote(atm_vol_handle, delta_type, expiration_time, atm_type)
delta25_c_dvol_quote = ql.DeltaVolQuote(0.25, delta25_c_vol_handle, expiration_time, delta_type)
delta25_p_dvol_quote = ql.DeltaVolQuote(-0.25, delta25_p_vol_handle, expiration_time, delta_type)
atm_dvol_handle = ql.DeltaVolQuoteHandle(atm_dvol_quote)
delta25_c_dvol_handle = ql.DeltaVolQuoteHandle(delta25_c_dvol_quote)
delta25_p_dvol_handle = ql.DeltaVolQuoteHandle(delta25_p_dvol_quote)

atm_std_handle = ql.QuoteHandle(ql.CompositeQuote(atm_vol_handle, exp_time_sqrt_handle, lambda x, y: x * y))
delta25_c_std_handle = ql.QuoteHandle(ql.CompositeQuote(delta25_c_vol_handle, exp_time_sqrt_handle, lambda x, y: x * y))
delta25_p_std_handle = ql.QuoteHandle(ql.CompositeQuote(delta25_p_vol_handle, exp_time_sqrt_handle, lambda x, y: x * y))

# Setting the global evaluation date
ql.Settings.instance().evaluationDate = today
eur_dates = [ql.Date(27, ql.August, 2025), ql.Date(27, ql.August, 2026), ql.Date(27, ql.August, 2027)]
eur_dfs = [1.0, 0.98, 0.95]
eur_curve = ql.DiscountCurve(eur_dates, eur_dfs, dc)
eur_curve.enableExtrapolation()
eur_disc_ts = ql.YieldTermStructureHandle(eur_curve)

usd_dates = [ql.Date(27, ql.August, 2025), ql.Date(27, ql.August, 2026), ql.Date(27, ql.August, 2027)]
usd_dfs = [1.0, 0.985, 0.96]
usd_curve = ql.DiscountCurve(usd_dates, usd_dfs, dc)
usd_curve.enableExtrapolation()
usd_disc_ts = ql.YieldTermStructureHandle(usd_curve)

We know, from empirical experience, that the volatilities across a specific time to expiration are not the same for all the strikes, this is due a number of different reasons: market demand dynamics, skewness of returns, the presence of jumps, …

Thus let’s define the smile for the barrier options expiring in 6 months, assuming that we know the values of the vols for the ATM, 25 puts, and 25 calls. To do that, QuantLib come in handy with ready classes to define a smile across different strikes with a fixed tenor.

The SmileSection class, is an object provided by the QuantLib library that represent a volatility smile for a specific tenor. QuantLib export some subclasses of SmileSection using different interpolation methods, thus you can choose some of them according to you needs.

call_barrier_factory = FxBarrierOptionFactory(spot_handle, ql.Option.Call)
put_barrier_factory = FxBarrierOptionFactory(spot_handle, ql.Option.Put)
put_vanilla_factory = FxVanillaOptionFactory(spot_handle, expiration_date, ql.Option.Put)
call_vanilla_factory = FxVanillaOptionFactory(spot_handle, expiration_date, ql.Option.Call)
delta_call_calc = ql.BlackDeltaCalculator(
    ql.Option.Call, 
    ql.DeltaVolQuote.Spot, 
    EUR_USD, 
    eur_curve.discount(expiration_time), 
    usd_curve.discount(expiration_time), 
    np.sqrt(black_vol.blackVariance(expiration_time, EUR_USD)))
delta_put_calc = ql.BlackDeltaCalculator(
    ql.Option.Put, 
    ql.DeltaVolQuote.Spot, 
    EUR_USD, 
    eur_curve.discount(expiration_time), 
    usd_curve.discount(expiration_time), 
    np.sqrt(black_vol.blackVariance(expiration_time, EUR_USD)))

# Get the strikes equivalent for the 0.25 delta for call and put options
d25_call_strike = delta_call_calc.strikeFromDelta(0.25)
d25_put_strike = delta_put_calc.strikeFromDelta(-0.25)
atm_strike = delta_call_calc.atmStrike(ql.DeltaVolQuote.AtmDeltaNeutral)
# Define the smile using a Spline Cubic interpolation
smile = ql.SplineCubicInterpolatedSmileSection(
    expiration_time, 
    [d25_put_strike, atm_strike, d25_call_strike],
    [delta25_p_std_handle, atm_std_handle, delta25_c_std_handle],
    ql.makeQuoteHandle(atm_strike)
)

def get_smile_vols(smile: ql.SmileSection, strikes: Union[np.array, List[float]]) -> List[float]:
    return [smile.volatility(s) for s in strikes]
strikes = np.arange(d25_put_strike - 0.01, d25_call_strike + 0.04, 0.01)
smile_vols = get_smile_vols(smile, strikes)

As mentioned above, the pricing method used in this notebook resembles what is acctually used in real life to be consistent with market prices. To take into account also for the smile a pricing method has been developed by Castagna and Mercurio (see Castagna and Mercurio 2007).

The Vanna-Volga method takes into account the volatility smile when pricing FX options by adjusting the BS price. It is based on the construction of a locally replicating portfolio whose associate hedging costs are added to the corresponding BS price so as to produce smile-consisent values.

Assume that we construct our hedging portfolio with the following options: 25 put, ATM call and 25 call where the strikes are denoted by and market implied volatilities are denoted by . Using these options we can build a portfolio that zeros the partial derivatives up to the second order. In fact, denoting respectively by and the units of underlying assets and options with strikes held at time and selling under diffusion dynamics both for and , we have by Ito’s Lemma:

Choosing and so as to zero the coefficient of , the whole portfolio (long position + hedges) is locally riskless at time , in what no stochastic terms are involved in its differential:

To find the weight of the hedging portfolio we need to solve the following system

Now, for the model to be useful it has to be consistent with market prices, thus the hedging costs at prevaling market prices has to be included in the option price to produce an arbitrage-free price taht is consistent with the quoted option prices . In case of a short maturity, i.e. for a small equation can be approximated as

by adjusting the BS price with Market prices we have

substitute yields to

which can be simplified to

by isolating we have then that

Thus from the above approximation, we are seening that the payoff of the option can still be replicated by shorting units of the underlying asset, buying options with strike and investing the resulting cash at rate .

The quantity is defined as the VV option’s premium, implicitly assuming that the replication error is negligible for longer maturities. Such a premium is equal the BS price plus the cost difference of the hedging portfolio induced by the market implied volatilities with respect to the constant volatility. Since we set using the market volatility for strike , (2) can be simplified to:

The model that extends the Black-Scholes model when dealing with FX options is the Garman-Kohlhagen model, whose dynamics have been defined above. Thus we need to create an instances of the Garman-Kohlhagen process in order to price FX vanilla options.

For the sake of simplicity we assume that all the options on the book have the same expiration, and again since we are under the Garman-Kohlhagen model the vol curve is flat, thus the vol across the different strikes is the same (unrealistic assumption). Here’s how the trader book is composed of:

1st Barrier

# Barrier 1
notional = 1_000_000
barrier = 1.30
barrier_type = ql.Barrier.UpOut
exercise = ql.EuropeanExercise(expiration_date)

barrier_25d_130b = call_barrier_factory.get_option(d25_call_strike, exercise, barrier, barrier_type)
barrier_1 = BarrierPosition(barrier_25d_130b, notional, NullInstrument())

2nd Barrier

# Barrier 2
notional = 2_000_000
barrier = 1.08
barrier_type = ql.Barrier.DownOut
exercise = ql.EuropeanExercise(expiration_date)

barrier_25d_108b = call_barrier_factory.get_option(d25_call_strike, exercise, barrier, barrier_type)
barrier_2 = BarrierPosition(barrier_25d_108b, notional, NullInstrument())

3rd Barrier

# Barrier 3
notional = 1_000_000
barrier = 1.20
barrier_type = ql.Barrier.UpIn
exercise = ql.EuropeanExercise(expiration_date)

barrier_25d_120b = call_barrier_factory.get_option(d25_call_strike, exercise, barrier, barrier_type)
backup_vanilla = call_vanilla_factory.get_option(d25_call_strike)
FxVanillaOptionFactory.assign_analyitcal_price_engine(backup_vanilla, process_25c)
barrier_3 = BarrierPosition(barrier_25d_120b, notional, backup_vanilla)

4th Barrier

# Barrier 4
notional = 1_000_000
barrier = 1.05
barrier_type = ql.Barrier.DownOut
exercise = ql.EuropeanExercise(expiration_date)

barrier_25d_105b = put_barrier_factory.get_option(d25_put_strike, exercise, barrier, barrier_type)
barrier_4 = BarrierPosition(barrier_25d_105b, notional, NullInstrument())

5th Barrier

# Barrier 5
notional = 2_000_000
barrier = 1.25
barrier_type = ql.Barrier.UpOut
exercise = ql.EuropeanExercise(expiration_date)

barrier_25d_105b = put_barrier_factory.get_option(d25_put_strike, exercise, barrier, barrier_type)
barrier_5 = BarrierPosition(barrier_25d_105b, notional, NullInstrument())
book: List[BarrierPosition] = [barrier_1, barrier_2, barrier_3, barrier_4, barrier_5]

for ins in book:
    FxBarrierOptionFactory.assign_vanna_volga_price_engine(
        ins.instrument, 
        atm_dvol_handle,
        delta25_p_dvol_handle,
        delta25_c_dvol_handle,
        spot_handle,
        usd_disc_ts,
        eur_disc_ts
    )

Thus the premium of the option will be the following

[438.32143676364166,
 23882.627384424337,
 13961.757334147904,
 403.5348985724314,
 27478.97645781696]

In the Vanna-Volga case, since we don’t have a single vol but a smile, the sensitivities that we care about in the case of hedging are slightly different from the sensitivity that we look at in the Black-Scholes world. We already know how to calculte those sensitivities using finte differences from the previous notebook, what we care now is how the VV price is sensible to the various movements of the volatility smile, in particular we care about how the price will change in case of:

  • a parallel shift of the three volatilities;
  • a change in the difference between the two 25 wings;
  • an increase of the two wings with fixed ATM volatility

In this way we should be able to capture the effect of a parallel, a twist and a convexity movements of the implied volatility surface. Mathematically speaking using finite differences we can get those sensitivities in the following way:

  • Level

  • Skew Sensitivity

  • Curvature

def central_diff(instrument: ql.Instrument, h: float, quote: ql.SimpleQuote) -> float:
    u0 = quote.value()
    quote.setValue(u0 + h)
    P_Plus = instrument.NPV()
    quote.setValue(u0 - h)
    P_Minus = instrument.NPV()

    quote.setValue(u0)
    
    return (P_Plus - P_Minus) / (2 * h)

def central_diff_2nd(instrument: ql.Instrument, h: float, quote: ql.SimpleQuote) -> float:
    u0 = quote.value()
    P = instrument.NPV()
    quote.setValue(u0 + h)
    P_Plus = instrument.NPV()
    quote.setValue(u0 - h)
    P_Minus = instrument.NPV()

    quote.setValue(u0)
    
    return (P_Plus - 2*P + P_Minus) / (h * h)

def cross_central_diff(instrument: ql.Instrument, h: float, k: float, quote_1: ql.SimpleQuote, quote_2: ql.SimpleQuote) -> float:
    u1_0 = quote_1.value()
    u2_0 = quote_2.value()
    
    quote_1.setValue(u1_0 + h)
    quote_2.setValue(u1_0 + k)
    P_Plus_Plus = instrument.NPV()

    quote_1.setValue(u1_0 + h)
    quote_2.setValue(u1_0 - k)
    P_Plus_Minus = instrument.NPV()

    quote_1.setValue(u1_0 - h)
    quote_2.setValue(u1_0 + k)
    P_Minus_Plus = instrument.NPV()

    quote_1.setValue(u1_0 - h)
    quote_2.setValue(u1_0 - k)
    P_Minus_Minus = instrument.NPV()

    quote_1.setValue(u1_0)
    quote_2.setValue(u2_0)
    
    return (P_Plus_Plus - P_Plus_Minus - P_Minus_Plus + P_Minus_Minus) / (4 * h * k)

def parallel_shift(instrument: ql.Instrument, quotes: List[ql.SimpleQuote], h: float):
    u0s = [quote.value() for quote in quotes]

    for quote, u0 in zip(quotes, u0s):
        quote.setValue(u0 + h)
    
    P_Plus = instrument.NPV()

    for quote, u0 in zip(quotes, u0s):
        quote.setValue(u0 - h)
    
    P_Minus = instrument.NPV()

    for quote, u0 in zip(quotes, u0s):
        quote.setValue(u0)

    return (P_Plus - P_Minus) / (2*h) 

def skew_sensitivity(instrument: ql.Instrument, d25_c_quote: ql.SimpleQuote, d25_p_quote: ql.SimpleQuote, h: float) -> float:
    u1 = d25_c_quote.value()
    u2 = d25_p_quote.value()

    d25_c_quote.setValue(u1 + h / 2)
    d25_p_quote.setValue(u2 - h / 2)

    instrument.recalculate()
    up_rr = instrument.NPV()

    d25_c_quote.setValue(u1 - h / 2)
    d25_p_quote.setValue(u2 + h / 2)

    instrument.recalculate()
    down_rr = instrument.NPV()

    d25_c_quote.setValue(u1)
    d25_p_quote.setValue(u2)

    return (up_rr - down_rr) / (2 * h)

def curv_sensitivity(instrument: ql.Instrument, d25_c_quote: ql.SimpleQuote, d25_p_quote: ql.SimpleQuote, h: float) -> float:
    u1 = d25_c_quote.value()
    u2 = d25_p_quote.value()

    d25_c_quote.setValue(u1 + h)
    d25_p_quote.setValue(u2 + h)

    up_bf = instrument.NPV()

    d25_c_quote.setValue(u1 - h)
    d25_p_quote.setValue(u2 - h)

    down_bf = instrument.NPV()

    d25_c_quote.setValue(u1)
    d25_p_quote.setValue(u2)

    return (up_bf - down_bf) / (2 * h)

The plot below gives a visual clue on what those sensitivities measure:

To give you a more naive mathematical intuition, let’s assume that a vol smile is represented by the following 2nd order polynomial (a very likely assumption):

  • in the level sensitivity we are varying
  • when calculating the skew we are varying
  • while when calculating the curvature we are varying

So we want to know how varying each of the function parameters effect the whole volatility smile, which in turns effected the option price.

delta = partial(central_diff, quote=spot_quote)
vega = partial(central_diff, quote=atm_vol_quote)
gamma = partial(central_diff_2nd, quote=spot_quote)
volga = partial(central_diff_2nd, quote=atm_vol_quote)
vanna = partial(cross_central_diff, quote_1=spot_quote, quote_2=atm_vol_quote)

Hedging the book

As explained in the Hedging a book of exotics options, we want to keep low exposure also to the other high order greeks, but since we don’t have a single vol but smile for a specific tenor we want to hedge ourselves from the possible movements of that smile as described above.

Hedge methodology

Let our exposure vector be:

and let our hedge matrix be:

Then we can solve the following linear system and find the weights (position sizes) just by:

When we want to calculate the greeks of our portfolio, we want to do it in meaningful way, thus this requires to us to set the shift operator in a way that makes sense to measure the specific risk of our porfolio. The two main ways that industry professional do that is by using 1% of the spot change and 1% vol change.

spot_change = 0.01 * spot_quote.value() / 2
vol_change = 0.01
quotes = [atm_vol_quote, delta25_call_vol_quote, delta25_put_vol_quote]

delta_book = sum([pos.sensitivity(partial(central_diff, quote=spot_quote), h=spot_change) for pos in book])
level_book = sum([pos.sensitivity(partial(parallel_shift, quotes=quotes), h=vol_change) for pos in book])
skew_book = sum([pos.sensitivity(partial(skew_sensitivity, 
                                         d25_c_quote=delta25_call_vol_quote,
                                         d25_p_quote=delta25_put_vol_quote), h=vol_change) for pos in book])
curv_book = sum([pos.sensitivity(partial(curv_sensitivity, 
                                         d25_c_quote=delta25_call_vol_quote,
                                         d25_p_quote=delta25_put_vol_quote), h=vol_change) for pos in book])

The raw Greek exposition for our book is then the following:

Book Delta exposure: -115632.67827744933
Book Level exposure: 718295.615419507
Book Skew exposure: 137760.4070661429
Book Curvature Call exposure: 417234.2386220757

To get a more meaningful value of the sensitivities needed for the trader’s perspective, we need to multiply the by the spot value and the smile sensitivities by the of vol that we’ve used to measure those sensitivities (thus in our case by ).

Book Delta exposure: $-136446.5603673902
Residual Level exposure: $7182.956154195071
Residual Skew exposure: $1377.6040706614292
Residual Curvature exposure: $4172.342386220757

Our exposure vector is:

# Greek exposure vector
E = np.array([delta_book, level_book, skew_book, curv_book])
E
array([-115632.67827745,  718295.61541951,  137760.40706614,
        417234.23862208])

For each of the base instrument (Spot, ATM call, ATM put, call and put) let’s calculate the basic greeks.

# hedge_matrix
base_notional = np.float64(1_000_000)
spot_greeks = np.array([1, 0, 0, 0]) * base_notional
atm_call_greeks = np.array([
    central_diff(atm_call, h=spot_change, quote=spot_quote), # Delta
    parallel_shift(atm_call, quotes, h=vol_change), # Level
    skew_sensitivity(atm_call,  # Skew
                     d25_c_quote=delta25_call_vol_quote, 
                     d25_p_quote=delta25_put_vol_quote,
                     h=vol_change),
    curv_sensitivity(atm_call, # Curvature
                     d25_c_quote=delta25_call_vol_quote, 
                     d25_p_quote=delta25_put_vol_quote,
                     h=vol_change)
]) * base_notional

atm_put_greeks = np.array([
    delta(atm_put, h=spot_change),
    parallel_shift(atm_put, quotes, h=vol_change),
    skew_sensitivity(atm_put, 
                     d25_c_quote=delta25_call_vol_quote, 
                     d25_p_quote=delta25_put_vol_quote,
                     h=vol_change),
    curv_sensitivity(atm_put, 
                     d25_c_quote=delta25_call_vol_quote, 
                     d25_p_quote=delta25_put_vol_quote,
                     h=vol_change)
]) * base_notional

delta25_call_greeks = np.array([
    delta(delta25_call, h=spot_change),
    parallel_shift(delta25_call, quotes, h=vol_change),
    skew_sensitivity(delta25_call, 
                     d25_c_quote=delta25_call_vol_quote, 
                     d25_p_quote=delta25_put_vol_quote,
                     h=vol_change),
    curv_sensitivity(delta25_call, 
                     d25_c_quote=delta25_call_vol_quote, 
                     d25_p_quote=delta25_put_vol_quote,
                     h=vol_change)
]) * base_notional

delta25_put_greeks = np.array([
    delta(delta25_put, h=spot_change),
    parallel_shift(delta25_put, quotes, h=vol_change),
    skew_sensitivity(delta25_put, 
                     d25_c_quote=delta25_call_vol_quote, 
                     d25_p_quote=delta25_put_vol_quote,
                     h=vol_change),
    curv_sensitivity(delta25_put, 
                     d25_c_quote=delta25_call_vol_quote, 
                     d25_p_quote=delta25_put_vol_quote,
                     h=vol_change)
]) * base_notional
# Let's create the straddle, RR, Butterfly from the base vanilla options
atm_straddle = atm_call_greeks + atm_put_greeks
rr = delta25_call_greeks - delta25_put_greeks
butterfly = delta25_call_greeks + delta25_put_greeks - 2 * atm_straddle

# Hedge Matrix
H = np.stack([spot_greeks, atm_straddle, rr, butterfly]).T

Since our system the number of equations is the same as the number of variables, thus can find the optiomal solution of the system by using np.linalg.solve

x = np.linalg.solve(H, E)

Now that we have a solution let’s see what’s our remaining exposure to each of the choosen hedged greeks. We do that by

residual_greeks = (H @ x - E).tolist()

print(f"Residual Delta exposure: ${residual_greeks[0] * spot_quote.value()}")
print(f"Residual Level exposure: ${residual_greeks[1] * 0.01}")
print(f"Residual Skew exposure: ${residual_greeks[2] * 0.01}")
print(f"Residual Curvature exposure: ${residual_greeks[3] * 0.01}")
Residual Delta exposure: $0.0
Residual Level exposure: $1.1641532182693482e-12
Residual Skew exposure: $0.0
Residual Curvature exposure: $0.0

Another crucial thing when hedging a book is, of course, to measure the P&L from one rebalancing period to another. Let’s then calculate the value of the various components of our hedging portfolio. We have the the P&L from time is calculated as:

where:

  • is the value of our book at time , which is the sum of the premiums that we’ve been collected
  • is the value of the hedging portfolio, the sum of the premium of the structures that we have bought to hedge our from the various sensistivies
  • the cash/bank account of our portfolio which includes financing of cash and trade cashflows

A shorter way to express the P&L, is just by considering the variation of the value of the book + the variation of the value of the hedges + cost of borrowing + interest accrued:

since the rebalancing of the hedges of the bank account happend at the end of trading day.

spot_premium_eur = x[0] * base_notional
spot_premium_usd = x[0] * base_notional * spot_quote.value()
atm_straddle_premium = atm_call.NPV() + atm_put.NPV() * base_notional * x[1]
rr_premium = delta25_call.NPV() - delta25_put.NPV() * base_notional * x[2]
butterfly_premium = (delta25_call.NPV() + delta25_put.NPV() - 2 * (atm_call.NPV() + atm_put.NPV())) * x[3] * base_notional

The usd borrowed (which is the sum of the premiums of or hedging instrument) is crucial for use to calculate the interest accrued for borrowing the usd dollars to buy the hedging structures.

hedging_str_premium = atm_straddle_premium + rr_premium + butterfly_premium + spot_premium_usd
hedging_str_premium
np.float64(-543905.6415990698)

Thus the value of the cash at time is the equal to all the cash that we’ve borrowed to build the hedging structures plus the premiums that we’ve been collected from selling the exotics options

bank_account_value = - hedging_str_premium + np.sum(premiums)
bank_account_value
np.float64(610070.8591107951)
port_value = [hedging_str_premium - np.sum(premiums) + bank_account_value]

print(f"The portfolio value at time t = 0 is {port_value[0]}")
The portfolio value at time t = 0 is 0.0

Changes of the hedging portfolio with the changes of the market conditions

Now that we have setup our hedging portfolio, let’s verify how it will change as the spot and vol smile change. Let’s assume that in a week period the spot went go down by 300 pips, the ATM vol went up by while the the 25 Put vol went up (since the price to hedge from downside has went up because of the underlying so there is more demand for puts).

ref_date = today + ql.Period(7, ql.Days)
expiration_time = dc.yearFraction(ref_date, expiration_date)
exp_time_quote.setValue(expiration_time)

spot_quote.setValue(1.15)
atm_vol_quote.setValue(atm_vol + 0.005)
delta25_put_vol_quote.setValue(delta25_put_vol + 0.008)

new_d25_call_strike = delta_call_calc.strikeFromDelta(0.25)
new_d25_put_strike = delta_put_calc.strikeFromDelta(-0.25)
new_atm_strike = delta_call_calc.atmStrike(ql.DeltaVolQuote.AtmDeltaNeutral)

new_smile = ql.SplineCubicInterpolatedSmileSection(
    expiration_time, 
    [new_d25_put_strike, new_atm_strike, new_d25_call_strike],
    [delta25_p_std_handle, atm_std_handle, delta25_c_std_handle],
    atm_vol_handle
)

# Move vols and expiry time
ql.Settings.instance().evaluationDate = ref_date

Here’s how the new smile looks like compared to the old the smile:

new_premiums = [pos.NPV() for pos in book]

With the new spot and vols let’s recalculate the book exposure

delta_book = sum([pos.sensitivity(partial(central_diff, quote=spot_quote), h=spot_change) for pos in book])
level_book = sum([pos.sensitivity(partial(parallel_shift, quotes=quotes), h=vol_change) for pos in book])
skew_book = sum([pos.sensitivity(partial(skew_sensitivity, 
                                         d25_c_quote=delta25_call_vol_quote,
                                         d25_p_quote=delta25_put_vol_quote), h=vol_change) for pos in book])
curv_book = sum([pos.sensitivity(partial(curv_sensitivity, 
                                         d25_c_quote=delta25_call_vol_quote,
                                         d25_p_quote=delta25_put_vol_quote), h=vol_change) for pos in book])

# new Exposure vector
E = np.array([delta_book, level_book, skew_book, curv_book])
Book Delta exposure: $-426252.06994998624
Residual Level exposure: $6494.259093454982
Residual Skew exposure: $1365.6531019809127
Residual Curvature exposure: $5016.983190482754

As before let’s recalculate the greeks for the basic trading instruments, and then combine to obtain the greeks for the structures used in the hedging portfolio.

# hedge_matrix
base_notional = np.float64(1_000_000)
spot_greeks = np.array([1, 0, 0, 0]) * base_notional
atm_call_greeks = np.array([
    central_diff(atm_call, h=spot_change, quote=spot_quote), # Delta
    parallel_shift(atm_call, quotes, h=vol_change), # Level
    skew_sensitivity(atm_call,  # Skew
                     d25_c_quote=delta25_call_vol_quote, 
                     d25_p_quote=delta25_put_vol_quote,
                     h=vol_change),
    curv_sensitivity(atm_call, # Curvature
                     d25_c_quote=delta25_call_vol_quote, 
                     d25_p_quote=delta25_put_vol_quote,
                     h=vol_change)
]) * base_notional

atm_put_greeks = np.array([
    delta(atm_put, h=spot_change),
    parallel_shift(atm_put, quotes, h=vol_change),
    skew_sensitivity(atm_put, 
                     d25_c_quote=delta25_call_vol_quote, 
                     d25_p_quote=delta25_put_vol_quote,
                     h=vol_change),
    curv_sensitivity(atm_put, 
                     d25_c_quote=delta25_call_vol_quote, 
                     d25_p_quote=delta25_put_vol_quote,
                     h=vol_change)
]) * base_notional

delta25_call_greeks = np.array([
    delta(delta25_call, h=spot_change),
    parallel_shift(delta25_call, quotes, h=vol_change),
    skew_sensitivity(delta25_call, 
                     d25_c_quote=delta25_call_vol_quote, 
                     d25_p_quote=delta25_put_vol_quote,
                     h=vol_change),
    curv_sensitivity(delta25_call, 
                     d25_c_quote=delta25_call_vol_quote, 
                     d25_p_quote=delta25_put_vol_quote,
                     h=vol_change)
]) * base_notional

delta25_put_greeks = np.array([
    delta(delta25_put, h=spot_change),
    parallel_shift(delta25_put, quotes, h=vol_change),
    skew_sensitivity(delta25_put, 
                     d25_c_quote=delta25_call_vol_quote, 
                     d25_p_quote=delta25_put_vol_quote,
                     h=vol_change),
    curv_sensitivity(delta25_put, 
                     d25_c_quote=delta25_call_vol_quote, 
                     d25_p_quote=delta25_put_vol_quote,
                     h=vol_change)
]) * base_notional
# Let's create the straddle, RR, Butterfly from the base vanilla options
atm_straddle = atm_call_greeks + atm_put_greeks
rr = delta25_call_greeks - delta25_put_greeks
butterfly = delta25_call_greeks + delta25_put_greeks - 2 * atm_straddle

# Hedge Matrix
H = np.stack([spot_greeks, atm_straddle, rr, butterfly]).T

The esposure of our hedging portfolio is now is:

# New exposure of the hedging portfolio
exposure = (H @ x - E).tolist()

print(f"Residual Delta exposure: ${exposure[0] * spot_quote.value()}")
print(f"Residual Level exposure: ${exposure[1] * 0.01}")
print(f"Residual Skew exposure: ${exposure[2] * 0.01}")
print(f"Residual Curvature exposure: ${exposure[3] * 0.01 * spot_quote.value()}")
Residual Delta exposure: $2738.4458590258755
Residual Level exposure: $-67.84857193228905
Residual Skew exposure: $-411.47083519745325
Residual Curvature exposure: $-1701.7232883233276

To calculate the from time to we need to calculate the change of the value of the hedging portfolio as well

spot_premium_usd = x[0] * base_notional * spot_quote.value()
atm_straddle_premium = atm_call.NPV() + atm_put.NPV() * base_notional * x[1]
rr_premium = delta25_call.NPV() - delta25_put.NPV() * base_notional * x[2]
butterfly_premium = (delta25_call.NPV() + delta25_put.NPV() - 2 * (atm_call.NPV() + atm_put.NPV())) * x[3] * base_notional
new_hedging_str_premium = atm_straddle_premium + rr_premium + butterfly_premium + spot_premium_usd
dt = dc.yearFraction(today, today + ql.Period(7, ql.Days))
usd_interest_cost = hedging_str_premium * r_d * dt
eur_interest_accr = spot_premium_eur * r_f * dt
new_total_portfolio_value = new_hedging_str_premium - np.sum(new_premiums) + bank_account_value - usd_interest_cost + eur_interest_accr * spot_quote.value()

print(f"Portfolio value at time t = 1 is: ${new_total_portfolio_value}")
Portfolio value at time t = 1 is: $30021.90322561409
The P&L after a week is: $30021.90322561409

If we want to reduce our exposure and bring it back to a lower one, we need to recalculate the optimal hedging weights for our hedging portfolio as before:

x_new = np.linalg.solve(H, E)

This how our hedging portfolio has to change:

(x_new - x) * base_notional
array([-101803.29731514,  418687.61215821,  208353.40317859,
        322112.47789261])

The residual greek exposure after the rebalancing is:

Residual Delta exposure: $1.3387762010097503e-10
Residual Level exposure: $0.0
Residual Skew exposure: $0.0
Residual Curvature exposure: $0.0

References

Castagna, Antonio, and Fabio Mercurio. 2007. “The Vanna-Volga Method for Implied Volatilities.” Risk, January, 106–11.
]]> Quantitative finance Hedging Exotic options https://your-website-url.example.com/posts/post-with-code/exotic-book-vanna-volga.html Sat, 24 Jan 2026 00:00:00 GMT Hedging a book of exotic options https://your-website-url.example.com/posts/post-with-code/exotic-book.html In this notebook, we take on the role of a trader working on an investment bank’s exotic options desk, focusing on FX derivatives. We will explore how such traders hedge their books and how the portfolio’s value and Greek exposures change as the underlying market parameters evolve. To keep things simple, we assume the underlying follows a geometric Brownian motion, with flat term structures for both the volatility surface and the domestic and foreign interest rates. This places us in a Black-Scholes framework (specifically the BS-extended model for FX options, the Garman-Kohlhagen model), described by the following dynamics under the risk-neutral measure:

The investments banks are said to be on the “sell-side”, which basically means that they facilitate transactions between institutions, and provide access to financial markets. In our case we are manifacturing exotics options for our clients, who are seeking market opportunities. This leaves the trader with a significant exposition, as the bank take the opposite side of client trades. To manage the risk and ensure the bank meet its obligations when options are exercised, the trader must hedge against market movements.

The hedging of exotics does not only involves hedging first order greeks (the and the ), but its involves hedging high order greeks like , (DvolDspot) and (DvegaDvol). Another completixity when hedging exotics option, especially when dealing with binary or barriers, pin risks needs to be taken into account when the barrier is hit.

The library we use for option pricing is QuantLib, the largest open-source quantitative finance library available. QuantLib offers a comprehensive suite of tools for modeling, pricing, and risk management of financial derivatives. Its active community and extensive documentation make it a popular choice among both practitioners and researchers in the field.

Market Data

Let’s assume that we are an USD based desk and we are dealing with EURUSD exotics. The initial market data at time is the following

EUR_USD = 1.18
spot_quote = ql.SimpleQuote(EUR_USD)
today = ql.Date(16, ql.September, 2025)
r_d = 0.045
r_f = 0.02
vol_quote = ql.SimpleQuote(0.13)
spot_handle = ql.QuoteHandle(spot_quote)
vol_handle = ql.QuoteHandle(vol_quote)

dc = ql.Actual365Fixed()
calendar = ql.JointCalendar(ql.Italy(), ql.UnitedStates(ql.UnitedStates.NYSE))

expiration_date = today + ql.Period(6, ql.Months)
expiration_time = dc.yearFraction(today, expiration_date)
domestic_rf_handle = ql.YieldTermStructureHandle(ql.FlatForward(today, r_d, dc))
foreign_rf_handle = ql.YieldTermStructureHandle(ql.FlatForward(today, r_f, dc))
black_vol = ql.BlackConstantVol(today, ql.NullCalendar(), vol_handle, dc)
vol_ts_handle = ql.BlackVolTermStructureHandle(black_vol)

# Setting the global evaluation date
ql.Settings.instance().evaluationDate = today
eur_dates = [ql.Date(27, ql.August, 2025), ql.Date(27, ql.August, 2026), ql.Date(27, ql.August, 2027)]
eur_dfs = [1.0, 0.98, 0.95]
eur_curve = ql.DiscountCurve(eur_dates, eur_dfs, dc)
eur_curve.enableExtrapolation()

usd_dates = [ql.Date(27, ql.August, 2025), ql.Date(27, ql.August, 2026), ql.Date(27, ql.August, 2027)]
usd_dfs = [1.0, 0.985, 0.96]
usd_curve = ql.DiscountCurve(usd_dates, usd_dfs, dc)
usd_curve.enableExtrapolation()

The forex option market has a particular way of quoting options, the strike prices are quoted in terms of the Delta of the option: this means that before closing the deal, the strike level is not determined yet in absolute terms. Once the deal is closed, given the level of FX spot rate and the IV agreed upon, the strike will be set at a level yielding the BS Delta the two counterparties were dealing. This way of quoting is smart: it allows us not to worry about small movements of the underlying during the bargaining process, because the absolute strike will be defined only after the agreement on the price, so that the trader is sure to trade an option with given features in terms of exposures both to the underlying asset and to the implied volatility.

The most liquid FX optios are usually the 25- calls and put and the ATM calls and puts, thus those are going to be our basic hedging instruments and the strikes that we are going to refer to for the exotic in our book.

Here is an example on how FX volatility are quoted:

ATM
1W 11.96% 11.69% 11.67% 11.75% 11.94% 12.19% 12.93%
2W 11.81% 11.54% 11.52% 11.60% 11.79% 12.04% 12.78%
1M 11.60% 11.39% 11.39% 11.50% 11.72% 11.99% 12.77%
2M 11.43% 11.16% 11.15% 11.25% 11.48% 11.76% 12.60%
3M 11.22% 10.92% 10.90% 11.00% 11.23% 11.52% 12.39%
6M 11.12% 10.78% 10.76% 10.87% 11.12% 11.43% 12.39%
9M 11.04% 10.72% 10.71% 10.83% 11.09% 11.41% 12.39%
1Y 11.00% 10.69% 10.68% 10.80% 11.06% 11.39% 12.38%
2Y 11.02% 10.63% 10.60% 10.70% 10.94% 11.28% 12.34%

To get the strike from the Delta-Vol quote QuantLib comes in handy with a BlackDeltaCalculator that from a given delta (and option type, discount factor, spot value, and delta-vol quote value) it returns the strike associated with it.

call_barrier_factory = FxBarrierOptionFactory(spot_handle, ql.Option.Call)
put_barrier_factory = FxBarrierOptionFactory(spot_handle, ql.Option.Put)
put_vanilla_factory = FxVanillaOptionFactory(spot_handle, expiration_date, ql.Option.Put)
call_vanilla_factory = FxVanillaOptionFactory(spot_handle, expiration_date, ql.Option.Call)
delta_call_calc = ql.BlackDeltaCalculator(
    ql.Option.Call, 
    ql.DeltaVolQuote.Spot, 
    EUR_USD, 
    eur_curve.discount(expiration_time), 
    usd_curve.discount(expiration_time), 
    np.sqrt(black_vol.blackVariance(expiration_time, EUR_USD)))
delta_put_calc = ql.BlackDeltaCalculator(
    ql.Option.Put, 
    ql.DeltaVolQuote.Spot, 
    EUR_USD, 
    eur_curve.discount(expiration_time), 
    usd_curve.discount(expiration_time), 
    np.sqrt(black_vol.blackVariance(expiration_time, EUR_USD)))

# Get the strikes equivalent for the 0.25 delta for call and put options
d25_call_strike = delta_call_calc.strikeFromDelta(0.25)
d25_put_strike = delta_put_calc.strikeFromDelta(-0.25)
atm_strike = delta_call_calc.atmStrike(ql.DeltaVolQuote.AtmDeltaNeutral)

The model that extends the Black-Scholes model when dealing with FX options is the Garman-Kohlhagen model, whose dynamics have been defined above. Thus we need to create an instance of the Garman-Kohlhagen process in order to price FX options.

For the sake of simplicity we assume that all the options on the book have the same expiration, and again since we are under the Garman-Kohlhagen model the vol curve is flat, thus the vol across the different strikes is the same (unrealistic assumption). Here’s how the trader book is composed of:

1st Barrier

# Barrier 1
notional = 1_000_000
barrier = 1.30
barrier_type = ql.Barrier.UpOut
exercise = ql.EuropeanExercise(expiration_date)

barrier_25d_130b = call_barrier_factory.get_option(d25_call_strike, exercise, barrier, barrier_type)
barrier_1 = BarrierPosition(barrier_25d_130b, notional, NullInstrument())

2nd Barrier

# Barrier 2
notional = 2_000_000
barrier = 1.08
barrier_type = ql.Barrier.DownOut
exercise = ql.EuropeanExercise(expiration_date)

barrier_25d_108b = call_barrier_factory.get_option(d25_call_strike, exercise, barrier, barrier_type)
barrier_2 = BarrierPosition(barrier_25d_108b, notional, NullInstrument())

3rd Barrier

# Barrier 3
notional = 1_000_000
barrier = 1.20
barrier_type = ql.Barrier.UpIn
exercise = ql.EuropeanExercise(expiration_date)

barrier_25d_120b = call_barrier_factory.get_option(d25_call_strike, exercise, barrier, barrier_type)
backup_vanilla = call_vanilla_factory.get_option(d25_call_strike)
FxVanillaOptionFactory.assign_analyitcal_price_engine(backup_vanilla, process)
barrier_3 = BarrierPosition(barrier_25d_120b, notional, backup_vanilla)

4th Barrier

# Barrier 4
notional = 1_000_000
barrier = 1.05
barrier_type = ql.Barrier.DownOut
exercise = ql.EuropeanExercise(expiration_date)

barrier_25d_105b = put_barrier_factory.get_option(d25_put_strike, exercise, barrier, barrier_type)
barrier_4 = BarrierPosition(barrier_25d_105b, notional, NullInstrument())

5th Barrier

# Barrier 5
notional = 2_000_000
barrier = 1.25
barrier_type = ql.Barrier.UpOut
exercise = ql.EuropeanExercise(expiration_date)

barrier_25d_105b = put_barrier_factory.get_option(d25_put_strike, exercise, barrier, barrier_type)
barrier_5 = BarrierPosition(barrier_25d_105b, notional, NullInstrument())
book: List[BarrierPosition] = [barrier_1, barrier_2, barrier_3, barrier_4, barrier_5]

for ins in book:
    FxBarrierOptionFactory.assign_analyitcal_price_engine(ins.instrument, process)

Thus the premium of the options will be the following

[309.09996820797926,
 36387.852679406504,
 18342.987983359482,
 2064.118402600054,
 25897.462236607375]

Since the AnalyticBarrierEngine in QuantLib doesn’t provide greek calculation functionalities, the simplest method that we can use to calculate the greeks numerically is by using the finite difference method. Let’s the define the basic central differences formulas below, and then specialize them using a partial function application to get the greeks of interest.

First order Finite Difference:

Second order Finite Difference:

Cross partial derivative:

def central_diff(instrument: ql.Instrument, h: float, quote: ql.SimpleQuote) -> float:
    u0 = quote.value()
    quote.setValue(u0 + h)
    P_Plus = instrument.NPV()
    quote.setValue(u0 - h)
    P_Minus = instrument.NPV()

    quote.setValue(u0)
    
    return (P_Plus - P_Minus) / (2 * h)


def central_diff_2nd(instrument: ql.Instrument, h: float, quote: ql.SimpleQuote) -> float:
    u0 = quote.value()
    P = instrument.NPV()
    quote.setValue(u0 + h)
    P_Plus = instrument.NPV()
    quote.setValue(u0 - h)
    P_Minus = instrument.NPV()

    quote.setValue(u0)
    
    return (P_Plus - 2*P + P_Minus) / (h * h)

def cross_central_diff(instrument: ql.Instrument, h: float, k: float, quote_1: ql.SimpleQuote, quote_2: ql.SimpleQuote) -> float:
    u1_0 = quote_1.value()
    u2_0 = quote_2.value()
    
    quote_1.setValue(u1_0 + h)
    quote_2.setValue(u1_0 + k)
    P_Plus_Plus = instrument.NPV()

    quote_1.setValue(u1_0 + h)
    quote_2.setValue(u1_0 - k)
    P_Plus_Minus = instrument.NPV()

    quote_1.setValue(u1_0 - h)
    quote_2.setValue(u1_0 + k)
    P_Minus_Plus = instrument.NPV()

    quote_1.setValue(u1_0 - h)
    quote_2.setValue(u1_0 - k)
    P_Minus_Minus = instrument.NPV()

    quote_1.setValue(u1_0)
    quote_2.setValue(u2_0)
    
    return (P_Plus_Plus - P_Plus_Minus - P_Minus_Plus + P_Minus_Minus) / (4 * h * k)

From that we can easily define the greeks functions:

delta = partial(central_diff, quote=spot_quote)
vega = partial(central_diff, quote=vol_quote)
gamma = partial(central_diff_2nd, quote=spot_quote)
volga = partial(central_diff_2nd, quote=vol_quote)
vanna = partial(cross_central_diff, quote_1=spot_quote, quote_2=vol_quote)

Hedging the book

Now that we have set up the trader portfolio, we need to find the optimal hedge for that portfolio that is going to minimize the sensitivities that we want not be exposed to. Usually a trader sitting in a exotic desk will not just keep low exposure to the classical greeks like , and , but also in some higher order Greeks live DVegaDvol (a.k.a. ) and the DVegaDSpot (a.k.a. ).

This need comes from the fact that in case of exotics (especially for barrier and binaries) the “barrier” risks needs to be hedged: as spot moves closer to the barrier, vega can spike, that’s vanna risk.

The most common way to hedge those greeks in the FX option market is by using simple structure that can be obtained by calls and puts and ATM calls and puts. Here’s the basic structures that will compose our hedging portfolio:

  • Spot: to oviously to hedge the
  • ATM straddles: involves buying an ATM vanilla call and ATM vanilla put, this structure provides positive gamma and positive vega
  • RR (Risks reversals): involves buying an vanilla call and sell a vanilla put, provides a strong vanna exposure (becuase calls and puts respond differently as spot moves)
  • Butterflies: involves buying an vanilla call and sell a vanilla put and selling twice a straddle, provides a strong volga exposure.

Hedge methodology

The way we are going to find the optimal weights of our hedging portfolio is by using the classical parameter hedging methodology. Which mathematically means to set up a linear system where:

The exposure vector is:

which represent the total exposure of our portfolio (the weighted sum of each instrument greek in our exotic portfolio). For each hedge instrument (spot, ATM straddle, RR, BF), compute its greek vector . Form the hedge matrix:

Then solve for weights (position sizes):

In our case the exposure vector is bigger than the hedging vector , since we only 4 instruments and 5 greeks to hedge. We end up with a linear system with 4 variables and 5 equations, thus there is not an exact solution, but we can find a solution that minimized the sum of residual squares.

When we want to calculate the greeks of our portfolio, we want to do it in meaningful way, thus this requires to us to set the shift operator in a way that makes sense to measure the specific risk of our porfolio. The two main ways that industry professional do that is by using 1% of the spot change and 1% vol change.

spot_change = 0.01 * spot_quote.value() / 2
vol_change = 0.01 / 2

delta_book = sum([pos.sensitivity(delta, h=spot_change) for pos in book])
vega_book = sum([pos.sensitivity(vega, h=vol_change) for pos in book])
volga_book = sum([pos.sensitivity(volga, h=vol_change) for pos in book])
gamma_book = sum([pos.sensitivity(gamma, h=spot_change) for pos in book])
vanna_book = sum([pos.sensitivity(vanna, h=spot_change, k=vol_change) for pos in book])

The raw Greek exposition for our book is then the following:

Book Delta exposure: 371644.134787602
Book Gamma exposure: 13330632.102691187
Book Vega exposure: 1183872.580309415
Book Volga exposure: 380633.56067277736
Book Vanna exposure: 190025.47439962075

In FX, Greeks can be confusing, because they depend on the quotation of the currency pair as well as the currency in which they are calculated. Furthermore, premium can be included or excluded, smile-effect can be included or not included, and numerical approximations may further add to the confusion.

What traders use in real life are a “modified version” of the plain greeks:

  • The plain of a forex option gives the amount of Foreing currency a trader would have to buy in the spot-market to delta-hedge a sold-option. To get the amount of dollars to buy those EURs (in our case) we need to multiply the delta by the current spot value.

  • Traders’ : where the spot in the finite diff method is varied by 0.5% and then multiplied by 1%, since traders consider the change of delta as spot changes relatively by 1%.

  • Traders’ : A trader will typically consider vega as the change of the USD or EUR value of a derivative contract (or a book of derivatives) assuming a 1% absolute/constant change in volatility.

Book Delta exposure: $438540.0790493703
Book Gamma exposure: $157301.458811756
Book Vega exposure: $11838.72580309415
Book Volga exposure: $3806.3356067277737
Book Vanna exposure: $2242.300597915525

As you might guess the exposition is negative since we are on the sell-side of the trade, thus we need to buy the hedging structures to hedge ourselves from those greeks.

Our exposure vector is:

# Greek exposure vector
E = np.array([delta_book, gamma_book, vega_book, volga_book, vanna_book])
E
array([  371644.1347876 , 13330632.10269119,  1183872.58030942,
         380633.56067278,   190025.47439962])

For each of the base instrument (Spot, ATM call, ATM put, call and put) let’s calculate the basic greeks.

# hedge_matrix
base_notional = np.float64(1_000_000)
spot_greeks = np.array([1, 0, 0, 0, 0]) * base_notional
atm_call_greeks = np.array([
    delta(atm_call, h=spot_change),
    gamma(atm_call, h=spot_change),
    vega(atm_call, h=vol_change),
    volga(atm_call, h=vol_change),
    vanna(atm_call, h=spot_change, k=vol_change),
]) * base_notional
atm_put_greeks = np.array([
    delta(atm_put, h=spot_change),
    gamma(atm_put, h=spot_change),
    vega(atm_put, h=vol_change),
    volga(atm_put, h=vol_change),
    vanna(atm_put, h=spot_change, k=vol_change),
]) * base_notional
delta25_call_greeks = np.array([
    delta(delta25_call, h=spot_change),
    gamma(delta25_call, h=spot_change),
    vega(delta25_call, h=vol_change),
    volga(delta25_call, h=vol_change),
    vanna(delta25_call, h=spot_change, k=vol_change),
]) * base_notional
delta25_put_greeks = np.array([
    delta(delta25_put, h=spot_change),
    gamma(delta25_put, h=spot_change),
    vega(delta25_put, h=vol_change),
    volga(delta25_put, h=vol_change),
    vanna(delta25_put, h=spot_change, k=vol_change),
]) * base_notional

From there let’s calculate the greek exposure for the strcutures that we are going to use in out hedging portfolio, and then create our Hedge Matrix:

# Let's create the straddle, RR, Butterfly from the base vanilla options
atm_straddle = atm_call_greeks + atm_put_greeks
rr = delta25_call_greeks - delta25_put_greeks
butterfly = delta25_call_greeks + delta25_put_greeks - 2 * atm_straddle

# Hedge Matrix
H = np.stack([spot_greeks, atm_straddle, rr, butterfly]).T

Since our system have more equations than variables, we must use a least square method (provided by np.linalg.lstsq) to solve it. Least square method minimizes the Euclidian 2-norm $ || E - Hx || $.

x, _, _, _ = np.linalg.lstsq(H, E)

Now that we have a solution let’s see what’s our remaining exposure to each of the choosen hedged greeks. We do that by

residual_greeks = (H @ x - E).tolist()

print(f"Residual Delta exposure: ${residual_greeks[0] * spot_quote.value()}")
print(f"Residual Gamma exposure: ${residual_greeks[1] * 0.01 * spot_quote.value()}")
print(f"Residual Vega exposure: ${residual_greeks[2] * 0.01}")
print(f"Residual Volga exposure: ${residual_greeks[3] * 0.01}")
print(f"Residual Vanna exposure: ${residual_greeks[4] * spot_quote.value() * 0.01}")
Residual Delta exposure: $-2.6100315153598783e-09
Residual Gamma exposure: $-13.422826034608855
Residual Vega exposure: $126.72764540341916
Residual Volga exposure: $0.016476123058237136
Residual Vanna exposure: $-0.09291220850032404

Another crucial thing when hedging a book is, of course, to measure the P&L from one rebalancing period to another. Let’s then calculate the value of the various components of our hedging portfolio. We have the the P&L from time is calculated as:

where:

  • is the value of our book at time , which is the sum of the premiums that we’ve been collected
  • is the value of the hedging portfolio, the sum of the premium of the structures that we have bought to hedge our from the various sensistivies
  • the cash/bank account of our portfolio which includes financing of cash and trade cashflows

A shorter way to express the P&L, is just by considering the variation of the value of the book + the variation of the value of the hedges + cost of borrowing + interest accrued:

since the rebalancing of the hedges of the bank account happend at the end of trading day.

spot_premium_eur = x[0] * base_notional
spot_premium_usd = x[0] * base_notional * spot_quote.value()
atm_straddle_premium = atm_call.NPV() + atm_put.NPV() * base_notional * x[1]
rr_premium = delta25_call.NPV() - delta25_put.NPV() * base_notional * x[2]
butterfly_premium = (delta25_call.NPV() + delta25_put.NPV() - 2 * (atm_call.NPV() + atm_put.NPV())) * x[3] * base_notional

The usd borrowed (which is the sum of the premiums of or hedging instrument) is crucial for use to calculate the interest accrued for borrowing the usd dollars to buy the hedging structures.

hedging_str_premium = atm_straddle_premium + rr_premium + butterfly_premium + spot_premium_usd
hedging_str_premium
np.float64(4182631.052146415)

Thus the value of the cash at time is the equal to all the cash that we’ve borrowed to build the hedging structures plus the premiums that we’ve been collected from selling the exotics options

bank_account_value = - hedging_str_premium + np.sum(premiums)
bank_account_value
np.float64(-4099629.5308762337)
port_value = [hedging_str_premium - np.sum(premiums) + bank_account_value]

print(f"The portfolio value at time t = 0 is {port_value[0]}")
The portfolio value at time t = 0 is 0.0

Changes of the hedging portfolio with the changes of the market conditions

Now that we have setup our hedging portfolio see verify how its will change as the spot and vol change. Let’s assume that in a week period the spot went go down by 300 pips and the vol went up by .

spot_quote.setValue(1.15)
vol_quote.setValue(0.14)
ql.Settings.instance().evaluationDate = today + ql.Period(7, ql.Days)
new_premiums = [pos.NPV() for pos in book]

With the new spot and vol let’s recalculate the book exposure

delta_book = sum([pos.sensitivity(delta, h=spot_change) for pos in book])
vega_book = sum([pos.sensitivity(vega, h=vol_change) for pos in book])
volga_book = sum([pos.sensitivity(volga, h=vol_change) for pos in book])
gamma_book = sum([pos.sensitivity(gamma, h=spot_change) for pos in book])
vanna_book = sum([pos.sensitivity(vanna, h=spot_change, k=vol_change) for pos in book])

# new Exposure vector
E = np.array([delta_book, gamma_book, vega_book, volga_book, vanna_book])
Book Delta exposure: $16549.207988699432
Book Gamma exposure: $138778.80052508457
Book Vega exposure: $11096.72161278602
Book Volga exposure: $560.5276947207037
Book Vanna exposure: $2416.5207043533637

As before let’s recalculate the greeks for the basic trading instruments, and then combine to obtain the greeks for the structures used in the hedging portfolio.

# hedge_matrix
base_notional = np.float64(1_000_000)
spot_greeks = np.array([1, 0, 0, 0, 0]) * base_notional
atm_call_greeks = np.array([
    delta(atm_call, h=spot_change),
    gamma(atm_call, h=spot_change),
    vega(atm_call, h=vol_change),
    volga(atm_call, h=vol_change),
    vanna(atm_call, h=spot_change, k=vol_change),
]) * base_notional
atm_put_greeks = np.array([
    delta(atm_put, h=spot_change),
    gamma(atm_put, h=spot_change),
    vega(atm_put, h=vol_change),
    volga(atm_put, h=vol_change),
    vanna(atm_put, h=spot_change, k=vol_change),
]) * base_notional
delta25_call_greeks = np.array([
    delta(delta25_call, h=spot_change),
    gamma(delta25_call, h=spot_change),
    vega(delta25_call, h=vol_change),
    volga(delta25_call, h=vol_change),
    vanna(delta25_call, h=spot_change, k=vol_change),
]) * base_notional
delta25_put_greeks = np.array([
    delta(delta25_put, h=spot_change),
    gamma(delta25_put, h=spot_change),
    vega(delta25_put, h=vol_change),
    volga(delta25_put, h=vol_change),
    vanna(delta25_put, h=spot_change, k=vol_change),
]) * base_notional
# Let's create the straddle, RR, Butterfly from the base vanilla options
atm_straddle = atm_call_greeks + atm_put_greeks
rr = delta25_call_greeks - delta25_put_greeks
butterfly = delta25_call_greeks + delta25_put_greeks - 2 * atm_straddle

# Hedge Matrix
H = np.stack([spot_greeks, atm_straddle, rr, butterfly]).T

The esposure of our hedging portfolio is now is:

# New exposure of the hedging portfolio
exposure = (H @ x - E).tolist()

print(f"Residual Delta exposure: ${exposure[0] * spot_quote.value()}")
print(f"Residual Gamma exposure: ${exposure[1] * 0.01 * spot_quote.value()}")
print(f"Residual Vega exposure: ${exposure[2] * 0.01}")
print(f"Residual Volga exposure: ${exposure[3] * 0.01}")
print(f"Residual Vanna exposure: ${exposure[4] * 0.01 * spot_quote.value()}")
Residual Delta exposure: $-348789.7260608019
Residual Gamma exposure: $73758.42210270112
Residual Vega exposure: $5879.026689021433
Residual Volga exposure: $-54024.14332019365
Residual Vanna exposure: $117.87655605534354

To calculate the P&L from time t to t+1 we need to calculate the change of the value of the hedging portfolio as well

spot_premium_usd = x[0] * base_notional * spot_quote.value()
atm_straddle_premium = atm_call.NPV() + atm_put.NPV() * base_notional * x[1]
rr_premium = delta25_call.NPV() - delta25_put.NPV() * base_notional * x[2]
butterfly_premium = (delta25_call.NPV() + delta25_put.NPV() - 2 * (atm_call.NPV() + atm_put.NPV())) * x[3] * base_notional
new_hedging_str_premium = atm_straddle_premium + rr_premium + butterfly_premium + spot_premium_usd
dt = dc.yearFraction(today, today + ql.Period(7, ql.Days))
usd_interest_cost = hedging_str_premium * r_d * dt
eur_interest_accr = spot_premium_eur * r_f * dt
new_total_portfolio_value = new_hedging_str_premium - np.sum(new_premiums) + bank_account_value - usd_interest_cost + eur_interest_accr * spot_quote.value()

print(f"Portfolio value at time t = 1 is: ${new_total_portfolio_value}")
Portfolio value at time t = 1 is: $-8014.640804257949
The P&L after a week is: $-8014.640804257949

If we want to reduce our exposure and bring it back to a lower one, we need to recalculate the optiomal hedging weight for our hedging portfolio as before:

x_new, _, _, _ = np.linalg.lstsq(H, E)

This how our hedging portfolio has to change:

x_new - x
array([-0.33252725,  3.27195222,  0.99407244,  3.52132318])

The residual greek exposure after the rebalancing is:

Residual Delta exposure: $-4.2255123844370243e-10
Residual Gamma exposure: $1.7120357189066706
Residual Vega exposure: $-16.21605768425856
Residual Volga exposure: $-0.0021280367333383764
Residual Vanna exposure: $0.014062687186218682
]]> Quantitative finance Hedging Exotic options https://your-website-url.example.com/posts/post-with-code/exotic-book.html Sat, 27 Sep 2025 00:00:00 GMT