Portfolios

The Programs page described how a single cedent’s placement is assembled — a coordinated set of layers on a shared exposure set. But a reinsurer does not write only one program. It writes a portfolio of programs and contracts: SunCoast’s three-layer program sits beside Pacific Mutual’s Californian earthquake program, Baltica’s European windstorm quota share, and Atlas Cat Fund’s Japanese earthquake placement.

The portfolio is where a reinsurer’s business becomes visible — and it is not a passive record. Like an investment fund’s portfolio, it is actively managed: what to write, what to renew, what to shed is a continuous business decision, made with insurance contracts where a fund manager deals in capital-market instruments. Portfolio-level metrics are the KPIs the company steers by, tactically and strategically: the written portfolio is the culmination of everything the reinsurer sells, and everything else it does — investment strategy, retrocession, sidecars, cat bonds — depends on that portfolio existing and behaving predictably. Pricing and capital decisions are not made against the portfolio alone, but it is a necessary input with one of the heaviest weights. Before any of that management can act on numbers, though, the portfolio has to be reduced to a single loss distribution. This page is about the portfolio as a modelling object and the roll-up — the mechanical task that produces that distribution — and the one property that makes the result interesting: expected loss adds across contracts, but tail risk does not.

A portfolio is a bundle of bundles

Nothing structurally new appears at the portfolio level. The nesting goes one level deeper:

A term transforms a loss. A contract is a composition of terms. A program is a bundle of contracts on one exposure set — and even a placement of a single layer, like Pacific Mutual’s or Atlas’s, arrives as a program of one contract. A portfolio bundles written programs and contracts for analysis. Each level is a container for the one below, and each level’s loss is a sum of the losses one level down.

A portfolio is two things at once. To the business it is a managed object — a set of positions whose composition is deliberately steered and whose metrics are company KPIs. To the modelling machinery it is a selection — a construct that picks programs and contracts and bundles them for aggregate analysis. Reinsurers routinely run several portfolios at once, some independent, most of them slices of the top-level portfolio (the whole book of business) — cut by business unit, by line of business, by coverage period, or by binding status (the live bound portfolio versus the live working portfolio of deals still in negotiation, watched to catch risk concentrations building up during the underwriting cycle before they bind). One school of thought holds that there is only one portfolio — the book of business — and everything else is a slice of it. Either way: the same construct, a different filter.

Remember

“Portfolio” here means the reinsurer’s collection of in-force programs and contracts — like a financial portfolio, a set of actively managed positions that may generate profit or loss. Do not confuse it with a cedent’s program, which is one placement the reinsurer might write a share of. A program is something you buy or write; a portfolio is what you manage across everything you have written.

The roll-up: participation, then sum

Each contract, evaluated on its cedent’s YELT, produces a per-trial gross loss — the loss at the 100% layer. But the reinsurer rarely writes the whole layer; it writes a participation share $p_i$, placed alongside a panel of other reinsurers (why layers are split is covered in Foundations). So the roll-up has two steps, and the order matters:

$$L_j^{\text{portfolio}} = \sum_{i=1}^{n} p_i \, C_i(L_j)$$

For each trial $j$, take every contract’s gross loss $C_i(L_j)$ — the 100% layer result by definition, since compositions carry no participation — scale it by that contract’s participation $p_i$ (the roll-up’s own scaling step), and add the scaled losses together. Portfolio roll-up is the task of producing that sum across all $N$ trials — reducing the constituents’ loss tables to a single loss distribution for the whole selection.

Why participation before the sum? Because the portfolio is Helios Re’s own position, and Helios Re only carries its share of each contract. Summing the 100% layers first would roll up losses that belong to the other panel members. Scale each contract to the written share, then combine. Reverse the order and the portfolio distribution is wrong by whatever the rest of the panel wrote.

Roll-up earns its status as a named task — often conflated with portfolio analytics itself — for two reasons beyond the arithmetic. Operationally, the constituents rarely sit in one tidy place: business units manage their own portfolios, sometimes on different models and in different data formats, and assembling an enterprise-wide portfolio is a reconciliation exercise before it is a sum. Computationally, the reduction is big: thousands of contract YELTs across 100,000+ trials, often broken out by line of business and other exposure characteristics, reduced to one loss table. That process is I/O-bound and not instant — which is why the roll-up is often scheduled, monitored, and treated as a pipeline stage of its own, although demand for a faster, live view of the portfolio is growing across the industry, driven largely by advances in underwriting rigor and risk selection. Portfolio analytics is the business requirement; the roll-up is its prerequisite.

