实验 79 用真实数据检验有效市场：随机游走

import io, math, urllib.request, zipfile
import numpy as np

# 数据：Kenneth French 数据库（Fama/French 三因子，月度和日度；CRSP 的美国股市，市值加权）。1927 年 1 月到 2025 年 12 月，和第 38 讲一样。
# 代码会自己下载（需要联网）。数据库偶尔修订，小数位可能有极小差别。
BASE = "https://mba.tuck.dartmouth.edu/pages/faculty/ken.french/ftp/"

def load_french(zip_name, csv_name, ncols, date_len, first, last):
    raw = urllib.request.urlopen(BASE + zip_name, timeout=60).read()
    text = zipfile.ZipFile(io.BytesIO(raw)).read(csv_name).decode("latin-1")
    rows = []
    for line in text.splitlines():
        p = [x.strip() for x in line.split(",")]
        if len(p) == ncols and len(p[0]) == date_len and p[0].isdigit() and first <= int(p[0]) <= last:
            rows.append((int(p[0]), *map(float, p[1:])))
    return rows

monthly = load_french("F-F_Research_Data_Factors_CSV.zip", "F-F_Research_Data_Factors.csv", 5, 6, 192701, 202512)
daily = load_french("F-F_Research_Data_Factors_daily_CSV.zip", "F-F_Research_Data_Factors_daily.csv", 5, 8, 19270101, 20251231)
RM = np.array([r[1] + r[4] for r in monthly]) / 100                  # 月度：市场总收益 = 超额收益 + 无风险利率
RFM = np.array([r[4] for r in monthly]) / 100
RD = np.array([r[1] + r[4] for r in daily]) / 100                    # 日度
RFD = np.array([r[4] for r in daily]) / 100
DATES_M = np.array([r[0] for r in monthly]); DATES_D = np.array([r[0] for r in daily])
print(f"月度：{monthly[0][0]} 至 {monthly[-1][0]}，{len(RM)} 个月；月平均 {RM.mean():.2%}，月标准差 {RM.std(ddof=1):.2%}")
print(f"日度：{daily[0][0]} 至 {daily[-1][0]}，{len(RD)} 个交易日；日平均 {RD.mean():.3%}，日标准差 {RD.std(ddof=1):.2%}")
print(f"日度里，最坏的一天 {RD.min():.1%}（{DATES_D[int(np.argmin(RD))]}），最好的一天 {RD.max():.1%}（{DATES_D[int(np.argmax(RD))]}）")

# 一、"随机游走"，是在说什么？一种说法：每天（月）的收益，是互相独立的：昨天发生了什么，对今天，毫无影响。
# 我们拿真实的收益，把顺序打乱：打乱以后，每个收益都还在，分布完全一样，只是顺序，没有任何规律。
def acf(x, k):
    x = x - x.mean(); return float((x[k:] * x[:-k]).sum() / (x * x).sum())

def kurtosis(x):
    x = x - x.mean(); return float((x ** 4).mean() / (x ** 2).mean() ** 2)

rng = np.random.default_rng(79)
shuffles = [rng.permutation(RD) for _ in range(500)]
print("\n一、日度收益：真实的顺序，和打乱顺序（500 次）之后：")
print(f"  峰度（正态分布是 3）：真实 {kurtosis(RD):.1f}；打乱之后一样（分布没有变）：{kurtosis(shuffles[0]):.1f}")
print("  自相关（如果收益互相独立，应该在 0 附近；±2/√n 是随机波动的范围）：")
band = 2 / math.sqrt(len(RD))
print(f"    ±{band:.3f}：" + "；".join(f"滞后 {k}：真实 {acf(RD, k):+.3f}" for k in (1, 2, 3, 5)))
print("  收益的绝对值（衡量「波动」）的自相关：")
for k in (1, 2, 5, 10, 20):
    sh = [acf(np.abs(s), k) for s in shuffles[:200]]
    print(f"    滞后 {k:>2}：真实 {acf(np.abs(RD), k):+.3f}；打乱之后的 95% 范围 {np.quantile(sh, 0.025):+.3f} 到 {np.quantile(sh, 0.975):+.3f}")
print("  → 收益的方向，几乎没有自相关；可是「波动」，有很强的自相关：大波动之后，还是大波动。")

