5D Library › Enterprise Bottleneck Diagnostics, SKU Cannibalization Audits and Automation Return Bounds · 中文

Chapter 3. Self-Cannibalization in a Product Line: Nested Logit and Diversion Ratios

A demand model for ten SKUs

A shop sells ten SKUs: a flagship F, four close sub-line variants A1 to A4 (cheaper, with lower margins), and five budget items B1 to B5. Buyers can also buy elsewhere or not at all: the “outside option”. A nested logit model puts similar products in the same nest (McFadden 1978; Berry 1994): products in a nest substitute more strongly for one another, and the smaller the nest parameter λg\lambda_g, the stronger the substitution within the nest. The share of product jj is

sj=eδj/λgDg⋅Dgλgeu0+∑hDhλh,Dg=∑k∈geδk/λg,s_j = \frac{e^{\delta_j/\lambda_g}}{D_g}\cdot\frac{D_g^{\lambda_g}}{e^{u_0} + \sum_h D_h^{\lambda_h}},\qquad D_g = \sum_{k \in g} e^{\delta_k/\lambda_g},

where δj\delta_j is quality minus price times price sensitivity and u0u_0 is the utility of the outside option.

The most direct measure of cannibalization is the diversion ratio: when product jj is delisted, the share of its buyers who switch to product kk (Farrell and Shapiro 2010).

Calculation

# Chapter 3. p05: Nested logit demand for ten SKUs and diversion ratios.
# Nest A holds the flagship and four sub-line variants (close substitutes,
# lambda 0.6); nest B holds five budget items (lambda 0.85). Utility is
# q_j - 0.02 * price; the outside option (rival shops, or buying nothing)
# has utility u0 = 2.0.
# Diversion j -> k when j is delisted: (s_k without j - s_k) / s_j.
from math import exp

SKUS = (  # name, nest, price RM, unit margin RM, quality
    ("F", "A", 299, 120, 6.9), ("A1", "A", 259, 90, 5.7),
    ("A2", "A", 229, 60, 5.25), ("A3", "A", 199, 40, 4.5),
    ("A4", "A", 189, 32, 4.2), ("B1", "B", 129, 40, 2.2),
    ("B2", "B", 119, 34, 1.9), ("B3", "B", 109, 28, 1.6),
    ("B4", "B", 99, 22, 1.3), ("B5", "B", 89, 16, 0.9))
LAM = {"A": 0.6, "B": 0.85}
U0 = 2.0
SHOPPERS = 10000

def shares(active, lam=LAM, skus=SKUS, u0=U0):
    d = {s[0]: s[4] - 0.02 * s[2] for s in skus if s[0] in active}
    nest = {s[0]: s[1] for s in skus}
    D = {}
    for j, v in d.items():
        D[nest[j]] = D.get(nest[j], 0.0) + exp(v / lam[nest[j]])
    top = exp(u0) + sum(Dg ** lam[g] for g, Dg in D.items())
    out = {}
    for j, v in d.items():
        g = nest[j]
        out[j] = exp(v / lam[g]) / D[g] * D[g] ** lam[g] / top
    out["none"] = exp(u0) / top
    return out

def diversion(j, active, lam=LAM, skus=SKUS, u0=U0):
    s = shares(active, lam, skus, u0)
    s2 = shares([a for a in active if a != j], lam, skus, u0)
    return {k: (s2[k] - s[k]) / s[j] for k in s2}

ALL = [s[0] for s in SKUS]

if __name__ == "__main__":
    s = shares(ALL)
    print("   SKU  share  units/month")
    for name in ALL + ["none"]:
        print("   {:<4} {:.3f}  {:7.0f}".format(name, s[name],
                                              SHOPPERS * s[name]))
    for j in ("A4", "A3", "B5"):
        dv = diversion(j, ALL)
        top = sorted(dv.items(), key=lambda kv: -kv[1])[:3]
        print("   delist {}: diversion ".format(j) + ", ".join(
            "{} {:.3f}".format(k, v) for k, v in top))
#    SKU  share  units/month
#    F    0.109     1094
#    A1   0.056      562
#    A2   0.072      721
#    A3   0.056      562
#    A4   0.048      475
#    B1   0.038      383
#    B2   0.034      340
#    B3   0.030      302
#    B4   0.027      269
#    B5   0.021      213
#    none 0.508     5079
#    delist A4: diversion none 0.323, F 0.216, A2 0.143
#    delist A3: diversion none 0.327, F 0.221, A2 0.146
#    delist B5: diversion none 0.445, F 0.096, B1 0.076

With illustrative parameters, out of 10,000 shoppers a month the flagship’s share is 0.109 (1,094 units) and the outside option’s 0.508. Delist the sub-line A4 and 0.323 of its buyers go elsewhere or buy nothing, 0.216 switch to the flagship and 0.143 to A2. Delist A3 and 0.221 switch to the flagship. Delist the budget item B5 and 0.445 go to the outside option, only 0.096 to the flagship and 0.076 to B1.

Cutting the bottom 30%

