Calculate Discrete Aggregate Losses by Recursion

Why Use a Recursion for Aggregate Losses?

A compound aggregate loss combines a random number of payments with a random payment amount for each claim. Even when the claim count and individual payments have simple distributions, directly enumerating every possible combination of claim counts and payment amounts can become cumbersome. Discretizing payments onto a regular grid makes it possible to calculate aggregate probabilities sequentially, one grid point at a time.

This tutorial develops the compound Poisson recursion for that calculation. The recursion applies to the discretized model: it gives exact probabilities for the chosen grid approximation, not necessarily for the original continuous payment distribution. The grid and rounding rule therefore matter.

Definition: Let $N\sim\operatorname{Poisson}(\lambda)$ be the number of claims, and let $Y$ be the payment for one claim, independent of $N$. Suppose the payment has been discretized onto the lattice $0,h,2h,\ldots$, where $h>0$, with $P(Y=jh)=f_j$ for $j=0,1,\ldots$. The discretized aggregate payment is $S=\sum_{r=1}^{N}Y_r$, with $S=0$ when $N=0$. Define $q_k=P(S=kh)$.

The probabilities $f_j$ must form a probability distribution: $f_j\geq 0$ and $\sum_{j=0}^{\infty}f_j=1$. In a finite severity table, any probability not assigned to a listed positive payment must still be accounted for, often as a zero payment. In a coverage setting, $Y$ is the per-claim payment after applying the hypothetical policy terms, not automatically the ground-up loss.

A zero payment is allowed. For example, a claim may produce no payment because it does not exceed a deductible. The Poisson count $N$ may count all claims, including claims with zero payment. In that case $f_0$ is part of the severity vector and affects the aggregate distribution. Equivalently, the number of positive payments is Poisson with mean $\lambda(1-f_0)$, but the recursion below works directly with $N$ and the full severity vector.

The Compound Poisson Recursion

Under the assumptions above—independent Poisson claim count, independent and identically distributed nonnegative claim payments, and payments on a common lattice—the aggregate probabilities satisfy

q_0=\exp\{-\lambda(1-f_0)\}, \qquad q_k=\frac{\lambda}{k}\sum_{j=1}^{k}j f_j q_{k-j},\quad k\geq 1.

The recursion calculates $q_0$ first, then $q_1$, then $q_2$, and so on. At stage $k$, every term on the right uses an aggregate probability already calculated. Severity probabilities $f_j$ with $j>k$ cannot contribute to an aggregate of exactly $kh$, since all payments are nonnegative.

Why the Recursion Holds

A probability generating function (PGF) for a nonnegative integer-valued random variable $W$ is $E[z^W]$. Represent one discretized payment $Y$ by its lattice index $J=Y/h$, whose PGF is $F(z)=\sum_{j=0}^{\infty}f_jz^j$. Conditional on $N=n$, the aggregate lattice index is a sum of $n$ independent copies of $J$, so its PGF is $F(z)^n$. Averaging over a Poisson count gives the aggregate PGF

G(z)=E[z^{S/h}] =\sum_{n=0}^{\infty}e^{-\lambda}\frac{\lambda^n}{n!}F(z)^n =\exp\{\lambda(F(z)-1)\}.

Differentiate this identity. Since $G'(z)=\sum_{k\geq 1}kq_kz^{k-1}$ and $F'(z)=\sum_{j\geq 1}j f_jz^{j-1}$, the chain rule gives $G'(z)=\lambda F'(z)G(z)$. Equating coefficients of $z^{k-1}$ on both sides gives

kq_k=\lambda\sum_{j=1}^{k}j f_jq_{k-j}.

Dividing by $k$ yields the recursion. Also, $G(0)=q_0=\exp\{\lambda(f_0-1)\}$, which is the stated expression for $q_0$. This starting value includes cases where one or more claims occur but all their payments are zero. If there are no zero payments, $f_0=0$, and $q_0=e^{-\lambda}$, the probability of no claims.

Worked Example: Strictly Below a Grid Threshold

A hypothetical portfolio has $N\sim\operatorname{Poisson}(0.8)$ claims. After all policy terms, each claim payment is \$0 with probability 0.20, \$50 with probability 0.50, and \$100 with probability 0.30. Calculate the probability that the discretized aggregate payment is less than \$100. There is no discounting or mortality assumption in this one-period payment model.

