Vol surface no-arbitrage conditions

Intuition. A call option with expiry T2 > T1 cannot be worth less than the same call at T1, same strike. The T2 option gives the holder everything the T1 option gives — the right to buy the asset at K — plus the additional right to benefit from the period between T1 and T2. If the T2 option were cheaper, you could buy the T2 option, sell the T1 option, pocket the difference, and guarantee a non-negative payoff at expiry.

Formal condition. Define the total variance at expiry T and strike K:

w(T, K) = σ²_implied(T, K) × T

Calendar-spread no-arbitrage requires w to be non-decreasing in T for every fixed K. Equivalently, the forward variance between T1 and T2

w_fwd = w(T2, K) − w(T1, K)

must be non-negative.

QuantLib detection.

// blackForwardVariance returns w(T2,K) - w(T1,K)
Real fwdVar = volSurface->blackForwardVariance(t1, t2, strike);
if (fwdVar < 0.0) {
    // Calendar-spread arbitrage: the surface cannot be used
    // with LocalVolSurface — Dupire's numerator is negative.
    throw std::runtime_error("Calendar-spread arbitrage detected");
}

BlackVarianceSurface stores and interpolates total variance. It does not enforce this condition on its own — it returns whatever the interpolation gives. LocalVolSurface will silently produce NaN if you pass it an arbitraged surface.

Numbers example. Suppose at K = 100:

This is fine: 0.01 < 0.0162 < 0.0361. Now suppose the 0.5Y vol is 14% instead of 18%:

Now w(0.5) = 0.0098 < w(0.25) = 0.01. Calendar-spread arbitrage.

Intuition. A butterfly spread is: buy a call at K−δ, sell two calls at K, buy a call at K+δ. Its payoff at expiry is always non-negative (it is tent-shaped). If it has a negative cost today, that is a free lunch. For the butterfly to have non-negative cost, the call price function must be convex in the strike direction.

Formal condition. The second derivative of the call price with respect to strike:

∂²C/∂K² ≥ 0 everywhere

This quantity is proportional to the risk-neutral density. A negative second derivative means a negative probability density — the smile is "too concave" in that region. Geometrically: if you plot the vol smile σ(K) and it bends downward too aggressively (the wings drop away from the ATM too fast), the implied density in the wings can go negative.

Why it happens in practice. The SABR model at low strikes (high skew, low vol) is well-known to violate butterfly arbitrage. A tightly calibrated SVI (Stochastic Volatility Inspired) parameterisation can also produce it if the wings are pushed too hard.

QuantLib detection.

// SmileSection::digitalOptionPrice gives the undiscounted digital call price
// = integral of density from K to infinity, so must be in [0, 1]
Real digi = smileSection->digitalOptionPrice(strike, Option::Call);
if (digi < 0.0 || digi > 1.0) {
    // Butterfly arbitrage: the density is negative somewhere
}

// More directly: density at K is
Real density = smileSection->density(strike);
if (density < 0.0) {
    // Butterfly arbitrage
}

NoArbSabrSmileSection and NoArbSabrInterpolatedSmileSection are QuantLib classes that build a SABR smile with an explicit butterfly constraint. They are significantly slower than plain SabrSmileSection because they enforce the constraint numerically.

Numbers example. Suppose at T = 1Y the smile gives (hypothetically):

Butterfly cost at K = 100: 8.50 − 2 × 5.00 + 2.80 = 1.30 > 0. Fine. Now suppose the skew is more extreme:

Butterfly cost: 7.80 − 10.00 + 3.50 = 1.30. Still fine. But:

Butterfly cost: 6.00 − 10.00 + 4.50 = 0.50. Fine. And:

Butterfly cost: 5.20 − 10.00 + 5.10 = 0.30. Fine. But if we flatten the smile so much that:

Butterfly cost: 4.80 − 10.00 + 5.30 = 0.10. Still fine, but the smile is now inverted (higher strike = higher call price), which is separately weird. The violation arises when the call price curve is not convex — a concave region gives a negative butterfly.

Intuition. Put-call parity is the relationship:

C(T, K) − P(T, K) = DF(T) × (F(T) − K)

where DF(T) is the discount factor to T and F(T) is the forward price. Given this relationship, the implied vol of a call equals the implied vol of the put at the same strike and expiry. If they differ, you can construct a riskless portfolio.

When it is violated. In practice, put-call parity is trivially satisfied if you use a single consistent model: same implied vol, same forward, same discount factor for calls and puts at the same strike/expiry. It only breaks when:

1. Different forward conventions are used for calls vs puts (e.g. mixing ATM forward conventions in FX surface construction).
2. Dividend or funding adjustments are inconsistent.
3. Two separate surfaces are calibrated independently for calls and puts.

In ORE and QuantLib, if you use a single BlackVarianceSurface or a single SmileSection for both calls and puts, put-call parity is automatic. The risk is in bespoke calibration pipelines that calibrate puts and calls separately.

A Gaussian Mixture Model (GMM) fitted to historical returns lives in the physical measure (P-measure): it describes what prices have done historically, not what the market prices them at today. The resulting surface may violate both calendar-spread and butterfly conditions because:

• Historical expiry slices are fitted independently; total variance is not constrained to be non-decreasing across time.
• The mixture components at a given expiry are chosen to fit historical data, not to satisfy ∂²C/∂K² ≥ 0.

Post-processing is required: either re-fit with explicit constraints, or apply a repair step (e.g. monotone projection of total variance).

A GJR-GARCH neural-network model generates a Gaussian mixture density directly in the risk-neutral measure (Q-measure). Because a Gaussian mixture density is always strictly positive (each component is a Gaussian bell curve; a positive weighted sum of positive functions is positive), butterfly arbitrage is automatically satisfied for each fixed expiry.

Calendar-spread arbitrage can still be violated if two separately generated expiry slices produce inconsistent ATM levels (e.g. the 3M surface has higher total variance than the 6M surface). The frozen-pool method addresses exactly this.

The key result from the sprint-21 paper (Van den Berg) is that calendar-spread arbitrage across expiry pillars can be enforced cheaply if the smile representation is a mixture density (Gaussian or lognormal).

The idea: between two calibrated expiry pillars T1 and T2, represent the intermediate call price surface as a convex combination of the pillar call price surfaces:

C(T, K) = α(T) × C(T1, K) + (1 − α(T)) × C(T2, K),   T ∈ [T1, T2]

where α(T) decreases from 1 at T1 to 0 at T2. Because C(T1,K) and C(T2,K) are both valid call price surfaces (non-negative ∂²C/∂K²), their convex combination is also a valid call price surface — butterfly no-arbitrage is preserved at all intermediate times.

Calendar-spread no-arbitrage is also preserved: the derivative ∂C/∂T is proportional to C(T2,K) − C(T1,K), which is non-negative if and only if the T2 pillar has higher total variance than the T1 pillar at every strike. The "frozen-pool" constraint is that component locations (means and spreads of the mixture) are held constant between pillars; only the mixture weights α(T) move. This makes the interpolation analytically tractable and avoids introducing new arbitrage.

Why this is useful for ORE. ORE's BlackVarianceSurface uses bilinear or cubic interpolation of total variance between pillars. That interpolation does not in general preserve butterfly no-arbitrage (it only trivially preserves calendar-spread if total variance is linearly interpolated). The frozen-pool method is a drop-in replacement that provides stronger guarantees and is still cheap to evaluate.