Policy Values

Policy Values#

Policy value at time \(t\) is the expected present value, at time \(t\), of the future loss random variable, where \(P\) is the premium for \(b\) units of insurance, not necessarily the benefit premium determined from the equivalence principle.

Net future loss at issue

For net future loss at time \(t=0\), we consider benefit payments and net premiums only.

\(_0L = b~v^{K_x + 1} - P\ddot{a}_{\overline{K_x + 1|}} = (b + \dfrac{P}{d})~v^{K_x+1} - \dfrac{P}{d}\)

  • net future loss at issue of fully discrete whole life insurance

\(_0L = b~v^{T_x} - P\overline{a}_{\overline{T_x|}} = (b + \dfrac{P}{\delta})~v^{T_x} - \dfrac{P}{\delta}\) (continuous)

  • net future loss at issue of fully continuous whole life insurance

Gross future loss at issue

For gross future loss at time \(t=0\), expenses are included along with benefits payments and gross premiums.

\(_0L = (b + E + \dfrac{G - e_r}{d})~v^{K_x+1} - \dfrac{G - e_r}{d} + (e_i - e_r)\)

  • gross future loss at issue of fully discrete whole life insurance

Net policy value#

The amount needed at time \(t\) to cover the shortfall of expected future benefits greater than the EPV of future net premiums after time \(t\) is called the policy value for the policy at time \(t\), denoted \(_tV\),

\(_tV = E[_tL] = EPV_t (\textsf{future benefits}) - EPV_t (\textsf{future net premiums})\)

  • net policy value at time \(t\) is the expected net future loss of benefits less premiums after time \(t\)

\(_0V = 0\)

  • net policy value at issue is 0 because of the equivalence principle

Term insurance:

\(_nV = 0\)

  • net policy value at year \(n\) is 0 for a n-year term insurance

Endowment insurance:

\(_nV = \) endowment benefit

  • net policy value at year \(n\) is equal to the endowment benefit for a n-year endowment insurance

Shortcuts for whole life and endowment insurance:

These have a simple relationship between insurance and annuity, hence the policy value formulas can be expressed in temrs of insurances only or annuities only.

\(_tV = b[1 - \dfrac{\ddot{a}_{x+t}}{\ddot{a}_{x}}]\) or \(b[\dfrac{A_{x+t} - A_x}{1 - A_x}]\space \)

  • net policy value at time \(t\) of fully-discrete whole life insurance

\(_tV = b[1 - \dfrac{\overline{a}_{x+t}}{\overline{a}_{x}}]\) or \(b[\dfrac{\overline{A}_{x+t} - \overline{A}_x}{1 - \overline{A}_x}] \space \)

  • net policy value at time \(t\) of fully-continuous whole life insurance

\(_tV = b[1 - \dfrac{\ddot{a}_{x+t:\overline{n-t|}}}{\ddot{a}_{x:\overline{n|}}}]\) or \(b[\dfrac{A_{x+t:\overline{n-t|}} - A_{x:\overline{n|}}}{1 - A_{x:\overline{n|}}}]\space \)

  • net policy value at time \(t\) of fully-discrete endowment insurance

\(_tV = b[1 - \dfrac{\overline{a}_{x+t:\overline{n-t|}}}{\overline{a}_{x:\overline{n|}}}]\) or \(b[\dfrac{\overline{A}_{x+t:\overline{n-t|}} - \overline{A}_{x:\overline{n|}}}{1 - \overline{A}_{x:\overline{n|}}}] \space \)

  • net policy value at time \(t\) of fully-continuous endowment insurance

Gross policy value#

Gross premium policy values explicitly allow for expenses and for the full gross premium.

\(_tV^g = E[_tL^g] = EPV_t (\textsf{future benefits}) + EPV_t (\textsf{future expenses}) - EPV_t (\textsf{future premiums})\)

  • gross policy value at time \(t\) is the expected net future loss of benefits and expenses less premiums after time \(t\)

Variance of future loss#

These formulas apply to whole life and endowment insurance only. In these cases, the function of the random variable \(v^{T_x}\) is the same for both the insurance and annuity of premiums which simplifies the formulas for variance of future loss.

Net future loss

\(Var[_tL] = (b + \dfrac{P}{d})^2~[^{2}A_{x+t} - (A_{x+t})^2]\)

  • fully discrete whole life insurance

\(Var[_tL] = (b + \dfrac{P}{\delta})^2~[^{2}\overline{A}_{x+t} - (\overline{A}_{x+t})^2]\)

  • fully continuous whole life insurance

\(Var[_tL] = (b + \dfrac{P}{d})^2~[^{2}A_{x+t:\overline{n-t|}} - (A_{x+t:\overline{n-t|}})^2]\)

  • fully discrete endowment insurance

