实验 78 银行挤兑：Diamond–Dybvig 的完整模拟

import numpy as np
from statistics import NormalDist

# 第 35 讲的小银行：100 个存款人，每人存 1，银行把 100 全部投进一个长期项目。
#   第 1 期（提前）清算：每 1 份只能变现 s = 0.6；等到第 2 期（到期）：每 1 份变成 R = 1.4。
#   银行承诺：第 1 期来取的人，付 1（先到先得，钱付完为止）；留到第 2 期的人，平分剩下的资产。
#   25% 的存款人是「急用钱的人」，一定在第 1 期取；其余 75% 是「不急的人」，哪个更划算，选哪个。
N, S_LIQ, R_MAT, EARLY = 100, 0.6, 1.4, 0.25

def run_payoff(f, s=S_LIQ):
    """第 1 期，一共有 f 比例的人来取钱（f × N 个人）。银行最多能付出 s × N。来取钱的人，期望拿到多少？
    钱够付（f ≤ s）：每人 1；不够：随机排队，前面的拿 1，后面的拿 0，期望 s / f"""
    return 1.0 if f <= s else s / f

def wait_value(f, r=R_MAT, s=S_LIQ):
    """f 比例的人在第 1 期取钱之后，留到第 2 期的人，每人能拿到多少"""
    if f >= 1: return 0.0
    sold = f / s                                     # 为了付给 f 比例的人，要变现的资产（占全部资产的比例）
    return 0.0 if sold >= 1 else (1 - sold) * r / (1 - f)

def threshold(r=R_MAT, s=S_LIQ):
    """等下去的价值，恰好等于现在去取：f* = (R - 1) / (R / s - 1)"""
    return (r - 1) / (r / s - 1)

f_star = threshold()
print(f"临界值 f* = (R - 1) ÷ (R ÷ s - 1) = {f_star:.4f}；正常取钱的比例 = {EARLY:.2f}")

# 不急的人里，有 p 的比例选择「去取」，总取钱比例 f = 0.25 + 0.75 p。每个不急的人，比较：去取，和等下去，哪个更好？
p_star = (f_star - EARLY) / (1 - EARLY)                              # 内部均衡处，不急的人里去取的比例
print("\n不急的人里，有 p 的比例去取钱：总取钱比例 f，去取的人拿多少，等下去的人拿多少")
print("      p       f     去取    等下去    谁更划算")
for p in (0.0, 0.03, p_star, 0.10, 0.25, 0.5, 0.75, 1.0):
    f = EARLY + (1 - EARLY) * p; a, b = run_payoff(f), wait_value(f)
    print(f"  {p:6.4f}  {f:6.3f}  {a:6.3f}  {b:6.3f}    {'等下去' if b > a + 1e-9 else ('一样' if abs(b - a) < 1e-9 else '去取')}")

# 均衡：没有人想单独改变。在 p 处，「等下去 - 去取」的差；差 > 0 时，等下去更好，所以 p 会变小；差 < 0 时，去取更好，p 会变大
gap = lambda p: wait_value(EARLY + (1 - EARLY) * p) - run_payoff(EARLY + (1 - EARLY) * p)
ps = np.linspace(0, 1, 100001); g = np.array([gap(p) for p in ps])
print("\n均衡有：")
if g[0] >= 0: print(f"  p = 0（不急的人，全部等），f = {EARLY:.3f}：等下去更好（{g[0]:+.3f}）：好的均衡")
for i in range(len(ps) - 1):
    if g[i] > 0 >= g[i + 1]: print(f"  p = {ps[i]:.4f}（一部分人去取），f = {EARLY + (1 - EARLY) * ps[i]:.3f}：去取和等下去一样好：内部均衡")
if g[-1] <= 0: print(f"  p = 1（不急的人，全部去取），f = 1.000：去取更好（{g[-1]:+.3f}）：坏的均衡")
print("内部均衡是「刀刃」：p 比它小一点，大家都想等，p 回到 0；p 比它大一点，大家都想去取，p 一路走到 1。")

# 用真正的排队，随机模拟，核对「去取的人，期望拿多少」（f > 0.6，钱不够付）
rng = np.random.default_rng(78)
print("\n随机排队的模拟（20000 次），去取钱的人，期望拿多少：")
for f in (0.7, 0.85, 1.0):
    k = int(round(f * N)); capacity = int(round(S_LIQ * N)); mine = 0
    for _ in range(20000):
        position = rng.integers(k)                 # 我在 k 个去取的人里，排第几（0 是第一个）
        mine += 1.0 if position < capacity else 0.0
    print(f"  f = {f:.2f}：模拟 {mine / 20000:.3f}，公式 s / f = {run_payoff(f):.3f}")

临界值 f* = (R - 1) ÷ (R ÷ s - 1) = 0.3000；正常取钱的比例 = 0.25

不急的人里，有 p 的比例去取钱：总取钱比例 f，去取的人拿多少，等下去的人拿多少
      p       f     去取    等下去    谁更划算
  0.0000   0.250   1.000   1.089    等下去
  0.0300   0.273   1.000   1.050    等下去
  0.0667   0.300   1.000   1.000    一样
  0.1000   0.325   1.000   0.951    去取
  0.2500   0.438   1.000   0.674    去取
  0.5000   0.625   0.960   0.000    去取
  0.7500   0.812   0.738   0.000    去取
  1.0000   1.000   0.600   0.000    去取

均衡有：
  p = 0（不急的人，全部等），f = 0.250：等下去更好（+0.089）：好的均衡
  p = 0.0667（一部分人去取），f = 0.300：去取和等下去一样好：内部均衡
  p = 1（不急的人，全部去取），f = 1.000：去取更好（-0.600）：坏的均衡
内部均衡是「刀刃」：p 比它小一点，大家都想等，p 回到 0；p 比它大一点，大家都想去取，p 一路走到 1。

随机排队的模拟（20000 次），去取钱的人，期望拿多少：
  f = 0.70：模拟 0.854，公式 s / f = 0.857
  f = 0.85：模拟 0.706，公式 s / f = 0.706
  f = 1.00：模拟 0.601，公式 s / f = 0.600

# 第二步：存款人的信念不一样。第一步里，每个不急的人，都知道项目到期会变成 R = 1.4，所以大家的临界值一样，都是 30%。
# 现实里，大家对银行资产好坏的看法不一样：第 i 个人相信的到期收益是 R_i。每个人的临界值：f_i* = (R_i - 1) / (R_i / s - 1)。
# R_i 在 [1.4 - w, 1.4 + w] 上均匀分布（取 1000 个等分位数，没有随机数）：w 越大，大家的看法越分散。
def thresholds(w, n=1000):
    r = R_MAT + w * (2 * (np.arange(n) + 0.5) / n - 1)
    return (r - 1) / (r / S_LIQ - 1)

def next_f(f, thr):
    """如果大家预期，这一期的取钱比例是 f：不急的人里，临界值低于 f 的人，会去取。下一期的总取钱比例 = 急用钱的 + 去取的"""
    return EARLY + (1 - EARLY) * np.mean(thr < f)

def settle(f0, thr, steps=300):
    f = f0
    for _ in range(steps): f = next_f(f, thr)
    return f

print("看法的分散程度 w 不同：最悲观的人的临界值；平静时，会不会有人先跑，把大家拖进去？")
print("   w    最悲观的人 R_i   最悲观的人的临界值   平静时（f = 25%）最后的取钱比例   从「25% + 额外 x 的人先跑」出发，最后的取钱比例")
print("                                                                                   x = 3%    x = 6%    x = 10%   x = 20%")
het = {}
for w in (0.0, 0.05, 0.09, 0.10, 0.15, 0.25):
    thr = thresholds(w); het[w] = thr
    calm = settle(EARLY, thr)
    cells = "    ".join(f"{settle(EARLY + x, thr):6.3f}" for x in (0.03, 0.06, 0.10, 0.20))
    print(f"  {w:4.2f}     {R_MAT - w:5.2f}            {thr.min():6.3f}                  {calm:6.3f}                          {cells}")

# 均衡：f = 0.25 + 0.75 × F(f)，F 是临界值的分布函数。在 f 的格子上，看曲线和 45 度线，穿过几次，哪些是稳定的
print("\n均衡（f = 急用钱的 + 不急的里临界值低于 f 的），以及稳定的（被推离一点，会回来）：")
fs = np.linspace(0, 1, 4001)
for w in (0.0, 0.05, 0.10, 0.15, 0.25):
    thr = het[w]; h = np.array([next_f(f, thr) - f for f in fs])
    stable = [fs[i] for i in range(len(fs) - 1) if h[i] > 0 >= h[i + 1]]
    unstable = [fs[i] for i in range(len(fs) - 1) if h[i] < 0 <= h[i + 1]]
    print(f"  w = {w:4.2f}：稳定的 f = " + "、".join(f"{x:.3f}" for x in stable) + "；不稳定的（刀刃）f = " + ("、".join(f"{x:.3f}" for x in unstable) if unstable else "没有"))

# 对照：如果信念是正态分布（没有上下界），尾巴里总有人悲观到「平时就去取」
thr_n = np.array([(r - 1) / (r / S_LIQ - 1) for r in np.maximum(R_MAT + 0.05 * np.array([NormalDist().inv_cdf((i + 0.5) / 1000) for i in range(1000)]), 1.0001)])
print(f"\n对照：R_i 服从正态分布（标准差 0.05），平静时最后的取钱比例 = {settle(EARLY, thr_n):.3f}：最悲观的几个人，平时就会去取，把一串临界值更高的人，一个一个地拖进来。")

看法的分散程度 w 不同：最悲观的人的临界值；平静时，会不会有人先跑，把大家拖进去？
   w    最悲观的人 R_i   最悲观的人的临界值   平静时（f = 25%）最后的取钱比例   从「25% + 额外 x 的人先跑」出发，最后的取钱比例
                                                                                   x = 3%    x = 6%    x = 10%   x = 20%
  0.00      1.40             0.300                   0.250                           0.250     1.000     1.000     1.000
  0.05      1.35             0.280                   0.250                           0.250     1.000     1.000     1.000
  0.09      1.31             0.262                   0.250                           1.000     1.000     1.000     1.000
  0.10      1.30             0.257                   0.250                           1.000     1.000     1.000     1.000
  0.15      1.25             0.231                   1.000                           1.000     1.000     1.000     1.000
  0.25      1.15             0.164                   1.000                           1.000     1.000     1.000     1.000

均衡（f = 急用钱的 + 不急的里临界值低于 f 的），以及稳定的（被推离一点，会回来）：
  w = 0.00：稳定的 f = 0.250、1.000；不稳定的（刀刃）f = 0.300
  w = 0.05：稳定的 f = 0.250、1.000；不稳定的（刀刃）f = 0.282
  w = 0.10：稳定的 f = 0.250、1.000；不稳定的（刀刃）f = 0.258
  w = 0.15：稳定的 f = 1.000；不稳定的（刀刃）f = 没有
  w = 0.25：稳定的 f = 1.000；不稳定的（刀刃）f = 没有

对照：R_i 服从正态分布（标准差 0.05），平静时最后的取钱比例 = 1.000：最悲观的几个人，平时就会去取，把一串临界值更高的人，一个一个地拖进来。

# 第三步：如果存款人不知道 R 是多少，只能各自收到一个带噪声的消息，会怎样？（「全局博弈」：Morris 和 Shin 1998 年提出，
# Goldstein 和 Pauzner 2005 年用到了挤兑上。）
# 项目到期的真实收益 R（「基本面」），谁也不确定，先验是平的。每个不急的人，收到一个信号 x_i = R + sigma × 噪声（噪声是正态分布，每人不同）。
# 策略：信号低于某个门槛 x*，就去取钱。于是，真实收益是 R 时，不急的人里去取钱的比例是 Phi((x* - R) / sigma)，总取钱比例 f(R) = 0.25 + 0.75 × 这个比例。
# 一个收到信号 x 的人，认为 R 服从 N(x, sigma²)；他比较：等下去的期望收益，和去取的期望收益。门槛 x* 就是他刚好觉得一样的信号。
PHI = NormalDist().cdf
Z = np.linspace(-6, 6, 1201); WEIGHT = np.exp(-Z ** 2 / 2); WEIGHT /= WEIGHT.sum()          # 标准正态的权重