Method and severity check. The grid width is $h=\$50$, so the lattice indices for the three payment amounts are 0, 1, and 2. Thus $f_0=0.20$, $f_1=0.50$, and $f_2=0.30$. The probabilities are nonnegative and sum to $0.20+0.50+0.30=1.00$.

First calculate the probability of aggregate payment zero:

q_0=e^{-0.8(1-0.20)}=e^{-0.64}=0.527292.

For an aggregate of \$50, the recursion gives

q_1=\frac{0.8}{1}(1)(0.50)q_0 =0.40(0.527292)=0.210917.

The event “aggregate payment is less than \$100” includes both lattice outcomes \$0 and \$50. Therefore,

P(S<\$100)=q_0+q_1 =0.527292+0.210917 =0.738209\approx 0.7382.

The answer is a probability, and the two included outcomes are disjoint. The calculation is checked by summing both of them; using $q_0$ alone would omit the possible \$50 aggregate.

Working from Contract Payments to the Severity Vector

When the payment distribution is supplied through a hypothetical contract, first determine the payment for each possible loss, then discretize those payments. Do not discretize the ground-up loss and treat the result as the covered payment unless the problem specifically defines that method. The recursion needs the probability vector for the quantity that is actually being aggregated.

Worked Example: Discretizing Payments After a Deductible and Limit

A hypothetical policy pays the lesser of the amount above a \$50 deductible and a \$150 per-claim limit. Ground-up losses are \$40, \$130, and \$260 with probabilities 0.25, 0.50, and 0.25, respectively. The claim count is $N\sim\operatorname{Poisson}(1.2)$. Downward-discretize the policy payments to a grid of $h=\$50$, and calculate the probability that aggregate payment is at most \$100. No interest or mortality is assumed.

Method and payment calculation. The payment is $Y=\min((X-\$50)_+,\$150)$, where $(a)_+=\max(a,0)$. The three losses produce payments

\$40\longmapsto \$0,\qquad \$130\longmapsto \$80,\qquad \$260\longmapsto \$150.

Downward discretization sends a payment $y$ to $h\lfloor y/h\rfloor$. Consequently, \$0 maps to \$0, \$80 maps to \$50, and \$150 maps to \$150. In lattice indices, the payments are 0, 1, and 3, so $f_0=0.25$, $f_1=0.50$, $f_2=0$, $f_3=0.25$. These probabilities sum to 1.

The zero-aggregate probability is

q_0=e^{-1.2(1-0.25)}=e^{-0.9}=0.406570.

The next two probabilities follow in order:

q_1=\frac{1.2}{1}(0.50)q_0 =0.60(0.406570)=0.243942, $$ $$ q_2=\frac{1.2}{2}\{(1)(0.50)q_1+(2)(0)q_0\} =0.60(0.121971)=0.073183.

“At most \$100” includes lattice indices 0, 1, and 2, so the required probability is

P(S\leq \$100)=q_0+q_1+q_2 =0.406570+0.243942+0.073183 =0.723695\approx 0.7237.

The index 3 payment is \$150, which exceeds the threshold. It is correct that $f_3$ does not enter the recursions for $q_1$ and $q_2$, but its probability must remain in the severity vector and is relevant to higher aggregate amounts.

Discretization Changes Aggregate Probabilities

Downward discretization replaces each payment by a value no larger than the original payment; upward discretization replaces it by a value no smaller. These choices can shift aggregate probabilities, especially near a threshold. A probability calculated on a grid is not automatically an exact probability for the unrounded payments. The next example compares the event directly with two grid approximations.

Worked Example: Comparing Exact and Rounded Aggregate Probabilities

A hypothetical portfolio has $N\sim\operatorname{Poisson}(0.5)$ claims. Each claim payment is \$25 with probability 0.40 or \$75 with probability 0.60. Find the exact probability that the aggregate is less than \$50, then compare it with downward and upward discretization using $h=\$50$. There is no discounting or mortality assumption.

Exact calculation. An aggregate below \$50 occurs either when there are no claims or when there is exactly one claim and its payment is \$25. Two or more claims produce at least \$50. Thus

P(S<\$50)=P(N=0)+P(N=1)P(Y=\$25) =e^{-0.5}+e^{-0.5}(0.5)(0.40) =0.727837\approx 0.7278.

