What does Commission Ladders and the Quarter-End Push conclude, in numbers, about “Dynamic Programming of Close Timing: Holding, Dragging and Quarter-End Pull-Ins”?

Answer: Chapter 3 finds the salesperson's timing policy by dynamic programming: under the accelerator the last two weeks run at 1.32 times the average week, while the step plan's quarter end slumps to 0.67 times.

Scope of the numbers: Marked boxes separate published evidence, runnable Python calculations (19 programs), classical sources and the author's hypotheses.

中文版

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.67, 1.32

weekshare Lshare Sshare A
10.07680.12830.2137
20.07670.07650.0457
30.07670.07780.0451
60.07670.07790.0475
90.07710.07760.0685
100.07730.07300.0726
110.07670.07390.1000
120.07690.06550.1009
130.07700.03800.1022
L: last two weeks 0.154, ratio to average week 1.00
S: last two weeks 0.103, ratio to average week 0.67
A: last two weeks 0.203, ratio to average week 1.32
Show the full program
# Chapter 3. p32: The hockey stick. Following the optimal policy of p31
# for 20,000 simulated quarters (fixed seed; shared core; parameters
# illustrative), we count closes by week of the quarter under the linear
# plan L, the step plan S and the accelerator A, as a share of all
# closes, and the ratio of the last two weeks to the average week.
# 按周统计成交份额:期末两周与平均周之比(参数示意)。
import math
import random

# ---- shared core (identical in every DP program of this book) ----
# 一个季度 T 周;每周以概率 p 来一单(标价 1),p 由努力决定,
# 在 [P0, P1] 之间,努力成本为 k*(p-P0)^2/2。来单可当季成交,
# 或压到下季度(每单以 hloss 的概率流失)。最后 pullw 周,
# 每周以 acc 的概率可让下季度的一单打 disc 的折扣提前成交。
# 提前成交的单子下季度不再出现(下季度从负数起计)。
T, P0, P1, GM = 13, 0.6, 0.9, 0.30
BMAX, SMAX = 3, 24
BASE = dict(k=0.2, acc=0.5, disc=0.15, pullw=3, hloss=0.1,
            beta=0.9, hmax=4)
LIN = (0.05, 0.05, 10, 0.0)      # rate below, rate above, quota, bonus
STEP = (0.03, 0.03, 10, 0.25)
ACCEL = (0.03, 0.08, 10, 0.0)


def inc(plan, k, price):
    # commission paid for the k-th deal of the quarter at this price
    lo, hi, q, b = plan
    if k <= 0:
        return 0.0
    return (lo if k <= q else hi) * price + (b if k == q else 0.0)


def backward(plan, vst, m):
    hmax = m["hmax"]
    sn, cn = range(-BMAX, SMAX + 1), range(-BMAX, hmax + 1)
    nxt = {(s, c): m["beta"] * vst[c] for s in sn for c in cn}
    pol = {}
    for t in range(T, 0, -1):
        pv, pd = {}, {}
        for s in sn:
            s1 = min(s + 1, SMAX)
            for c in cn:
                stay, do = nxt[(s, c)], False
                best = stay
                if c > -BMAX and t > T - m["pullw"]:
                    v = inc(plan, s + 1, 1 - m["disc"]) + nxt[(s1, c - 1)]
                    if v > stay + 1e-12:
                        best, do = v, True
                pv[(s, c)] = (1 - m["acc"]) * stay + m["acc"] * best
                pd[(s, c)] = do
        cur = {}
        for s in sn:
            s1 = min(s + 1, SMAX)
            for c in cn:
                hold = False
                if s < 0:
                    a = pv[(s1, c)]
                else:
                    a = inc(plan, s + 1, 1.0) + pv[(s1, c)]
                    if c < hmax and pv[(s, c + 1)] > a + 1e-12:
                        a, hold = pv[(s, c + 1)], True
                p = pv[(s, c)]
                e = min(max((a - p) / m["k"], 0.0), P1 - P0)
                cur[(s, c)] = p + (P0 + e) * (a - p) - m["k"] * e * e / 2
                pol[(t, s, c)] = (P0 + e, hold, pd[(s, c)])
        nxt = cur
    return nxt, pol