月度：192701 至 202512，1188 个月；月平均 0.96%，月标准差 5.31%
日度：19270103 至 20251231，26001 个交易日；日平均 0.043%，日标准差 1.08%
日度里，最坏的一天 -17.4%（19871019），最好的一天 15.7%（19330315）

一、日度收益：真实的顺序，和打乱顺序（500 次）之后：
  峰度（正态分布是 3）：真实 19.1；打乱之后一样（分布没有变）：19.1
  自相关（如果收益互相独立，应该在 0 附近；±2/√n 是随机波动的范围）：
    ±0.012：滞后 1：真实 +0.046；滞后 2：真实 -0.025；滞后 3：真实 -0.001；滞后 5：真实 +0.006
  收益的绝对值（衡量「波动」）的自相关：
    滞后  1：真实 +0.299；打乱之后的 95% 范围 -0.012 到 +0.012
    滞后  2：真实 +0.332；打乱之后的 95% 范围 -0.011 到 +0.012
    滞后  5：真实 +0.309；打乱之后的 95% 范围 -0.011 到 +0.011
    滞后 10：真实 +0.256；打乱之后的 95% 范围 -0.011 到 +0.013
    滞后 20：真实 +0.225；打乱之后的 95% 范围 -0.012 到 +0.012
  → 收益的方向，几乎没有自相关；可是「波动」，有很强的自相关：大波动之后，还是大波动。

# 第二步：方差比检验（Lo 和 MacKinlay 1988 年，Review of Financial Studies，1 卷 1 期，41–66 页）。
# 想法：如果每期的收益互相独立，q 期的收益的方差，应该正好是 1 期的方差的 q 倍。VR(q) = Var(q 期收益) ÷ (q × Var(1 期收益)) 应该约等于 1。
#   VR(q) > 1：收益有「动量」（涨了还涨）；VR(q) < 1：收益有「均值回归」（涨了会跌回来）。
def variance_ratio(r, q):
    """r：每期的对数收益（T 个）。返回 VR(q)，同方差下的 z，异方差稳健的 z*（都是标准正态分布，在「收益互相独立」的原假设下）"""
    r = np.asarray(r); T = len(r); mu = r.mean()
    a = ((r - mu) ** 2).sum() / (T - 1)                                     # 1 期方差（无偏）
    rq = np.convolve(r, np.ones(q), mode="valid")                            # 重叠的 q 期收益，共 T - q + 1 个
    m = q * (T - q + 1) * (1 - q / T)
    c = ((rq - q * mu) ** 2).sum() / m                                       # q 期方差，除以 q 之前
    vr = c / a
    z = (vr - 1) * math.sqrt(T) / math.sqrt(2 * (2 * q - 1) * (q - 1) / (3 * q))     # 同方差的标准误
    d = (r - mu) ** 2; denom = d.sum() ** 2
    theta = sum((2 * (q - j) / q) ** 2 * T * (d[j:] * d[:-j]).sum() / denom for j in range(1, q))   # 异方差稳健的标准误
    z_star = (vr - 1) * math.sqrt(T) / math.sqrt(theta)
    return vr, z, z_star

# 先检验这个检验本身：用「一定是独立的」数据，看它会不会冤枉好人。5% 水平：|z| > 1.96 就拒绝。
def garch_series(T, rng, omega=1e-6, alpha=0.10, beta=0.88):
    """波动有聚集（大波动之后，还是大波动），但是收益的方向，完全不可预测"""
    r = np.empty(T); var = omega / (1 - alpha - beta)
    for t in range(T):
        r[t] = math.sqrt(var) * rng.standard_normal(); var = omega + alpha * r[t] ** 2 + beta * var
    return r

rng = np.random.default_rng(79); q = 12; T = 1188; reps = 1000
rej = {"独立、同方差": [0, 0], "方向不可预测，波动聚集（GARCH）": [0, 0]}
for rep in range(reps):
    for name, x in (("独立、同方差", rng.standard_normal(T)), ("方向不可预测，波动聚集（GARCH）", garch_series(T, rng))):
        _, z, zs = variance_ratio(x, q); rej[name][0] += abs(z) > 1.96; rej[name][1] += abs(zs) > 1.96
print(f"一、检验会不会冤枉好人？用「方向不可预测」的数据，T = {T}，q = {q}，{reps} 次，名义上 5% 的拒绝率：")
for name, (a, b) in rej.items(): print(f"  {name}：同方差的 z 拒绝 {a / reps:.1%}，稳健的 z* 拒绝 {b / reps:.1%}")

