Skip to content

Economic Modelling · Ruin theory

Discrete-Time Ruin Probability and Simulation

Updated 11 October 2026 · Fact-checked

Discrete-time ruin looks at an insurer's surplus only at the end of each period. Ruin happens if the surplus is ever below zero. To find the finite-time ruin probability, work out the survival probability by conditioning on the first period's claim, and repeat. If that is too hard, simulate many surplus paths and count the ruined ones.

Understand Discrete-Time Ruin and Simulation

A surplus process tracks an insurer's money over time. In discrete time you look at it at times 0, 1, 2, and so on. The surplus at time t is U(t) = u + c·t − S(t). Here u is the initial surplus, c is the premium received each period, and S(t) is the total of the claims up to time t.

Ruin means the surplus falls below zero at one of the time points. The finite-time ruin probability ψ(u, n) is the chance that ruin happens at some time t ≤ n. The survival probability is φ(u, n) = 1 − ψ(u, n). Surplus is only checked at the end of each period, so a dip below zero in the middle of a period does not count. Surplus of exactly zero is not ruin.

The key idea behind the recursion is to look at what happens in the first period. The surplus becomes u + c − X, where X is the first claim. If that is negative you are ruined. If not, the process starts afresh from the new surplus with one period fewer left. This gives a formula that is easy to run on a table, working from n = 1 upwards.

This works well when claims and premiums are whole numbers, so only a few surplus values are possible. Then you can build a small table of φ(u, n) by hand. When claims are continuous or the model is more complex, exact answers are hard. You then use simulation: generate many surplus paths with random claims, record whether each is ruined, and use the proportion ruined as an estimate of ψ.

A simulated estimate is a sample proportion, so it has a standard error. More simulations make the estimate more precise. The error falls with the square root of the number of simulations, so cutting the error to half needs four times as many runs.

Key rules to remember

Discrete-time surplus
U(t) = u + c·t − S(t), where S(t) = X₁ + X₂ + … + X_t
Checked at t = 1, 2, 3, … only. Claims X_i are independent and identically distributed in the basic model.
Finite-time ruin probability
ψ(u, n) = P(U(t) < 0 for some t in {1, 2, …, n}) = 1 − φ(u, n)
Ruin is strictly below zero. State this convention in your answer.
Boundary conditions
φ(u, 0) = 1 for u ≥ 0, and φ(u, n) = 0 for u < 0
Use the second one whenever the surplus after a period is negative.
Survival recursion
φ(u, n) = Σ over x of P(X = x) · φ(u + c − x, n − 1)
For discrete claims. For continuous claims the sum becomes an integral. Terms with u + c − x < 0 are zero.
Simulated estimate of ruin probability
ψ̂ = (number of ruined paths) ÷ N
N is the number of simulated paths.
Standard error and approximate 95% confidence interval
SE = √(ψ̂(1 − ψ̂) ÷ N); interval: ψ̂ ± 1.96 × SE
Uses the normal approximation, which is fine when N is large and ψ̂ is not very close to 0 or 1.
Simulations needed for a target standard error
N = p(1 − p) ÷ SE²
Use a rough guess of p, or p = 0.5 for the worst case.
Inverse transform for a discrete claim
Generate V from U(0,1). Pick the claim whose cumulative probability range contains V.
Fix the rule first, for example V < 0.6 gives claim 1, otherwise claim 4.

How to solve Discrete-Time Ruin and Simulation questions

Use this method for any question on discrete-time ruin, whether it asks for an exact finite-time probability or a simulation.

  1. 1Write down the model: u, c per period, the claim distribution and the number of periods n. State that ruin means surplus below zero at a time point.
  2. 2List the possible surplus values. For whole-number claims and premiums this is a short list. Anything below zero means ruin.
  3. 3Set the boundaries: φ(u, 0) = 1 for u ≥ 0 and φ(u, n) = 0 for u < 0.
  4. 4Build the table from n = 1 upwards using φ(u, n) = Σ P(X = x) · φ(u + c − x, n − 1). Work out only the surplus values you need.
  5. 5Read off the answer φ(u, n) and give ψ(u, n) = 1 − φ(u, n) if the question asks for ruin.
  6. 6For simulation questions, define the rule that turns uniform random numbers into claims. Then simulate each path period by period, and stop it as soon as the surplus is negative.
  7. 7Set ψ̂ = ruined paths ÷ N. Work out the standard error and the confidence interval if asked.
  8. 8Check the answer. Ruin probability must be between 0 and 1, and ψ(u, n) must not fall as n rises.

Quickest way: Path tree for short horizons

When to use it: Use it when n is 2 or 3 and claims take only two or three values. It is quicker than a full table.

  1. Draw the first-period branches. Mark any branch with negative surplus as ruin and stop it there.
  2. From each surviving branch, add the next period's branches with the new surplus.
  3. Multiply probabilities along each ruined branch and add them up. This is ψ directly.
  4. Cross-check with the recursion for one surplus value. If the two agree, the answer is safe.
  5. If the surplus value repeats on different branches, merge them. This is why the recursion is faster for longer horizons.

