- Published on

# What is Exposure at Default (EAD) and How to Calculate It

- Authors
- Name
- Benton Li

Prerequisite:

- Some knowledge of probability and statistics
- Knowledge of netting set
- Knowledge of CCR

**Warning ⚠️:** This blog is very hardcore

**Definition**

As the name indicates, exposure at default means how much money you gain/lose if your counterparty defaults

Imagine Alice owes you $20.

When can a default happen? Well, in the past, now, and in the future.

- Past: whatever happened happened. The loss is known.
*Yea, Alice has gone default before and I lost like $1. It is what it is.*

- Present: If my counterparty defaults now. I can compute how much I will lose or gain after applying netting. This is called
**current exposure (CE)***“Oh really, she can’t pay me today. But I need to pay her $10 for the wifi money next week. Discounting that, I think I will lose $10.”*

- Future: Take a time machine to the future and calculate CE. Just kidding, we will get into that.

## Current exposure (CE)

This measures the potential loss if your counterparty defaults today. This is also known as replacement cost. It is also understood as the current market value of the contract(or portfolio of contracts under a netting set)

**CE = max(replacement cost, 0)**

Why should CE be positive? Suppose I owe Alice $50. If she doesn’t pay me $20, I will subtract it from my $50 debt then. Anyway, that’s her exposure, not mine. She can still go after my ass for this net debt of $30.

## Future exposure

This is a “what-if” loss if your counterparty defaults at a specific future moment. To compute this, we need two things:

- Modeling (e.g. Monte Carlo Methods) future exposures (values of the contract)
- Projecting a loss distribution (e.g. normal distribution)

We will illustrate the concept of **future exposures** including **expected positive exposure (EPE)** and **potential future exposure (PFE)** using the two figures below. But before that, we need to introduce **expected exposure (EE)** first.

Figure 1: Distribution of the value of a portfolio/contract/transaction (Courtesy of Giovanni Cesari and UBS).

Figure 2: Computing exposures of a vanilla swap from simulations. (Courtesy of Giovanni Cesari and UBS).

### Understanding the Simulations

First thing first, we run hella simulations and get hella projected values over a future time horizon. Let's look at the figures above:

**Horizontally**, we see hella colourful lines. Yup, those are the traces of simulations. One trace shows us a hypothesized price movement under certain scenarios.

**Vertically**, we see a few bell curves on top of a vertical line. The intersections of a vertical line and traces tell us an array of possible prices at that time. For example, on September 12, we could have 15 possible values, each from a different trace of simulation.

**How are simulations made?** It’s beyond the scope of this blog. I will write one ad libitum in the future.

### Expected exposure (EE)

Before we introduce **EPE**, we need to introduce its component — **EE**.

**EE** at time t is the mean distribution of positive exposure at a particular future time t. Don’t worry if this doesn’t make sense. We will get into that.

Intuitively, find/draw a vertical line, and mark all the intersections that have positive values. The average value of them is the EE at that time.

Notice that future time t should be before the transaction with the longest maturity in the netting set (After that time there won’t be any concerning transaction)

You may ask, how and why tf does contract value change? Well, the values of contracts like options do change over time.

Mathematically,

Pseudo codes:

```
// oo style using C++
vector<int> sim_t = simulations[t];
ee[t] = accumulate(sim_t.begin(), sim_t.end() / sim_t.size();
if (ee[t] < 0.0)
ee[t] = 0.0;
```

```
(* functional style using OCaml *)
let ee_val = List.fold_left (+.) 0. simulations.(i) in
ee.(i) <- Float.max 0.0
```

### Expected positive exposure (EPE)

EPE is the weighted EE over time interval between now and some future time $t_e$, where the weights are proportional to the time interval that EE represents.

Intuitively, EPE is the mean of the positive part of the distribution as shown in the graph.

Mathematically,

Pseudo codes:

```
// oo style using C++
int int_te = static_cast<int>(te);
epe_te = accumulate(ee.begin(), ee.begin() + int_te, 0) / te;
```

```
(* functional style using OCaml *)
let epe_te = Array.sub ee 0 1
|> Array.fold_left (+.) 0.
|> ( *. ) (1.0 /. te);;
```

## Future exposures in the worst case

Keep in mind that the simulations give us a range of possible values. An expected positive exposure is not sufficient because sometime odds can beat us.

Say you expect to lose $xxx, but what if J Pow turns on his little money printer again? your $xxx can go stonked. So always think about the worst case.

Two key metrics are **EEPE** and **PFE**

### Effective expected exposure (EEE)

Just like EPE which requires EE, EEPE requires EEE.

EEE at time t is the maximum EE that occurs at time t or any time before t .

In effect, the Effective Expected Exposure is the Expected Exposure that is constrained to be non-decreasing over time.

Source: Section 50.29, Basel Framework

Think of EEE as a non-decreasing version of EE.

Mathematically,

Pseudo codes:

```
// oo style using C++
int int_te = static_cast<int>(te);
eee[te] = max(ee[te], eee[te-1]);
```

```
(* functional style using OCaml *)
let int_te = Float.to_int te in
eee.(int_te) <- Float.max eee.(int_te - 1) ee.(int_te)
```

**Effective** expected positive exposure (EEPE)

Similarly, EEPE is the weighted EEE over time interval between now some time $t_e$, where the weights are proportional to the time interval that EEE represents.

EEPE at $t_e$ average of EEE from now to $t_e$

```
// oo style using C++
int int_te = static_cast<int>(te);
eepe_te = accumulate(eee.begin(), eee.begin() + int_te, 0) / te;
```

```
(* functional style using OCaml *)
let eepe_te = Array.sub eee 0 1
|> Array.fold_left (+.) 0.
|> ( *. ) (1.0 /. te);;
```

### Potential future exposure (PFE)

PFE is very similar to VaR (will be introduced in future posts if you don’t know). It’s basically a huge ass loss on a future date with a high degree of confidence interval (e.g. 95%)

Roughly speaking, at a time t, we have an array of simulated value. Some are high and some are low. The 99th percentile (a value greater than 99% of all values at that time) will be our **PFE** at time t with CI of 99%

Mathematically,

```
// oo style using C++
sort(sim_t.begin(), sim_t.end());
int int_t = ceil((1.0 - alpha) * sim_t.size());
pfe_t_a = sim_t[int_t];
```

```
(* functional style using OCaml *)
Array.sort compare sim_t;;
let pfe_t_a = Array.length sim_t
|> Int.to_float
|> ( *. ) (1.0 -. alpha)
|> Float.to_int
|> Array.get sim_t
```

## EAD computation workflow

Finally, we can summarize a generic workflow:

- Make assumptions and run hella simulations
- Using the simulations and
- Compute EE → Compute EEE and EEPE
- Compute PFE

- Use appropriate models to compute EAD
- e.g. SA-CCR: $EAD = α * (RC+PFE)$ , where RC is the replacement cost and α is a magic number
- e.g. IMM: $EAD = α * EEPE$ , where α is a magic number

### Remark

This blogs use the naming convention according to

## Advanced reading

Basel III ← Coming soon

Read more: