In this blog post, we're going to talk about net premiums in insurance. We'll explain what they are, how to calculate them, and even walk you through some practical exercises using Python with real-life examples.

While we touched upon the concept of net **single** premiums in a previous discussion about life insurance,
real-life scenarios often involve **monthly** premium payments for life insurance policies.

List of content:

## Net vs gross premiums

Before delving further into the world of net premiums, let's revisit the distinction between net and gross premiums.

The gross premium represents the actual amount a policyholder pays to the insurance company. This premium encompasses several components, including:

- coverage for life insurance benefits,
- expenses associated with initiating and maintaining the insurance policy,
- profit margins for the insurance company,
- provisions for offsetting potential adverse experiences.

In contrast, net premiums are specifically designated for covering only the benefit payments.

## The equivalence principle

To determine the value of a premium, insurance companies employ the equivalence principle. This principle hinges on calculating the insurer's loss, denoted as \( L \). This loss represents the random variable of the present value of benefits to be paid by the insurer, minus the random variable of the present value of the annuity of premiums to be paid by the insured.

The essence of the equivalence principle is captured in this equation:

\( E[L] = 0 \)In simpler terms, the expected value of the financial loss must be zero.

Consider, for instance, a whole life insurance policy where the policyholder receives a benefit of 1 in the event of their death. Let \( P_{x} \) represent the premium. According to the equivalence principle:

\( A_{x} - P_{x} \cdot a_{x} = 0 \)This equation implies:

\( P_{x} = \frac{A_{x}}{a_{x}} \)## Premium formulas

We can further categorize net premiums based on the type of insurance product. We will focus on discrete premiums as these are usually used in cash flow models.

Product | Premium formula |
---|---|

Whole Life Insurance | \( P_{x} = \frac {A_{x}} {\ddot{a}_{x}} \) |

n-Year Term Insurance | \( \require{enclose} P^1_{x:} {}^{}_{\enclose{actuarial}{n}} = \frac {A^1_{x:} {}^{}_{\enclose{actuarial}{n}}} {\ddot{a}^{}_{x:} {}^{}_{\enclose{actuarial}{n}}} \) |

n-Year Endowment Insurance | \( \require{enclose} P^{}_{x:} {}^{}_{\enclose{actuarial}{n}} = \frac {A^{}_{x:} {}^{}_{\enclose{actuarial}{n}}} {\ddot{a}^{}_{x:} {}^{}_{\enclose{actuarial}{n}}} \) |

n-Year Pure Endowment | \( \require{enclose} P^{}_{x:} {}^{1}_{\enclose{actuarial}{n}} = \frac {A^{}_{x:} {}^{1}_{\enclose{actuarial}{n}}} {\ddot{a}^{}_{x:} {}^{}_{\enclose{actuarial}{n}}} \) |

## Modelling

In this section, we'll provide a comprehensive example of how to calculate the net premium for a term insurance policy using the "cashflower" open-source Python package. If you're new to cashflower, refer to our beginner's guide to get started.

### Scenario

Let's begin with a scenario: the policyholder has purchased a 5-year term insurance policy with a sum assured of 200 000. Premium payments are made monthly at the start of each month, and the benefit is paid out at the end of the month in the event of the policyholder's death. The interest rate remains constant at 0.5% per month, and the mortality rate is 0.2% per month.

### Input

We'll start by defining the inputs, beginning with the policyholder's attributes. We've already transformed the 5-year term into 60 months.

input.py```
main = ModelPointSet(data=pd.DataFrame({
"id": [1],
"age_at_entry": [35],
"term": [60],
"sum_assured": [200_000],
}))
```

Next, we'll specify our assumptions.

input.py```
assumption = {
"interest_rate": 0.005,
"mortality_rate": 0.002,
}
```

### Model

Now, let's dive into the calculations step by step.

We'll first calculate the probability of survival for a given number of periods:

model.py```
@variable()
def survival_for_t_periods(t):
if t == 0:
return 1
else:
return survival_for_t_periods(t-1) * (1 - assumption["mortality_rate"])
```

The annuity due represents the present value of all future survival rates:

model.py```
@variable()
def annuity_due(t):
v = 1/(1+assumption["interest_rate"])
if t >= main.get("term"):
return 0
elif t == main.get("term"):
return survival_for_t_periods(t)
else:
return survival_for_t_periods(t) + annuity_due(t+1) * v
```

We calculate the expected benefit, which is the payout in case of death:

model.py```
@variable()
def expected_benefit(t):
if t == 0 or t > main.get("term"):
return 0
else:
return main.get("sum_assured") * survival_for_t_periods(t-1) * assumption["mortality_rate"]
```

Next, we find the present value of the expected benefit:

model.py```
@variable()
def pv_expected_benefit(t):
v = 1/(1+assumption["interest_rate"])
if t == settings["T_MAX_CALCULATION"]:
return expected_benefit(t)
else:
return expected_benefit(t) + pv_expected_benefit(t+1) * v
```

Finally, we calculate the net premium, which is determined for the beginning of the projection:

model.py```
@variable()
def premium(t):
if t >= main.get("term"):
return 0
return pv_expected_benefit(0) / annuity_due(0)
```

To ensure equivalence, we will compare the present value of expected benefits to the present value of expected premiums:

model.py```
@variable()
def expected_premium(t):
if t >= main.get("term"):
return 0
return premium(t) * survival_for_t_periods(t)
@variable()
def pv_expected_premium(t):
v = 1 / (1 + assumption["interest_rate"])
if t == settings["T_MAX_CALCULATION"]:
return expected_premium(t)
else:
return expected_premium(t) + pv_expected_premium(t+1) * v
```

If these values match, we've correctly calculated the net premium for this insurance. This demonstrates the application of actuarial principles in determining insurance premiums.

### Results

Let's examine a subset of the results:

```
t expected_benefit pv_expected_benefit premium expected_premium pv_expected_premium
0 0.00 19573.76 398.01 398.01 19573.76
1 400.00 19671.63 398.01 397.21 19271.63
2 399.20 19367.99 398.01 396.42 18968.79
3 398.40 19063.63 398.01 395.63 18665.23
...
58 356.86 1063.15 398.01 354.38 706.29
59 356.15 709.82 398.01 353.67 353.67
60 355.44 355.44 0.00 0.00 0.00
```

A few key observations:

- premium is paid upfront, so it's paid at t=0, but it's zero at t=60.
- benefit is paid at the end of the month, so the expected benefit amounts to zero at t=0.
- the present value of expected benefits (what the insurance company pays out) equals the present value of expected premiums (what the policyholders pay) at t=0. This demonstrates the fulfillment of the equivalence principle in insurance calculations.

As we conclude our discussion on net premiums in insurance, I encourage you to keep the conversation going. If you have questions or need further clarification on any aspect of insurance premiums or related topics, please don't hesitate to reach out. Feel free to drop your questions or thoughts in the comments section below.