\(Var[_tL] = (b + \dfrac{P}{\delta})^2~[^{2}\overline{A}_{x+t:\overline{n-t|}} - (\overline{A}_{x+t:\overline{n-t|}})^2]\)

  • fully continuous endowment insurance

Gross future loss

\(Var[_tL] = (b + E + \dfrac{G-e_r}{d})^2~[^{2}A_{x+t} - (A_{x+t})^2]\)

  • fully discrete whole life insurance

\(Var[_tL] = (b + E + \dfrac{G-e_r}{d})^2~[^{2}A_{x+t:\overline{n-t|}} - (A_{x+t:\overline{n-t|}})^2]\)

  • fully discrete endowment insurance

Shortcuts for variance of net future loss under equivalence principle

When net premiums are set under equivalence principle, these shortcuts are available without explicitly specifying the value of net premiums (which can be stated as a function of insurance only under this assumption) for whole life and endowment insurance only:

\(Var[_tL] = b^2[\dfrac{^{2}A_{x+t} - (A_{x+t})^2}{(1 - A_{x})^2}]\)

  • variance of net future loss for fully-discrete whole life insurance under EPP

\(Var[_tL] = b^2[\dfrac{^{2}\overline{A}_{x+t} - (\overline{A}_{x+t})^2}{(1 - \overline{A}_{x})^2}]\)

  • variance of net future loss for fully-continuous whole life insurance under EPP

\(Var[_tL] = b^2[\dfrac{^{2}A_{x+t:\overline{n-t|}} - (A_{x+t:\overline{n-t|}})^2}{(1 - A_{x:\overline{n|}})^2}]\)

  • variance of net future loss for fully-discrete endowment insurance under EPP

\(Var[_tL] = b^2[\dfrac{^{2}\overline{A}_{x+t:\overline{n-t|}} - (\overline{A}_{x+t:\overline{n-t|}})^2}{(1 - \overline{A}_{x:\overline{n|}})^2}]\)

  • variance of net future loss for fully-continuous endowment insurance under EPP

Expense reserve#

\(P^e = P^g - P^n\)

  • expense premium (sometimes, expense loading) is defined as the difference of gross premium and net premium: if expenses are weighted to the start of the contract, as is normally the case, then \(P^e\) will be greater than the renewal expense as it must fund both the renewal and initial expenses.

\(_tV^e = ~_tV^g - ~_tV = EPV_t(\textsf{future expenses}) - EPV_t(\textsf{future expense loadings})\)

  • expense reserves, defined as the difference between gross reserves and net reserves, also equals the expected present value of future expenses less the expected present value of future expense loadings (or expense premiums)

Generally:

  • \(_tV^e < 0\)

  • \(~_tV > ~_tV^g > 0 > ~_tV^e\)

Probabilities and Percentiles#

For whole life, term and endowment insurance, the present value of benefits decreases with time, while the present value of the premium annuity increases

Percentile of \(_0L\):

Since loss at issue is a monotonically decreasing function of lifetime, the \(100p\)-th percentile of the loss at issue r.v. is determined from the \(100p\)-th percentile of the survival function.

Probability of \(_0L\):

To calculate the probability that the present value of loss at issue is greater than some value \(Pr(_0L \ge L_{\pi})\), calculate the time \(t_{\pi}\) for which \(_0L = b~v^{t_{\pi}} - P\overline{a}_{\overline{t_{\pi}|}}\) has the required value, then calculate the probability that time of death \(T_x\) is in that range.

Methods#

The PolicyValues class implements methods for computing net and gross future losses, and policy values (expected present values). The Contract class is used store and retrieve policy contract terms, such as benefit amounts and the various types of expenses.

from actuarialmath.policyvalues import PolicyValues, Contract
import math
import describe
describe.methods(PolicyValues)

class PolicyValues - Compute net and gross future losses and policy values

    Methods:
    --------

    gross_policy_value(x, s, t, n, contract):
      Gross policy values for insurance: t_V = E[L_t]

    gross_policy_variance(x, s, t, n, contract):
      Variance of gross policy value for WL and Endowment Insurance only

    net_policy_value(x, s, t, b, n, endowment, discrete):
      Net policy value assuming premiums from equivalence: E[L_t]

    net_policy_variance(x, s, t, b, n, endowment, discrete):
      Variance of net future loss for WL or Endowment Insurance only

    net_future_loss(A, A1, b):
      Shortcut for net policy value with WL or Endowment Insurance factors

    gross_future_loss(A, a, contract):
      Shortcut for gross policy value with WL or Endowment Insurance factors

    net_variance_loss(A1, A2, A, b):
      Variance of net loss with WL or Endowment Insurance factors

    gross_variance_loss(A1, A2, contract):
      Variance of gross loss with WL or endowment insurance factors

    L_from_t(t, contract):
      PV of Loss L(t) at time of death t = T_x

    L_from_prob(x, prob, contract):
      Percentile of PV future loss r.v. L given probability

    L_to_t(L, contract):
      Time of death T_x s.t. PV future loss is no more than L

    L_to_prob(x, L, contract):
      Probability such that PV of future loss r.v. is no more than L"

    L_plot(x, s, stop, T, contract, ax, dual, title, color, alpha):
      Plot PV of future loss r.v. L vs time of death T_x