def report(label, r, qs):
    print(f"  {label}（{len(r)} 个）：" + "   ".join(f"q={qq}: VR {v:.2f} (z {z:+.1f}, z* {zs:+.1f})" for qq in qs for v, z, zs in [variance_ratio(r, qq)]))

print("\n二、真实的数据（对数收益）。VR > 1：涨了还涨；VR < 1：涨了会回来。（z：同方差；z*：异方差稳健；|z| > 1.96，是 5% 水平上的显著）")
LM, LD = np.log1p(RM), np.log1p(RD)
print("月度，1927–2025：")
report("全部", LM, (2, 3, 6, 12, 24, 36))
for lo, hi in ((192701, 196212), (196301, 199212), (199301, 202512)):
    sel = (DATES_M >= lo) & (DATES_M <= hi); report(f"  {lo}–{hi}", LM[sel], (2, 6, 12, 24))
print("日度，1927–2025：")
report("全部", LD, (2, 5, 10, 20))
for lo, hi in ((19270101, 19621231), (19630101, 19921231), (19930101, 20251231)):
    sel = (DATES_D >= lo) & (DATES_D <= hi); report(f"  {lo // 10000}–{hi // 10000}", LD[sel], (2, 5, 10, 20))

# 三、游程检验（Wald–Wolfowitz）：把每个月，记成涨（+）或者跌（-）。连在一起的相同符号，叫一个「游程」。
#   如果涨跌互相独立，游程的个数，大约是 2 n₊ n₋ ÷ n + 1。游程太少：同一个方向，连得太久（动量）；太多：来回切换（反转）。
def runs_test(x):
    s = x > 0; n1, n2 = int(s.sum()), int((~s).sum()); n = n1 + n2
    runs = 1 + int((s[1:] != s[:-1]).sum())
    mean = 2 * n1 * n2 / n + 1; var = 2 * n1 * n2 * (2 * n1 * n2 - n) / (n ** 2 * (n - 1))
    return runs, mean, (runs - mean) / math.sqrt(var)
print("\n三、游程检验（涨 / 跌的符号）：")
for label, x in (("月度", RM - RFM), ("日度", RD - RFD)):
    runs, mean, z = runs_test(x); print(f"  {label}：游程 {runs} 个，独立时的期望 {mean:.1f} 个，z = {z:+.2f}")

一、检验会不会冤枉好人？用「方向不可预测」的数据，T = 1188，q = 12，1000 次，名义上 5% 的拒绝率：
  独立、同方差：同方差的 z 拒绝 5.1%，稳健的 z* 拒绝 5.1%
  方向不可预测，波动聚集（GARCH）：同方差的 z 拒绝 11.6%，稳健的 z* 拒绝 5.2%

二、真实的数据（对数收益）。VR > 1：涨了还涨；VR < 1：涨了会回来。（z：同方差；z*：异方差稳健；|z| > 1.96，是 5% 水平上的显著）
月度，1927–2025：
  全部（1188 个）：q=2: VR 1.09 (z +3.0, z* +1.8)   q=3: VR 1.10 (z +2.4, z* +1.4)   q=6: VR 1.09 (z +1.2, z* +0.7)   q=12: VR 1.19 (z +1.7, z* +1.1)   q=24: VR 1.19 (z +1.2, z* +0.8)   q=36: VR 1.10 (z +0.5, z* +0.3)
    192701–196212（432 个）：q=2: VR 1.12 (z +2.6, z* +1.5)   q=6: VR 1.12 (z +1.0, z* +0.6)   q=12: VR 1.32 (z +1.8, z* +1.1)   q=24: VR 1.43 (z +1.6, z* +1.0)
    196301–199212（360 个）：q=2: VR 1.07 (z +1.3, z* +1.1)   q=6: VR 1.08 (z +0.6, z* +0.6)   q=12: VR 1.02 (z +0.1, z* +0.1)   q=24: VR 0.87 (z -0.5, z* -0.4)
    199301–202512（396 个）：q=2: VR 1.03 (z +0.7, z* +0.5)   q=6: VR 1.08 (z +0.6, z* +0.5)   q=12: VR 1.19 (z +1.0, z* +0.8)   q=24: VR 1.29 (z +1.1, z* +0.9)
日度，1927–2025：
  全部（26001 个）：q=2: VR 1.05 (z +7.7, z* +3.2)   q=5: VR 1.06 (z +4.1, z* +1.7)   q=10: VR 1.06 (z +3.1, z* +1.3)   q=20: VR 1.12 (z +3.8, z* +1.7)
    1927–1962（10145 个）：q=2: VR 1.08 (z +8.5, z* +3.4)   q=5: VR 1.10 (z +4.6, z* +1.9)   q=10: VR 1.15 (z +4.5, z* +2.0)   q=20: VR 1.27 (z +5.4, z* +2.5)
    1963–1992（7549 个）：q=2: VR 1.20 (z +17.0, z* +8.0)   q=5: VR 1.31 (z +12.5, z* +5.1)   q=10: VR 1.38 (z +9.9, z* +4.1)   q=20: VR 1.44 (z +7.6, z* +3.5)
    1993–2025（8307 个）：q=2: VR 0.93 (z -6.0, z* -2.7)   q=5: VR 0.88 (z -4.9, z* -2.2)   q=10: VR 0.81 (z -5.1, z* -2.3)   q=20: VR 0.80 (z -3.7, z* -1.7)

三、游程检验（涨 / 跌的符号）：
  月度：游程 527 个，独立时的期望 567.8 个，z = -2.48
  日度：游程 11895 个，独立时的期望 12920.3 个，z = -12.80

# 第三步：技术分析的规则，能不能赚钱？一条规则，我们在第 38 讲试过（上月涨就持股，上月跌就持有国库券）。现在，一次试 22 条，再问：
# 「挑出来最好的那条」，是本事，还是运气？
# 规则的世界：每个月底，看信号；信号是「是」，下个月持有股票；是「否」，下个月持有国库券（无风险利率）。
#   移动平均规则 MA(k)：价格高于最近 k 个月月末价格的平均，k = 3, 4, ..., 12（10 条）
#   动量规则 MOM(k)：最近 k 个月累计收益大于 0，k = 1, 2, ..., 12（12 条；MOM(1) 就是第 38 讲那条）
RULES = [("MA", k) for k in range(3, 13)] + [("MOM", k) for k in range(1, 13)]
WARM = 12                                                              # 前 12 个月，用来算信号；从 1928 年 1 月开始，计入成绩

def positions(r, rule):
    """第 t 个月月底的信号 -> 第 t + 1 个月持有股票（1）还是国库券（0）。返回长度 T - WARM 的数组，对应第 WARM, WARM + 1, ..., T - 1 个月"""
    kind, k = rule; T = len(r); price = np.concatenate([[1.0], np.cumprod(1 + r)])        # price[t + 1] = 第 t 个月月底的价格
    out = np.empty(T - WARM, dtype=bool)
    for t in range(WARM, T):                                                               # 用到第 t - 1 个月月底为止的信息，决定第 t 个月的持仓
        end = t                                                                             # price[end] = 第 t - 1 个月月底的价格
        out[t - WARM] = price[end] > price[end - k + 1:end + 1].mean() if kind == "MA" else price[end] > price[end - k]
    return out

def strategy_returns(r, rf, pos, cost):
    """每个月的收益：持股就拿 r，否则拿 rf；每次换仓（股票 <-> 国库券），扣掉 cost（占财富的比例）"""
    r, rf = r[WARM:], rf[WARM:]
    gross = np.where(pos, r, rf)
    switch = np.concatenate([[False], pos[1:] != pos[:-1]])
    return (1 + gross) * np.where(switch, 1 - cost, 1.0) - 1

def sharpe(x, rf):
    ex = x - rf; return ex.mean() / ex.std(ddof=1) * math.sqrt(12)

def rule_table(r, rf, cost):
    """每条规则相对买入持有的夏普之差，和换仓的次数"""
    bh = sharpe(r[WARM:], rf[WARM:]); out = []
    for rule in RULES:
        pos = positions(r, rule); x = strategy_returns(r, rf, pos, cost)
        out.append((sharpe(x, rf[WARM:]) - bh, int((pos[1:] != pos[:-1]).sum()), float(np.prod(1 + x))))
    return bh, out

bh0, tab0 = rule_table(RM, RFM, 0.0)
print(f"一、22 条规则，1928–2025（{len(RM) - WARM} 个月），不计交易成本：买入持有的夏普比率 {bh0:.3f}，1 元变成 {np.prod(1 + RM[WARM:]):,.0f} 元")
print("  规则       夏普之差（规则 − 买入持有）   换仓次数    1 元变成")
for rule, (d, sw, w) in zip(RULES, tab0):
    print(f"  {rule[0]}({rule[1]:>2})        {d:+.3f}                 {sw:>4}      {w:>8,.0f}")
diffs0 = np.array([d for d, _, _ in tab0]); best0 = int(np.argmax(diffs0))
print(f"  22 条里，夏普比买入持有高的有 {int((diffs0 > 0).sum())} 条；最好的是 {RULES[best0][0]}({RULES[best0][1]})，高 {diffs0[best0]:+.3f}")

print("\n二、交易成本：每次换仓，扣掉财富的 c。夏普比买入持有高的规则有几条？最好的那条还高多少？")
costs = (0.0, 0.001, 0.0025, 0.005, 0.01)
tabs = {c: rule_table(RM, RFM, c)[1] for c in costs}
for c in costs:
    d = np.array([x[0] for x in tabs[c]]); i = int(np.argmax(d))
    print(f"  c = {c:.2%}：有 {int((d > 0).sum()):>2} 条规则的夏普高于买入持有；最好的是 {RULES[i][0]}({RULES[i][1]})，高 {d[i]:+.3f}；规则的平均夏普之差 {d.mean():+.3f}")

# 三、「挑出来最好的」是不是本事？用排列检验：把月份的顺序打乱（收益和国库券利率一起打乱），任何「顺序里的规律」都没了；
# 在每一个打乱之后的数据上，把 22 条规则都试一遍，记下「最好的那条的夏普之差」。看真实数据里，最好的那条，在这些「随机的最好」里，排第几。
# 但是，打乱顺序，也抹掉了「波动聚集」。所以，再做第二个对照：保留每个月的绝对大小（所以大波动还是连在一起），只把涨跌的符号，随机地重新安排
# （涨的概率，取到让平均收益和真实一样）：方向完全不可预测，波动聚集。
rng = np.random.default_rng(79); n_perm = 1000
i_mom1 = RULES.index(("MOM", 1)); best_shuf = np.empty(n_perm); mom1_shuf = np.empty(n_perm)
for i in range(n_perm):
    p = rng.permutation(len(RM)); d = np.array([x[0] for x in rule_table(RM[p], RFM[p], 0.0)[1]]); best_shuf[i] = d.max(); mom1_shuf[i] = d[i_mom1]
p_up = (RM.mean() / np.abs(RM).mean() + 1) / 2
n_sign = 500; best_sign = np.empty(n_sign)
for i in range(n_sign):
    fake = np.abs(RM) * np.where(rng.random(len(RM)) < p_up, 1.0, -1.0); best_sign[i] = max(x[0] for x in rule_table(fake, RFM, 0.0)[1])
print(f"\n三、「挑最好的」，是本事，还是运气？")
print(f"  只看 MOM(1)（事先选好的一条）：真实 {diffs0[i_mom1]:+.3f}；打乱月份顺序 {n_perm} 次，随机地不小于它的比例 = {(mom1_shuf >= diffs0[i_mom1]).mean():.3f}")
print(f"  22 条里挑最好的（{RULES[best0][0]}({RULES[best0][1]})，{diffs0[best0]:+.3f}）：")
print(f"    对照一，打乱顺序（{n_perm} 次）：「随机的最好」中位数 {np.median(best_shuf):+.3f}，95% 分位数 {np.quantile(best_shuf, 0.95):+.3f}，不小于真实的比例 {(best_shuf >= diffs0[best0]).mean():.3f}")
print(f"    对照二，保留波动聚集、符号随机（{n_sign} 次）：中位数 {np.median(best_sign):+.3f}，95% 分位数 {np.quantile(best_sign, 0.95):+.3f}，不小于真实的比例 {(best_sign >= diffs0[best0]).mean():.3f}")