def waiting_minus_running(x, x_star, sigma, s):
    """信号为 x 的人，等下去，比去取，期望多得多少（对 R ~ N(x, sigma²) 取平均）"""
    r = x + sigma * Z
    f = EARLY + (1 - EARLY) * np.array([PHI((x_star - ri) / sigma) for ri in r])
    return float(WEIGHT @ np.array([wait_value(fi, ri, s) - run_payoff(fi, s) for fi, ri in zip(f, r)]))

def equilibrium_threshold(sigma, s, hi=12.0):
    """二分法：找 x*，让「信号刚好是 x* 的人」觉得，等和取一样好"""
    lo = 1.0
    for _ in range(40):
        mid = (lo + hi) / 2
        if waiting_minus_running(mid, mid, sigma, s) > 0: hi = mid        # 等更好，说明门槛可以再低一点
        else: lo = mid
    return (lo + hi) / 2

def laplace_threshold(s, early=EARLY):
    """噪声趋于 0 的极限：每个人对「别人去取的比例」没有任何信息，认为它在 [早取的比例, 1] 上均匀分布（Laplace 信念）；门槛 R*，让平均的「等 - 取」等于 0"""
    ls = np.linspace(0, 1, 2001)
    avg = lambda r: np.mean([wait_value(early + (1 - early) * l, r, s) - run_payoff(early + (1 - early) * l, s) for l in ls])
    lo, hi = 1.0, 20.0
    for _ in range(50):
        mid = (lo + hi) / 2
        if avg(mid) > 0: hi = mid
        else: lo = mid
    return (lo + hi) / 2

print("一、噪声趋于 0 的极限：银行到期收益低于 R*，就一定被挤兑；高于 R*，就不会。R* 取决于资产的变现能力 s（R = 1.4 时的 f* 也列出来）")
print("   s    R*     R = 1.4 时的 f*")
for s in (0.5, 0.6, 0.7, 0.8, 0.9, 0.95):
    print(f"  {s:4.2f}  {laplace_threshold(s):5.2f}      {threshold(1.4, s):.3f}")
print(f"  （第一步的小银行，s = 0.6：R* = {laplace_threshold(0.6):.2f}。这个玩具里，银行承诺的「提前取，付 1」太慷慨，提前变现的损失又大，所以只有到期收益高到 4，才不会被挤兑；数字不要当成现实，要看的是：s 越大，R* 越低。）")

print("\n二、资产比较好变现的银行（s = 0.9），存款人只收到带噪声的信号：门槛 x*，以及真实收益 R 不同时，不急的人里去取的比例")
print("  噪声 sigma    门槛 x*      R = 1.1、1.3、1.5、1.7、1.9 时，不急的人里，去取的比例")
x_stars = {}
for sigma in (0.02, 0.05, 0.10):
    xs = equilibrium_threshold(sigma, 0.9); x_stars[sigma] = xs
    print(f"    {sigma:5.2f}       {xs:6.3f}       " + "、".join(f"{PHI((xs - r) / sigma):5.3f}" for r in (1.1, 1.3, 1.5, 1.7, 1.9)))
print(f"  对照：噪声趋于 0 时的 R* = {laplace_threshold(0.9):.3f}；噪声越小，门槛，越接近它。")
print("  没有噪声时（第一步），R = 1.7 的银行，也有「全部去取」这个均衡；有噪声时，只有 R 低于门槛附近，才有人去取：均衡唯一，由基本面决定。")

一、噪声趋于 0 的极限：银行到期收益低于 R*，就一定被挤兑；高于 R*，就不会。R* 取决于资产的变现能力 s（R = 1.4 时的 f* 也列出来）
   s    R*     R = 1.4 时的 f*
  0.50   6.31      0.222
  0.60   3.99      0.300
  0.70   2.80      0.400
  0.80   2.04      0.533
  0.90   1.49      0.720
  0.95   1.26      0.844
  （第一步的小银行，s = 0.6：R* = 3.99。这个玩具里，银行承诺的「提前取，付 1」太慷慨，提前变现的损失又大，所以只有到期收益高到 4，才不会被挤兑；数字不要当成现实，要看的是：s 越大，R* 越低。）