describe.methods(Contract)

class Contract - Set and retrieve policy contract terms

    Args:
      premium : level premium amount
      benefit : insurance death benefit amount
      settlement_policy : settlement expense per policy
      endowment : endowment benefit amount
      initial_policy : first year total expense per policy
      initial_premium : first year total premium per $ of gross premium
      renewal_policy : renewal expense per policy
      renewal_premium : renewal premium per $ of gross premium
      discrete : annuity due (True) or continuous (False)
      T : term of insurance
      discrete : annuity due (True) or continuous (False)

    Methods:
    --------

    set_contract(terms):
      Update any existing policy contract terms

    premium_terms():
      Dict of terms required for calculating gross premiums

    renewal_profit():
      Renewal dollar profit (premium less renewal expenses)

    initial_cost():
      Total initial cost (excludes renewal expenses)

    claims_cost():
      Total claims cost (death benefit + settlement expense)

    renewals(t):
      Returns contract object with initial terms set to renewal terms

Examples#

The Contract helper class can be initialized to store expenses, benefit amounts and values of other contract features. Its set_contract method is called to update individual values, its renewals method returns a new Contract object with its initial expenses changed to be the same as renewal expenses, and other “getter” methods derive various summary values.

contract = Contract(benefit=1000, 
                    settlement_policy=20, 
                    initial_policy=10, 
                    initial_premium=0.75, 
                    renewal_policy=2, 
                    renewal_premium=0.1)
print(contract.premium_terms)
print(contract.renewals().premium_terms)
contract.set_contract(premium=35.38618830746352)
print(contract.initial_cost)
print(contract.claims_cost)
print(contract.renewal_profit)

{'benefit': 1000, 'initial_policy': 10, 'initial_premium': 0.75, 'renewal_policy': 2, 'renewal_premium': 0.1, 'settlement_policy': 20}
{'benefit': 1000, 'initial_policy': 2, 'initial_premium': 0.1, 'renewal_policy': 2, 'renewal_premium': 0.1, 'settlement_policy': 20}
31.00102239985129
1020
29.84756947671717

The gross_policy_value method in the PolicyValues class compute policy values at issue or future year \(t\) for general insurances and premiums. For whole life and endowment insurances only, gross_policy_variance computes the variance of the future gross loss PV random variable. Internally, these use the gross_future_loss and gross_variance_loss helper methods, which are also available to be called directly if the actuarial insurance factors are already provided as inputs.

When net premiums are given by the equivalence principle, net_policy_value computes the net policy values at issue or a future year \(t\). For whole life and endowment insurances only, net_policy_variance compute the variance of the future net loss PV random variable. Internally, these use the net_future_loss and net_variance_loss helper methods, which are also available to be called directly if the actuarial insurance factors are already provided as inputs.

def S(x, s, t):  # define a survival function
    return math.exp(-.00022*t - (.0000027*1.124**(x+s)*(1.124**t-1))/math.log(1.124))
life = PolicyValues().set_survival(S=S, minage=20, maxage=130)\
                     .set_interest(i=0.05)
print(life.net_policy_value(x=20, b=contract.benefit, discrete=contract.discrete), 
      life.net_policy_value(x=20, t=5, b=contract.benefit, discrete=contract.discrete))
print(life.net_policy_variance(x=20, b=contract.benefit, discrete=contract.discrete), 
      life.net_policy_variance(x=20, t=5, b=contract.benefit, discrete=contract.discrete))

print(life.gross_policy_value(x=20, contract=contract),
      life.gross_policy_variance(x=20, contract=contract))

0.0 12.88972064810054
3734.4039865925088 4534.593306902999
-514.7435740643272 9155.101027638082

The L_from_t method computes the present value of the future loss when death occurs at time \(t\), while L_from_prob returns the \(100p\)-th percentile value of \(L\). The inverse computations are performed by L_to_t and L_to_prob methods respectively. L_plot plots the present value of future loss r.v. \(L\) as a function of time \(t\). The example below determines the breakeven lifetime, when the present value of future loss L(t) = 0, and annotates in a plot with survival probabilities.

def S(x, s, t):  # define a survival function
    return math.exp(-.00022*t - (.0000027*1.124**(x+s)*(1.124**t-1))/math.log(1.124))
