5D Library › Unbundling Economics, Anti-Arbitrage Identity Locking and Multi-Tier Licensing Ladders · 中文

Chapter 2. How a Cheap All-Access Pass Cannibalizes, and Heavy Tails

Where the pass price comes from

Chapter 1 compared optimally priced bundles. A real “all-access pass” is seldom priced that way; it is often set at “a little more than one module” so that it looks like a bargain. Chapter 1’s program already shows the cost of such a pass: under indep, a pass priced at 1.5 times the mean single price cuts revenue to about three quarters of separate selling, and the same happens under segm. Only under pareto does such a pass earn more than separate selling (38.58 against 31.05 per buyer, p02), because there the goods should be bundled anyway. This chapter sweeps the pass price from low to high to see where the loss comes from.

Cannibalization: high-value buyers come back down

Keep the segm structure: 92% consumers, 8% studios. The four single prices stay at their optimum, and a pass is added at ff times the sum of the single prices; each buyer takes whichever gives her more surplus, single modules or the pass.

Calculation

# Chapter 2. [p03] How a cheap all-access pass cannibalizes high-value
# buyers. Regime segm of p02 (92% consumers, 8% studios that value the
# business-script module B at 1,000..5,000). Separate prices are held
# at their optimum; a pass is added at a fraction f of the sum of the
# separate prices. For each f we report revenue per buyer relative to
# separate pricing, the share of studios that switch to the pass, and
# the revenue those studios used to pay that is now lost.
import math
import random

N, MODS = 8000, 4

def draw(rng):
    v = [rng.uniform(0, 100) for _ in range(3)]
    if rng.random() < 0.08:
        return v + [rng.uniform(1000, 5000)], True
    return v + [rng.uniform(0, 10)], False

def best_price(values):
    s = sorted(values)
    n = len(s)
    top = n - n // 100
    return max((s[i] * (n - i), s[i]) for i in range(top))[1]

def outcome(v, prices, pp):
    sep_s = math.fsum(max(0.0, x - p) for x, p in zip(v, prices))
    sep_r = math.fsum(p for x, p in zip(v, prices) if x >= p)
    t = math.fsum(v)
    # an indifferent buyer takes the pass; the 1e-9 keeps that tie a tie
    if t >= pp and t - pp >= sep_s - 1e-9:
        return pp, sep_r, True
    return sep_r, sep_r, False

if __name__ == "__main__":
    rng = random.Random(70)
    pop = [draw(rng) for _ in range(N)]
    prices = [best_price([v[j] for v, s in pop]) for j in range(MODS)]
    total = math.fsum(prices)
    base = math.fsum(outcome(v, prices, 1e18)[0] for v, s in pop) / N
    studios = sum(1 for v, s in pop if s)
    print("   separate prices sum to {:.1f}; revenue {:.2f} per buyer".format(
        total, base))
    print("     f   pass price  revenue/SEP  studios on pass  lost/buyer")
    for f in (0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.8, 0.9, 1.0):
        pp = f * total
        rev, lost, sw = 0.0, 0.0, 0
        for v, s in pop:
            r, old, took = outcome(v, prices, pp)
            rev += r
            if s and took:
                sw += 1
                lost += old - r
        print("   {:4.2f} {:11.1f} {:12.3f} {:16.3f} {:11.2f}".format(
            f, pp, rev / N / base, sw / studios, lost / N))
    print("\nReading: any pass priced below the studio price of B moves")
    print("studios onto it; the loss is their consumer surplus handed")
    print("back, and it is not made up by the consumers the pass adds.")
#    separate prices sum to 2709.1; revenue 206.54 per buyer
#      f   pass price  revenue/SEP  studios on pass  lost/buyer
#    0.05       135.5        0.413            1.000      126.88
#    0.10       270.9        0.439            1.000      115.79
#    0.20       541.8        0.547            1.000       93.61
#    0.30       812.7        0.654            1.000       71.43
#    0.40      1083.6        0.761            0.998       49.39
#    0.50      1354.5        0.836            0.936       33.87
#    0.60      1625.5        0.893            0.866       22.00
#    0.80      2167.3        0.979            0.745        4.27
#    0.90      2438.2        0.992            0.673        1.65
#    1.00      2709.1        1.000            0.078        0.00
#
# Reading: any pass priced below the studio price of B moves
# studios onto it; the loss is their consumer surplus handed
# back, and it is not made up by the consumers the pass adds.
Pass price (as a multiple of the sum of single prices) and revenue (separate selling = 1).

The single prices sum to 2709.1. As soon as the pass is cheaper than what a studio pays for B alone, every studio switches to it: for ff up to 0.30 the share switching is 1.000. At a tenth of the sum, revenue is only 0.439 of separate selling, a loss of 115.79 per buyer; at half the sum it is 0.836. The consumers the pass attracts come nowhere near making up the surplus the studios take back. The loss goes to zero only when the pass price approaches the sum of single prices, and by then the pass is no longer “cheap”.

Calculation