Watch Out

The roll-up is a sum of losses within the same trial, not a sum of metrics. It is tempting to combine contracts by adding each one’s EL, VaR, or TVaR — the numbers are right there. EL survives that shortcut; the tail metrics do not (the reason is a section below). An obvious point once stated, but easy to slip past when the per-contract metrics are already computed: roll up at the loss level, then compute metrics on the combined column.

Two resolutions: trial and occurrence

What the roll-up produces depends on the resolution of the sum, and the distinction matters enough to name the outputs.

Trial level → a YLT. Sum each contract’s participated losses per trial and the result has one row per trial: trial_id, loss. That structure is a YLT (Year Loss Table) — not a YELT, because the occurrence detail (timestamp, event_id) is gone. A YLT is all the AEP view needs, and it is the fast path when aggregate metrics are the only consumers.

Occurrence level → a YELT. Keep the occurrence key, sum the participated losses per occurrence (shared event_ids add across cedents), and the result is a genuine portfolio YELT: the portfolio’s loss for every simulated catastrophe. This is the roll-up that supports OEP metrics — the distribution of the single worst event — and any downstream contract with occurrence terms. It asks more of the constituents: a contract with an aggregate component must attribute its gross back to occurrences in erosion order, the same per-occurrence audit trail the AggXoL page describes.

In practice, occurrence level is the default: OEP metrics need occurrence losses, and a portfolio protected by retrocession with occurrence terms cannot be evaluated without them. The trial-level YLT remains useful twice over — as the cheap roll-up when only AEP metrics are needed, and as the simpler structure to reason about, which is why this page teaches it first. Reducing a YELT to a YLT is lossy and irreversible; when in doubt, roll up at occurrence resolution and collapse later.

Helios Re’s portfolio, rolled up

Helios Re’s six base contracts, at the shares it writes:

Contract	Cedent	Peril · region	Participation
C1	SunCoast	Hurricane · US (FL)	14.5%
C2	SunCoast	Earthquake · US (CA/AZ)	20%
C3	SunCoast	All-US backstop (net of C1, C2)	10%
C4	Pacific Mutual	Earthquake · US (CA)	25%
C5	Baltica	Windstorm · EU	30%
C6	Atlas Cat Fund	Earthquake · Japan	15%

Running the roll-up across the locked 20-trial demo tier — at both resolutions — gives the portfolio’s loss distribution, read as a pair of EP curves:

AEP (trial aggregate) OEP (largest occurrence)

The portfolio's EP curves from the roll-up; hover for the metrics at any return period. AEP reads the trial aggregate: the 1-in-10-year loss is $22.08M, the second-worst of twenty trials. OEP reads the largest single occurrence per trial from the occurrence-level roll-up: its 1-in-10 loss is $5.00M. The flat OEP top is the SunCoast backstop's participated share concentrating on the occurrence that pushes its aggregate layer through.

helios_re/portfolio_rollup.py Python

▶ Run Reset

The metrics come off those curves with the same helpers used everywhere else on the site — nothing about a portfolio distribution is special once it exists:

Portfolio metric (AEP basis)	Value
Expected loss (EL)	$14.59M
VaR(90%)	$22.08M
TVaR(90%)	$23.51M

On the OEP basis the 1-in-10 single-occurrence loss is $5.00M. The occurrence-level roll-up that produced it collapses back to the trial-level numbers exactly — the code above asserts it — which is the practical face of “lossy in one direction only.”

Expected loss adds; tail risk diversifies

Here is the property that makes the rolled-up distribution more than bookkeeping. Take the six contracts’ standalone metrics — each computed on its own participated loss — and compare the sum against the portfolio’s:

Metric: TVaR(90%) EL

Contract, standalone Naive sum Portfolio, combined

Each contract's standalone value at its participation, the sum of those values, and the portfolio's own. On the TVaR(90%) view the portfolio ($23.5M) sits $13.0M below the sum of the standalone tails ($36.5M) — a 35.6% diversification benefit, because the contracts do not reach their worst losses in the same trials. Toggle to EL and the two summary bars are identical ($14.59M): expected loss adds exactly, so the entire reduction lives in the tail.

Expected loss adds exactly. The six contracts’ participated ELs sum to $14.59M, the portfolio EL to the cent, because expectation is linear: trial by trial the portfolio loss is the sum of the contract losses, so the means add. Structure is invisible to EL — it does not matter which cedent, peril, or region a dollar of expected loss comes from.

