这是第五个实验。第 20 讲末尾，我们留了一个承诺：用大量买家和卖家的模拟，看"好车一轮一轮退出"到底是怎么发生的。那一讲用公式和一个连续的质量分布，算出了价格螺旋，和"买家的估值要是卖家的两倍，市场才撑得住"的门槛。这个实验，把那些公式放进 1000 个具体的卖家里去走一遍，再往前走几步：
- 好车多一点，门槛会降多少？
- 一个正常的市场，被突然压低一点价格，会怎样？塌了以后，还救得回来吗？
- 对付逆向选择，有两个很不一样的办法：让卖家花钱认证，或者规定最低质量。哪个更好？
怎么用：和前面的实验一样，代码块是接着往下写的：后面的块会用到前面块里定义的东西。把它们依次拼成一个文件（比如 lab74.py），用 python lab74.py 运行，不到 2 秒；也可以一段一段地在 Python 里依次运行。只需要 Python 3 和 NumPy。这个实验里没有随机数：1000 辆车的质量，取的是 1000 个等间距的分位数，所以你跑出来的数字，会和下面的输出一模一样。
一、四个问题
先停一下：请先凭直觉，回答下面四个问题，写下来。
问题 1： 1000 个卖家，每人一辆车，质量均匀地从 0 分布到 1。每辆车，买家都比卖家多看重 50%（g = 1.5）。买家看不出每辆车的好坏。一轮一轮地交易下去，市场里最后还剩多少辆车？买家要比卖家多看重多少，市场才不会萎缩？
问题 2： 如果车的质量，不是均匀分布，而是好车更多，这个门槛会降到多少？
问题 3： 一个正常运转的市场，某一轮价格突然被压低了 1%，会怎样？如果市场已经塌了，有人临时把价格托上去，再撤走，能把它救活吗？
问题 4： 有两种办法：（a）让卖家花钱请人检测，拿到认证；（b）规定质量低于某条线的车，不许卖。哪个能让市场的总好处更大？
我们会一个一个回来。
二、实验的设计
2.1 市场
- 卖家：1000 个，每人一辆车。质量 q 在 0 到 1 之间，卖家对车的估值是 10q（万元），也就是他的最低卖价。
- 买家：对质量 q 的车，估值是 g × 10q（g > 1）。所以，每一笔成交，都对双方有好处：好处是 (g − 1) × 10q。如果所有车都成交，总好处是这个数的总和，我们把它叫做"最大好处"。
- 买家看不出每辆车的 q。 买家之间竞争，所以买家的出价，等于他们愿意付的价：g × 在市场上卖的车的平均估值。
2.2 一轮一轮地走
每一轮：
- 价格是 p 时，估值不超过 p 的卖家，愿意卖；其余的，不卖。
- 买家看到这一轮在卖的车的平均估值，下一轮就按它的 g 倍出价。
这就是第 20 讲 3.2 节的迭代，只是这一次，用 1000 个真实的卖家，而不是一个连续的分布。
三、第一步：价格螺旋，和门槛
import numpy as np
# 一个二手车市场，1000 个卖家，每人一辆车。车的质量 q 在 0 到 1 之间均匀分布（取 1000 个等间距的分位数，这样没有随机数）。
# 卖家对自己的车估值 10q（万元）；买家的估值是 g × 10q（g > 1：每辆车，买家都比卖家更看重）。
# 买家看不出每辆车的 q，只看得到「上一轮在市场上卖的车」的平均质量；买家之间竞争，所以出价 = g × 10 × 那个平均质量。
N = 1000
Q = (np.arange(N) + 0.5) / N # 每个卖家的车的质量
V = 10 * Q # 卖家的估值（卖家的最低价，万元）
def simulate(values, g, rounds=40, p0=10.0, forced=None):
"""values：每个卖家的估值（万元）。每一轮：估值不超过价格的卖家，愿意卖；买家按「在卖的车的平均估值」的 g 倍出价，作为下一轮的价格。
forced：可选，{轮数: 价格}，表示这一轮的价格被外力定死（后面的实验会用）。返回每轮的（价格，在卖的车数，在卖的车的平均估值）"""
p, hist = p0, []
for t in range(rounds + 1):
if forced and t in forced: p = forced[t]
on = values <= p
n = int(on.sum()); avg_v = values[on].mean() if n else 0.0
hist.append((p, n, avg_v))
if n == 0: break # 一辆车也没有：买家没有任何可以参考的东西，市场停摆
p = g * avg_v # 下一轮的价格（买家愿付：在卖的车的平均估值 × g）
return hist
# 核对：g = 1.5，第 20 讲的数字（价格 10 → 7.5 → 5.625 → 4.219 ……）
print("g = 1.5：每一轮的价格、在卖的车数、在卖的车的平均估值（对照第 20 讲的 10 → 7.5 → 5.625 → 4.219 → …）")
h = simulate(V, 1.5, rounds=30)
for t in (0, 1, 2, 3, 5, 10, 15, 20, 30):
p, n, av = h[t]
print(f" 第 {t:>2} 轮：价格 {p:6.3f} 万，在卖 {n:>4} 辆，平均估值 {av:.3f} 万")
print(f"最后一轮：{h[-1][1]} 辆在卖。最差的那辆车，卖家估值只有 {V[0]:.3f} 万，买家愿付它的 1.5 倍，所以它永远能卖掉：市场没有死，只是缩成了最差的几辆车。")
# 核对：门槛 g = 2
print("\n不同的 g：40 轮之后，1000 辆车里还有多少辆在卖？")
for g in (1.2, 1.5, 1.8, 1.9, 1.95, 2.0, 2.2):
h = simulate(V, g, rounds=40)
print(f" g = {g:<4}：{h[-1][1]:>4} 辆，价格 {h[-1][0]:.3f} 万")
# 每辆车成交，都有好处：买家估值 - 卖家估值 = (g - 1) × 10q。算一算
g = 1.5; potential = ((g - 1) * V).sum()
print(f"\ng = {g}：买家看得出好坏时，所有车都成交，总好处 {potential:.0f} 万；看不出时：")
h = simulate(V, g, rounds=30)
for t in (0, 3, 10, 20):
on = V <= h[t][0]; got = ((g - 1) * V[on]).sum()
print(f" 第 {t:>2} 轮：成交的车产生的好处 {got:7.1f} 万（{got / potential:6.1%}）")
输出：
g = 1.5：每一轮的价格、在卖的车数、在卖的车的平均估值（对照第 20 讲的 10 → 7.5 → 5.625 → 4.219 → …）
第 0 轮：价格 10.000 万，在卖 1000 辆，平均估值 5.000 万
第 1 轮：价格 7.500 万，在卖 750 辆，平均估值 3.750 万
第 2 轮：价格 5.625 万，在卖 563 辆，平均估值 2.815 万
第 3 轮：价格 4.223 万，在卖 422 辆，平均估值 2.110 万
第 5 轮：价格 2.370 万，在卖 237 辆，平均估值 1.185 万
第 10 轮：价格 0.570 万，在卖 57 辆，平均估值 0.285 万
第 15 轮：价格 0.135 万，在卖 14 辆，平均估值 0.070 万
第 20 轮：价格 0.038 万，在卖 4 辆，平均估值 0.020 万
第 30 轮：价格 0.015 万，在卖 2 辆，平均估值 0.010 万
最后一轮：2 辆在卖。最差的那辆车，卖家估值只有 0.005 万，买家愿付它的 1.5 倍，所以它永远能卖掉：市场没有死，只是缩成了最差的几辆车。
不同的 g：40 轮之后，1000 辆车里还有多少辆在卖？
g = 1.2 ： 1 辆，价格 0.006 万
g = 1.5 ： 2 辆，价格 0.015 万
g = 1.8 ： 15 辆，价格 0.153 万
g = 1.9 ： 129 辆，价格 1.292 万
g = 1.95： 364 辆，价格 3.637 万
g = 2.0 ：1000 辆，价格 10.000 万
g = 2.2 ：1000 辆，价格 11.000 万
g = 1.5：买家看得出好坏时，所有车都成交，总好处 2500 万；看不出时：
第 0 轮：成交的车产生的好处 2500.0 万（100.0%）
第 3 轮：成交的车产生的好处 445.2 万（ 17.8%）
第 10 轮：成交的车产生的好处 8.1 万（ 0.3%）
第 20 轮：成交的车产生的好处 0.0 万（ 0.0%）
逐段看：
- g = 1.5：价格 10 → 7.5 → 5.625 → 4.223……和第 20 讲的 4.219 差一点点，因为这里是 1000 个整数的卖家，不是连续分布。第 10 轮只剩 57 辆车，第 20 轮 4 辆，第 30 轮 2 辆。
- 市场没有"死"：最差的那辆车，卖家估值只有 0.005 万，买家愿付它的 1.5 倍，所以它永远能卖掉。真实的市场，没有"一辆车都不剩"，而是"缩成了最差的几辆车"。对买家，对好车的卖家，这个市场，都等于不存在。
- 门槛：40 轮之后，g = 1.8 剩 15 辆，g = 1.9 剩 129 辆，g = 1.95 剩 364 辆，g = 2.0 一辆不少。右图的曲线，在 g = 2 处，一下子从"萎缩"变成"撑得住"，和第 20 讲的公式 g ≥ 2 一致。
- 损失有多大：g = 1.5 时，买家看得出好坏，总好处是 2500 万。看不出时，第 3 轮只剩 17.8%，第 10 轮 0.3%，第 20 轮 0。没有人做错任何事。
问题 1 的答案：最后只剩最差的几辆；买家要比卖家多看重一倍（g ≥ 2），市场才不会萎缩。
四、第二步：好车多一点，会好很多
质量不一定是均匀分布。设质量的分布函数是 q 的 k 次方：k = 1 是均匀；k 越大，好车越多。
# 第二步：好车多一点，会不会好一点？质量不一定均匀分布。设质量的分布函数是 F(q) = q^k：k = 1 就是均匀；k 越大，好车越多。
def values_k(k):
return 10 * ((np.arange(N) + 0.5) / N) ** (1 / k)
print("g = 1.4，不同的 k：40 轮后，还有多少辆车在卖（共 1000 辆）？（对照第 20 讲：k = 1、2、3 → 0%、0.4%、100%）")
for k in (1, 2, 3, 5):
h = simulate(values_k(k), 1.4, rounds=40)
print(f" k = {k}：理论门槛 g ≥ {(k + 1) / k:.2f}；40 轮后在卖 {h[-1][1]:>4} 辆，价格 {h[-1][0]:.3f} 万")
# 画一张"相图"：横轴 g，纵轴 k，每个点：300 轮之后，市场里还剩百分之几的车？
gs = np.round(np.arange(1.05, 2.201, 0.05), 2); ks = [1, 1.5, 2, 3, 4, 6, 8]
print("\n300 轮之后，市场里还剩百分之几的车（行：k；列：g）。*：理论上撑得住的（g ≥ (k + 1) / k）")
print(" k \\ g " + " ".join(f"{g:>5.2f}" for g in gs[::2]))
phase = np.zeros((len(ks), len(gs)))
for i, k in enumerate(ks):
vk = values_k(k)
for j, g in enumerate(gs): phase[i, j] = simulate(vk, g, rounds=300)[-1][1] / N
print(f" {k:>4} " + " ".join(f"{100 * phase[i, j]:4.0f}{'*' if g >= (k + 1) / k - 1e-9 else ' '}" for j, g in enumerate(gs) if j % 2 == 0))
输出：
g = 1.4，不同的 k：40 轮后，还有多少辆车在卖（共 1000 辆）？（对照第 20 讲：k = 1、2、3 → 0%、0.4%、100%）
k = 1：理论门槛 g ≥ 2.00；40 轮后在卖 1 辆，价格 0.007 万
k = 2：理论门槛 g ≥ 1.50；40 轮后在卖 4 辆，价格 0.596 万
k = 3：理论门槛 g ≥ 1.33；40 轮后在卖 1000 辆，价格 10.500 万
k = 5：理论门槛 g ≥ 1.20；40 轮后在卖 1000 辆，价格 11.667 万
300 轮之后，市场里还剩百分之几的车（行：k；列：g）。*：理论上撑得住的（g ≥ (k + 1) / k）
k \ g 1.05 1.15 1.25 1.35 1.45 1.55 1.65 1.75 1.85 1.95 2.05 2.15
1 0 0 0 0 0 0 0 0 1 2 100* 100*
1.5 0 0 0 0 0 0 3 100* 100* 100* 100* 100*
2 0 0 0 0 1 100* 100* 100* 100* 100* 100* 100*
3 0 0 0 100* 100* 100* 100* 100* 100* 100* 100* 100*
4 0 0 100* 100* 100* 100* 100* 100* 100* 100* 100* 100*
6 0 1 100* 100* 100* 100* 100* 100* 100* 100* 100* 100*
8 0 100* 100* 100* 100* 100* 100* 100* 100* 100* 100* 100*
逐段看：
- 理论门槛 g ≥ (k + 1) ÷ k：k = 1 要 2，k = 2 要 1.5，k = 3 要 1.33，k = 8 只要 1.125。好车越多，买家需要多看重的程度，越低。
- 相图和理论完全吻合：打 * 的格子（理论上撑得住），全部是 100%；没有打 * 的，全是 0%，或者最多 3%，而且还在慢慢掉（比如 k = 1，g = 1.95，只剩 2%：离门槛 2.0 很近，所以掉得很慢）。
- 在 g = 1.4 时：k = 1 剩 1 辆，k = 2 剩 4 辆，k = 3 一辆不少。
问题 2 的答案：降很多。均匀分布要 g ≥ 2；好车稍微多一点（k = 3），g ≥ 1.33 就够。同样一份买家的"多看重"，好车比例的高低，决定了市场的生死。
（第 20 讲里，k = 2 那一行，原来写的是"还有 6.3% 的车"。那其实是质量最低的 6.3% 的范围；按车的数量算，只有 0.4%。我们已经在第 20 讲里改了过来。上面这段代码按车的数量数，是 4 辆，和它一致。）
五、第三步：一个有"分界价格"的市场
第 20 讲还有一个例子：三成是有毛病的车（卖家估值 0 到 3 万），七成是好车（7 到 10 万），中间没有。g = 1.6 时，从"所有车都在卖"出发，市场撑住；从"只有便宜车在卖"出发，市场塌掉。现在，我们把这个"分界"找出来，再问：一个正常的市场，被推一下，会怎样？
# 第三步：两头的分布：三成是有毛病的车（卖家估值 0 到 3 万），七成是好车（7 到 10 万），中间没有。买家 g = 1.6。
V2 = np.concatenate([3 * (np.arange(300) + 0.5) / 300, 7 + 3 * (np.arange(700) + 0.5) / 700])
G2 = 1.6
def final_state(p0, rounds=300, forced=None):
h = simulate(V2, G2, rounds, p0, forced); return h[-1]
print("不同的出发价格，300 轮之后：")
for p0 in (10, 9, 8, 7.5, 7.2, 7.0, 6.9, 6.0, 3.0):
p, n, av = final_state(p0)
print(f" 出发价 {p0:>4}：最后价格 {p:7.3f} 万，在卖 {n:>4} 辆" + (" （好车还在市场上）" if av > 3 else " （好车退光了）"))
lo, hi = 3.0, 10.0 # 二分法：找「分界价格」
for _ in range(40):
mid = (lo + hi) / 2
if final_state(mid)[2] > 3: hi = mid
else: lo = mid
p_c = hi
print(f"\n分界价格 ≈ {p_c:.4f} 万：出发价高于它，好车留在市场上；低于它，好车一步步退光")
# 不同的 g，分界价格（"全部车都在卖"能撑住的话）
print("\n买家越看重（g 越大），分界价格越低，但都远高于 7（低于 7，好车一辆也不在卖）：")
for g in (1.6, 1.8, 2.0, 2.2):
lo, hi = 0.5, 10.0
for _ in range(40):
mid = (lo + hi) / 2
if simulate(V2, g, 400, mid)[-1][2] > 3: hi = mid
else: lo = mid
print(f" g = {g}：全部都在卖的价格 {simulate(V2, g, 400, 10.0)[-1][0]:.2f} 万；分界价格 {hi:.3f} 万")
# 冲击：正常的市场里，某一轮价格被压到 p_shock，之后买家恢复正常的出价规则
print("\n冲击（g = 1.6）：正常的市场里，第 5 轮价格被压到 p_shock，之后恢复正常的出价规则：")
for p_shock in (10.0, 9.6, 9.5, 9.4, 9.0, 8.0, 5.0):
h = simulate(V2, G2, 300, 10.0, forced={5: p_shock})
print(f" p_shock = {p_shock:>4}：300 轮之后，价格 {h[-1][0]:7.3f} 万，在卖 {h[-1][1]:>4} 辆" + ("（恢复了）" if h[-1][2] > 3 else "（回不来了）"))
# 救市：塌掉的市场（只剩最差的两辆车在卖）。有人把价格托在 P_f 一轮，然后撤走
print("\n救市：塌掉的市场，第 5 轮有人把价格托在 P_f，然后撤走：")
for P_f in (8.0, 9.0, 9.4, 9.5, 10.0):
h = simulate(V2, G2, 300, 0.016, forced={5: P_f})
print(f" P_f = {P_f:>4}：300 轮之后，价格 {h[-1][0]:7.3f} 万，在卖 {h[-1][1]:>4} 辆" + ("（救活了）" if h[-1][2] > 3 else "（没救活）"))
输出：
不同的出发价格，300 轮之后：
出发价 10：最后价格 10.240 万，在卖 1000 辆 （好车还在市场上）
出发价 9：最后价格 0.016 万，在卖 2 辆 （好车退光了）
出发价 8：最后价格 0.016 万，在卖 2 辆 （好车退光了）
出发价 7.5：最后价格 0.016 万，在卖 2 辆 （好车退光了）
出发价 7.2：最后价格 0.016 万，在卖 2 辆 （好车退光了）
出发价 7.0：最后价格 0.016 万，在卖 2 辆 （好车退光了）
出发价 6.9：最后价格 0.016 万，在卖 2 辆 （好车退光了）
出发价 6.0：最后价格 0.016 万，在卖 2 辆 （好车退光了）
出发价 3.0：最后价格 0.016 万，在卖 2 辆 （好车退光了）
分界价格 ≈ 9.4321 万：出发价高于它，好车留在市场上；低于它，好车一步步退光
买家越看重（g 越大），分界价格越低，但都远高于 7（低于 7，好车一辆也不在卖）：
g = 1.6：全部都在卖的价格 10.24 万；分界价格 9.432 万
g = 1.8：全部都在卖的价格 11.52 万；分界价格 8.322 万
g = 2.0：全部都在卖的价格 12.80 万；分界价格 7.898 万
g = 2.2：全部都在卖的价格 14.08 万；分界价格 7.662 万
冲击（g = 1.6）：正常的市场里，第 5 轮价格被压到 p_shock，之后恢复正常的出价规则：
p_shock = 10.0：300 轮之后，价格 10.240 万，在卖 1000 辆（恢复了）
p_shock = 9.6：300 轮之后，价格 10.240 万，在卖 1000 辆（恢复了）
p_shock = 9.5：300 轮之后，价格 10.240 万，在卖 1000 辆（恢复了）
p_shock = 9.4：300 轮之后，价格 0.016 万，在卖 2 辆（回不来了）
p_shock = 9.0：300 轮之后，价格 0.016 万，在卖 2 辆（回不来了）
p_shock = 8.0：300 轮之后，价格 0.016 万，在卖 2 辆（回不来了）
p_shock = 5.0：300 轮之后，价格 0.016 万，在卖 2 辆（回不来了）
救市：塌掉的市场，第 5 轮有人把价格托在 P_f，然后撤走：
P_f = 8.0：300 轮之后，价格 0.016 万，在卖 2 辆（没救活）
P_f = 9.0：300 轮之后，价格 0.016 万，在卖 2 辆（没救活）
P_f = 9.4：300 轮之后，价格 0.016 万，在卖 2 辆（没救活）
P_f = 9.5：300 轮之后，价格 10.240 万，在卖 1000 辆（救活了）
P_f = 10.0：300 轮之后，价格 10.240 万，在卖 1000 辆（救活了）
逐段看：
- 出发价 10，市场撑住（价格 10.24，1000 辆）；出发价 9，市场塌了（只剩最差的 2 辆）。分界价格，约是 9.4321 万。
- 看左图：蓝色曲线是"这一轮价格 → 下一轮买家愿付的价格"。在 9.43 以上，曲线在 45° 线上方，价格往上走，走到 10.24（所有车都在卖）；在 9.43 以下，曲线在 45° 线下方，价格往下走：好车一辆一辆退出，曲线在 3 到 7 之间是平的（只剩有毛病的车，买家只愿付它们平均估值的 1.6 倍，约 2.4 万）。
- 买家越看重，分界价格越低，但都远高于 7：g = 1.6 是 9.43，g = 2.2 也有 7.66。（价格低于 7，市场上就没有好车了。）
- 冲击：在一个正常的市场里，第 5 轮价格被压到 9.5，之后买家恢复正常的出价规则，市场恢复了；压到 9.4，回不来了，300 轮之后只剩最差的 2 辆。差 0.1 万，也就是 1% 的价格，结局完全不同。
- 救市：已经塌掉的市场，有人在第 5 轮，把价格托在 9.4，然后撤走：没救活；托在 9.5：救活了，300 轮之后，价格回到 10.24，1000 辆车都在卖。要把市场救回来，临时的支持，必须把价格托过分界价格；差一点点，也没用。
问题 3 的答案：取决于有多大；这个例子里，1% 的价格冲击，就可能让市场塌掉；救市也是，托得不够高，等于白托。
要小心，不要过度解读：这条"刀刃"很窄，是因为我们假设的规则很机械：价格一变，谁卖谁不卖立刻变；买家立刻按上一轮的结果调整出价。现实里，价格是有黏性的，卖家可以等，买家也不只看上一轮的价格。所以，别把"1%“当成现实里的数字。这个例子想说明的是结构：有两个稳定的状态（热闹的、冷清的），中间隔着一个临界点，这和第 17 讲的临界规模，是同一类现象。此外，我们没有算谁来付托价的钱：塌掉的市场里，买家只愿付 0.02 万左右，把价格托到 9.5 万，差额得有人付。
六、第四步：办法一，让卖家花钱认证
对付逆向选择的一个办法，是让好车的卖家，自己把信息送出去：请人检测，拿一张可信的证明。认证过的车，买家看得出真实质量，愿付 g × 估值；没认证的车，买家只能按"没认证的车的平均估值"出价。设认证费是 c（卖家自己付）。
每个卖家，在三件事里选最划算的：认证后卖、不认证直接卖（只要价格不低于自己的估值）、不卖。买家对没认证的车的出价，和卖家的选择，互相影响，所以我们让代码反复迭代，直到谁也不再改变。
# 第四步：让卖家可以花钱请人检测并开具证明（认证）。认证过的车，买家看得出真实质量，愿付 g × 估值；
# 没认证的车，买家只能按「没认证的车的平均估值」出价。认证费是 c（万元，卖家自己付）。
def certify_equilibrium(values, g, c, rounds=500):
"""每个卖家在三件事里选最划算的：认证后卖、不认证直接卖（只要价格不低于自己估值）、不卖。
买家对没认证的车的出价 = g × 市场上没认证的车的平均估值。反复迭代，直到不再变化。"""
p_u = g * values.mean() # 没认证的车的初始出价
for _ in range(rounds):
gain_cert = (g - 1) * values - c # 认证后卖，比不卖多得到的好处
gain_unc = np.where(values <= p_u, p_u - values, -np.inf) # 不认证直接卖
cert = gain_cert >= np.maximum(gain_unc, 0) + 1e-12
unc = (~cert) & (gain_unc >= 0)
new_p = g * values[unc].mean() if unc.any() else 0.0
if abs(new_p - p_u) < 1e-9: break
p_u = new_p
return cert, unc, p_u
g = 1.5; potential = ((g - 1) * V).sum()
print(f"买家看得出好坏时，总好处 {potential:.0f} 万（g = {g}）。没有认证时，市场塌到只剩最差的几辆车（好处约 0）。")
print("\n认证费 c 不同：")
print(" c（万元） 认证的车 不认证、直接卖 不卖 没认证的车的价格 总好处（扣掉认证费） 占最大好处的比例")
cert_results = {}
for c in (0.0, 0.1, 0.25, 0.5, 1.0, 2.0, 3.0, 4.0, 5.0):
cert, unc, p_u = certify_equilibrium(V, g, c)
welfare = ((g - 1) * V[cert] - c).sum() + ((g - 1) * V[unc]).sum()
cert_results[c] = (cert.sum(), unc.sum(), welfare, p_u)
print(f" {c:>7.2f} {int(cert.sum()):>8} {int(unc.sum()):>12} {N - int(cert.sum()) - int(unc.sum()):>4} {p_u:>14.3f} {welfare:>16.1f} {welfare / potential:>12.1%}")
输出：
买家看得出好坏时，总好处 2500 万（g = 1.5）。没有认证时，市场塌到只剩最差的几辆车（好处约 0）。
认证费 c 不同：
c（万元） 认证的车 不认证、直接卖 不卖 没认证的车的价格 总好处（扣掉认证费） 占最大好处的比例
0.00 999 1 0 0.007 2500.0 100.0%
0.10 980 2 18 0.015 2401.0 96.0%
0.25 950 2 48 0.015 2256.3 90.3%
0.50 900 2 98 0.015 2025.0 81.0%
1.00 800 2 198 0.015 1600.0 64.0%
2.00 600 2 398 0.015 900.0 36.0%
3.00 400 2 598 0.015 400.0 16.0%
4.00 200 2 798 0.015 100.0 4.0%
5.00 0 2 998 0.015 0.0 0.0%
逐段看：
- c = 0（认证不要钱）：999 辆车都认证，总好处回到最大值 2500。唯一例外，是质量最差的那辆：它认证和不认证，好处一样（都只有 0.0025）。这是”信息展开"（unraveling）：只要披露不要钱，每个卖家都愿意披露，因为不披露，本身就像是在承认自己的车不好。
- c > 0：总好处 = 最大好处 × (1 − c ÷ 5)²（这里的 5 是 10 × (g − 1)，也就是最好的那辆车的好处）。可以对着表检验：c = 1，2500 × 0.8² = 1600；c = 2，2500 × 0.6² = 900；c = 0.5，2500 × 0.9² = 2025。原因：认证的车，是好处大于认证费的车，也就是 q ≥ c ÷ 5 的车；那些好处小于认证费的车，不认证，也不卖，这是有效率的，因为它们的交易，本来就不值那笔认证费。认证费，只挡掉了本来不值得的交易，加上认证费本身这笔开销。
- 没认证的车的价格，一直只有 0.01 万出头：认证没有救活"没认证的市场"，而是绕过了它。
- 认证费太高时，认证就没人用了：c = 5（等于最好的车的好处），一辆车都不认证，回到完全塌缩的市场。
这个模型的逻辑，和 Grossman（1981 年，Journal of Law and Economics，24 卷 3 期，461–483 页）、Milgrom（1981 年，Bell Journal of Economics，12 卷 2 期，380–391 页）的"信息展开"结果相通：披露免费时，每个卖家都披露。（我只核对了这两篇文章的出处和摘要。）Lewis（2011 年，American Economic Review，101 卷 4 期，1535–1546 页）用 eBay Motors 的数据发现：卖家在拍卖页面上披露的信息，是价格的重要决定因素，而披露的成本，会影响披露的程度和价格；这和我们这里"认证费决定了谁来认证"的逻辑，是同一个方向。（也只核对了摘要。）
局限：我们假设认证可信（没有伪造、没有和卖家串通），认证费和质量无关，买家之间竞争，价格等于完全信息下的估值（所有的好处都归了卖家）。现实里，检测机构往往是卖家付钱请的，可信度本身就是一个问题。
七、第五步：办法二，规定最低质量
另一个办法，是规定质量低于 q_min 的车，不许卖（比如强制检测，不合格的车不许上市）。市场里只剩质量在 q_min 以上的车，相当于把分布的下端切掉。
# 第五步：另一种办法：规定最低质量（比如强制检测，不合格的车不许上市）：质量低于 q_min 的车，不许卖。
def standard_equilibrium(g, q_min, rounds=400):
allowed = V >= 10 * q_min # 不许卖的车被拿走了；剩下的才进市场
h = simulate(V[allowed], g, rounds, 10.0)
return h[-1][0], h[-1][1], allowed
print(f"g = {g}：规定最低质量 q_min（质量低于它的车，不许卖）。市场里剩下的车，价格 p* 和成交情况：")
print(" q_min p*（万元） 成交的车数 总好处 占最大好处的比例")
std_results = {}
for q_min in (0.0, 0.05, 0.1, 0.2, 0.25, 0.3, 1 / 3, 0.4, 0.5):
p_star, n, allowed = standard_equilibrium(g, q_min)
on = allowed & (V <= p_star)
welfare = ((g - 1) * V[on]).sum(); std_results[q_min] = (p_star, n, welfare)
print(f" {q_min:5.3f} {p_star:9.3f} {n:>9} {welfare:8.1f} {welfare / potential:>12.1%}")
print(f"\n公式：p* = 10 g q_min / (2 - g) = {10 * g * (1 / 3) / (2 - g):.2f}（q_min = 1/3）；最优的 q_min 正好让 p* = 10：q_min = (2 - g) / g = {(2 - g) / g:.4f}")
print("\n不同的 g：最优的 q_min 和它的总好处")
for gg in (1.2, 1.5, 1.8):
pot = ((gg - 1) * V).sum()
best = max(((q, ((gg - 1) * V[(V >= 10 * q) & (V <= standard_equilibrium(gg, q)[0])]).sum()) for q in np.arange(0, 0.8, 0.005)), key=lambda x: x[1])
print(f" g = {gg}：公式 (2 - g) / g = {(2 - gg) / gg:.3f}；数值最优 q_min = {best[0]:.3f}，总好处 {best[1]:.1f}（最大好处的 {best[1] / pot:.1%}）")
# 认证（第四步）和最低质量（第五步），哪个更好？找出认证费 c 的分界点：低于它，认证带来的总好处，比最好的最低质量标准还多
best_std = max(w for (_, _, w) in std_results.values())
lo, hi = 0.0, 5.0
for _ in range(40):
mid = (lo + hi) / 2
cert, unc, _ = certify_equilibrium(V, g, mid)
w = ((g - 1) * V[cert] - mid).sum() + ((g - 1) * V[unc]).sum()
if w > best_std: lo = mid
else: hi = mid
print(f"\ng = {g}：最好的最低质量标准（q_min = 1/3）总好处 {best_std:.1f} 万；认证费低于 {lo:.3f} 万时，认证的总好处更多")
输出：
g = 1.5：规定最低质量 q_min（质量低于它的车，不许卖）。市场里剩下的车，价格 p* 和成交情况：
q_min p*（万元） 成交的车数 总好处 占最大好处的比例
0.000 0.015 2 0.0 0.0%
0.050 1.515 102 51.5 2.1%
0.100 3.015 202 203.0 8.1%
0.200 6.008 401 803.0 32.1%
0.250 7.515 502 1257.5 50.3%
0.300 9.015 602 1809.0 72.4%
0.333 9.998 667 2222.8 88.9%
0.400 10.500 600 2100.0 84.0%
0.500 11.250 500 1875.0 75.0%
公式：p* = 10 g q_min / (2 - g) = 10.00（q_min = 1/3）；最优的 q_min 正好让 p* = 10：q_min = (2 - g) / g = 0.3333
不同的 g：最优的 q_min 和它的总好处
g = 1.2：公式 (2 - g) / g = 0.667；数值最优 q_min = 0.665，总好处 553.8（最大好处的 55.4%）
g = 1.5：公式 (2 - g) / g = 0.333；数值最优 q_min = 0.335，总好处 2219.4（最大好处的 88.8%）
g = 1.8：公式 (2 - g) / g = 0.111；数值最优 q_min = 0.115，总好处 3947.1（最大好处的 98.7%）
g = 1.5：最好的最低质量标准（q_min = 1/3）总好处 2222.8 万；认证费低于 0.285 万时，认证的总好处更多
逐段看：
- q_min = 0（不管）：塌缩，总好处 0。
- q_min 一路提高：价格 p* 一路上升，成交的车数、总好处也上升，到 q_min = 1/3 时，p* = 10（所有剩下的车，正好全部成交）：成交 667 辆，总好处 2222.8，是最大好处的 88.9%。
- 再提高，总好处下降：q_min = 0.4 是 84.0%，0.5 是 75.0%：剩下的车都成交了，可是被禁止的车越来越多，它们的好处，就浪费了。
- 公式：对均匀分布，市场里剩下的是质量在 [q_min, 1] 的车，稳定的价格是 p* = 10 g q_min ÷ (2 − g)；让 p* = 10 的 q_min，就是最优的：q_min = (2 − g) ÷ g。g = 1.5 是 1/3；g = 1.8 是 1/9；g = 1.2 是 2/3。最优标准的总好处，是最大好处的 1 − q_min²：g = 1.5 是 88.9%，g = 1.8 是 98.8%，g = 1.2 是 55.6%。（代码里用的是间隔 0.005 的网格，所以数值最优，和公式有一点小差别。）
- g 越小，市场越难救：g = 1.2 时，最好的标准，也只能留下最大好处的一半多一点。买家和卖家的估值差越小，信息问题造成的损失，越难补救。
最后，两个办法比一比。最好的最低质量标准（g = 1.5）是 2222.8；认证费低于 0.285 万（2850 元）时，认证的总好处更多。
问题 4 的答案：看认证费有多高。认证费很低（接近 0），认证好得多：它精准地只挡掉"不值得"的交易；认证费高过 0.285 万，最低质量标准反而更好。最低质量标准是个"钝刀"：它不分青红皂白地禁掉所有低质量的车，其中有一些，本来是值得交易的。
八、这个实验说明了什么，没说明什么
说明了：
- 逆向选择的崩溃，是一个有门槛的、一轮一轮发生的过程。 在均匀分布下，买家要多看重一倍；好车多一点，门槛低很多。
- 市场可能有两个稳定的状态，中间有分界。一个小冲击，可以让它塌掉；救回来，必须把价格托过分界。
- 让信息流动，和强制标准，是两个很不一样的办法。 前者精准、有效率，但要有人付认证费；后者简单、可以强制，但钝，会浪费好的交易。
没说明：
- 现实里的市场，不是这样机械地一轮一轮地调整。 价格的黏性、卖家的耐心、买家手里别的信息，都会让"刀刃"变宽。
- 所有的结论，来自一个很简单的设定：质量是单一的数，卖家的估值是它的固定倍数，买家都是同一个 g，没有风险厌恶，没有搜寻成本。
- 认证的可信度、最低标准的执行成本和监督成本，都没有进入模型。
- 谁付钱：认证费、救市的托价，我们都没有讨论分配。
九、和前面、后面的联系
- 第 17 讲：临界规模和两个稳定状态。第三步的"分界价格"，是同一类结构。
- 第 20 讲：这个实验，是 3.2 节价格螺旋的"放大版"；6 节讲的办法（披露、认证、质保、规则），在第四步、第五步里，被数出了具体的好处。第 20 讲的 k = 2 那一行，我们在这里按车的数量重新数了一遍。
- 第 21 讲：信号和筛选，质量是有成本的信号，认证费，就是这样一种成本。
- 第 23 讲：外部性，好车的卖家，被迫补贴有毛病的车的卖家。
- 实验 75：换一个主题，一价拍卖与二价拍卖。
十、练习
下面的练习，都可以在上面的代码上改几个数字做出来。提示里的数字，都是我跑过的。
练习 1（衰减的速度）。 g = 1.9 时，要几轮，市场里的车才会减到 100 辆以下？
提示：
simulate(V, 1.9, 400)：第 10、20、30、40 轮，分别是 598、358、215、129 辆；第 46 轮才降到 100 辆以下。越靠近门槛 2.0，衰减得越慢。
练习 2（门槛的两边）。 k = 4 时，理论门槛是 1.25。g = 1.24 和 g = 1.26，各会怎样？
提示：
simulate(values_k(4), g, 300)：g = 1.24，300 轮后只剩 19 辆，价格 3.69 万（在缓慢地缩）；g = 1.26，1000 辆都在卖，价格 10.08 万。（g = 1.24 在 300 轮之后还剩 19 辆，只是因为离门槛太近，掉得很慢，不是"撑住了"。）
练习 3（有毛病的车，占多大比例）。 把"两头的分布"里，有毛病的车的比例，从 30% 改成 10% 和 20%（g = 1.6），分界价格各是多少？改成 40% 呢？
提示：10% 有毛病的：全部都在卖的价格 12.48 万，分界价格 7.405 万；20%：11.36 万，8.063 万；30%：10.24 万，9.432 万；40%：全部都在卖，也撑不住（最后只剩 2 辆）。有毛病的车越少，分界价格越低，市场越稳。
练习 4（认证的总好处）。 g = 1.5，认证费 c = 1.5 万，有多少辆车会认证？总好处是多少？用公式验证。
提示：
certify_equilibrium(V, 1.5, 1.5)：700 辆认证（q ≥ 1.5 ÷ 5 = 0.3，也就是 1000 − 300 = 700 辆）；总好处 1225.0；公式 2500 × (1 − 1.5 ÷ 5)² = 2500 × 0.49 = 1225。
练习 5（最优标准）。 g = 1.8，最优的 q_min 是多少？这时 p*、成交的车数、总好处是多少？
提示：q_min = (2 − 1.8) ÷ 1.8 = 1/9。
standard_equilibrium(1.8, 1/9)：p* = 9.999 万（≈ 10），成交 889 辆，总好处 3950.7，是最大好处 4000 的 98.8%（= 1 − (1/9)²，公式是 3950.6，差的 0.1 来自格子）。
练习 6（认证 还是 标准）。 对 g = 1.2 和 g = 1.8，认证费低于多少，认证比最好的最低质量标准更好？
提示：用第五步最后一段的办法（二分法找）：g = 1.2，最好的标准的总好处是 556.4，认证费要低于 0.508 万；g = 1.8，最好的标准已经是最大好处的 98.8%，认证费要低于 0.05 万，才能比它更好。买家和卖家的估值差越大，最低质量标准越接近完美，认证越不容易胜出；估值差越小，标准越差，认证的空间越大。
十一、局限
- 质量只有一个数，卖家的估值是它的固定倍数，所有买家的 g 一样。
- 价格调整是机械的：每一轮，价格马上决定谁卖，买家马上按上一轮的平均估值调整出价，没有价格黏性，没有学习，没有"等一等"。
- 认证：假设可信、成本和质量无关，买家之间竞争；没有伪造，也没有认证机构和卖家的利益冲突。
- 最低质量标准：假设标准能被无成本地执行，被禁止的车不能转作别的用途。
- 没有讨论质保、声誉（第 20 讲 6.2、6.3 节）；它们也是对付逆向选择的办法，这里没有做。
参考
- Akerlof, G. A. (1970). The market for “lemons”: Quality uncertainty and the market mechanism. Quarterly Journal of Economics, 84(3), 488–500.
- Grossman, S. J. (1981). The informational role of warranties and private disclosure about product quality. Journal of Law and Economics, 24(3), 461–483.
- Milgrom, P. R. (1981). Good news and bad news: Representation theorems and applications. Bell Journal of Economics, 12(2), 380–391.
- Lewis, G. (2011). Asymmetric information, adverse selection and online disclosure: The case of eBay Motors. American Economic Review, 101(4), 1535–1546.