一、22 条规则，1928–2025（1176 个月），不计交易成本：买入持有的夏普比率 0.437，1 元变成 12,031 元
  规则       夏普之差（规则 − 买入持有）   换仓次数    1 元变成
  MA( 3)        +0.001                  392         2,473
  MA( 4)        -0.033                  304         1,804
  MA( 5)        +0.024                  260         3,435
  MA( 6)        +0.068                  214         6,141
  MA( 7)        +0.084                  192         5,816
  MA( 8)        +0.058                  172         4,436
  MA( 9)        +0.086                  162         6,529
  MA(10)        +0.107                  144         8,523
  MA(11)        +0.127                  134        10,803
  MA(12)        +0.110                  130         9,040
  MOM( 1)        +0.053                  512         5,281
  MOM( 2)        -0.100                  354           828
  MOM( 3)        +0.011                  252         3,361
  MOM( 4)        +0.066                  200         4,427
  MOM( 5)        +0.090                  166         7,152
  MOM( 6)        +0.074                  146         5,842
  MOM( 7)        +0.121                  124         9,500
  MOM( 8)        +0.109                  116        11,998
  MOM( 9)        +0.103                  108        12,006
  MOM(10)        +0.170                   88        26,245
  MOM(11)        +0.113                   90        14,031
  MOM(12)        +0.119                   76        12,455
  22 条里，夏普比买入持有高的有 20 条；最好的是 MOM(10)，高 +0.170

二、交易成本：每次换仓，扣掉财富的 c。夏普比买入持有高的规则有几条？最好的那条还高多少？
  c = 0.00%：有 20 条规则的夏普高于买入持有；最好的是 MOM(10)，高 +0.170；规则的平均夏普之差 +0.071
  c = 0.10%：有 18 条规则的夏普高于买入持有；最好的是 MOM(10)，高 +0.163；规则的平均夏普之差 +0.055
  c = 0.25%：有 16 条规则的夏普高于买入持有；最好的是 MOM(10)，高 +0.153；规则的平均夏普之差 +0.032
  c = 0.50%：有 13 条规则的夏普高于买入持有；最好的是 MOM(10)，高 +0.136；规则的平均夏普之差 -0.008
  c = 1.00%：有  8 条规则的夏普高于买入持有；最好的是 MOM(10)，高 +0.101；规则的平均夏普之差 -0.088

三、「挑最好的」，是本事，还是运气？
  只看 MOM(1)（事先选好的一条）：真实 +0.053；打乱月份顺序 1000 次，随机地不小于它的比例 = 0.010
  22 条里挑最好的（MOM(10)，+0.170）：
    对照一，打乱顺序（1000 次）：「随机的最好」中位数 -0.018，95% 分位数 +0.065，不小于真实的比例 0.000
    对照二，保留波动聚集、符号随机（500 次）：中位数 -0.018，95% 分位数 +0.075，不小于真实的比例 0.002

# 第四步：这个「好处」，到底是什么？稳不稳？样本外呢？
bh_r, bh_rf = RM[WARM:], RFM[WARM:]; dates = DATES_M[WARM:]
def max_drawdown(x):
    w = np.cumprod(1 + x); return float((w / np.maximum.accumulate(w) - 1).min())

pos10 = positions(RM, ("MOM", 10)); x10 = strategy_returns(RM, RFM, pos10, 0.0)
print("一、拆开看 MOM(10)（在 22 条里最好的那条），不计成本：")
print(f"  {'':<14}  年均超额收益   年化波动    夏普    最大回撤    最差的一个月   在股市里的时间")
print(f"  买入持有        {12 * (bh_r - bh_rf).mean():8.2%}    {bh_r.std(ddof=1) * math.sqrt(12):8.2%}   {sharpe(bh_r, bh_rf):5.2f}   {max_drawdown(bh_r):8.1%}    {bh_r.min():8.1%}        100%")
print(f"  MOM(10)         {12 * (x10 - bh_rf).mean():8.2%}    {x10.std(ddof=1) * math.sqrt(12):8.2%}   {sharpe(x10, bh_rf):5.2f}   {max_drawdown(x10):8.1%}    {x10.min():8.1%}       {pos10.mean():4.0%}")
print("  → 平均的超额收益几乎一样；夏普高，是因为波动小、回撤浅：躲开了大熊市。")

print("\n二、稳不稳？分三段看，所有 22 条规则的平均夏普之差（不计成本），和 MOM(10)：")
pos_all = {rule: positions(RM, rule) for rule in RULES}
for lo, hi in ((192801, 196212), (196301, 199212), (199301, 202512)):
    sel = np.flatnonzero((dates >= lo) & (dates <= hi)); a, b = sel[0], sel[-1] + 1
    ds = []
    for rule in RULES:
        x = strategy_returns(RM, RFM, pos_all[rule], 0.0); ds.append(sharpe(x[a:b], bh_rf[a:b]) - sharpe(bh_r[a:b], bh_rf[a:b]))
    print(f"  {lo}–{hi}（{b - a} 个月）：22 条规则里 {sum(d > 0 for d in ds)} 条夏普高于买入持有，平均之差 {np.mean(ds):+.3f}；MOM(10) {ds[RULES.index(('MOM', 10))]:+.3f}")

