5D Library › Multistage Ultimatum Bargaining, Accounts-Receivable Decay Kinetics and Optimal Escalation Sequences · 中文
Chapter 4. When to Escalate
Three stages
A common collection sequence moves from friendly reminders, to stopping service or deliveries, to a lawyer’s letter and a report to a credit bureau. Each step makes some debtors pay faster and costs something: stopping service to a customer who was merely late can lose future business, and a lawyer’s letter costs money and goodwill. p07 values the sequence for the debtors of book A and searches for the best days to take the second and third steps.
Calculation
# Chapter 4. p07: When to escalate. One overdue invoice of 1, debtor of
# book A in p05 (prompt-but-late 60%, slow 30%, distressed 10%). Daily
# hazards of paying: 1/15, 1/90, 1/400; distressed debtors also become
# insolvent at 1/250 a day. Three stages:
# 1 friendly reminders from day 0: hazards x 1.5, no cost;
# 2 stop service from day t2: x 3 for prompt and slow, x 1.5 for
# distressed; costs 0.3 (lost future margin) if the debtor is a
# prompt-but-late customer still unpaid on day t2;
# 3 lawyer's letter and credit reporting from day t3: x 6 for slow,
# x 3 for distressed (who now pay this creditor first); costs 0.05
# plus 0.3 for any prompt customer still unpaid.
# Expected net recovery within 365 days, by exact daily integration;
# grid search over t2 and t3.
KINDS = ((0.6, 1 / 15, 0.0, "prompt"), (0.3, 1 / 90, 0.0, "slow"),
(0.1, 1 / 400, 1 / 250, "distressed"))
MULT = {"prompt": (1.5, 3.0, 3.0), "slow": (1.5, 3.0, 6.0),
"distressed": (1.5, 1.5, 3.0)}
def value(t2, t3, days=365, parts=False):
total, by = 0.0, []
for share, h0, fail, kind in KINDS:
alive, got, cost = 1.0, 0.0, 0.0
for d in range(days):
if d == t2 and kind == "prompt":
cost += 0.3 * alive
if d == t3:
cost += 0.05 * alive + (0.3 * alive if kind == "prompt"
else 0.0)
m = MULT[kind]
k = m[2] if d >= t3 else m[1] if d >= t2 else m[0]
h = min(1.0, h0 * k)
got += alive * h
alive *= (1 - h) * (1 - fail)
total += share * (got - cost)
by.append(got - cost)
return by if parts else total
if __name__ == "__main__":
never = 10 ** 6
grid = [(t2, t3) for t2 in range(15, 181, 15)
for t3 in list(range(t2, 241, 15)) + [never]]
best = max(grid, key=lambda g: value(*g))
print(" policy t2 t3 net prompt slow"
" distr.")
for lab, g in (("reminders only", (never, never)),
("everything on day 1", (1, 1)),
("30/60/90 habit", (60, 90)),
("best on the grid", best)):
t3 = "never" if g[1] == never else str(g[1])
t2 = "never" if g[0] == never else str(g[0])
p = value(*g, parts=True)
print(" {:<21} {:>5} {:>5} {:6.4f} {:5.3f} {:5.3f} {:5.3f}"
.format(lab, t2, t3, value(*g), *p))
# policy t2 t3 net prompt slow distr.
# reminders only never never 0.9450 1.000 0.998 0.456
# everything on day 1 1 1 0.5936 0.415 0.951 0.593
# 30/60/90 habit 60 90 0.9507 0.999 0.993 0.530
# best on the grid 60 105 0.9508 0.999 0.996 0.523Reminders alone recover 0.9450 of the amount, net of costs. Taking every step on day 1 recovers only 0.5936: the distressed debtors pay a little more (0.593 against 0.456), but prompt customers, who would have paid anyway, are lost (0.415 instead of 1.000). The common habit of stopping service at day 60 and sending a letter at day 90 gives 0.9507, and the best pair on the grid, days 60 and 105, gives 0.9508. The gain from escalation is real but small, and it comes almost entirely from the distressed debtors: their recovery rises from 0.456 to 0.523. Its cost falls on the good customers, so the main rule is not to escalate before they have had time to pay.
One timetable or one for each kind?
If escalation helps only with distressed debtors, why not escalate those at once and leave the rest alone? p08 tries this with an imperfect screen.
Calculation
# Chapter 4. p08: One timetable for all, or one for each kind? Same
# debtors and stages as p07. A uniform timetable escalates everyone at
# the same days; a segmented one escalates debtors flagged as
# distressed on day 1 and the rest on days 60 and 105. Flags come from
# a screen that marks a distressed debtor with chance s and a sound one
# with chance 0.05. Then the best uniform timetable for three costs of
# lost future margin M.
KINDS = ((0.6, 1 / 15, 0.0, "prompt"), (0.3, 1 / 90, 0.0, "slow"),
(0.1, 1 / 400, 1 / 250, "distressed"))
MULT = {"prompt": (1.5, 3.0, 3.0), "slow": (1.5, 3.0, 6.0),
"distressed": (1.5, 1.5, 3.0)}
def one(kind, h0, fail, t2, t3, margin=0.3, days=365):
alive, got, cost = 1.0, 0.0, 0.0
for d in range(days):
if d == t2 and kind == "prompt":
cost += margin * alive
if d == t3:
cost += 0.05 * alive + (margin * alive if kind == "prompt"
else 0.0)
m = MULT[kind]
k = m[2] if d >= t3 else m[1] if d >= t2 else m[0]
h = min(1.0, h0 * k)
got += alive * h
alive *= (1 - h) * (1 - fail)
return got - cost
def segmented(s, false_flag=0.05):
total = 0.0
for share, h0, fail, kind in KINDS:
flag = s if kind == "distressed" else false_flag
v = flag * one(kind, h0, fail, 1, 1) + \
(1 - flag) * one(kind, h0, fail, 60, 105)
total += share * v
return total
def uniform(t2, t3, margin):
return sum(sh * one(k, h, f, t2, t3, margin) for sh, h, f, k in KINDS)
if __name__ == "__main__":
print(" uniform 60 / 105: {:.4f}".format(uniform(60, 105, 0.3)))
print(" screen catches s of distressed segmented value")
for s in (0.0, 0.5, 0.8, 1.0):
print(" {:31.1f} {:15.4f}".format(s, segmented(s)))
print(" perfect screen (s = 1, no false flags): {:.4f}".format(
segmented(1.0, 0.0)))
print(" lost margin M best uniform t2 t3 value")
grid = [(a, b) for a in range(15, 181, 15) for b in range(a, 241, 15)]
for m in (0.1, 0.3, 0.6):
g = max(grid, key=lambda x: uniform(x[0], x[1], m))
print(" {:13.1f} {:15d} {:3d} {:6.4f}".format(
m, g[0], g[1], uniform(g[0], g[1], m)))
# uniform 60 / 105: 0.9508
# screen catches s of distressed segmented value
# 0.0 0.9326
# 0.5 0.9361
# 0.8 0.9382
# 1.0 0.9396
# perfect screen (s = 1, no false flags): 0.9578
# lost margin M best uniform t2 t3 value
# 0.1 60 105 0.9510
# 0.3 60 105 0.9508
# 0.6 75 105 0.9506A uniform timetable gives 0.9508. Escalating at once against debtors flagged as distressed gives 0.9326 if the screen catches none of them and 0.9396 even if it catches all, because it also flags 5% of sound customers, and treating a good customer as a bad one costs more than the extra recovery from the distressed. Only a perfect screen, with no false flags, does better: 0.9578. The best uniform days barely change with the value of lost future margin (0.9510, 0.9508 and 0.9506). The lesson is the same as in the early-warning chapter of Vol. 093: a screen with even a small false-alarm rate can cost more than it saves when the condition it looks for is rare.
Hypothesis · not established
The author’s interpretation (not yet tested): for creditors whose overdue book is dominated by customers who are only late, moving the first coercive step (stopping service) earlier than about two months lowers net recovery including the value of lost customers. What would show it wrong: in a pre-registered field experiment randomising the day of the first coercive step, earlier steps raise net recovery including customer lifetime value.
Summary
Escalation pays only against debtors who would not otherwise pay, and its cost falls on customers who would. Late escalation for everyone beats early escalation, and targeting is worth it only with a screen that rarely flags good customers.
Fan, Y. (2026). Multistage Ultimatum Bargaining, Accounts-Receivable Decay Kinetics and Optimal Escalation Sequences: Ackerman Concession Curves, Credible Threat Thresholds and Default Recovery Bounds [多阶段最后通牒议价、应收账款衰减动力学与最优施压序列] (Version 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.24090245 · Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0).