Panjer Recursion for Aggregate Claims

The Panjer Class

Panjer recursion applies when the claim count distribution belongs to the (a,b,0) class, meaning it satisfies the recursive relationship P(N=n) = (a + b/n) * P(N=n-1) for n >= 1. Only three distributions belong to this class: the Poisson, the negative binomial, and the binomial. Each is characterized by specific values of a and b.

For the Poisson distribution with parameter lambda: a = 0 and b = lambda. The recursive relationship becomes P(N=n) = (lambda/n) * P(N=n-1), which you can verify directly from the Poisson PMF. For the negative binomial with parameters r and beta: a = beta/(1+beta) and b = (r-1)*beta/(1+beta). For the binomial with parameters m and q: a = -q/(1-q) and b = (m+1)*q/(1-q). The sign of a distinguishes the three: a = 0 for Poisson, a > 0 for negative binomial, and a < 0 for binomial.

Why Panjer Recursion Matters

Computing the distribution of aggregate losses S = X_1 + X_2 + ... + X_N requires knowing the distribution of a random sum. For general frequency and severity distributions, this involves an infinite mixture of convolutions, which is analytically intractable. Direct computation would require summing P(S=s) = sum over n of P(N=n) * P(X_1+...+X_n = s), where each convolution P(X_1+...+X_n = s) is expensive to compute.

Panjer recursion avoids this by exploiting the recursive structure of the (a,b,0) frequency class. Instead of computing convolutions for each possible value of N separately, the recursion builds the aggregate PMF directly, one value at a time, using previously computed values. This is vastly more efficient and makes exact aggregate loss calculations practical for realistic portfolio sizes.

Setting Up the Recursion

Before applying the recursion, the severity distribution must be discretized onto a lattice with span h. If the severity is already discrete with values that are multiples of h, no approximation is needed. Otherwise, you discretize using one of three methods: the rounding method (each loss is rounded to the nearest multiple of h), the unmodified method (probability mass is concentrated at the lower lattice point), or the method of rounding that preserves the mean.

Let f_j = P(X = j*h) denote the discretized severity PMF for j = 0, 1, 2, .... The starting value of the recursion is g_0 = P(S = 0) = P_N(f_0), where P_N is the probability generating function of N evaluated at f_0. For the Poisson with parameter lambda, g_0 = exp(-lambda*(1-f_0)). If the severity has no probability at zero (f_0 = 0), then g_0 = P(N=0).

The Recursion Formula

The Panjer recursion computes g_k = P(S = k*h) for k = 1, 2, 3, ... using the formula: g_k = (1/(1 - a*f_0)) * sum from j=1 to k of (a + b*j/k) * f_j * g_{k-j}. Each new value g_k depends on the severity values f_1 through f_k and the previously computed aggregate probabilities g_0 through g_{k-1}. The factor 1/(1 - a*f_0) accounts for the possibility of zero-amount claims.

When f_0 = 0 (which is common since most severity distributions have no probability mass at zero), the formula simplifies to g_k = sum from j=1 to k of (a + b*j/k) * f_j * g_{k-j}, since the denominator becomes 1.

Worked Example

Suppose N ~ Poisson(2) and the severity distribution is P(X=1) = 0.6, P(X=2) = 0.3, P(X=3) = 0.1, with h = 1. Then a = 0, b = 2, and f_0 = 0, f_1 = 0.6, f_2 = 0.3, f_3 = 0.1.

Starting value: g_0 = exp(-2*(1-0)) = exp(-2) = 0.1353.

For k=1: g_1 = (0 + 2*1/1)*f_1*g_0 = 2*0.6*0.1353 = 0.1624.

For k=2: g_2 = (0 + 2*1/2)*f_1*g_1 + (0 + 2*2/2)*f_2*g_0 = 1*0.6*0.1624 + 2*0.3*0.1353 = 0.0974 + 0.0812 = 0.1786.

For k=3: g_3 = (2*1/3)*f_1*g_2 + (2*2/3)*f_2*g_1 + (2*3/3)*f_3*g_0 = (2/3)*0.6*0.1786 + (4/3)*0.3*0.1624 + 2*0.1*0.1353 = 0.0714 + 0.0650 + 0.0271 = 0.1635.

You can verify these results against the direct calculation by conditioning on N = 0, 1, 2, 3, ... and computing convolutions, but the recursion is far more efficient.

Practical Considerations

The choice of span h involves a trade-off between accuracy and computation. A smaller h gives a finer approximation of the continuous severity distribution but requires more recursion steps to cover the same range of aggregate losses. A larger h reduces computation but introduces more discretization error. In practice, h should be small enough that the discretized severity accurately represents the original distribution's shape.

The recursion must be carried out to a sufficiently large value of k that the cumulative probability sum of g_0 through g_K is close to 1 (typically 0.999 or higher). Once the aggregate PMF is computed, you can calculate any quantity of interest: the CDF of S, stop-loss premiums E[max(S-d, 0)], VaR, TVaR, and other risk measures.

Common Pitfalls

A frequent error is misidentifying the values of a and b for the given frequency distribution. Double-check by verifying that the recursion P(N=n) = (a + b/n)*P(N=n-1) reproduces the correct probabilities for the first few values of n. Another common mistake is forgetting the 1/(1-a*f_0) factor when f_0 is nonzero. When working through the recursion by hand, carefully track each term in the sum and avoid arithmetic errors by organizing your work in a table with columns for j, (a + b*j/k), f_j, g_{k-j}, and their product.

Students also sometimes confuse the span h with the claim amounts. If the severity takes values 100, 200, 300, you can use h = 100 and work with f_1, f_2, f_3 on the rescaled lattice. The aggregate probabilities g_k then correspond to aggregate losses of k*100.

Study Tips

Exam STAM tests your ability to set up and execute several steps of Panjer recursion by hand. Practice with Poisson frequency first (since a = 0 simplifies the formula), then move to negative binomial examples. Work through at least three complete examples, computing g_0 through g_4 or g_5. Make sure you can handle both the case f_0 = 0 and f_0 > 0. Once you have the aggregate PMF, practice computing stop-loss premiums and percentiles from it. Speed is important, so develop a systematic tabular approach that minimizes the chance of arithmetic errors.