5D Library › Subscription Unit Economics, Net Revenue Retention and AI Inference Scaling Laws · 中文

Chapter 6. Network Effects: n², n log n, and the Point Where More Users Hurt

Two laws

Metcalfe’s law says a network’s value grows as the square of its users, because the number of possible connections does; Metcalfe himself revisited it after forty years of Ethernet (Metcalfe 2013). Briscoe, Odlyzko and Tilly argued that it overstates value badly: not all connections are equally valuable, and if a user’s kk-th most valuable contact is worth about 1/k1/k of her most valuable one (a Zipf law), each user’s value grows only as ln⁡n\ln n and the network’s as nln⁡nn \ln n (Odlyzko and Tilly 2005; Briscoe et al. 2006).

Calculation

# Chapter 6. How network value grows with the number of users n.
#   Metcalfe:        every pair of users is worth the same -> V ~ n (n - 1) /
#   2 ~ n^2 Odlyzko-Tilly:   a user values her k-th most valuable contact at
#   1/k (Zipf), so each
#                    user is worth H(n-1) = 1 + 1/2 + ... + 1/(n-1) ~ ln n ->
#                    V ~ n ln n
# A. Ratio of value when the network grows tenfold.
# B. Two networks of sizes n1 > n2 interconnect. Under each law, how much does
#    each side's value rise? (Briscoe, Odlyzko and Tilly's argument about why
#    the larger network is reluctant.)
import math

def H(m):
    if m < 1:
        return 0.0
    if m < 1000:
        return sum(1.0 / k for k in range(1, m + 1))
    return math.log(m) + 0.5772156649 + 1 / (2 * m)

def v_metcalfe(n):
    return n * (n - 1) / 2

def v_zipf(n):
    return n * H(n - 1)

if __name__ == "__main__":
    print("A. Value multiple when the network grows tenfold")
    print("   from n        Metcalfe   Zipf (n ln n)")
    for n in (100, 10000, 1000000):
        print(
            "   {:>9,}    x {:6.1f}    x {:5.2f}".format(
                n,
                v_metcalfe(10 * n) / v_metcalfe(n),
                v_zipf(10 * n) / v_zipf(n),
            )
        )
    print(
        "\nB. Interconnecting networks of 1,000,000 and 100,000 users: gain"
        " in value"
    )
    print("   law          larger network's   smaller network's   ratio")
    print(
        "                gain               gain                small/large"
    )
    n1, n2 = 1000000, 100000
    # each side's users gain n_other pairs / 2
    g1m = n1 * n2 / 2.0
    g2m = n1 * n2 / 2.0
    g1z = n1 * (H(n1 + n2 - 1) - H(n1 - 1))
    g2z = n2 * (H(n1 + n2 - 1) - H(n2 - 1))
    print(
        "   Metcalfe     {:14,.0f}     {:14,.0f}      {:6.2f}".format(
            g1m, g2m, g2m / g1m
        )
    )
    print(
        "   Zipf         {:14,.0f}     {:14,.0f}      {:6.2f}".format(
            g1z, g2z, g2z / g1z
        )
    )
    print("\nReading: under Metcalfe, tenfold users means"
          " a hundredfold value and both")
    print("sides gain equally from joining. Under the"
          " Zipf law, tenfold users means a")
    print("little over tenfold value, and the smaller"
          " network gains about two and a")
    print("half times as much as the larger one -"
          " consistent with large networks'")
    print("reluctance to interconnect on equal terms.")
# A. Value multiple when the network grows tenfold
#    from n        Metcalfe   Zipf (n ln n)
#          100    x  100.9    x 14.46
#       10,000    x  100.0    x 12.35
#    1,000,000    x  100.0    x 11.60
#
# B. Interconnecting networks of 1,000,000 and 100,000 users: gain in value
#    law          larger network's   smaller network's   ratio
#                 gain               gain                small/large
#    Metcalfe     50,000,000,000     50,000,000,000        1.00
#    Zipf                 95,310            239,790        2.52
#
# Reading: under Metcalfe, tenfold users means a hundredfold value and both
# sides gain equally from joining. Under the Zipf law, tenfold users means a
# little over tenfold value, and the smaller network gains about two and a
# half times as much as the larger one - consistent with large networks'
# reluctance to interconnect on equal terms.

Section A shows how differently the laws scale. Growing a network tenfold multiplies its value by 100.0 under Metcalfe and by 11.60 to 14.46 under the Zipf law. Business plans that cite “network effects” usually mean the first and live in the second.

