What does Pruning a Domain Portfolio conclude, in numbers, about “Pruning under a Budget: the Knapsack, the Greedy Ratio and a Ten-Year Back-Test of Policies”?
Answer: Chapter 4 writes pruning as a knapsack and runs a ten-year back-test: prune and wait has a mean present value of 11,121 against 1,344 for keeping everything and building by net present value, though waiting also widens the spread.
Scope of the numbers: Chapter 2 examines the price evidence: in the illustrative model a repeat-sales estimate is biased upwards by 0.1284, and applying the index's growth of 0.0723 a year leads to systematic under-pruning. Marked boxes separate published evidence, runnable Python calculations (20 programs), classical sources and the author's hypotheses.
Data table
The numbers below are printed verbatim by the chapter's Python program and can be reproduced by running it. standard-library Python onlyprinted values that match the answer: 11121, 1344
| A. 42 names, 2,000 paths, ten years, PV at r = 0.08 | |||||
| policy | mean PV | s.e. | 5th pct | fees PV | builds |
| prune+wait | 11,121 | 185 | -37 | 1,675 | 0.89 |
| keep+wait | 4,114 | 188 | -7,327 | 9,494 | 0.91 |
| keep+NPV | 1,344 | 50 | -1,446 | 9,150 | 3.65 |
| prune+NPV | 8,510 | 46 | 5,976 | 1,354 | 3.39 |
| B. prune+wait minus keep+NPV: 9,777 per pool |
Show the full program
# Chapter 4. p42: ten years of four renewal policies on the same paths.
# Model: the 42 names of p13; V follows geometric Brownian motion with
# drift r - y (y = 0.06) and volatility 0.35, one step a year, 2,000
# seeded scenarios, the same draws for every policy. Fees are paid at
# the start of each held year, builds pay V - K, all discounted at r.
# After ten years a still-held name is marked at its model value W(V).
# Policies: prune + wait (drop at L, build at H), keep all + wait,
# keep all + build at V >= K (NPV rule), prune + NPV rule.
import math
import random
def roots(r, d, s):
a = 0.5 - (r - d) / (s * s)
b = math.sqrt(a * a + 2 * r / (s * s))
return a + b, a - b
def solve(c, k, r=0.08, d=0.06, s=0.35):
b1, b2 = roots(r, d, s)
x = -b2 * (c / r) / (b1 - b2)
y = b1 * (c / r) / (b1 - b2)
def rhs(z):
return (b1 - 1) * x * z ** b1 + (b2 - 1) * y * z ** b2 + c / r
lo, hi = 1.0, 64.0
for _ in range(200):
mid = (lo + hi) / 2
lo, hi = (mid, hi) if rhs(mid) < k else (lo, mid)
z = (lo + hi) / 2
low = (b1 * x * z ** b1 + b2 * y * z ** b2) / z
return low, z * low, x, y, b1, b2, c / r
def w_of(v, k, sol):
low, high, x, y, b1, b2, pv = sol
if v <= low:
return 0.0
if v >= high:
return v - k
return x * (v / low) ** b1 + y * (v / low) ** b2 - pv
CATS = [("geo-svc", 10, 1500), ("geo", 8, 900), ("brand", 12, 250),
("generic", 12, 500)]
FEES = (12, 15, 35, 60)
def make_pool():
rng = random.Random(20261120)
pool = []
for cat, n, vmed in CATS:
for _ in range(n):
v = vmed * math.exp(rng.gauss(0, 1.1))
rng.gauss(0, 0.6)
c = FEES[rng.randrange(4)]
k = rng.choice((4000, 6000, 8000))
pool.append((v, c, k))
return pool
def run(paths=2000, years=10, r=0.08, y=0.06, s=0.35):
pool = make_pool()
sols = [solve(c, k) for _, c, k in pool]
rng = random.Random(20261121)
pols = ("prune+wait", "keep+wait", "keep+NPV", "prune+NPV")
res = {p: ([], [], []) for p in pols}
drift = r - y - s * s / 2
for _ in range(paths):
zs = [[rng.gauss(0, 1) for _ in range(years)] for _ in pool]
for p in pols:
pv, fees, builds = [], [], 0
for (v0, c, k), sol, z in zip(pool, sols, zs):
v, low, high = v0, sol[0], sol[1]
trig = high if p.endswith("wait") else k
for t in range(years + 1):
disc = math.exp(-r * t)
if t == years:
pv.append(disc * w_of(v, k, sol))
break
if v >= trig:
pv.append(disc * (v - k))
builds += 1
break
if p.startswith("prune") and v <= low:
break
fees.append(disc * c)
pv.append(-disc * c)
v *= math.exp(drift + s * z[t])
res[p][0].append(math.fsum(pv))
res[p][1].append(math.fsum(fees))
res[p][2].append(builds)
return pols, res
if __name__ == "__main__":
pols, res = run()
print("A. 42 names, 2,000 paths, ten years, PV at r = 0.08")
print(" policy mean PV s.e. 5th pct fees PV builds")
for p in pols:
pv, fees, b = res[p]
n = len(pv)
m = math.fsum(pv) / n
sd = math.sqrt(math.fsum((x - m) ** 2 for x in pv) / (n - 1))
p5 = sorted(pv)[n // 20]
print(" {:<11} {:>8,.0f} {:>5.0f} {:>8,.0f} {:>7,.0f} {:.2f}"
.format(p, m, sd / math.sqrt(n), p5,
math.fsum(fees) / n, math.fsum(b) / n))
base = math.fsum(res["keep+NPV"][0]) / len(res["keep+NPV"][0])
best = math.fsum(res["prune+wait"][0]) / len(res["prune+wait"][0])
print("B. prune+wait minus keep+NPV: {:,.0f} per pool".format(
best - base))Single source and citation
Fan, Y. (2026). Real-Options Valuation of Geo-Exact Domain Portfolios, Optimal Renewal Pruning and the Moats of Organic Search (Version 1.0.0), Chapter 4: Pruning under a Budget: the Knapsack, the Greedy Ratio and a Ten-Year Back-Test of Policies. 5D Library. DOI pending
DOI pending · monograph page goes live after publication · 5DL-B-341 · v1.0.0 · CC-BY-NC-ND-4.0
BibTeX
@book{fan2026341,
author = {Fan, Yafu},
title = {Real-Options Valuation of Geo-Exact Domain Portfolios, Optimal Renewal Pruning and the Moats of Organic Search},
year = {2026},
publisher = {5D Library},
edition = {1.0.0},
note = {DOI pending}
}Other chapter answers in this book
- Chapter 1 · Carrying Cost and the Development Option: the Value of Waiting, Renewal Fees and Two Boundaries
- Chapter 2 · The Price Evidence: Repeat-Sales Indices, Survivorship Bias and the Cost of Holding
- Chapter 3 · A Finite-Horizon Lattice: Renewing, Lapsing and Building Year by Year
- Chapter 5 · Rank, Clicks and Direct Navigation: Where the Moat of a Geo-Exact Name Comes From
- Chapter 6 · Generative Search and Entity Consistency: Only Structured Data that Visitors Can See
- Chapter 7 · Classics East and West: Bai Gui's "Take What Others Discard" and Henry George on Land Speculation
- Chapter 8 · The Annual Renewal Audit and a Plan for Refutation