What does Decomposing the IRR of Savings Insurance conclude, in numbers, about “Surrender and Liquidity: What Ten Thousand Policies Actually Earn and the Cost of Needing Cash”?

Answer: Chapter 4 follows ten thousand illustrative policies: 0.3285 of holders surrender at a loss, the pooled return falls to 0.02129, and the cost of surrender and policy loans under a sudden need for cash is computed.

Scope of the numbers: Chapter 1 shows that the illustrative policy held for thirty years returns only 0.02462, its cash value just 0.9906 of a bond ladder fed with the same premiums. Chapter 4 follows ten thousand illustrative policies: 0.3285 of holders surrender at a loss, the pooled return falls to 0.02129, and the cost of surrender and policy loans under a sudden need for cash is computed.

中文版

Data table

The numbers below are printed verbatim by the chapter's Python program and can be reproduced by running it. standard-library Python onlyprinted values that match the answer: 0.02129, 0.3285

exit band holders realised IRR (mid-band)
1 to3 1,782 -0.34102
4 to6 867 -0.07022
7 to9 636 -0.00932
10 to 15812 0.01211
16 to 291,369 0.02220
30 to 303,949 0.02462
deaths in years 1 to 30586
share who surrender at a loss0.3285
pooled cohort IRR0.02129
IRR of a 30-year holder0.02462
Show the full program
# Chapter 4. p41: What a cohort of policyholders actually earns.
# Model: 10,000 holders of the illustrative policy of p11. Each policy
# year a holder lapses (surrenders) with an illustrative probability that
# falls from 0.08 in year 1 to 0.02 from year 11; deaths follow the
# Gompertz law. The cohort is followed to year 30, when every survivor
# is assumed to surrender. We report how holders are spread over exit
# years, the IRR each group realises, the share who get back less than
# they paid, and the IRR of the pooled cohort cash flows compared with
# the IRR of a holder who keeps the policy for 30 years.
# 模型:一万名投保人的退保分布与实现收益率,退保率为示意。
import math

PREM, PAY, AGE, RATE, N = 10000.0, 10, 30, 0.030, 30
LOAD = [0.50, 0.25, 0.12, 0.06, 0.06, 0.03, 0.03, 0.03, 0.03, 0.03]
SURR = [0.20, 0.16, 0.12, 0.09, 0.07, 0.05, 0.03, 0.02, 0.01, 0.005]
DB_MULT, GA, GB = 1.2, 0.00005, 0.09
LAPSE = [0.08, 0.06, 0.05, 0.04, 0.04, 0.03, 0.03, 0.03, 0.03, 0.03]


def q_at(x):
    return 1.0 - math.exp(-GA / GB * (math.exp(GB * (x + 1))
                                      - math.exp(GB * x)))


def schedule():
    acc, paid, cv, db = 0.0, 0.0, [], []
    for t in range(1, N + 1):
        p = PREM if t <= PAY else 0.0
        paid = paid + p
        load = LOAD[t - 1] if t <= PAY else 0.0
        pre = (acc + p * (1.0 - load)) * (1.0 + RATE)
        risk = max(DB_MULT * paid - pre, 0.0)
        acc = pre - q_at(AGE + t - 1) * risk
        sc = SURR[t - 1] if t <= len(SURR) else 0.0
        cv.append(acc * (1.0 - sc))
        db.append(max(DB_MULT * paid, acc))
    return cv, db


def irr(cf):
    def npv(x):
        return math.fsum(c / (1.0 + x) ** t for t, c in enumerate(cf))
    lo, hi = -0.99, 1.0
    for _ in range(200):
        mid = 0.5 * (lo + hi)
        if npv(lo) * npv(mid) <= 0.0:
            hi = mid
        else:
            lo = mid
    return 0.5 * (lo + hi)


if __name__ == "__main__":
    cv, db = schedule()
    alive, pooled, groups, deaths = 10000.0, [0.0] * (N + 1), [], []
    for t in range(1, N + 1):
        pay = PREM * alive if t <= PAY else 0.0
        pooled[t - 1] = pooled[t - 1] - pay
        dead = alive * q_at(AGE + t - 1)
        lap = (alive - dead) * (LAPSE[t - 1] if t <= PAY else 0.02)
        if t == N:
            lap = alive - dead
        pooled[t] = pooled[t] + dead * db[t - 1] + lap * cv[t - 1]
        groups.append((t, lap, cv[t - 1]))
        deaths.append(dead)
        alive = alive - dead - lap
    loss = math.fsum(g[1] for g in groups
                     if g[2] < PREM * min(g[0], PAY)) / 10000.0
    print("exit band   holders  realised IRR (mid-band)")
    for lo, hi in ((1, 3), (4, 6), (7, 9), (10, 15), (16, 29), (30, 30)):
        n = math.fsum(g[1] for g in groups if lo <= g[0] <= hi)
        mid = (lo + hi) // 2
        cf = [-PREM if t < min(mid, PAY) else 0.0 for t in range(mid)]
        print("{:>2} to {:>2}    {:>7,.0f}  {:>10.5f}"
              .format(lo, hi, n, irr(cf + [cv[mid - 1]])))
    print("deaths in years 1 to 30: {:,.0f}".format(math.fsum(deaths)))
    print("share who surrender at a loss: {:.4f}".format(loss))
    print("pooled cohort IRR: {:.5f}".format(irr(pooled)))
    cf = [-PREM if t < PAY else 0.0 for t in range(N)] + [cv[N - 1]]
    print("IRR of a 30-year holder: {:.5f}".format(irr(cf)))

Single source and citation

Fan, Y. (2026). Decomposing the IRR of Savings Insurance: Halley's Life Table and the Limits of Buying Term and Investing the Difference (Version 1.0.0), Chapter 4: Surrender and Liquidity: What Ten Thousand Policies Actually Earn and the Cost of Needing Cash. 5D Library. DOI pending

DOI pending · monograph page goes live after publication · 5DL-B-220 · v1.0.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026220,
  author    = {Fan, Yafu},
  title     = {Decomposing the IRR of Savings Insurance: Halley's Life Table and the Limits of Buying Term and Investing the Difference},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

Other chapter answers in this book