Section B is Odlyzko and Tilly’s sharpest point. Interconnecting a network of 1,000,000 users with one of 100,000 benefits both sides equally under Metcalfe. Under the Zipf law the smaller network gains 239,790 and the larger 95,310 — the smaller gains 2.52 times as much. That asymmetry fits what large networks do: they resist interconnecting on equal terms, or demand payment for it.

When more users make it worse

Neither law has a downside. Real networks do: more users bring more noise, spam, congestion and unwanted contact, and each user’s exposure grows with the number of others who can reach her. The thirteenth program adds the simplest such cost, cnc\,n per user, to the Zipf benefit.

Calculation

Value with congestion. V(n)=n(bln⁡n−cn)V(n) = n\,(b \ln n – c\,n), maximised where b(ln⁡n+1)=2cnb(\ln n + 1) = 2\,c\,n. Past that size, each additional user lowers total value.

Calculation

# Chapter 6. When more users make a network worse. Each user gets benefit b ln
# n from the network (the Zipf law of p12) and bears a cost c n from
# congestion, noise and spam that grows with the number of other users who can
# reach her. Total value
#     V(n) = n (b ln n - c n),     maximised where b (ln n + 1) = 2 c n.
# b = 1; c is the cost per reachable user. Moderation, filtering and ranking
# lower c.
import math

def V(n, c, b=1.0):
    return n * (b * math.log(n) - c * n)

def n_star(c, b=1.0):
    lo, hi = 2.0, 1e12
    for _ in range(200):
        mid = math.sqrt(lo * hi)
        if b * (math.log(mid) + 1) > 2 * c * mid:
            lo = mid
        else:
            hi = mid
    return lo

if __name__ == "__main__":
    print(
        "   cost per reachable   value-maximising   peak value      value at"
    )
    print("   user c               n                                  3 x n*")
    for c in (1e-4, 1e-5, 1e-6, 1e-7):
        ns = n_star(c)
        print(
            "   {:>10.0e}       {:>14,.0f}   {:>14,.0f}   {:>14,.0f}".format(
                c, ns, V(ns, c), V(3 * ns, c)
            )
        )
    print("\nReading: with any congestion cost that grows"
          " with reach, value peaks and")
    print("then falls; past the peak, adding users"
          " destroys value. Cutting the cost")
    print("per reachable user tenfold raises the peak"
          " size by more than tenfold,")
    print("which is why filtering and ranking are part"
          " of the network effect, not an")
    print("extra.")
#    cost per reachable   value-maximising   peak value      value at
#    user c               n                                  3 x n*
#         1e-04               60,011          300,126       -1,062,659
#         1e-05              724,674        4,526,848      -15,540,180
#         1e-06            8,476,398       63,372,926     -213,040,342
#         1e-07           96,948,450      842,951,741   -2,791,019,647
#
# Reading: with any congestion cost that grows with reach, value peaks and
# then falls; past the peak, adding users destroys value. Cutting the cost
# per reachable user tenfold raises the peak size by more than tenfold,
# which is why filtering and ranking are part of the network effect, not an
# extra.

With a cost per reachable user of 10−510^{-5}, value peaks at 724,674 users; at three times that size it is negative. Cutting the cost tenfold, to 10−610^{-6}, moves the peak to 8,476,398 — more than tenfold, because the benefit grows logarithmically. Filtering, ranking and moderation are therefore not overheads on a network effect: they are what determines how large the network can usefully become.

Left: network value under Metcalfe’s n^2 and the Zipf law’s n \ln n. Right: value with a congestion cost per reachable user of 10^{-5} and 10^{-6}: value peaks and then falls.

How the data “confirm” Metcalfe

Several studies have fitted revenue or market value against users and found an exponent near 2; one fitted Tencent and Facebook data and reported that they validated Metcalfe’s law (Zhang et al. 2015). The fourteenth program shows how that can happen when the law is false. The true value follows nln⁡nn \ln n, but the company’s monetisation per unit of value grows over time — as it adds advertising, pricing and products — while users also grow.

Calculation

# Chapter 6. How growth data can "confirm" Metcalfe's law when it is false. A
# company grows from 100,000 to 3,000,000 users over 8 years (logistic
# adoption, 32 quarters). Its TRUE network value per user follows the Zipf law
# of p12 (V ~ n ln n), but the revenue it earns per unit of value - its
# monetisation - rises g a year as it adds advertising, pricing and products.
# Quarterly revenue = monetisation x n ln n x noise (lognormal, sd 0.10). An
# analyst regresses log revenue on log users:
#     log Rev = a + beta log n.
# Metcalfe predicts beta = 2; n ln n predicts beta a little above 1.
import math
import random

