Skip to content

Heavy-Tail Simulation Scenario Set

Simulation method — instantiates Tail-Dominance Modeling and Control

Runs Monte-Carlo simulation under deliberately fat-tailed, correlated assumptions so the model actually produces the rare catastrophes that thin-tailed sampling almost never draws.

If you simulate a tail-dominated system with Gaussian inputs, the catastrophic combinations that actually threaten it are drawn so rarely they never appear — and the aggregate looks reassuringly tame. The Heavy-Tail Simulation Scenario Set fixes this at the source: it seeds the simulation with heavy-tailed input distributions and tail dependence, so extremes co-occur, then runs many draws to build the full distribution of aggregate outcomes. Its defining move is to make the correlated pile-up appear in the output by putting it into the assumptions, rather than hoping to stumble on it. Its two deliverables are a library of tail-enriched scenarios and — read off the deep end of the simulated aggregate — the sized consequence budget the rest of the control loop is built to withstand.

Example

A cyber-insurer needs the potential aggregate loss across a book of policies exposed to correlated events — where a single worm or a shared-vendor compromise can hit many insureds at once. A naive simulation drawing independent, thin-tailed per-firm losses shows a comfortable aggregate with a modest worst case. The Heavy-Tail Simulation Scenario Set instead seeds fat-tailed severity for each event and a common-shock structure that lets losses arrive together, then runs a large Monte-Carlo.

The simulated aggregate grows a long right tail dominated by a handful of correlated-catastrophe draws. The 1-in-200-year aggregate loss comes out several times the naive estimate — and that number, not the average, becomes the consequence budget the capital, caps, and reserves are sized to. The simulation has made a catastrophe that had never happened concrete enough to budget for.[1]

How it works

The method deliberately replaces thin-tailed input assumptions with heavy-tailed ones and, crucially, models dependence in the tail — because in a tail-dominated system the danger is not the marginal draw but the correlated co-occurrence. Many trials are run, the aggregate outcome of each is collected, and the deep quantiles of that simulated distribution are read as the consequence budget. Because those deep quantiles are exactly the region a plain sampler visits least, the method is often driven by a rare-event sampling engine to reach them without astronomical run counts.

Tuning parameters

  • Input tail heaviness — how fat the seeded input distributions are. Heavier surfaces more extreme scenarios but risks overstating the danger if unwarranted; match it to the diagnosed tail, not to a fear or a hope.
  • Dependence structure — independent draws vs common shocks or copula tail-dependence. Tail dependence is where the real catastrophes live; leaving it out is the commonest way a simulation under-scares.
  • Trial count — more draws stabilize the deep quantiles but cost compute; the deeper the budget quantile, the more trials — or the more you must lean on importance sampling.
  • Aggregation level and horizon — what outcome is accumulated (portfolio loss, downtime, casualties) and over what period.
  • Budget quantile — which deep quantile of the simulated aggregate defines the consequence budget (1-in-100 vs 1-in-200 vs worst-of-N). Deeper is more conservative and hungrier for samples.

When it helps, and when it misleads

Its strength is that it makes the correlated catastrophe visible and countable before it happens, converting "how bad could it get" into a sized number for provisioning caps and reserves — and it exposes precisely the outcomes a thin-tailed average erases.

Its weakness is that the output is only as heavy as the assumptions you feed it: both the input tail and the dependence structure are hard to estimate and easy to under-set, so a comfortable result may just mean comfortable inputs. Deep quantiles are sampling-noisy without rare-event methods, and a precise-looking "1-in-200" invites false confidence in what is a model artifact. The classic misuse is dialling the tail or the correlation down until the required capital becomes affordable — running the simulation backwards onto a target budget. The discipline is to source the tail and dependence assumptions from diagnostics rather than convenience, stress the assumptions themselves, and report the budget with its sampling error and its dependence on those assumptions.

How it implements the components

  • stress_scenario_set — the simulation generates the library of tail-enriched, correlated extreme scenarios the rest of the archetype reasons over.
  • tail_consequence_budget — the deep quantile of the simulated aggregate sizes the consequence budget: the loss the system must be built to survive.

It does not fit the analytic threshold model behind the input tails (tail_boundary_definition, model_scope_boundary — Extreme-Value Threshold Model), design the efficient sampling scheme that makes deep quantiles tractable (tail_sampling_and_observation_plan — Rare-Event or Importance Sampling), or enforce the budget as limits (exposure_cap_or_buffer, tail_response_layer — Exposure Cap Policy).

Notes

It differs from a stress test in how it explores the tail. A stress test asks "what if this specific scenario occurs" — deterministic, often reverse-engineered from a break point. The heavy-tail simulation asks "across many stochastic draws under fat tails, what does the whole outcome distribution look like." The two are complements: the simulation finds the shape of the tail; the reverse stress test names the single scenario that breaks you.

References

[1] For subexponential distributions — a broad heavy-tailed class — the sum of many draws is dominated by its single largest term (the "single big jump"). This is why a correlated pile-up, not the typical draw, drives the aggregate, and why a simulation must seed heavy tails and dependence to reproduce it. ↩