# 三、样本外：每年 1 月，用过去 20 年（240 个月）的成绩，在 22 条规则里，选夏普最高的那条，用它做接下来的 12 个月。
# 这样，每一个月的持仓，都只用到了「当时已经知道」的信息。
def walk_forward(cost, train=240, step=12):
    out = []; n = len(RM) - WARM
    series = {rule: strategy_returns(RM, RFM, pos_all[rule], cost) for rule in RULES}
    for s0 in range(train, n, step):
        best = max(RULES, key=lambda rule: sharpe(series[rule][s0 - train:s0], bh_rf[s0 - train:s0]))
        out.append((s0, best, series[best][s0:s0 + step]))
    return out

print("\n三、样本外：每年用过去 20 年的成绩，在 22 条规则里选最好的，用一年：")
for cost in (0.0, 0.0025, 0.005):
    wf = walk_forward(cost); xs = np.concatenate([o[2] for o in wf]); s0 = wf[0][0]; L = len(xs)
    r_, f_ = bh_r[s0:s0 + L], bh_rf[s0:s0 + L]
    print(f"  c = {cost:.2%}：{dates[s0]} 起 {L} 个月，样本外的夏普 {sharpe(xs, f_):.3f}，买入持有 {sharpe(r_, f_):.3f}；1 元变成 {np.prod(1 + xs):,.0f} 元，买入持有 {np.prod(1 + r_):,.0f} 元")
wf = walk_forward(0.0); counts = {}
for _, rule, _ in wf: counts[rule] = counts.get(rule, 0) + 1
print("  选出来最多的规则（不计成本）：" + "，".join(f"{r[0]}({r[1]}) {c} 次" for r, c in sorted(counts.items(), key=lambda kv: -kv[1])[:4]) + f"（一共选了 {len(wf)} 次，用过 {len(counts)} 条不同的规则）")

一、拆开看 MOM(10)（在 22 条里最好的那条），不计成本：
                  年均超额收益   年化波动    夏普    最大回撤    最差的一个月   在股市里的时间
  买入持有           8.08%      18.44%    0.44     -83.7%      -28.7%        100%
  MOM(10)            8.05%      13.24%    0.61     -41.7%      -22.6%        75%
  → 平均的超额收益几乎一样；夏普高，是因为波动小、回撤浅：躲开了大熊市。

二、稳不稳？分三段看，所有 22 条规则的平均夏普之差（不计成本），和 MOM(10)：
  192801–196212（420 个月）：22 条规则里 18 条夏普高于买入持有，平均之差 +0.105；MOM(10) +0.233
  196301–199212（360 个月）：22 条规则里 11 条夏普高于买入持有，平均之差 -0.020；MOM(10) +0.065
  199301–202512（396 个月）：22 条规则里 19 条夏普高于买入持有，平均之差 +0.110；MOM(10) +0.172

三、样本外：每年用过去 20 年的成绩，在 22 条规则里选最好的，用一年：
  c = 0.00%：194801 起 936 个月，样本外的夏普 0.640，买入持有 0.552；1 元变成 2,445 元，买入持有 5,157 元
  c = 0.25%：194801 起 936 个月，样本外的夏普 0.536，买入持有 0.552；1 元变成 1,312 元，买入持有 5,157 元
  c = 0.50%：194801 起 936 个月，样本外的夏普 0.522，买入持有 0.552；1 元变成 1,425 元，买入持有 5,157 元
  选出来最多的规则（不计成本）：MOM(1) 25 次，MOM(4) 13 次，MOM(10) 12 次，MOM(7) 7 次（一共选了 78 次，用过 10 条不同的规则）

# 第五步：检验的「检验力」。如果市场真的有一点点可预测性，我们这 99 年的数据，测得出来吗？
# 做法：自己造数据，注入一个已知的可预测性：r_t = μ + ρ (r_{t-1} - μ) + 噪声（月度，均值和标准差，取真实的 0.96% 和 5.31%）。ρ = 0 就是随机游走。
# 再用两个检验去测：（1）一阶自相关超出 ±2/√n；（2）q = 12 的方差比，异方差稳健的 |z*| > 1.96。看每个 ρ 下，测出来的比例（5% 水平）。
def ar1_series(T, rho, rng, mu=0.0096, sd=0.0531):
    e = rng.standard_normal(T + 200) * sd * math.sqrt(1 - rho ** 2); x = np.empty(T + 200); x[0] = 0.0
    for t in range(1, T + 200): x[t] = rho * x[t - 1] + e[t]
    return mu + x[200:]                                                      # 前 200 个月，丢掉（让序列进入稳态）