The rule of thumb says: rank SKUs by contribution, delist the bottom 30%, and profit often rises rather than falls. Each listed SKU costs RM 2,500 a month to maintain (inventory, listings, photography and support). Ranked by units times unit margin minus that cost, the bottom three are B5, B4 and B3.

Calculation

# Chapter 3. p06: Pareto pruning - delist the 30% of SKUs (3 of 10) with
# the lowest contribution (units x margin - listing cost) and recompute
# profit with the demand of p05. Each listed SKU costs RM 2,500 a month
# (inventory, listings, photos, support). The gain is split into its
# parts; then the flagship is capped at its current output (no spare
# capacity), so demand diverted to it beyond the cap is lost.
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")
FIXED = 2500.0
MARGIN = {s[0]: s[3] for s in p05.SKUS}
PRICE = {s[0]: s[2] for s in p05.SKUS}
N = p05.SHOPPERS

def units(active, cap_f=None):
    s = p05.shares(active)
    u = {j: N * s[j] for j in active}
    if cap_f is not None and "F" in u:
        u["F"] = min(u["F"], cap_f)
    return u

def profit(active, cap_f=None):
    u = units(active, cap_f)
    return sum(u[j] * MARGIN[j] for j in u) - FIXED * len(active)

def tail(active, k):
    u = units(active)
    return sorted(active, key=lambda j: u[j] * MARGIN[j] - FIXED)[:k]

if __name__ == "__main__":
    allv = list(p05.ALL)
    cut = tail(allv, 3)
    kept = [j for j in allv if j not in cut]
    u0, u1 = units(allv), units(kept)
    p0, p1 = profit(allv), profit(kept)
    print("   delist {} (lowest contribution)".format(", ".join(cut)))
    print("   units {:,.0f} -> {:,.0f}; revenue RM {:,.0f} -> {:,.0f}".format(
        sum(u0.values()), sum(u1.values()),
        sum(u0[j] * PRICE[j] for j in u0),
        sum(u1[j] * PRICE[j] for j in u1)))
    print("   profit RM {:,.0f} -> {:,.0f} ({:+.1%})".format(
        p0, p1, p1 / p0 - 1))
    lost = sum(u0[j] * MARGIN[j] for j in cut)
    to_f = (u1["F"] - u0["F"]) * MARGIN["F"]
    other = sum((u1[j] - u0[j]) * MARGIN[j] for j in kept if j != "F")
    print("   parts: listing costs saved RM {:,.0f}".format(3 * FIXED))
    print("          margin lost on delisted SKUs RM {:,.0f}".format(-lost))
    print("          recaptured by the flagship RM {:,.0f}".format(to_f))
    print("          recaptured by other SKUs RM {:,.0f}".format(other))
    cap = u0["F"]
    q0, q1 = profit(allv, cap), profit(kept, cap)
    print("   flagship capped at {:,.0f} units: RM {:,.0f} -> {:,.0f}"
          " ({:+.1%})".format(cap, q0, q1, q1 / q0 - 1))
#    delist B5, B4, B3 (lowest contribution)
#    units 4,921 -> 4,539; revenue RM 1,007,776 -> 1,010,436
#    profit RM 282,460 -> 297,334 (+5.3%)
#    parts: listing costs saved RM 7,500
#           margin lost on delisted SKUs RM -17,786
#           recaptured by the flagship RM 9,877
#           recaptured by other SKUs RM 15,282
#    flagship capped at 1,094 units: RM 282,460 -> 287,456 (+1.8%)

Delisting these three, units fall from 4,921 to 4,539, revenue rises from RM 1,007,776 to RM 1,010,436, and profit rises from RM 282,460 to RM 297,334 (+5.3%). Taken apart: RM 7,500 of maintenance saved; RM 17,786 of margin lost on the three; RM 9,877 recaptured by the flagship; RM 15,282 recaptured by the other listed products. The rise in profit comes mainly from diversion: some buyers switch to products with higher margins.

Note

Diverted demand needs somewhere to land. If the flagship is already at full capacity and cannot take the extra demand, the gain from delisting is much smaller: with the flagship’s supply capped at today’s 1,094 units, the same delisting raises profit only from RM 282,460 to RM 287,456 (+1.8%). It is the same question as in Chapter 1: diverted demand has to pass through the bottleneck.

Summary

In the illustrative nested logit model, delisting the lowest-contributing 30% of SKUs raises profit by 5.3%, because some buyers switch to products with higher margins and the maintenance cost is saved. The conclusion depends on the diversion ratios and on the capacity of the products receiving the demand; the next chapter checks whether it holds in other settings.

References

Berry, Steven T. 1994. “Estimating Discrete-Choice Models of Product Differentiation.” The RAND Journal of Economics 25 (2): 242–62.
Farrell, Joseph, and Carl Shapiro. 2010. “Antitrust Evaluation of Horizontal Mergers: An Economic Alternative to Market Definition.” The B.E. Journal of Theoretical Economics 10 (1).
McFadden, Daniel. 1978. “Modelling the Choice of Residential Location.” In Spatial Interaction Theory and Planning Models, edited by Anders Karlqvist, Lars Lundqvist, Folke Snickars, and Jörgen W. Weibull. North-Holland.

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).