SVI Raw Parametrisation — Verification Notebook

Companion notebook to the SVI Raw Parametrisation article (Vol Surface Parametrisation, Module 1). Verifies every quantitative claim using Python standard library only.

§0 — Imports
§1 — SVI formula: positivity and shape verification
§2 — Derivatives w′(k) and w″(k): analytic vs finite difference
§3 — Roger Lee bounds check
§4 — Durrleman condition g(k): valid and invalid parameter sets
§5 — Vertex positivity constraint
§6 — Full validation summary

Run cells in order — each cell builds on definitions from the previous ones. Press Shift+Enter to run the focused cell.

§0 — Imports

Standard library only: math for transcendental functions.

import math

print("Imports ready.")

§1 — SVI formula: positivity and shape

Implement the SVI raw parametrisation and verify w(k) > 0 over 200 k-values from −2 to 2.

Reference parameters: a=0.04, b=0.3, ρ=−0.4, m=0, σ=0.1 — a typical equity surface at T=0.5yr.

# SVI raw parametrisation: w(k) = a + b * [rho*(k-m) + sqrt((k-m)^2 + sigma^2)]
A, B, RHO, M, SIGMA = 0.04, 0.3, -0.4, 0.0, 0.1
T = 0.5  # years

def svi_w(k, a=A, b=B, rho=RHO, m=M, sigma=SIGMA):
    return a + b * (rho * (k - m) + math.sqrt((k - m)**2 + sigma**2))

# Grid of 200 k-values
N = 200
k_vals = [-2 + 4 * i / (N - 1) for i in range(N)]
w_vals = [svi_w(k) for k in k_vals]

# Check positivity
min_w = min(w_vals)
max_w = max(w_vals)
atm_w = svi_w(0.0)
atm_vol = math.sqrt(atm_w / T)

print(f"ATM total variance w(0) = {atm_w:.6f}")
print(f"ATM implied vol = sqrt(w(0)/T) = {atm_vol:.4f}  ({atm_vol*100:.2f}%)")
print(f"Min w(k) over grid: {min_w:.6f}  (must be > 0)")
print(f"Max w(k) over grid: {max_w:.6f}")
print(f"All w(k) > 0: {all(w > 0 for w in w_vals)}")
print()
print("Sample values:")
for k in [-1.0, -0.5, 0.0, 0.5, 1.0]:
    print(f"  k={k:+.1f}: w={svi_w(k):.6f}, σ_impl={math.sqrt(svi_w(k)/T)*100:.2f}%")

§2 — Analytic derivatives vs finite differences

Verify that w′(k) and w″(k) match central finite differences to tolerance 10⁻⁸.

def svi_w_prime(k, a=A, b=B, rho=RHO, m=M, sigma=SIGMA):
    """Analytic first derivative dw/dk."""
    return b * (rho + (k - m) / math.sqrt((k - m)**2 + sigma**2))

def svi_w_double_prime(k, a=A, b=B, rho=RHO, m=M, sigma=SIGMA):
    """Analytic second derivative d²w/dk²."""
    return b * sigma**2 / ((k - m)**2 + sigma**2)**1.5

h = 1e-5  # finite difference step

check_points = [-1.5, -0.5, 0.0, 0.5, 1.5]
TOL = 1e-8

print(f"{'k':>6}  {'w_prime analytic':>18}  {'w_prime FD':>14}  {'|error|':>12}  {'ok?':>5}")
print("-" * 62)
all_ok = True
for k in check_points:
    analytic = svi_w_prime(k)
    fd = (svi_w(k + h) - svi_w(k - h)) / (2 * h)
    err = abs(analytic - fd)
    ok = err < TOL
    all_ok = all_ok and ok
    print(f"{k:>6.1f}  {analytic:>18.10f}  {fd:>14.10f}  {err:>12.2e}  {'✓' if ok else '✗':>5}")