rng = np.random.default_rng(79); reps = 600
print("一、有可预测性（一阶自相关 ρ）时，两个检验能测出来的比例（600 次；5% 水平；每格：自相关检验 / 方差比检验）：")
print("  样本长度           ρ = 0（假警报）   ρ = 0.05     ρ = 0.10     ρ = 0.20")
power = {}
for T, label in ((120, "10 年（120 个月）"), (360, "30 年（360 个月）"), (1188, "99 年（1188 个月）")):
    row = []
    for rho in (0.0, 0.05, 0.10, 0.20):
        a = b = 0
        for _ in range(reps):
            x = ar1_series(T, rho, rng); a += abs(acf(x, 1)) > 2 / math.sqrt(T); b += abs(variance_ratio(np.log1p(x), 12)[2]) > 1.96
        row.append((a / reps, b / reps))
    power[T] = row
    print(f"  {label:<14}  " + "    ".join(f"{a:4.0%} / {b:4.0%}" for a, b in row))

# 二、这点可预测性，值多少钱？ 同一个 AR(1)，用「上月涨就持股，上月跌就持国库券」，夏普比率比买入持有，高多少？（1188 个月，无成本，rf 取 0.3%/月）
print("\n二、如果收益有一阶自相关 ρ，那条「上月涨就持股」的规则，夏普比率比买入持有高多少？（1188 个月，200 次平均，不计成本）")
rng = np.random.default_rng(79); sharpe_gap = {}
for rho in (0.0, 0.05, 0.10, 0.20, 0.30):
    gaps = []
    for _ in range(200):
        x = ar1_series(1188, rho, rng); rf = np.full(len(x), 0.003)
        hold = np.where(x[:-1] > 0.003, x[1:], rf[1:]); gaps.append(sharpe(hold, rf[1:]) - sharpe(x[1:], rf[1:]))
    sharpe_gap[rho] = (float(np.mean(gaps)), float(np.std(gaps)))
    print(f"  ρ = {rho:.2f}：夏普之差的平均 {sharpe_gap[rho][0]:+.3f}，标准差 {sharpe_gap[rho][1]:.3f}（单次，大约会在 {sharpe_gap[rho][0] - 2 * sharpe_gap[rho][1]:+.2f} 到 {sharpe_gap[rho][0] + 2 * sharpe_gap[rho][1]:+.2f} 之间）")
print("  对照：真实数据里，这条规则的夏普之差是 +0.047（第 38 讲）。")

一、有可预测性（一阶自相关 ρ）时，两个检验能测出来的比例（600 次；5% 水平；每格：自相关检验 / 方差比检验）：
  样本长度           ρ = 0（假警报）   ρ = 0.05     ρ = 0.10     ρ = 0.20
  10 年（120 个月）      5% /   6%      7% /   8%     16% /  13%     50% /  30%
  30 年（360 个月）      4% /   6%     13% /   9%     40% /  21%     95% /  53%
  99 年（1188 个月）     5% /   5%     39% /  17%     93% /  47%    100% /  94%

二、如果收益有一阶自相关 ρ，那条「上月涨就持股」的规则，夏普比率比买入持有高多少？（1188 个月，200 次平均，不计成本）
  ρ = 0.00：夏普之差的平均 -0.108，标准差 0.067（单次，大约会在 -0.24 到 +0.03 之间）
  ρ = 0.05：夏普之差的平均 -0.021，标准差 0.072（单次，大约会在 -0.16 到 +0.12 之间）
  ρ = 0.10：夏普之差的平均 +0.074，标准差 0.075（单次，大约会在 -0.08 到 +0.22 之间）
  ρ = 0.20：夏普之差的平均 +0.256，标准差 0.081（单次，大约会在 +0.09 到 +0.42 之间）
  ρ = 0.30：夏普之差的平均 +0.439，标准差 0.081（单次，大约会在 +0.28 到 +0.60 之间）
  对照：真实数据里，这条规则的夏普之差是 +0.047（第 38 讲）。