lifelib's basic term in cashflower

Policyholder

Policyholder's attributes

We determine the policyholder's time in force, age and projection length.

@variable()
def duration_mth(t):
    if t == 0:
        return model_point.get("duration_mth")
    else:
        return duration_mth(t-1) + 1


@variable()
def duration(t):
    return duration_mth(t) // 12


@variable()
def age(t):
    return model_point.get("age_at_entry") + duration(t)


@variable()
def proj_len():
    return max(12 * model_point.get("policy_term") - model_point.get("duration_mth") + 1, 0)

Premium calculation

The premium per policy is determined based on the sum assured and the premium rate from the assumption table.

@variable()
def premium_pp():
    df = assumption["premium_table"]
    age_at_entry = model_point.get("age_at_entry")
    policy_term = model_point.get("policy_term")
    premium_rate = df.loc[(df['age_at_entry'] == age_at_entry) &
                          (df['policy_term'] == policy_term), 'premium_rate'].values[0]
    return round(model_point.get("sum_assured") * premium_rate, 2)

Lapse and mortality rates

The lapse rate is assumed to decrease with duration but remains above a minimum threshold.

@variable()
def lapse_rate(t):
    return max(0.1 - 0.02 * duration(t), 0.02)

Mortality rates are read from the mortality table. The function avoids redundant reads for performance optimization.

@variable()
def mort_rate(t):
    if t > 0 and age(t-1) == age(t) and (duration(t-1) == duration(t) or duration(t) > 5):
        return mort_rate(t-1)
    age_t = int(max(min(age(t), 120), 18))
    duration_t = str(int(max(min(duration(t), 5), 0)))
    return assumption["mort_table"].loc[age_t, duration_t]

@variable()
def mort_rate_mth(t):
    return 1-(1-mort_rate(t))**(1/12)

Economic

We define the discount rates and inflation factor used in the model.

Discount rates

The annual discount rate is retrieved from the assumption table, avoiding unnecessary lookups within the same year.

@variable()
def discount_ann(t):
    if t > 0 and (t-1)//12 == t//12:
        return discount_ann(t-1)
    return assumption["disc_rate_ann"].loc[t//12, 'zero_spot']

The monthly discount rate is derived from the annual rate.

@variable()
def discount(t):
    return (1 + discount_ann(t))**(-t/12)

Inflation factor

The inflation factor grows exponentially based on the inflation rate assumption.

@variable()
def inflation_factor(t):
    return (1 + assumption["inflation_rate"])**(t/12)

Cash flows

The model distinguishes between inflows (premiums) and outflows (claims, commissions, and expenses). The net cash flow is the difference between these components.

Inflows

Premiums are received monthly as long as the policy is active.

@variable()
def premiums(t):
    if t >= proj_len():
        return 0
    return premium_pp() * pols_if_at_bef_decr(t)

Outflows

Claims are paid when policyholders pass away.

@variable()
def claims(t):
    if t >= proj_len():
        return 0
    return model_point.get("sum_assured") * pols_death(t)

Commissions are paid in full when the policy is sold.

@variable()
def commissions(t):
    if duration(t) == 0:
        return premiums(t)
    else:
        return 0

Expenses consist of acquisition costs at policy inception and ongoing maintenance costs, adjusted for inflation.

@variable()
def expenses(t):
    if t >= proj_len():
        return 0

    return (assumption["expense_acq"] * pols_new_biz(t) + pols_if_at_bef_decr(t) * assumption["expense_maint"]/12
            * inflation_factor(t))

Net cash flow

Net cash flow is the difference between inflows and outflows.

@variable()
def net_cf(t):
    return premiums(t) - claims(t) - expenses(t) - commissions(t)

Policy count

This section tracks the number of policies in force (IF) at different stages, considering new business, lapses, deaths and maturities.

Initial policy count

At the start of the projection, policies may already exist.

@variable()
def pols_if_init():
    if duration_mth(0) > 0:
        return model_point.get("policy_count")
    else:
        return 0

Policies before decrements

The number of policies before lapses, death and maturities is the sum of last period's in-force policies and new business.

@variable()
def pols_if_at_bef_decr(t):
    return pols_if_at_bef_nb(t) + pols_new_biz(t)

Decrements (lapses and deaths)

Lapses occur based on the lapse rate.

@variable()
def pols_lapse(t):
    return (pols_if_at_bef_decr(t) - pols_death(t)) * (1 - (1 - lapse_rate(t)) ** (1 / 12))

Deaths occur based on the mortality rate.

@variable()
def pols_death(t):
    return pols_if_at_bef_decr(t) * mort_rate_mth(t)

Policies before maturities

After accounting for lapses and deaths, we determine policies before maturities.

@variable()
def pols_if_at_bef_mat(t):
    if t == 0:
        return pols_if_init()
    else:
        return pols_if_at_bef_decr(t-1) - pols_lapse(t-1) - pols_death(t-1)

Maturities

Policies mature when they reach the end of their term.

@variable()
def pols_maturity(t):
    if duration_mth(t) == model_point.get("policy_term") * 12:
        return pols_if_at_bef_mat(t)
    else:
        return 0

Policies before new business

This represents policies before adding new business for the period.

@variable()
def pols_if_at_bef_nb(t):
    return pols_if_at_bef_mat(t) - pols_maturity(t)

New business

New policies are added when they are first issued.

@variable()
def pols_new_biz(t):
    if duration_mth(t) == 0:
        return model_point.get("policy_count")
    else:
        return 0

Final policies in force

The final number of in-force policies after all adjustments.

@variable()
def pols_if(t):
    return pols_if_at_bef_mat(t)

Present values

Present value (PV) calculations discount future cash flows to today's value. These help in assessing the financial position of a policy over time.

Present value of policies in force

This represents the discounted sum of future in-force policies.

@variable()
def pv_pols_if(t):
    if t == settings["T_MAX_CALCULATION"]:
        return pols_if(t) * discount(t)
    return pols_if(t) * discount(t) + pv_pols_if(t+1)

Present value of premiums

The total value of all future premium payments, discounted to today.

@variable()
def pv_premiums(t):
    if t == settings["T_MAX_CALCULATION"]:
        return premiums(t) * discount(t)
    return premiums(t) * discount(t) + pv_premiums(t+1)

Present value of claims

The total expected claim payouts, adjusted for the time value of money.

@variable()
def pv_claims(t):
    if t == settings["T_MAX_CALCULATION"]:
        return claims(t) * discount(t)
    return claims(t) * discount(t) + pv_claims(t+1)

Present value of commissions

Total commissions payable over time, discounted to present value.

@variable()
def pv_commissions(t):
    if t == settings["T_MAX_CALCULATION"]:
        return commissions(t) * discount(t)
    return commissions(t) * discount(t) + pv_commissions(t+1)

Present value of expenses

The total expected expenses incurred, adjusted for discounting.

@variable()
def pv_expenses(t):
    if t == settings["T_MAX_CALCULATION"]:
        return expenses(t) * discount(t)
    return expenses(t) * discount(t) + pv_expenses(t+1)

Present value of net cash flows

The net position of the policy, factoring in all cash flows.

@variable()
def pv_net_cf(t):
    return pv_premiums(t) - pv_claims(t) - pv_expenses(t) - pv_commissions(t)

Net premium per policy

The premium required to cover expected claims, assuming no profit or loss.

@variable()
def net_premium_pp():
    if math.isclose(pv_pols_if(0), 0):
        return 0
    return pv_claims(0) / pv_pols_if(0)