What does Decomposing the IRR of Savings Insurance conclude, in numbers, about “Four Parts of the Return Shortfall: Spread, Expenses, Cost of Insurance and Surrender Charges”?

Answer: The total shortfall in year ten is 0.03506. Expenses receive a Shapley value of 0.02421, with marginal drops between 0.02379 and 0.02463 across orders; the spread receives 0.00975, ranging from 0.00943 to 0.01005; the surrender charge 0.00090; the cost of insurance 0.00020. In year thirty the total is 0.01538, of which the spread takes 0.00992, expenses 0.00540, the cost of insurance only 0.00005 and the surrender charge nothing. The four Shapley values add up to the total digit for digit.

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.00005, 0.00020, 0.00090, 0.00540, 0.00943, 0.00975

exit 10: total gap 0.03506
componentShapleymin dropmax drop
spread0.009750.009430.01005
expense0.024210.023790.02463
mortality0.000200.000040.00037
surrender0.000900.000900.00091
sum of Shapley values 0.03506
exit 30: total gap 0.01538
componentShapleymin dropmax drop
spread0.009920.009820.01001
expense0.005400.005270.00552
mortality0.000050.000010.00011
surrender0.000000.000000.00000
sum of Shapley values 0.01538
Show the full program
# Chapter 3. p32: Order-free attribution of the IRR gap (Shapley).
# Model: the four switches of p31 (spread, expense, mortality,
# surrender) on the same illustrative policy. A sequential decomposition
# depends on the order in which the switches are turned on, so we turn
# them on in all 24 orders, record each component's marginal drop, and
# report its average (the Shapley value) with the smallest and largest
# marginal drop. The four Shapley values add up to the total gap.
# 模型:对 24 种开启顺序取平均(沙普利值),消除拆解顺序的影响。
import itertools
import math

PREM, PAY, AGE = 10000.0, 10, 30
ASSET, PRICE = 0.040, 0.030
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
STEPS = ["spread", "expense", "mortality", "surrender"]


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


def cash_value(n, on):
    rate = PRICE if "spread" in on else ASSET
    acc, paid, cv = 0.0, 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 and "expense" in on) else 0.0
        pre = (acc + p * (1.0 - load)) * (1.0 + rate)
        risk = max(DB_MULT * paid - pre, 0.0)
        cost = q_at(AGE + t - 1) * risk if "mortality" in on else 0.0
        acc = pre - cost
        sc = SURR[t - 1] if (t <= len(SURR) and "surrender" in on) else 0.0
        cv = acc * (1.0 - sc)
    return cv


def irr(n, on):
    cf = [-PREM if t < min(n, PAY) else 0.0 for t in range(n)]
    cf.append(cash_value(n, on))

    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)


def shapley(n):
    memo = {}

    def val(on):
        key = tuple(sorted(on))
        if key not in memo:
            memo[key] = irr(n, set(on))
        return memo[key]
    marg = {s: [] for s in STEPS}
    for order in itertools.permutations(STEPS):
        on = []
        for s in order:
            before = val(on)
            on = on + [s]
            marg[s].append(before - val(on))
    return marg, val([]) - val(STEPS)


if __name__ == "__main__":
    for n in (10, 30):
        marg, total = shapley(n)
        print("exit {}: total gap {:.5f}".format(n, total))
        print("  component   Shapley   min drop  max drop")
        vals = []
        for s in STEPS:
            m = marg[s]
            vals.append(math.fsum(m) / len(m))
            print("  {:<10}  {:.5f}   {:.5f}   {:.5f}"
                  .format(s, vals[-1], min(m), max(m)))
        print("  sum of Shapley values {:.5f}".format(math.fsum(vals)))

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 3: Four Parts of the Return Shortfall: Spread, Expenses, Cost of Insurance and Surrender Charges. 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