def ols(x, y):
    n = len(x)
    mx, my = sum(x) / n, sum(y) / n
    b = sum((a - mx) * (c - my) for a, c in zip(x, y)) / sum(
        (a - mx) ** 2 for a in x
    )
    return b

if __name__ == "__main__":
    rng = random.Random(58014)
    print("   monetisation    fitted beta (mean    share with")
    print("   growth / year   of 500 histories)    beta > 1.8")
    for g in (0.0, 0.25, 0.50, 0.75):
        bs = []
        for _ in range(500):
            xs, ys = [], []
            for q in range(32):
                t = q / 4
                n = 100000 + 2900000 / (1 + math.exp(-(t - 4) * 1.1))
                rev = (
                    (1 + g) ** t
                    * n
                    * math.log(n)
                    * math.exp(rng.gauss(0, 0.10))
                )
                xs.append(math.log(n))
                ys.append(math.log(rev))
            bs.append(ols(xs, ys))
        print("   {:>13.0%}   {:12.2f}         {:10.3f}".format(
            g, sum(bs) / len(bs), sum(b > 1.8 for b in bs) / len(bs)))
    print("\nReading: with flat monetisation the regression"
          " recovers the true law (beta")
    print("near 1.1). Let monetisation grow while users"
          " grow and the slope absorbs")
    print("it: revenue-versus-users plots then look like"
          " Metcalfe's law although the")
    print("network itself follows n ln n. Users and time are confounded.")
#    monetisation    fitted beta (mean    share with
#    growth / year   of 500 histories)    beta > 1.8
#               0%           1.08              0.000
#              25%           1.53              0.000
#              50%           1.91              1.000
#              75%           2.23              1.000
#
# Reading: with flat monetisation the regression recovers the true law (beta
# near 1.1). Let monetisation grow while users grow and the slope absorbs
# it: revenue-versus-users plots then look like Metcalfe's law although the
# network itself follows n ln n. Users and time are confounded.

With flat monetisation, regressing log revenue on log users recovers the true law: an exponent of 1.08. With monetisation growing 50 % a year, the exponent is 1.91, and above 1.8 in every simulated history; at 75 %, 2.23. Users and time are confounded: anything that grows with time loads onto the users coefficient. A fit of revenue against users cannot distinguish Metcalfe’s law from nln⁡nn \ln n plus growing monetisation, unless monetisation is measured and controlled.

Note

What this does not say. It does not show that the cited fits are wrong, only that they cannot by themselves distinguish the laws. A test needs variation in users that is not also variation in time — for instance across markets of different size at the same moment.

Summary

Under Metcalfe’s law, tenfold users means a hundredfold value; under the Zipf (Odlyzko-Tilly) law, a little over tenfold, and smaller networks gain more from interconnecting than larger ones. With a congestion cost that grows with reach, value peaks and then falls, and lowering that cost moves the peak more than proportionally. Revenue-versus-users fits that appear to confirm Metcalfe can arise from nln⁡nn \ln n value and growing monetisation, because users and time move together.

References

Briscoe, Bob, Andrew Odlyzko, and Benjamin Tilly. 2006. “Metcalfe’s Law Is Wrong.” IEEE Spectrum 43 (7): 34–39.
Metcalfe, Bob. 2013. “Metcalfe’s Law after 40 Years of Ethernet.” Computer 46 (12): 26–31.
Odlyzko, Andrew, and Benjamin Tilly. 2005. A Refutation of Metcalfe’s Law and a Better Estimate for the Value of Networks and Network Interconnections. Working paper. Digital Technology Center, University of Minnesota.
Zhang, Xing-Zhou, Jing-Jie Liu, and Zhi-Wei Xu. 2015. “Tencent and Facebook Data Validate Metcalfe’s Law.” Journal of Computer Science and Technology 30 (2): 246–51.

Fan, Y. (2026). Subscription Unit Economics, Net Revenue Retention and AI Inference Scaling Laws: Cohort Survival Mixtures, Negative-Churn Differential Equations, Token Compute Margins and Metcalfe Congestion Limits [订阅制单位经济学、净收入留存与人工智能推理标度律] (Version 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.24090164 · Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0).