print()
print(f"{'k':>6}  {'w_dbl_prime analytic':>20}  {'w_dbl_prime FD':>16}  {'|error|':>12}  {'ok?':>5}")
print("-" * 66)
for k in check_points:
    analytic = svi_w_double_prime(k)
    fd = (svi_w(k + h) - 2*svi_w(k) + svi_w(k - h)) / h**2
    err = abs(analytic - fd)
    ok = err < 1e-4  # second derivative FD has larger rounding
    all_ok = all_ok and ok
    print(f"{k:>6.1f}  {analytic:>20.10f}  {fd:>16.10f}  {err:>12.2e}  {'✓' if ok else '✗':>5}")

print()
print(f"All derivative checks pass: {all_ok}")
print("Note: w''(k) > 0 everywhere (smile is always convex in k-space).")
print(f"Min w''(k) over grid: {min(svi_w_double_prime(k) for k in k_vals):.8f}")

§3 — Roger Lee bounds

The right-wing slope is b(1+ρ) and the left-wing slope is b(1−ρ). Both must be ≤ 2.

right_wing_slope = B * (1 + RHO)
left_wing_slope  = B * (1 - RHO)

print("Roger Lee bound check (slopes must be ≤ 2):")
print(f"  b(1 + ρ) = {B:.2f} × (1 + {RHO:.2f}) = {right_wing_slope:.4f}  ≤ 2: {right_wing_slope <= 2}")
print(f"  b(1 − ρ) = {B:.2f} × (1 − {RHO:.2f}) = {left_wing_slope:.4f}  ≤ 2: {left_wing_slope <= 2}")

# Show a case that violates the Lee bound
B2, RHO2 = 1.5, -0.4
r_slope2 = B2 * (1 + RHO2)
l_slope2 = B2 * (1 - RHO2)
print()
print("Example violating Lee bounds (b=1.5, ρ=−0.4):")
print(f"  b(1 + ρ) = {r_slope2:.4f}  ≤ 2: {r_slope2 <= 2}")
print(f"  b(1 − ρ) = {l_slope2:.4f}  ≤ 2: {l_slope2 <= 2}  ← VIOLATION")

# Verify asymptotically: as k→+inf, w(k) / k → b*(1+rho)
k_large = 20.0
w_large = svi_w(k_large)
asymptotic_slope = w_large / k_large
print()
print(f"Asymptotic check (k={k_large}): w(k)/k = {asymptotic_slope:.6f}  vs b(1+ρ) = {right_wing_slope:.6f}")

§4 — Durrleman condition g(k)

Compute g(k) over the grid and confirm g(k) ≥ 0 for the reference parameters; then demonstrate a butterfly-violating parameter set.

Key insight: SVI is NOT guaranteed to be butterfly-arbitrage-free — g(k) must be checked numerically after every calibration.

def durrleman_g(k, a=A, b=B, rho=RHO, m=M, sigma=SIGMA):
    """Durrleman condition: g(k) >= 0 iff no butterfly arbitrage."""
    w  = svi_w(k, a, b, rho, m, sigma)
    wp = svi_w_prime(k, a, b, rho, m, sigma)
    wpp= svi_w_double_prime(k, a, b, rho, m, sigma)
    term1 = (1 - k * wp / (2 * w))**2
    term2 = (wp**2 / 4) * (1/w + 1/4)
    term3 = wpp / 2
    return term1 - term2 + term3

# Reference parameters
g_vals = [durrleman_g(k) for k in k_vals]
min_g = min(g_vals)
print("Reference parameters (a=0.04, b=0.3, ρ=−0.4, m=0, σ=0.1):")
print(f"  min g(k) over grid: {min_g:.8f}  (must be ≥ 0)")
print(f"  g(k) ≥ 0 everywhere: {all(g >= 0 for g in g_vals)}")

