Panjer recursion
/ PAN-yer /
You want the full distribution of total annual losses S — not just its mean, but the probability that S equals 0, or 1,000, or 50,000, all the way up the tail. The brute-force way is to consider every possible number of claims and add up the size distributions, an explosion of calculations. The Panjer recursion is a clever shortcut that computes the whole aggregate distribution one value at a time, building each probability from the ones already found.
It works whenever frequency belongs to the (a,b,0) or (a,b,1) class (Poisson, binomial, negative binomial, and their zero-modified versions) and severity is put on a discrete grid (rounded to multiples of some unit, say 100). The recursion expresses the probability that the aggregate equals each grid point in terms of the severity probabilities and the probabilities for smaller aggregate values, using the same constants a and b that define the frequency class. Starting from the probability of zero total loss, it marches upward: each new probability is a weighted sum of earlier ones. This replaces an exact but astronomically slow convolution with an exact and fast loop.
The Panjer recursion is the standard exact method for aggregate-loss distributions in practice, used for pricing, reserving, reinsurance layers, and capital, and it is far more accurate in the tail than the tempting normal approximation. Two honest caveats. First, it requires discretising the severity, and the choice of span (grid width) trades accuracy against speed — too coarse a grid distorts the answer, especially in the tail. Second, it relies on frequency being in the (a,b,0)/(a,b,1) family; for frequencies outside that family, or for very large grids, practitioners turn to the fast Fourier transform or Monte Carlo simulation instead.
With Poisson frequency (a = 0, b = lambda) and severity discretised so a claim is 1 or 2 units with probabilities 0.6 and 0.4, the recursion starts from P(S = 0) = e^(-lambda) and then computes P(S = 1), P(S = 2), and so on, each from earlier values times the severity probabilities scaled by lambda/k. Within a quick loop the entire distribution of S — and hence any tail probability — is produced exactly.
Build P(S = each value) upward from P(S = 0) — exact, fast, far better in the tail than a normal fit.
The recursion needs the severity discretised onto a grid, and a too-coarse grid distorts the result, especially in the tail. It also requires frequency in the (a,b,0)/(a,b,1) family; outside it, use FFT or simulation instead.