5D Library › Enterprise Bottleneck Diagnostics, SKU Cannibalization Audits and Automation Return Bounds · 中文
Chapter 4. The Margin Dilution Matrix and the Limits of “Cut 30%”
The dilution matrix: who recaptures how much margin for each unit lost
Multiply each diversion ratio by the unit margin of the product receiving the demand and you get the margin dilution matrix: row , column is the margin product recaptures for every unit of product that is no longer sold. The row total is the “recaptured margin”. If a product’s recaptured margin exceeds its own unit margin, every unit it sells lowers the company’s total margin a little: its sales are mostly taken from its siblings.
Calculation
# Chapter 4. p07: The margin dilution matrix. Entry (j, k) = diversion
# j -> k times the unit margin of k: the RM that SKU k recaptures for
# every unit of j that disappears. A SKU's true (incremental) monthly
# contribution is profit with it minus profit without it; its naive
# contribution ignores what it takes from its siblings.
import importlib.util
def load(name):
spec = importlib.util.spec_from_file_location(name, name + ".py")
m = importlib.util.module_from_spec(spec)
spec.loader.exec_module(m)
return m
p05 = load("p05_nested_logit")
p06 = load("p06_pruning")
M = p06.MARGIN
def incremental(j, active):
return p06.profit(active) - p06.profit([a for a in active if a != j])
if __name__ == "__main__":
allv = list(p05.ALL)
nest_a = [s[0] for s in p05.SKUS if s[1] == "A"]
print(" dilution matrix, nest A (RM recaptured per unit lost)")
print(" from/to " + "".join("{:>7}".format(k) for k in nest_a)
+ " margin")
for j in nest_a:
dv = p05.diversion(j, allv)
cells = "".join("{:>7}".format("." if k == j else
"{:.1f}".format(dv[k] * M[k]))
for k in nest_a)
rec = sum(dv[k] * M[k] for k in allv if k != j)
print(" {:<7} {} {:>4} (recaptured {:.1f})".format(
j, cells, M[j], rec))
u = p06.units(allv)
print(" SKU naive RM incremental RM")
rows = [(j, u[j] * M[j] - p06.FIXED, incremental(j, allv))
for j in allv]
for j, nv, inc in rows:
print(" {:<4} {:8,.0f} {:12,.0f}".format(j, nv, inc))
neg = [j for j, _, inc in rows if inc < 0]
print(" SKUs that lower total profit: {}".format(", ".join(neg)))
# dilution matrix, nest A (RM recaptured per unit lost)
# from/to F A1 A2 A3 A4 margin
# F . 11.8 10.1 5.3 3.6 120 (recaptured 33.9)
# A1 26.5 . 8.7 4.5 3.1 90 (recaptured 45.7)
# A2 27.6 10.6 . 4.7 3.2 60 (recaptured 49.1)
# A3 26.5 10.2 8.7 . 3.1 40 (recaptured 51.4)
# A4 25.9 10.0 8.6 4.4 . 32 (recaptured 51.8)
# SKU naive RM incremental RM
# F 128,786 91,750
# A1 48,053 22,367
# A2 40,775 5,340
# A3 19,968 -8,904
# A4 12,715 -11,900
# B1 12,809 1,405
# B2 9,068 -1,247
# B3 5,969 -3,324
# B4 3,416 -4,929
# B5 900 -5,727
# SKUs that lower total profit: A3, A4, B2, B3, B4, B5The sub-line A3 has a unit margin of RM 40; for each unit it no longer sells, the other products recapture RM 51.4, of which the flagship RM 26.5. A4 has a unit margin of RM 32 and a recapture of RM 51.8. For each unit the flagship no longer sells, only RM 33.9 is recaptured, far below its own unit margin of RM 120.
So there are two contributions. The “naive contribution” is units times margin minus maintenance cost; the “incremental contribution” is the difference in the company’s total profit with and without the product. A3’s naive contribution is RM 19,968 but its incremental contribution RM -8,904; A4’s are RM 12,715 against RM -11,900. The flagship’s naive contribution is RM 128,786, its incremental contribution RM 91,750. Taken one at a time, six of the ten products lower total profit: A3, A4, B2, B3, B4 and B5.
Note
Ranking by naive contribution cuts the wrong ones. The cut by naive contribution in Chapter 3 removed B3, B4 and B5, while the worst dilution comes from the sub-line A3 and A4: their naive contributions rank in the middle, but their incremental contributions are the two lowest in the line.
“Cut the bottom 30%” is not a law
Computing incremental contributions one at a time has its own limit: once one product is delisted, the incremental contributions of the others change. A safer procedure is greedy: at each step delist the product whose removal raises total profit the most, until none does. Below, three procedures are compared over 400 random worlds, each with different qualities, margins, nest parameters, outside options and maintenance costs, and with one realistic factor added: the fuller the line, the more shoppers visit, with visits varying as the number of listed products to the power .
Calculation
# Chapter 4. p08: Is "delist the bottom 30%" a law? Greedy pruning (drop
# the SKU whose removal raises profit most, until none does) against two
# fixed 30% rules, over 400 random worlds: qualities +/- 0.4, margins
# x U(0.7, 1.3), lambda_A in [0.4, 0.9], lambda_B in [0.6, 1.0], outside
# utility in [1, 3], listing cost RM 1,000 to 4,000 a month, and a
# traffic elasticity eta in [0, 0.3]: a shop with n of its 10 SKUs draws
# (n / 10)^eta of the shoppers (range brings visits). Seed 83.
import importlib.util
import random
def load(name):
spec = importlib.util.spec_from_file_location(name, name + ".py")
m = importlib.util.module_from_spec(spec)
spec.loader.exec_module(m)
return m
p05 = load("p05_nested_logit")
def profit(active, skus, lam, u0, fixed, eta=0.0):
s = p05.shares(active, lam, skus, u0)
mg = {x[0]: x[3] for x in skus}
n = p05.SHOPPERS * (len(active) / len(skus)) ** eta
return sum(n * s[j] * mg[j] for j in active) - fixed * len(active)
def greedy(skus, lam, u0, fixed, eta=0.0):
act = [x[0] for x in skus]
cur = profit(act, skus, lam, u0, fixed, eta)
while len(act) > 1:
best = max(act, key=lambda j: profit([a for a in act if a != j],
skus, lam, u0, fixed, eta))
new = profit([a for a in act if a != best], skus, lam, u0, fixed,
eta)
if new <= cur:
break
act.remove(best)
cur = new
return act, cur
def rule(skus, lam, u0, fixed, eta, incremental):
act = [x[0] for x in skus]
base = profit(act, skus, lam, u0, fixed, eta)
if incremental:
key = {j: base - profit([a for a in act if a != j], skus, lam, u0,
fixed, eta) for j in act}
else:
s = p05.shares(act, lam, skus, u0)
key = {x[0]: p05.SHOPPERS * s[x[0]] * x[3] - fixed for x in skus}
cut = sorted(act, key=key.get)[:3]
return profit([a for a in act if a not in cut], skus, lam, u0, fixed,
eta)
if __name__ == "__main__":
act, best = greedy(p05.SKUS, p05.LAM, p05.U0, 2500.0)
base = profit(p05.ALL, p05.SKUS, p05.LAM, p05.U0, 2500.0)
print(" base world: greedy keeps {} ({:+.1%})".format(
" ".join(act), best / base - 1))
rng = random.Random(83)
stats = {"naive": [], "incr": [], "opt": []}
counts, etas = {}, []
for _ in range(400):
sk = tuple((n, g, p, m * rng.uniform(0.7, 1.3),
q + rng.uniform(-0.4, 0.4))
for n, g, p, m, q in p05.SKUS)
lam = {"A": rng.uniform(0.4, 0.9), "B": rng.uniform(0.6, 1.0)}
u0, fx = rng.uniform(1, 3), rng.uniform(1000, 4000)
eta = rng.uniform(0, 0.3)
b = profit([x[0] for x in sk], sk, lam, u0, fx, eta)
a, o = greedy(sk, lam, u0, fx, eta)
stats["opt"].append(o / b - 1)
stats["naive"].append(rule(sk, lam, u0, fx, eta, False) / b - 1)
stats["incr"].append(rule(sk, lam, u0, fx, eta, True) / b - 1)
etas.append((eta, stats["naive"][-1]))
k = 10 - len(a)
counts[k] = counts.get(k, 0) + 1
for key, label in (("naive", "cut 3 lowest naive"),
("incr", "cut 3 lowest incremental"),
("opt", "greedy optimum")):
v = stats[key]
print(" {:<25} mean {:+.1%} profit falls in {:3d}/400".format(
label, sum(v) / len(v), sum(1 for x in v if x < 0)))
ks = sorted(counts)
print(" SKUs the optimum removes (count: worlds)")
for half in (ks[:5], ks[5:]):
print(" " + ", ".join("{}: {}".format(k, counts[k])
for k in half))
gap = [o - n for o, n in zip(stats["opt"], stats["naive"])]
print(" naive rule leaves on average {:.1%} of profit".format(
sum(gap) / len(gap)))
hi = [g for e, g in etas if e > 0.2]
print(" when eta > 0.2 the naive cut loses in {}/{} worlds".format(
sum(1 for g in hi if g < 0), len(hi)))
# base world: greedy keeps F A1 B1 (+16.7%)
# cut 3 lowest naive mean -0.5% profit falls in 218/400
# cut 3 lowest incremental mean +5.4% profit falls in 74/400
# greedy optimum mean +8.1% profit falls in 0/400
# SKUs the optimum removes (count: worlds)
# 0: 35, 1: 48, 2: 72, 3: 78, 4: 63
# 5: 40, 6: 29, 7: 22, 8: 10, 9: 3
# naive rule leaves on average 8.6% of profit
# when eta > 0.2 the naive cut loses in 144/150 worldsIn the baseline world of Chapter 3 (no visit effect) the greedy procedure keeps only F, A1 and B1, for a profit of +16.7%. This exposes a bias of the nested logit: every product in it is only a substitute and brings no new buyers, so the model always favours a narrow line. With the visit effect added: cutting 30% by naive contribution averages -0.5% in profit and lowers profit in 218 of the 400 worlds; cutting 30% by incremental contribution averages +5.4% and lowers profit in 74; the greedy optimum averages +8.1%. The greedy optimum removes exactly three products in only 78 worlds; in the 150 worlds with a visit effect above 0.2, the naive 30% cut loses money in 144.
Hypothesis · not established
The author’s hypothesis (not yet tested): in multi-SKU online shops, pruning SKUs by incremental contribution (with diversion ratios estimated from delisting experiments) yields higher operating profit six months later than pruning the same number by naive contribution. What would show it wrong: in a trial assigning the pruning rule at random by shop or by region, operating profit under the former is not higher than under the latter.
Summary
The margin dilution matrix shows that sub-line products whose recaptured margin exceeds their own (here A3 and A4) lower total profit with every extra unit sold. “Cut the bottom 30%” is not a law: cutting by naive contribution loses money in most of the random worlds with a visit effect; cutting by incremental contribution does much better; the best number to cut differs from shop to shop, and is seldom exactly 30%.
Fan, Y. (2026). Enterprise Bottleneck Diagnostics, SKU Cannibalization Audits and Automation Return Bounds: Theory-of-Constraints Queueing Networks, Margin Dilution Matrices and Value-Based Advisory Pricing [企业瓶颈诊断、产品线自蚕食审计与自动化改造回报边界] (Version 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.24090217 · Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0).