def solve(plan, m):
    cn = range(-BMAX, m["hmax"] + 1)
    vst = {c: 0.0 for c in cn}
    for _ in range(400):
        w1, pol = backward(plan, vst, m)
        new = {}
        for c in cn:
            if c <= 0:
                new[c] = w1[(c, 0)]
                continue
            terms = []
            for n in range(c + 1):
                pr = (math.comb(c, n) * (1 - m["hloss"]) ** n
                      * m["hloss"] ** (c - n))
                pay = math.fsum(inc(plan, j, 1.0) for j in range(1, n + 1))
                terms.append(pr * (pay + w1[(n, 0)]))
            new[c] = math.fsum(terms)
        gap = max(abs(new[c] - vst[c]) for c in cn)
        vst = new
        if gap < 1e-7:
            break
    return pol


def simulate(plan, pol, m, nq, seed):
    # one record per quarter: owner profit, pay, deals by week, etc.
    rng = random.Random(20261112 + seed)
    c, out = 0, []
    for _ in range(nq):
        prof, pay, rev = [], [], []
        week, pulled = [0] * (T + 1), [0] * (T + 1)
        holds = lost = 0
        s = c
        if c > 0:
            s = 0
            for _ in range(c):
                if rng.random() < 1 - m["hloss"]:
                    s += 1
                else:
                    lost += 1
            for j in range(1, s + 1):
                x = inc(plan, j, 1.0)
                pay.append(x)
                prof.append(GM - x)
                rev.append(1.0)
            week[1] += s
        cn = 0
        for t in range(1, T + 1):
            p, hold, _ = pol[(t, s, cn)]
            if rng.random() < p:
                if s < 0:
                    s += 1
                elif hold:
                    cn += 1
                    holds += 1
                else:
                    x = inc(plan, s + 1, 1.0)
                    pay.append(x)
                    prof.append(GM - x)
                    rev.append(1.0)
                    s = min(s + 1, SMAX)
                    week[t] += 1
            if rng.random() < m["acc"] and pol[(t, s, cn)][2]:
                x = inc(plan, s + 1, 1 - m["disc"])
                pay.append(x)
                prof.append(GM - m["disc"] - x)
                rev.append(1 - m["disc"])
                s = min(s + 1, SMAX)
                cn -= 1
                week[t] += 1
                pulled[t] += 1
        c = cn
        out.append(dict(profit=math.fsum(prof), pay=math.fsum(pay),
                        rev=math.fsum(rev), week=week, pulled=pulled,
                        holds=holds, lost=lost))
    return out


def mean(xs):
    return math.fsum(xs) / len(xs)
# ---- end of shared core ----


if __name__ == "__main__":
    m = dict(BASE)
    shares = {}
    for name, plan in (("L", LIN), ("S", STEP), ("A", ACCEL)):
        rec = simulate(plan, solve(plan, m), m, 20000, 3)
        wk = [math.fsum(r["week"][t] for r in rec) for t in range(T + 1)]
        tot = math.fsum(wk)
        shares[name] = [x / tot for x in wk]
    print("week   share L  share S  share A")
    for t in (1, 2, 3, 6, 9, 10, 11, 12, 13):
        print(" {:2d}    {:.4f}   {:.4f}   {:.4f}".format(
            t, shares["L"][t], shares["S"][t], shares["A"][t]))
    for name in "LSA":
        sh = shares[name]
        print("{}: last two weeks {:.3f}, ratio to average week {:.2f}"
              .format(name, sh[T - 1] + sh[T], (sh[T - 1] + sh[T]) / 2 * T))

Single source and citation

Fan, Y. (2026). Nonlinear Commission Ladders, End-of-Period Timing Manipulation and Quota-Induced Game Distortion (Version 1.0.0), Chapter 3: Dynamic Programming of Close Timing: Holding, Dragging and Quarter-End Pull-Ins. 5D Library. DOI pending

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

BibTeX
@book{fan2026213,
  author    = {Fan, Yafu},
  title     = {Nonlinear Commission Ladders, End-of-Period Timing Manipulation and Quota-Induced Game Distortion},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

Other chapter answers in this book