Value at Risk

The loss exceeded with probability only 1 − α:

$$\operatorname{VaR}_\alpha(S) = F_S^{-1}(\alpha)$$

“In 199 years out of 200, the loss is no more than this.” (α = 99.5%, the Solvency II standard)

Tail Value at Risk (CTE)

The average loss given we’re in the tail:

$$\operatorname{TVaR}_\alpha(S) = E\big[S \mid S \ge \operatorname{VaR}_\alpha(S)\big]$$

# src/foundations/risk.py
import numpy as np


def value_at_risk(losses: np.ndarray,
                  level: float = 0.995) -> float:
    """Empirical VaR: the `level` quantile of losses."""
    if not 0 < level < 1:
        raise ValueError(f"level must be in (0, 1), got {level}")
    return float(np.quantile(losses, level))


def tail_value_at_risk(losses: np.ndarray,
                       level: float = 0.995) -> float:
    """Mean loss in the worst (1 - level) of outcomes."""
    var = value_at_risk(losses, level)
    return float(losses[losses >= var].mean())

• Driver k has N_k ~ Poisson(λ_k) claims, independently
• A sum of independent Poissons is Poisson: the portfolio’s claim count is N ~ Poisson(Σλ_k)
• Severities don’t depend on the driver, so each year’s total is a compound Poisson sum

So: draw a count per year, draw all severities at once, then add them up by year.

counts = np.array([2, 0, 3])            # claims in years 0, 1, 2
paid = np.array([10., 20, 30, 40, 50])  # all claims, in order
year = np.repeat(np.arange(3), counts)  # [0 0 2 2 2]
np.bincount(year, weights=paid, minlength=3)
# [ 30.   0. 120.]

def simulate_annual_losses(freq: np.ndarray,
                           n_years: int,
                           rng: np.random.Generator,
                           severity,
                           deductible: float = 500.0,
                           limit: float = 50_000.0
                           ) -> np.ndarray:
    """Total paid losses in each of n_years years.

    Claim counts are Poisson with rate freq.sum();
    each claim is severity - deductible, floored at
    0 and capped at limit.
    """
    counts = rng.poisson(freq.sum(), size=n_years)
    ground_up = severity.rvs(size=counts.sum(),
                             random_state=rng)
    paid = np.minimum(np.maximum(ground_up - deductible,
                                 0.0), limit)
    year = np.repeat(np.arange(n_years), counts)
    return np.bincount(year, weights=paid,
                       minlength=n_years)

make_portfolio is Lesson 7’s generator code as a function (same draws, same order). Runs in well under a second.