life = PolicyValues().set_survival(S=S, minage=20, maxage=130)\
                     .set_interest(i=0.05)
P = life.net_premium(x=20, discrete=False)
contract = Contract(premium=P, discrete=False)
T = life.L_to_t(L=0, contract=contract)        # breakeven T                            
life.L_plot(x=20, T=T, contract=contract, dual=True)
prob = life.L_to_prob(x=20, L=0, contract=contract)
print('L:', life.L_from_t(t=T, contract=contract), 
      life.L_from_prob(x=20, prob=prob, contract=contract))

L: -4.905848505210031e-10 -4.905742478911179e-10
_images/b9e8405916ac7917e618fbf0daa090ca09ae842f476acff4cba17d197c139801.png

SOA Question 6.24

For a fully continuous whole life insurance of 1 on (x), you are given:

  • L is the present value of the loss at issue random variable if the premium rate is determined by the equivalence principle

  • L^* is the present value of the loss at issue random variable if the premium rate is 0.06

  • \(\delta = 0.07\)

  • \(\overline{A}_x = 0.30\)

  • \(Var(L) = 0.18\)

Calculate \(Var(L^*)\).

print("SOA Question 6.24:  (E) 0.30")
life = PolicyValues().set_interest(delta=0.07)
x, A1 = 0, 0.30   # Policy for first insurance
P = life.premium_equivalence(A=A1, discrete=False)  # Need its premium
contract = Contract(premium=P, discrete=False)
def fun(A2):  # Solve for A2, given Var(Loss)
    return life.gross_variance_loss(A1=A1, A2=A2, contract=contract)
A2 = life.solve(fun, target=0.18, grid=0.18)
contract = Contract(premium=0.06, discrete=False)     # Solve second insurance
variance = life.gross_variance_loss(A1=A1, A2=A2, contract=contract)
print(variance)

SOA Question 6.24:  (E) 0.30
0.30419999999999975

SOA Question 6.30

For a fully discrete whole life insurance of 100 on (x), you are given:

  • The first year expense is 10% of the gross annual premium

  • Expenses in subsequent years are 5% of the gross annual premium

  • The gross premium calculated using the equivalence principle is 2.338

  • \(i = 0.04\)

  • \(\ddot{a}_x = 16.50\)

  • \(^2A_x = 0.17\)

Calculate the variance of the loss at issue random variable.

print("SOA Question 6.30:  (A) 900")
life = PolicyValues().set_interest(i=0.04)
contract = Contract(premium=2.338, benefit=100, initial_premium=.1,
                    renewal_premium=0.05)
var = life.gross_variance_loss(A1=life.insurance_twin(16.50),
                                A2=0.17, contract=contract)
print(var)

SOA Question 6.30:  (A) 900
908.141412994607

SOA Question 7.32

For two fully continuous whole life insurance policies on (x), you are given:

Death Benefit

Annual Premium Rate

Variance of the PV of Future Loss at t

Policy A

1

0.10

0.455

Policy B

2

0.16

-

  • \(\delta= 0.06\)

Calculate the variance of the present value of future loss at \(t\) for Policy B.

print("SOA Question 7.32:  (B) 1.4")
life = PolicyValues().set_interest(i=0.06)
contract = Contract(benefit=1, premium=0.1)
def fun(A2):
    return life.gross_variance_loss(A1=0, A2=A2, contract=contract)
A2 = life.solve(fun, target=0.455, grid=0.455)
contract = Contract(benefit=2, premium=0.16)
var = life.gross_variance_loss(A1=0, A2=A2, contract=contract)
print(var)

SOA Question 7.32:  (B) 1.4
1.3848168384380901

SOA Question 6.12

For a fully discrete whole life insurance of 1000 on (x), you are given:

  • The following expenses are incurred at the beginning of each year:

Year 1

Years 2+

Percent of premium

75%

10%

Maintenance expenses

10

2

  • An additional expense of 20 is paid when the death benefit is paid

  • The gross premium is determined using the equivalence principle

  • \(i = 0.06\)

  • \(\ddot{a}_x = 12.0\)

  • \(^2A_x = 0.14\)

Calculate the variance of the loss at issue random variable.

print("SOA Question 6.12:  (E) 88900")
life = PolicyValues().set_interest(i=0.06)
a = 12
A = life.insurance_twin(a)
contract = Contract(benefit=1000, settlement_policy=20, 
                    initial_policy=10, initial_premium=0.75, 
                    renewal_policy=2, renewal_premium=0.1)
contract.premium = life.gross_premium(A=A, a=a, **contract.premium_terms)
print(A, contract.premium)
L = life.gross_variance_loss(A1=A, A2=0.14, contract=contract)
print(L)

SOA Question 6.12:  (E) 88900
0.3207547169811321 35.38618830746352
88862.59592874818
Contents