Common mistakes in Discrete-Time Ruin and Simulation

  • Treating surplus of exactly zero as ruin.

    Students think ruin means the money has run out.

    Fix: Use ruin as surplus < 0 unless the question says otherwise. Say so at the start of your answer.

  • Forgetting to add the premium before subtracting the claim in each period.

    Students work with claims only and lose track of the surplus.

    Fix: Always write the next surplus as u + c − x and check it against zero.

  • Continuing a path after it has been ruined.

    Students want to fill the whole table or simulate all n periods.

    Fix: Once surplus is negative the path is ruined for good. Set φ = 0 and do not use that path again.

  • Mixing up survival and ruin probabilities in the recursion.

    The boundary values are opposite: φ(u, 0) = 1 but ψ(u, 0) = 0.

    Fix: Do the whole table in φ and convert to ψ = 1 − φ only at the end.

  • Stating a simulation estimate as the exact ruin probability.

    The estimate looks like a single number.

    Fix: Say it is an estimate, and quote its standard error or a confidence interval.

  • Using the wrong uniform-to-claim rule, such as overlapping or reversed ranges.

    Students are careless about cumulative probabilities.

    Fix: Write the ranges first, check that they cover 0 to 1, and use the same rule for every period.

Worked examples

Example 1

An insurer has initial surplus u = 0 and receives premium c = 2 at the end of each year. Annual claims are independent: X = 1 with probability 0.6 and X = 4 with probability 0.4. Ruin means surplus below zero at a year end. Find the probability of ruin within 3 years, ψ(0, 3), using the recursion.

Show the solution
  1. Let φ(u, n) be the probability of no ruin within n years. Boundaries: φ(u, 0) = 1 for u ≥ 0 and φ(u, n) = 0 for u < 0.
  2. Recursion: φ(u, n) = 0.6·φ(u + 2 − 1, n − 1) + 0.4·φ(u + 2 − 4, n − 1) = 0.6·φ(u + 1, n − 1) + 0.4·φ(u − 2, n − 1).
  3. For n = 1, find φ(2, 1): the new surplus is 3 or 0, both ≥ 0, so φ(2, 1) = 0.6 + 0.4 = 1.
  4. Next, φ(1, 1): the surplus becomes 2 or −1. So φ(1, 1) = 0.6 × 1 + 0.4 × 0 = 0.6.
  5. For n = 2, φ(1, 2) = 0.6·φ(2, 1) + 0.4·φ(−1, 1) = 0.6 × 1 + 0 = 0.6.
  6. For n = 3, φ(0, 3) = 0.6·φ(1, 2) + 0.4·φ(−2, 2) = 0.6 × 0.6 + 0 = 0.36.
  7. So ψ(0, 3) = 1 − 0.36 = 0.64.

Answer: ψ(0, 3) = 0.64. Check: the first-year ruin is 0.4. A second-year ruin adds 0.6 × 0.4 = 0.24. No third-year ruin is possible, because surplus is at least 2 after the second year, and 2 + 2 − 4 = 0 is not ruin. Total is 0.64.

Example 2

In the model of Example 1, a student simulates N = 1,000 three-year paths and finds that 640 are ruined. (a) Estimate the ruin probability and give an approximate 95% confidence interval. (b) How many simulations are needed for the standard error to be about 0.005 if the true probability is near 0.64? (c) Give a rule to simulate one year's claim from a U(0,1) number V.

Show the solution
  1. (a) ψ̂ = 640 ÷ 1,000 = 0.64.
  2. Standard error = √(0.64 × 0.36 ÷ 1,000) = √0.0002304 ≈ 0.0152.
  3. Margin = 1.96 × 0.0152 ≈ 0.030. So the interval is 0.64 ± 0.030, which is about (0.610, 0.670).
  4. (b) N = p(1 − p) ÷ SE² = 0.64 × 0.36 ÷ 0.005² = 0.2304 ÷ 0.000025 = 9,216.
  5. (c) The claim is 1 with probability 0.6 and 4 with probability 0.4. Rule: if V < 0.6, claim = 1. Otherwise, claim = 4.
  6. Each path starts from u = 0, adds 2 and subtracts a claim each year, and is marked ruined as soon as surplus is below 0.

Answer: (a) ψ̂ = 0.64, approximate 95% interval about (0.610, 0.670). (b) About 9,216 simulations. (c) Claim = 1 if V < 0.6, otherwise 4. Note that the exact value in Example 1 is 0.64, which lies inside the interval. A simulated estimate will usually differ a little from the exact value, and the standard error tells you by how much.

Exam tips

  • Write the ruin convention (surplus below zero, checked at year ends) in your first line. Examiners award marks for clear assumptions.
  • Show the recursion formula before you use it, then a neat table of φ values. Method marks depend on this even if arithmetic slips.
  • Check answers by a second route, for example the path tree on a short horizon, if time allows.
  • For simulation questions, state the random number rule, the stopping rule, the estimator and its standard error. These four points are the usual mark scheme items.
  • In computer-based papers, loop over periods, stop when surplus is below zero, and compute the proportion of ruined paths. Set a seed so results can be repeated.

Practice questions from Ruin theory

Discrete-Time Ruin and Simulation: frequently asked questions

What is the difference between finite-time and ultimate ruin probability?

Finite-time ruin ψ(u, n) is the chance of ruin within n periods. Ultimate ruin ψ(u) looks over an infinite horizon, so it is the limit of ψ(u, n) as n grows. Finite-time ruin is never larger than ultimate ruin.

Why do we use a recursion for ruin probabilities?

The surplus after one period starts a new, shorter problem. The recursion reuses answers for n − 1 periods to get answers for n periods. This avoids listing every possible claim path.

How many simulations should I run to estimate a ruin probability?

It depends on the precision you need. Use N = p(1 − p) ÷ SE² with a rough value of p. Smaller probabilities need more runs for a good relative accuracy.

Is surplus of zero ruin?

In the standard definition no. Ruin happens when surplus is strictly below zero. Some questions define it differently, so read the question and state the convention you use.