二、资产比较好变现的银行（s = 0.9），存款人只收到带噪声的信号：门槛 x*，以及真实收益 R 不同时，不急的人里去取的比例
  噪声 sigma    门槛 x*      R = 1.1、1.3、1.5、1.7、1.9 时，不急的人里，去取的比例
     0.02        1.486       1.000、1.000、0.240、0.000、0.000
     0.05        1.473       1.000、1.000、0.293、0.000、0.000
     0.10        1.451       1.000、0.934、0.312、0.006、0.000
  对照：噪声趋于 0 时的 R* = 1.495；噪声越小，门槛，越接近它。
  没有噪声时（第一步），R = 1.7 的银行，也有「全部去取」这个均衡；有噪声时，只有 R 低于门槛附近，才有人去取：均衡唯一，由基本面决定。

# 第五步：谁看见谁。第二步里，每个人都能看到全体的取钱比例。现实里，你只看得到身边的人：同事、邻居、群里的朋友。
# 1000 个存款人，放在一个社交网络上；每个人看得到 k 个「邻居」有没有取钱。急用钱的人（25%）第 0 轮一定去取；
# 不急的人，如果看到的邻居里，取钱的比例，高于自己的临界值（信念 R_i 在 [1.35, 1.45] 上均匀分布），下一轮就去取（取了就不回头）。
def make_network(kind, n=1000, k=8, rewire=0.05, rng=None):
    """返回每个人的邻居列表。random：随机网络（每人平均 k 个邻居）；ring：先排成一圈，每人和左右各 k/2 个人相连（朋友的朋友也是朋友），再把一部分连接，随机改接到别处（rewire 是比例）"""
    nbrs = [set() for _ in range(n)]
    if kind == "random":
        for i in range(n):
            while len(nbrs[i]) < k // 2:
                j = int(rng.integers(n))
                if j != i: nbrs[i].add(j); nbrs[j].add(i)
    else:
        for i in range(n):
            for d in range(1, k // 2 + 1): nbrs[i].add((i + d) % n); nbrs[(i + d) % n].add(i)
        for i in range(n):
            for j in list(nbrs[i]):
                if j > i and rng.random() < rewire:
                    new = int(rng.integers(n))
                    if new != i and new not in nbrs[i]: nbrs[i].discard(j); nbrs[j].discard(i); nbrs[i].add(new); nbrs[new].add(i)
    return [np.array(sorted(s)) for s in nbrs]

def cascade(nbrs, thr, early, seeds, rng):
    """返回最后取钱的比例，和用了几轮"""
    n = len(nbrs); out = early.copy(); out[seeds] = True            # 第 0 轮：急用钱的，加上被吓跑的「种子」
    for rnd in range(1, 100):
        seen = np.array([out[nb].mean() if len(nb) else 0.0 for nb in nbrs])      # 每个人看到的，邻居里取钱的比例
        new = (~out) & (seen > thr)
        if not new.any(): return out.mean(), rnd - 1
        out = out | new
    return out.mean(), 99

def experiment(kind, k, rbar, seeds_n=0, reps=20, w=0.05, n=1000, rewire=0.05):
    """reps 个不同的网络，每个网络上，银行的真实到期收益是 rbar（存款人的信念 R_i 在 [rbar - w, rbar + w] 上均匀分布）。
    返回：最后取钱比例的平均，和「把银行拖垮（取钱比例 > 60%）」的网络所占的比例"""
    rng = np.random.default_rng(78); res = []
    for _ in range(reps):
        nbrs = make_network(kind, n, k, rewire, rng)
        early = rng.random(n) < EARLY
        r = rbar - w + 2 * w * rng.random(n); thr = (r - 1) / (r / S_LIQ - 1)
        seeds = rng.choice(np.flatnonzero(~early), seeds_n, replace=False) if seeds_n else np.array([], dtype=int)
        res.append(cascade(nbrs, thr, early, seeds, rng)[0])
    return float(np.mean(res)), float(np.mean(np.array(res) > 0.6))

print("一、平静时（没有人先被吓跑）：每个人看到 k 个邻居，被局部的偶然波动，拖垮的网络占多少？（每格 20 个随机网络）")
print("  银行真实到期收益 R：      1.4（f* = 30.0%）        1.6（f* = 36.0%）        2.0（f* = 42.9%）")
print("  看到的邻居数 k      随机网络   小世界      随机网络   小世界      随机网络   小世界")
collapse = {}
for k in (8, 40, 100, 300, 600):
    row = []
    for rbar in (1.4, 1.6, 2.0):
        a, b = experiment("random", k, rbar)[1], experiment("ring", k, rbar)[1]; collapse[(k, rbar)] = (a, b); row += [a, b]
    print(f"  {k:>5}              " + "      ".join(f"{x:5.0%}" for x in row))
print("（「拖垮」= 最后取钱的比例 > 60%。小世界 = 先排成一圈、每人和左右邻居相连，再把 5% 的连接随机改接；随机网络里，朋友的朋友，未必是朋友。）")

print("\n二、R = 1.6，每人看到 k = 300 个邻居：平静时没事。如果一开始，有 m 个不急的人（占 1000 人里的 m ‰）被吓跑，会怎样？")
print("   m      拖垮的网络占多少      最后取钱比例的平均")
seed_res = {}
for m in (0, 20, 50, 100, 150):
    f, c = experiment("random", 300, 1.6, seeds_n=m); seed_res[m] = (f, c)
    print(f"  {m:>3}        {c:5.0%}               {f:6.3f}")

一、平静时（没有人先被吓跑）：每个人看到 k 个邻居，被局部的偶然波动，拖垮的网络占多少？（每格 20 个随机网络）
  银行真实到期收益 R：      1.4（f* = 30.0%）        1.6（f* = 36.0%）        2.0（f* = 42.9%）
  看到的邻居数 k      随机网络   小世界      随机网络   小世界      随机网络   小世界
      8               100%       100%       100%       100%       100%       100%
     40               100%       100%       100%       100%        20%        90%
    100               100%       100%        75%        70%         0%         0%
    300               100%        55%         0%         0%         0%         0%
    600                55%        15%         0%         0%         0%         0%
（「拖垮」= 最后取钱的比例 > 60%。小世界 = 先排成一圈、每人和左右邻居相连，再把 5% 的连接随机改接；随机网络里，朋友的朋友，未必是朋友。）

二、R = 1.6，每人看到 k = 300 个邻居：平静时没事。如果一开始，有 m 个不急的人（占 1000 人里的 m ‰）被吓跑，会怎样？
   m      拖垮的网络占多少      最后取钱比例的平均
    0           0%                0.252
   20          10%                0.344
   50          85%                0.892
  100         100%                1.000
  150         100%                1.000

# 第五步：办法。同一个小银行（N = 100，s = 0.6，R = 1.4，急用钱的 25%），看几种办法，能不能把「坏的均衡」去掉，代价是什么。
print("一、不同的办法，对「银行能承受的取钱比例」的影响（这个比例，超过了，坏均衡就出现）")
print("  办法                                    银行能承受的取钱比例      坏均衡还在吗")
print(f"  什么也不做                                  {threshold():6.1%}            在（只比正常的 25% 多 {threshold() - EARLY:.1%}）")

# 1. 存款保险（全额）：政府保证，不管别人怎么做，每个人该拿的都拿到。
print("  全额存款保险                                  不再取决于别人            不在（在这个模型里）")

# 2. 有限额的存款保险：每个账户，保到 cap；超过的部分，没有保险，这部分的存款人，才会参与挤兑
sigma, mu = 2.0, 0.0                                              # 账户余额 ~ 对数正态；平均余额 = e^(mu + sigma²/2)
mean_bal = np.exp(mu + sigma ** 2 / 2)
def uninsured_share(cap):
    """没有被保险保住的余额，占全部余额的比例：E[(X - cap)+] / E[X]"""
    d2 = (mu - np.log(cap)) / sigma; d1 = d2 + sigma
    return PHI(d1) - cap / mean_bal * PHI(d2)
u_star = (threshold() - EARLY) / (1 - EARLY)
print(f"\n二、有限额的存款保险：保险保到 cap（账户余额服从对数正态，平均余额 {mean_bal:.1f}，大账户很多）。没保住的余额占 u；")
print(f"   最坏的情形：没保住的余额全去取，总取钱比例 = 0.25 + 0.75 × u。坏均衡可能出现，当且仅当 0.25 + 0.75 × u > f* = {threshold():.3f}，也就是 u > {u_star:.1%}")
print("   保险的限额 cap        没保住的余额占比 u     最坏的取钱比例    坏均衡还可能出现吗")
for cap in (1, 5, 20, 50, 200, 1000):
    u = uninsured_share(cap); worst = EARLY + (1 - EARLY) * u
    print(f"   {cap:>5}（平均余额的 {cap / mean_bal:5.2f} 倍）      {u:6.1%}            {worst:6.3f}         {'可能' if worst > threshold() else '不可能'}")

# 3. 暂停兑付：银行宣布，第 1 期，最多只付给 K 比例的人（K 略低于 f*）。
print("\n三、暂停兑付：第 1 期，最多只付给 K 比例的存款人，其余的，等到第 2 期。急用钱的比例，其实是随机的（15% 到 35% 均匀分布）")
rng = np.random.default_rng(78); early_draw = rng.uniform(0.15, 0.35, 200000)
print("      K       等下去（f = K）比去取（1）好多少     急用钱，却没拿到钱的存款人：占全部存款人的比例")
for K in (0.28, 0.29, 0.30, 0.32):
    print(f"   {K:.2f}            {wait_value(K) - 1:+.3f}                              {np.mean(np.maximum(early_draw - K, 0)):.2%}")
print(f"   （不暂停、又发生了挤兑：每个人平均只拿到 0.6；而 K = 0.29 时，平均有 {np.mean(np.maximum(early_draw - 0.29, 0)):.2%} 的存款人，在急用钱的时候，拿不到钱。）")

# 4. 最后贷款人：央行愿意按 s' 的比例，替银行把资产「变现」（按一个比市场价更高的价格，借出钱来，银行不用甩卖）
print("\n四、最后贷款人：央行愿意按每 1 份资产 s' 的价格，借钱给银行（银行不用以 0.6 甩卖）：")
print("   s'      银行能承受的取钱比例 f*     坏均衡")
for sp in (0.6, 0.7, 0.8, 0.9, 1.0):
    fs = threshold(R_MAT, sp)
    print(f"  {sp:.1f}            {min(fs, 1.0):6.1%}              " + ("还在" if fs < 1 - 1e-9 else "不在（资产随时能按 1 变现）"))

一、不同的办法，对「银行能承受的取钱比例」的影响（这个比例，超过了，坏均衡就出现）
  办法                                    银行能承受的取钱比例      坏均衡还在吗
  什么也不做                                   30.0%            在（只比正常的 25% 多 5.0%）
  全额存款保险                                  不再取决于别人            不在（在这个模型里）

二、有限额的存款保险：保险保到 cap（账户余额服从对数正态，平均余额 7.4，大账户很多）。没保住的余额占 u；
   最坏的情形：没保住的余额全去取，总取钱比例 = 0.25 + 0.75 × u。坏均衡可能出现，当且仅当 0.25 + 0.75 × u > f* = 0.300，也就是 u > 6.7%
   保险的限额 cap        没保住的余额占比 u     最坏的取钱比例    坏均衡还可能出现吗
       1（平均余额的  0.14 倍）       91.0%             0.932         可能
       5（平均余额的  0.68 倍）       74.2%             0.806         可能
      20（平均余额的  2.71 倍）       51.1%             0.633         可能
      50（平均余额的  6.77 倍）       34.7%             0.510         可能
     200（平均余额的 27.07 倍）       14.9%             0.362         可能
    1000（平均余额的 135.34 倍）        3.6%             0.277         不可能

三、暂停兑付：第 1 期，最多只付给 K 比例的存款人，其余的，等到第 2 期。急用钱的比例，其实是随机的（15% 到 35% 均匀分布）
      K       等下去（f = K）比去取（1）好多少     急用钱，却没拿到钱的存款人：占全部存款人的比例
   0.28            +0.037                              1.23%
   0.29            +0.019                              0.90%
   0.30            +0.000                              0.63%
   0.32            -0.039                              0.23%
   （不暂停、又发生了挤兑：每个人平均只拿到 0.6；而 K = 0.29 时，平均有 0.90% 的存款人，在急用钱的时候，拿不到钱。）

四、最后贷款人：央行愿意按每 1 份资产 s' 的价格，借钱给银行（银行不用以 0.6 甩卖）：
   s'      银行能承受的取钱比例 f*     坏均衡
  0.6             30.0%              还在
  0.7             40.0%              还在
  0.8             53.3%              还在
  0.9             72.0%              还在
  1.0            100.0%              不在（资产随时能按 1 变现）