关于「老板的利润:线性与阶梯方案的蒙特卡洛对决」,《提成阶梯与期末冲量》给出的定量结论是什么?

结论:第四章用蒙特卡洛模拟比较老板利润,线性方案比台阶方案每季度多 0.2266,相当于 0.089;但在同等薪酬与某一努力弹性下,台阶方案反而小胜 0.017,所以命题只能说「往往」。

数据口径:书中的销售员、门店、费率与折扣均为示意参数;全部计算由书中程序生成;本书是非个人化的经营建议,不构成法律、税务或理财建议,涉及法规的表述以上架前人工复核为准。 第四章用蒙特卡洛模拟比较老板利润,线性方案比台阶方案每季度多 0.2266,相当于 0.089;但在同等薪酬与某一努力弹性下,台阶方案反而小胜 0.017,所以命题只能说「往往」。

English version

对照数据表

下表数字由本章 Python 程序原样打印,可重新运行复现。 程序只用 Python 标准库与结论吻合的打印值: 0.089, 0.2266

planprofit/qtr95% +/-pay/qtrdealscut/qtrlost/qtr
L2.76010.00450.552011.0400.00000.0000
S2.53350.00330.557610.4110.03230.0634
A2.57200.00590.477710.5510.11560.1955
L minus S: 0.2266 +/- 0.0056 per quarter, 0.089 of S
L minus A: 0.1882 +/- 0.0074 per quarter, 0.073 of A
查看完整验算程序
# Chapter 4. p41: The owner's profit, Monte Carlo. Each plan's optimal
# policy (p31) is simulated for 20,000 quarters with a fixed seed; the
# owner keeps a gross margin of 0.30 per list-price unit, minus any
# discount and commission (shared core; parameters illustrative).
# 95% intervals use 100 batch means of 200 quarters each, so that the
# carry-over between quarters does not shrink the interval.
# 老板利润的蒙特卡洛:线性 vs 台阶 vs 加速(批均值 95% 区间)。
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 ----
from statistics import NormalDist, stdev

Z = NormalDist().inv_cdf(0.975)


def batch_ci(xs, nb=100):
    size = len(xs) // nb
    bm = [mean(xs[i * size:(i + 1) * size]) for i in range(nb)]
    return mean(bm), Z * stdev(bm) / math.sqrt(nb), stdev(bm) ** 2 / nb


if __name__ == "__main__":
    m = dict(BASE)
    res = {}
    print("plan  profit/qtr  95% +/-   pay/qtr  deals  cut/qtr  lost/qtr")
    for name, plan in (("L", LIN), ("S", STEP), ("A", ACCEL)):
        rec = simulate(plan, solve(plan, m), m, 20000, 4)
        mu, hw, var = batch_ci([r["profit"] for r in rec])
        res[name] = (mu, var)
        cut = mean([math.fsum(r["pulled"]) for r in rec]) * m["disc"]
        print(" {}     {:.4f}    {:.4f}    {:.4f}  {:6.3f}  {:.4f}   {:.4f}"
              .format(name, mu, hw,
                      mean([r["pay"] for r in rec]),
                      mean([math.fsum(r["week"]) for r in rec]), cut,
                      mean([r["lost"] for r in rec])))
    for other in "SA":
        d = res["L"][0] - res[other][0]
        hw = Z * math.sqrt(res["L"][1] + res[other][1])
        print("L minus {}: {:.4f} +/- {:.4f} per quarter, {:.3f} of {}"
              .format(other, d, hw, d / res[other][0], other))

唯一数据源与引用

范雅福(Fan, Y.). (2026). 《销售提成阶梯非线性、期末冲量操纵与业绩配额博弈扭曲母典》第 4 章「老板的利润:线性与阶梯方案的蒙特卡洛对决」(版本 1.0.0). 5D Library. DOI 待发布

DOI 待发布 · 专著页正式发布后上线(本站暂无专著页) · 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}
}

本书其他章节结论