Downward discretization. The \$25 payment maps to \$0 and the \$75 payment maps to \$50. Therefore $f_0=0.40$, $f_1=0.60$, and

P(S_{\mathrm{down}}<\$50)=q_0 =e^{-0.5(1-0.40)} =e^{-0.30}=0.740818\approx 0.7408.

Only index 0 is below \$50 on this grid. The downward approximation is larger than the exact probability by $0.740818-0.727837=0.012981$, because some \$25 payments have been rounded down to zero.

Upward discretization. The \$25 payment maps to \$50 and the \$75 payment maps to \$100. There are no zero payments in this rounded severity vector, so

P(S_{\mathrm{up}}<\$50)=q_0=e^{-0.5}=0.606531\approx 0.6065.

The upward approximation is below the exact probability: a single original \$25 payment, which satisfies the strict threshold, has been rounded up to \$50 and no longer satisfies it. Both approximations use the same claim frequency; the difference arises from the payment rounding rule.

Common Exam Trap: Confusing a Threshold with One Lattice Outcome

A recursion returns $q_k$, the probability of exactly $kh$. A question asking for an aggregate below or at a threshold generally asks for a sum of several $q_k$'s. The strictness of the inequality matters: on a grid of width $h$, “less than $mh$” includes indices $0,\ldots,m-1$, while “at most $mh$” includes indices $0,\ldots,m$.

For example, in the first worked example, the incorrect calculation for “less than \$100” is $P(S<\$100)=q_0=0.5273$. That calculation counts only aggregate payment \$0. The correction is $P(S<\$100)=q_0+q_1=0.7382$, because \$50 is also less than \$100. In general, for nonnegative lattice payments,

P(S< mh)=\sum_{k=0}^{m-1}q_k,\qquad P(S\leq mh)=\sum_{k=0}^{m}q_k.

Other useful checks are to verify that the severity probabilities sum to one, retain any zero-payment probability, and ensure every recursion uses previously calculated probabilities. If the full aggregate distribution is calculated, its probabilities should sum to one; if only a finite range is calculated, their partial sum cannot exceed one.

Determine the payment.
Apply the hypothetical contract terms to each possible loss before constructing the payment distribution.

Choose and apply the grid.
State $h$ and whether payments are rounded down, up, or by another specified rule.

Check the severity vector.
Record all $f_j$, including $f_0$, and verify that the probabilities are nonnegative and sum to one.

Recurse and sum the requested outcomes.
Calculate $q_0,q_1,\ldots$ in order, then include every lattice index satisfying the stated threshold.

Key takeaway: The compound Poisson recursion calculates exact probabilities for a specified discretized model. Correct answers depend on using the post-coverage payment vector, handling $f_0$ correctly, and summing all lattice probabilities that meet the requested aggregate condition. This treatment is aligned with the SOA Exam ASTAM (Advanced Short-Term Actuarial Mathematics) syllabus.

Check Your Understanding

For each problem, identify the relevant lattice outcomes before summing aggregate probabilities.

A portfolio has $N\sim\operatorname{Poisson}(0.4)$. A payment is zero with probability 0.50 and \$10 with probability 0.50. Find the probability of zero aggregate payment. (Answer: 0.8187)
Let $N\sim\operatorname{Poisson}(1)$, with per-claim payments \$10 and \$20 having probabilities 0.60 and 0.40. Find the probability that the aggregate is less than \$20. (Answer: 0.5886)
Let $N\sim\operatorname{Poisson}(0.5)$, and let the payment probabilities at \$0, \$10, and \$20 be 0.20, 0.50, and 0.30. Using a \$10 grid, find the probability that the aggregate is at most \$20. (Answer: 0.9594)
Let $N\sim\operatorname{Poisson}(2)$, with discretized payments of \$0, \$10, and \$30 having probabilities 0.30, 0.40, and 0.30. Find the probability that the aggregate is at most \$20. (Answer: 0.5228)
A portfolio has $N\sim\operatorname{Poisson}(0.6)$, and raw payments of \$12, \$38, and \$62 have probabilities 0.20, 0.50, and 0.30. Downward-discretize to a \$25 grid and find the probability that aggregate payment is less than \$50. (Answer: 0.8044)

What You'll Learn