A bound on cannibalization. Let a high-value segment have share ss and pay single price pHp_H, and let the pass cost PP. If P<pHP < p_H the whole segment switches, and this item alone costs s(pH−P)s (p_H – P) per buyer whatever new buyers come in. In segm, ss is 8% and pHp_H about the single price of B, so every dollar off the pass costs about 0.08 per buyer: a hole the pass has to fill with new sales.

Heavy tails weaken the bundle but do not reverse it

The outline’s other claim is that bundling loses to separate selling when values follow a heavy-tailed Pareto law. Ibragimov and Walden showed that with very heavy tails (no finite mean) bundling can indeed lose (Ibragimov and Walden 2010). The program turns the Lomax tail index aa of the four modules from 5 down to 0.7, caps each module at a budget of 2,000, and keeps the rule that a price must sell to at least 1% of buyers.

Calculation

# Chapter 2. [p04] Heavy tails: when does the optimal bundle stop
# beating separate prices? Four modules with iid Lomax values (scale
# 20, tail index a), each capped at a budget of 2,000. A price must
# sell to at least 1% of buyers (as in p02). 8,000 buyers per a,
# seed 72. We also give the closed-form optimum of one uncapped
# module, p* = 20/(a - 1), which exists only for a > 1.
import random

N, MODS, CAP = 8000, 4, 2000.0

def best(values):
    s = sorted(values)
    n = len(s)
    top = n - n // 100
    return max((s[i] * (n - i), s[i]) for i in range(top))

if __name__ == "__main__":
    print("     a   SEP/buyer  BUN/buyer  SEP/BUN  closed-form p*")
    for a in (0.7, 0.9, 1.1, 1.5, 2.0, 3.0, 5.0):
        rng = random.Random(72)
        pop = [[min(CAP, 20 * ((1 - rng.random()) ** (-1 / a) - 1))
                for _ in range(MODS)] for _ in range(N)]
        sep = sum(best([v[j] for v in pop])[0] for j in range(MODS)) / N
        bun = best([sum(v) for v in pop])[0] / N
        star = "{:.1f}".format(20 / (a - 1)) if a > 1 else "none"
        print("   {:3.1f} {:10.2f} {:10.2f} {:8.3f} {:>15s}".format(
            a, sep, bun, sep / bun, star))
    print("\nReading: for a of 1.5 or more the bundle earns about a third")
    print("more than separate prices; as the tail gets heavier the edge")
    print("shrinks, to about 5% at a = 0.7. Heavy tails alone do not make")
    print("unbundling win; they only weaken the bundle.")
#      a   SEP/buyer  BUN/buyer  SEP/BUN  closed-form p*
#    0.7     318.07     334.78    0.950            none
#    0.9     120.89     135.45    0.892            none
#    1.1      59.11      75.66    0.781           200.0
#    1.5      31.49      42.59    0.739            40.0
#    2.0      20.44      27.64    0.739            20.0
#    3.0      12.09      16.29    0.742            10.0
#    5.0       6.66       8.93    0.747             5.0
#
# Reading: for a of 1.5 or more the bundle earns about a third
# more than separate prices; as the tail gets heavier the edge
# shrinks, to about 5% at a = 0.7. Heavy tails alone do not make
# unbundling win; they only weaken the bundle.

For tail indices of 1.5 or more, separate selling earns only 0.739 to 0.747 of the bundle, which makes about a third more; the heavier the tail, the smaller the bundle’s edge: 0.892 at 0.9 and 0.950 at 0.7. With this book’s parameters heavy tails only weaken the bundle; they do not let separate selling overtake it. For that, the separation of orders of magnitude of Chapter 1 is needed. Below a tail index of 1 the closed-form single-module price p*=20/(a−1)p^* = 20/(a-1) does not exist: without a cap the optimal price rises without bound and is set entirely by the richest few buyers. That is why the book constrains prices to sell to at least 1%.

Hypothesis · not established

The author’s interpretation (not yet tested): individual users’ values for a single module are roughly light-tailed, studios’ values for the business module heavy-tailed. What would show this wrong: if tail-index estimates from real willingness-to-pay data (for example a maximum-likelihood fit to the upper tail) fall below 1 for individual users too, then the consumer modules’ prices are also driven by a few large buyers and the menu of Chapter 5 must be replaced by robust pricing.

Summary

The loss from a cheap all-access pass comes from high-value buyers coming back down: once the pass is cheaper than what studios pay for the business module, they all switch; at a tenth of the sum of single prices, revenue falls to 0.439. Heavy tails shrink the bundle’s edge from about a third to about 5%, but with this book’s parameters do not let separate selling overtake it.

References

Ibragimov, Rustam, and Johan Walden. 2010. “Optimal Bundling Strategies under Heavy-Tailed Valuations.” Management Science 56 (11): 1963–76.

Fan, Y. (2026). Unbundling Economics, Anti-Arbitrage Identity Locking and Multi-Tier Licensing Ladders: Orthogonal Demand Partitioning, Resale Cannibalization Bounds, Affiliate Margin Preservation and Five-Figure B2B Upsell Equilibria [分拆经济学、防套利身份锁定与多阶授权阶梯] (Version 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.24090184 · Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0).