# Butterfly-violating parameters: extreme b and rho close to -1
A_bad, B_bad, RHO_bad, M_bad, SIGMA_bad = 0.01, 1.2, -0.95, 0.0, 0.05
g_bad = [durrleman_g(k, A_bad, B_bad, RHO_bad, M_bad, SIGMA_bad) for k in k_vals]
min_g_bad = min(g_bad)
argmin_k = k_vals[g_bad.index(min_g_bad)]
print()
print("Butterfly-violating parameters (a=0.01, b=1.2, ρ=−0.95, m=0, σ=0.05):")
print(f"  min g(k) = {min_g_bad:.8f} at k={argmin_k:.3f}  (< 0 → butterfly arbitrage)")
print(f"  g(k) ≥ 0 everywhere: {all(g >= 0 for g in g_bad)}")

§5 — Vertex positivity

The minimum of w(k) is at k=m, where w(m) = a + bσ√(1−ρ²). Verify the constraint.

def vertex_value(a, b, rho, sigma):
    """w at the vertex: a + b*sigma*sqrt(1 - rho^2)."""
    return a + b * sigma * math.sqrt(1 - rho**2)

test_cases = [
    (0.04,  0.30, -0.40, 0.10, "reference"),
    (0.00,  0.30, -0.40, 0.10, "a=0, boundary"),
    (-0.01, 0.30, -0.40, 0.10, "a<0, needs b*sigma*sqrt(1-rho^2)>0.01"),
    (0.04,  0.30, -0.99, 0.10, "rho near -1, vertex shrinks"),
]

print(f"{'Case':35} {'vertex w':>10} {'positive?':>10}")
print("-" * 58)
for a, b, rho, sigma, label in test_cases:
    v = vertex_value(a, b, rho, sigma)
    print(f"{label:35} {v:>10.6f} {'✓' if v >= 0 else '✗':>10}")

# Verify that the actual minimum of svi_w is at or near k=m
k_fine = [-2 + 4 * i / 999 for i in range(1000)]
w_fine = [svi_w(k) for k in k_fine]
k_min_numerical = k_fine[w_fine.index(min(w_fine))]
print(f"\nNumerical minimum of w at k = {k_min_numerical:.4f}  (m = {M})")

§6 — Validation summary

Consolidates all checks from §1–§5.

results = []

# 1. ATM value
w0 = svi_w(0.0)
expected_w0 = A + B * SIGMA  # = a + b*sigma at k=m=0
results.append(("ATM w(0) = a + b*sigma",
                abs(w0 - expected_w0) < 1e-12))

# 2. Positivity over grid
results.append(("w(k) > 0 for all k in [-2,2]",
                all(svi_w(k) > 0 for k in k_vals)))

# 3. Derivative accuracy (first)
max_err_prime = max(abs(svi_w_prime(k) - (svi_w(k+1e-5)-svi_w(k-1e-5))/(2e-5))
                    for k in check_points)
results.append(("w'(k) analytic vs FD: max |error| < 1e-8",
                max_err_prime < 1e-8))

# 4. w''(k) > 0 everywhere
results.append(("w''(k) > 0 for all k (smile always convex)",
                all(svi_w_double_prime(k) > 0 for k in k_vals)))

# 5. Lee bounds
results.append(("Lee bound: b(1+ρ) ≤ 2",
                B * (1 + RHO) <= 2))
results.append(("Lee bound: b(1−ρ) ≤ 2",
                B * (1 - RHO) <= 2))

# 6. Durrleman (reference params)
results.append(("Durrleman g(k) ≥ 0 (reference params)",
                all(durrleman_g(k) >= 0 for k in k_vals)))

# 7. Durrleman violation detected for bad params
results.append(("Butterfly violation detected (bad params)",
                any(durrleman_g(k, A_bad, B_bad, RHO_bad, M_bad, SIGMA_bad) < 0
                    for k in k_vals)))

# 8. Vertex positivity
results.append(("Vertex positivity: a + b*sigma*sqrt(1-rho^2) ≥ 0",
                vertex_value(A, B, RHO, SIGMA) >= 0))

print("=" * 62)
print("SVI Raw Parametrisation — Validation Summary")
print("=" * 62)
for label, passed in results:
    print(f"  {'✓' if passed else '✗'}  {label}")
total = sum(1 for _, p in results if p)
print(f"\n  {total}/{len(results)} checks passed.")