The tail does not add. The contracts’ standalone TVaR(90%)s sum to $36.54M, but the portfolio’s TVaR(90%) is $23.51M — $13.02M lower, a 35.6% reduction. The reason is structural: each contract’s TVaR averages its own worst trials, but the portfolio’s TVaR averages the trials where the total is worst — and those are different trials. SunCoast’s Florida hurricane peaks in one trial, Baltica’s European windstorm in another, Atlas’s Japanese quake in a third. They do not all fail together, so the portfolio’s worst trial is milder than the sum of each contract’s worst trial. That gap is the diversification benefit, and it is exactly TVaR’s sub-additivity — $\text{TVaR}(A + B) \le \text{TVaR}(A) + \text{TVaR}(B)$ — realised across the whole portfolio.

Key Insight

The diversification benefit is a property of the combined loss column, and of nothing else. No standalone view of the contracts can see it, because it lives in how their bad trials interleave — information that only exists once the losses share a trial index. That is why the roll-up is the prerequisite of every portfolio-level question: the quantity the business cares most about literally does not exist until the sum is taken. What that $13.02M of tail reduction is worth — and to whom — is a pricing question, taken up in the portfolio analytics story.

The portfolio YELT is also a subject loss

One more property makes the portfolio YELT worth having as a first-class object: it has the same schema as any other loss table, so it can serve as another contract’s subject loss. A reinsurer buys retrocession — reinsurance on reinsurance — for two reasons: to protect its portfolio, and to free up the capital the portfolio ties up so that more business can be written against the same capital base. Either way, the retro contract’s subject loss YELT may be precisely the portfolio YELT this roll-up produces. The retro layer transforms that subject loss into the retro’s gross loss — the recoveries the reinsurer collects — and netting those recoveries out of the portfolio YELT gives the portfolio’s net of retro loss. The perspectives chain — subject loss, gross loss, net loss — reappears one level up, with the whole portfolio playing the role a cedent’s exposure set played before. Resolution matters here too: a retro program with occurrence terms needs the portfolio loss at YELT resolution, not as a YLT — another reason the occurrence-level roll-up is the one production systems keep.

In practice: portfolios are flattened

Conceptually a portfolio is the tidy tree above — programs containing contracts containing terms. In production it is almost always flattened into a single list of participated layers, each tagged with the metadata that lets you slice it back apart: cedent, peril, region, program, business unit. The tree is how humans reason about a placement; the flat list is how an engine evaluates it. Both views describe the same object, and a well-built model moves between them freely — evaluate the flat list for speed, group by any tag to recover the structure. The grouping keys are also what define portfolios themselves: “the live bound US portfolio” is a filter over the flat list, not a separate object. They are what let a portfolio manager ask “how much of my tail is Californian earthquake?” without re-evaluating a single contract — the slice still needs its own roll-up over the selected constituents, but that is a filter and a sum over losses already computed, which a modern system turns around in near real time.

Consider

The roll-up is where the portfolio-first design principle earns its keep. If a system treats the portfolio as an afterthought — contracts evaluated in isolation, results bolted together — it cannot see the diversification benefit at all, because that benefit only exists in the combined loss column. A model built to roll up from day one gets portfolio distributions, slicing, and (with one more contract) marginal impact for free. A model that keeps only per-contract results has discarded the combined loss column — so every portfolio-level question forces it to re-evaluate the constituents from scratch, work the portfolio-first design never repeats. Design for the sum, not only the parts.

What carries forward

A portfolio is an actively managed selection of written programs and contracts; the roll-up — scale each contract to its participation, sum within each trial or occurrence — reduces it to one loss distribution: a YLT at trial resolution for AEP, a portfolio YELT at occurrence resolution for OEP and retrocession. Even those distributions are intermediaries: the business questions they serve are the portfolio KPIs — how much can the portfolio lose, and where is its risk concentrated. Expected loss rolls up by addition; tail risk rolls up below addition, and the gap between the sum of the standalone tails and the combined tail is the diversification benefit — a quantity that exists only in the combined column.

That closes the Financial Modelling chapter: from one term, to a contract, to a program, to the whole portfolio. What the chapter builds, the Applications chapter uses. The portfolio analytics story takes this exact portfolio and works it as a portfolio manager would — reading its risk posture, slicing it for concentrations, and weighing its expected loss against the premium it earns. And pricing one new contract against the rolled-up portfolio — the marginal view — is the flagship application the chapter builds toward.