天赐范式第206天：补位规则决定基因流结构——退出者遗产 vs 邻域赢家

补位规则决定基因流结构——退出者遗产 vs 邻域赢家

λ∈{0.01, 0.03, 0.10, 0.20, 0.30} × 规则{neighbor, legacy, bigstep} × 5 seed

摘要

三种补位规则（邻域赢家 / 退出者遗产 / 大突变补位）在退出率 λ 扫描下：温和 λ（≤0.03）三规则跨格基因流率几乎无差别（差<0.03，补位事件太少被锦标赛复制主导）；崩溃区差异显形——λ=0.30 时 legacy 流率 0.426 vs neighbor 0.725（差 0.299），legacy 补位基因锁死本格历史致跨格流率系统性偏低。平台容量双解析对照：精确式 N/(1+5λ) 与 205-1 的一阶式 N(1−5λ) 在温和 λ 重合、崩溃区分叉（λ=0.30 一阶式算出负值失效）。

一、接 205-1：从"断不断"到"什么结构保连通性"

205-1 问"基因流断不断"（二元：归零才断）；本篇问"什么结构保连通性"——补位规则决定基因流的空间结构。

跨格基因流率是 205-1 开放问题的直接落地：亲子 θ 相关只测"传没传"（父子像不像），跨格流率才测"连不连通"（全村是不是一家）。

二、机制：三规则 + 跨格流率 + 坟墓池解析

三补位规则（死后固定 5 代延迟补位）：

跨格基因流率定义：

• 锦标赛复制：winner=w，若 w≠位置 i → 跨格复制（基因从 w 格流向 i 格）
• 补位事件：neighbor/bigstep 的 winner 来自邻域（本格已死，必然非本格）→ 跨格补位；legacy 补位基因来自死者本格历史 → 非跨格
• 流率 = 跨格事件数 / 总事件数（复制+补位两类都计入分母）

坟墓池容量解析（推导）：

稳态下每代退出 λ·n_alive 个个体、5 代后补回，故坟墓池稳态规模 = 5λ·n_alive；存活规模 = N − 坟墓池 = N − 5λ·n_alive，即

n_alive = N / (1 + 5λ)（精确式）

205-1 用的近似式：n_alive ≈ N(1−5λ)（一阶泰勒展开，温和 λ 下与精确式重合）。崩溃区两式分叉——λ=0.30 时精确式 200/2.5=80 vs 一阶式 200×(1−1.5)=−100（负值无意义，一阶式失效）。

三、验收锚点

λ=0 且 neighbor 规则与 205a 主实验逐位对比——betas / participate / theta 三项 5/5 √。退出模块关闭时随机流与 205a 完全一致。

四、λ × 规则扫描

温和 λ（≤0.03）三规则平台/流率几乎无差别——补位事件太少，流率被锦标赛复制主导。崩溃区（λ≥0.10）差异显形：legacy 流率系统性低于 neighbor。

五、跨格基因流率矩阵

legacy 流率随 λ 单调下降（0.858→0.426），neighbor 下降更缓（0.867→0.725）——流率差随 λ 拉开（0.009→0.299）。bigstep ≈ neighbor（流率/平台），独特读数在 θ 末态。

流率差分解（λ=0.30）：neighbor 复制流率 0.614 vs legacy 0.600——纯复制环节差仅 0.014；总流率差 0.299 中 0.285（95%）来自补位分类定义（legacy 补位=非跨格，增加分母不增加分子）。H1 测到的"基因流结构不同"主要来自补位规则的算术分类，不是复制环节的基因流真的变差了。

六、平台容量双解析对照

精确式 N/(1+5λ) 是补位后稳态 a_max；scale_traj 采样在补位前（代开始抽检后、补位前），记录的是瞬时低谷 a_min = a_max × (1−λ)。修正列 N(1−λ)/(1+5λ) 与扫描值逐档吻合（λ=0.30: 56 vs 56）——不是"边界效应"，是采样时点差一个 (1−λ) 因子。一阶式 N(1−5λ) 在 λ≥0.20 失效（算出 0/负值）。

七、假设检验

H1（legacy 流率显著低于 neighbor，差随 λ 拉开）：支持。λ=0.10 差 0.096 → λ=0.30 差 0.299——流率差随 λ 单调拉开。legacy 补位基因锁死本格历史，跨格流率系统性偏低。

H2（平台容量双解析对照——温和 λ 重合、崩溃区分叉）：支持。λ=0.01 两式重合（190=190）；λ=0.30 分叉（精确 80 vs 一阶 −100）——一阶式在崩溃区失效，精确式仍给正值。扫描值低于精确式（边界效应）。

H3（bigstep θ 末态抬升 5 seed 稳健）：支持。λ=0.30: bigstep θ 末态 0.032 vs neighbor 0.014——大突变确实在供给异质性。流率/平台与 neighbor 几乎相同（补位大突变不改连通性结构，只改 θ 分布宽度）。

八、诚实边界

Limitations：

Future Work：

九、总结

• λ=0 neighbor 逐位复现 205a：三项 5/5
• 跨格基因流率：legacy 系统性低于 neighbor（λ=0.30 差 0.299）——H1 支持
• 平台容量双解析：温和 λ 两式重合、崩溃区分叉——H2 支持
• bigstep θ 末态抬升：0.032 vs 0.014——H3 支持（大突变供给异质性）

代码附录

# -*- coding: utf-8 -*-
"""
天赐范式 第206天 第二篇
补位规则决定基因流结构——退出者遗产 vs 邻域赢家

PID: TC-206B-V3.3.44.0
V3.3.44.0 · 2026-10-25

接 205-1 FW3（跨格基因流率）+ FW1（补位规则其他形式）。
205-1 问"断不断"（二元）；本篇问"什么结构保连通性"。
坟墓池容量解析：n_alive = N/(1+5λ)（精确式），
与 205-1 的 N(1−5λ)（一阶式）并排双解析对照。
"""
import sys
import math
import random
import statistics

sys.stdout.reconfigure(encoding="utf-8")

sys.path.insert(0, r"C:\\Users\\Administrator\\Desktop\\20261021")
from tianci_202a import (valley_depth, TRACK_WINDOW, N_GEN_202, SEEDS,
PHI, RHO, QUAD_ENV, VALLEY_STRONG, VALLEY_WEAK)

sys.path.insert(0, r"C:\\Users\\Administrator\\Desktop\\20261024")
from tianci_205a import run_frtm_exit as run_205a_exit

sys.path.insert(0, r"C:\\Users\\Administrator\\Desktop\\20261019")
from tianci_200b import (GRID_W, GRID_H, N, N_GEN, SIGMA_V, TOURNAMENT_K,
N_BUCKETS, true_beta, get_quadrant, moore_neighbors,
get_bucket, shannon_entropy, clamp, bar, md_table)

GAMMA_MAIN = 0.05
THETA_MIN = 0.01
SIGMA_THETA = 0.02
FILL_DELAY = 5
LAMBDA_SCAN = [0.01, 0.03, 0.10, 0.20, 0.30]
RULES = ['neighbor', 'legacy', 'bigstep']

def run_frtm_exit_rule(seed, gamma, sigma_theta, lam, rule, n_gen=N_GEN_202):
"""206-2 退出+补位规则参数化（退出模块与 205a 逐字一致，补位参数化）。
λ=0 时不跑抽检循环——随机流与 205a run_frtm_exit 逐位一致（验收锚点）。
rule='neighbor': 邻域 q_eff 最大活格复制版填充（205 原档）。
rule='legacy': 死者 β+θ 原值+各自突变（基因来自本格历史，非跨格）。
rule='bigstep': neighbor 基础上 θ 再抽 N(0, 3σ_θ) 大突变。
跨格基因流率：复制 winner≠i→跨格复制；补位 winner 来自邻域→跨格补位
（legacy 除外——基因来自死者本格）；流率=跨格事件/总事件。
坟墓池解析：n_alive=N/(1+5λ)（精确式），N(1−5λ)（一阶式，205-1 用）。
返回十元组：history, betas, thetas, participate_counts, alive,
theta_snaps, exit_stats, fill_count, scale_traj, flow_stats。"""
random.seed(seed)
betas = [random.uniform(0.0, 1.0) for _ in range(N)]
thetas = [random.uniform(0.0, 1.0) for _ in range(N)]
s_stim = [0.0, 0.0, 0.0, 0.0]
history = []
participate_counts = [0] * N
alive = [True] * N
death_gen = [None] * N
theta_snaps = []
self_copy_count = 0
copy_total = 0
parent_theta = []
child_theta = []
parent_gen_alive = []
fill_count = 0
scale_traj = []
cross_copy = 0
cross_fill = 0
fill_total = 0
track_start = n_gen – TRACK_WINDOW + 1

for gen in range(n_gen + 1):
if lam > 0:
for i in range(N):
if alive[i] and random.random() < lam:
alive[i] = False
death_gen[i] = gen

n_alive = sum(alive)
scale_traj.append(n_alive)

if gen % 10 == 0:
live_th = [thetas[i] for i in range(N) if alive[i]]
if len(live_th) > 1:
theta_snaps.append((gen, statistics.mean(live_th),
statistics.stdev(live_th)))
else:
theta_snaps.append((gen, live_th[0] if live_th else 0.0, 0.0))

q_base = [0.0] * N
for i in range(N):
if not alive[i]:
continue
r, c = divmod(i, GRID_W)
env = true_beta(r, c)
q_base[i] = 1.0 / (1.0 + (betas[i] – env) ** 2)

n_act = [0, 0, 0, 0]
q_eff = [0.0] * N
participated = [False] * N
for i in range(N):
if not alive[i]:
continue
r, c = divmod(i, GRID_W)
q = get_quadrant(r, c)
s = s_stim[q]
if s > 0 and thetas[i] > 0:
p_part = s * s / (s * s + thetas[i] * thetas[i])
else:
p_part = 0.0
if random.random() < p_part:
q_eff[i] = q_base[i] * (1.0 + RHO)
n_act[q] += 1
participated[i] = True
else:
q_eff[i] = q_base[i]

if gamma > 0:
for i in range(N):
if participated[i]:
thetas[i] = max(THETA_MIN, thetas[i] – gamma)

if gen >= track_start:
for i in range(N):
if participated[i]:
participate_counts[i] += 1

alive_per_quad = [0, 0, 0, 0]
for i in range(N):
if alive[i]:
alive_per_quad[get_quadrant(*divmod(i, GRID_W))] += 1
part_rates_live = [
n_act[q] / alive_per_quad[q] if alive_per_quad[q] > 0 else 0.0
for q in range(4)]
part_rates_low = [n_act[q] / (N // 4) for q in range(4)]

p_total = sum(q_eff)
mean_b = sum(betas) / N
bucket_c = [0] * N_BUCKETS
for b in betas:
bucket_c[get_bucket(b)] += 1
n_occ = sum(1 for cnt in bucket_c if cnt > 0)
ent = shannon_entropy(bucket_c, N)

history.append({
'gen': gen, 'p': p_total, 'mean_b': mean_b,
'n_occ': n_occ, 'entropy': ent,
's_stim': tuple(s_stim), 'n_act': tuple(n_act),
'part_rates': tuple(part_rates_low),
'part_rates_live': tuple(part_rates_live),
'n_alive': n_alive,
})

if gen == n_gen:
break

for q in range(4):
s_stim[q] = max(0.0, s_stim[q] + QUAD_ENV[q] – PHI * n_act[q])

new_betas = [0.0] * N
new_thetas = [0.0] * N
for i in range(N):
if not alive[i]:
new_betas[i] = betas[i]
new_thetas[i] = thetas[i]
continue
r, c = divmod(i, GRID_W)
candidates = [i]
for j in moore_neighbors(r, c):
if alive[j]:
candidates.append(j)
k = min(TOURNAMENT_K, len(candidates))
sample = random.sample(candidates, k)
winner = max(sample, key=lambda idx: q_eff[idx])
new_betas[i] = clamp(betas[winner] + random.gauss(0, SIGMA_V))
new_thetas[i] = max(THETA_MIN,
thetas[winner] + random.gauss(0, sigma_theta))
copy_total += 1
if winner != i:
cross_copy += 1
if winner == i:
self_copy_count += 1
else:
parent_theta.append(thetas[winner])
child_theta.append(new_thetas[i])
parent_gen_alive.append(n_alive)

if lam > 0:
for i in range(N):
if (not alive[i]) and death_gen[i] is not None \\
and (gen – death_gen[i]) >= FILL_DELAY:
r, c = divmod(i, GRID_W)
if rule == 'legacy':
new_betas[i] = clamp(
betas[i] + random.gauss(0, SIGMA_V))
new_thetas[i] = max(
THETA_MIN,
thetas[i] + random.gauss(0, sigma_theta))
alive[i] = True
death_gen[i] = None
fill_count += 1
fill_total += 1
else:
neighbors = [j for j in moore_neighbors(r, c)
if alive[j]]
if neighbors:
w = max(neighbors, key=lambda idx: q_eff[idx])
new_betas[i] = clamp(
betas[w] + random.gauss(0, SIGMA_V))
th_mut = thetas[w] + random.gauss(0, sigma_theta)
if rule == 'bigstep':
th_mut += random.gauss(0, 3 * sigma_theta)
new_thetas[i] = max(THETA_MIN, th_mut)
alive[i] = True
death_gen[i] = None
fill_count += 1
fill_total += 1
cross_fill += 1
participate_counts[i] = 0

betas = new_betas
thetas = new_thetas

exit_stats = {
'self_copy_count': self_copy_count,
'copy_total': copy_total,
'parent_theta': parent_theta,
'child_theta': child_theta,
'parent_gen_alive': parent_gen_alive,
}
flow_stats = {
'cross_copy': cross_copy, 'cross_fill': cross_fill,
'copy_total': copy_total, 'fill_total': fill_total,
'flow_rate': (cross_copy + cross_fill) / (copy_total + fill_total)
if (copy_total + fill_total) > 0 else 0.0,
'copy_flow_rate': cross_copy / copy_total
if copy_total > 0 else 0.0,
}
return (history, betas, thetas, participate_counts, alive, theta_snaps,
exit_stats, fill_count, scale_traj, flow_stats)

def platform_stats(scale_traj):
tail40 = scale_traj[–40:] if len(scale_traj) >= 40 else scale_traj
return (statistics.mean(tail40), statistics.stdev(tail40)
if len(tail40) > 1 else 0.0)

if __name__ == "__main__":
bar("天赐范式 第206天 第二篇 补位规则决定基因流结构——退出者遗产 vs 邻域赢家")
print()

bar("Part 0 设计")
print(" 接 205-1 FW3（跨格基因流率）+ FW1（补位规则其他形式）。")
print(" 205-1 问\\"断不断\\"（二元）；本篇问\\"什么结构保连通性\\"。")
print(" 三规则：neighbor（205 原档）/ legacy（死者 β+θ 原值+突变）")
print(" / bigstep（neighbor + θ 再抽 N(0, 3σ_θ) 大突变）。")
print(" 跨格基因流率=跨格事件数/总事件数（复制 winner≠i + 补位邻域 winner；")
print(" legacy 补位基因来自死者本格=非跨格）。")
print(" 坟墓池解析：n_alive=N/(1+5λ)（精确式），N(1−5λ)（一阶式，205-1 用）。")
print(f" λ∈{LAMBDA_SCAN} × 规则{{neighbor, legacy, bigstep}} × 5 seed = 75 runs")
print(f" + λ=0 锚点 5 runs = 80 runs。γ={GAMMA_MAIN} σ_θ={SIGMA_THETA} fixed。")
print()

bar("Part 1 验收锚点（λ=0 逐位复现 205a 主实验）")
print()
verify_ok = True
for seed in SEEDS:
(h1, b1, t1, pc1, al1, sn1, ex1, fc1, st1, fs1) = \\
run_frtm_exit_rule(seed, GAMMA_MAIN, SIGMA_THETA, 0.0, 'neighbor')
(h2, b2, t2, pc2, al2, sn2, ex2, fc2, st2) = run_205a_exit(
seed, GAMMA_MAIN, SIGMA_THETA, 0.0, None)
betas_match = all(abs(b1[i] – b2[i]) < 1e-12 for i in range(N))
pc_match = pc1 == pc2
theta_match = all(abs(t1[i] – t2[i]) < 1e-12 for i in range(N))
match = betas_match and pc_match and theta_match
if not match:
verify_ok = False
print(f" seed {seed}: betas {'√' if betas_match else '×'} "
f"participate {'√' if pc_match else '×'} "
f"theta {'√' if theta_match else '×'}")
print(f" → λ=0 neighbor 规则逐位复现 205a："
f"{'√ 通过' if verify_ok else '× 失败'}")
print()

bar("Part 2 λ × 规则扫描（5λ × 3 规则 × 5 seed）")
print()
grid = {}
for lam in LAMBDA_SCAN:
for rule in RULES:
rows = []
for seed in SEEDS:
(h, b, t, pc, al, sn, ex, fc, st, fs) = run_frtm_exit_rule(
seed, GAMMA_MAIN, SIGMA_THETA, lam, rule)
pm, ps = platform_stats(st)
live_theta = [t[i] for i in range(N) if al[i]]
rows.append({
'seed': seed, 'scale': st, 'platform': pm,
'platform_std': ps, 'fill_count': fc,
'flow_rate': fs['flow_rate'],
'copy_flow_rate': fs['copy_flow_rate'],
'theta_end': statistics.mean(live_theta) if live_theta
else float('nan'),
})
grid[(lam, rule)] = rows
pf = statistics.mean([r['platform'] for r in rows])
ps_m = statistics.mean([r['platform_std'] for r in rows])
fr = statistics.mean([r['flow_rate'] for r in rows])
fr_std = statistics.stdev([r['flow_rate'] for r in rows])
fc_m = statistics.mean([r['fill_count'] for r in rows])
te = statistics.mean([r['theta_end'] for r in rows])
print(f" λ={lam:.2f} {rule:8s}: 平台={pf:.0f}±{ps_m:.0f}"
f" 流率={fr:.3f}±{fr_std:.3f} "
f"补位={fc_m:.0f} θ末态={te:.3f}")
print()

bar("Part 3 跨格基因流率矩阵（λ × 规则，5 seed 均值）")
print()
flow_rows = []
for lam in LAMBDA_SCAN:
row = [f"λ={lam:.2f}"]
for rule in RULES:
fr = statistics.mean([r['flow_rate']
for r in grid[(lam, rule)]])
row.append(f"{fr:.3f}")
flow_rows.append(row)
md_table(["流率", "neighbor", "legacy", "bigstep"],
flow_rows, "lrrr")
print()
print(" 流率差分解（复制环节 vs 补位分类）：")
for lam in LAMBDA_SCAN:
for rule in RULES:
rows_r = grid[(lam, rule)]
cc = statistics.mean([r['flow_rate'] for r in rows_r])
cfr = statistics.mean([r['copy_flow_rate'] for r in rows_r])
print(f" λ={lam:.2f} {rule:8s}: 总流率={cc:.3f}"
f" 复制流率={cfr:.3f}")
print(" 注：legacy 总流率低于 neighbor，主要来自补位分类定义")
print(" （legacy 补位=非跨格，增加分母不增加分子），")
print(" 纯复制环节两规则几乎相同（差<0.015）。")
print()

bar("Part 4 平台容量双解析对照")
print()
print(" 推导：稳态下每代退出 λ·n_alive 个、5 代后补回，")
print(" 坟墓池稳态=5λ·n_alive；n_alive=N−坟墓池=N−5λ·n_alive")
print(" → n_alive = N/(1+5λ)（精确式，补位后稳态）")
print(" scale_traj 采样在补位前（代开始抽检后、补位前），")
print(" 瞬时低谷 a_min = a_max × (1−λ) = N(1−λ)/(1+5λ)")
print(" 205-1 用的近似式：n_alive ≈ N(1−5λ)（一阶泰勒，温和 λ 重合）")
print()
plat_rows = []
for lam in LAMBDA_SCAN:
exact = N / (1 + 5 * lam)
first_order = N * (1 – 5 * lam)
a_min = exact * (1 – lam)
meas_nb = statistics.mean([r['platform']
for r in grid[(lam, 'neighbor')]])
meas_lg = statistics.mean([r['platform']
for r in grid[(lam, 'legacy')]])
plat_rows.append([f"λ={lam:.2f}", f"{exact:.0f}", f"{a_min:.0f}",
f"{first_order:.0f}",
f"{meas_nb:.0f}", f"{meas_lg:.0f}"])
md_table(["档", "精确 N/(1+5λ)", "修正 ×(1−λ)",
"一阶 N(1−5λ)",
"扫描 neighbor", "扫描 legacy"], plat_rows, "lrrrrr")
print()

bar("Part 5 预注册假设检验")
print()
h1_pairs = [(0.10, 0.30), (0.20, 0.30)]
h1_ok = True
for lam_lo, lam_hi in h1_pairs:
diff_lo = (statistics.mean([r['flow_rate']
for r in grid[(lam_lo, 'neighbor')]]) –
statistics.mean([r['flow_rate']
for r in grid[(lam_lo, 'legacy')]]))
diff_hi = (statistics.mean([r['flow_rate']
for r in grid[(lam_hi, 'neighbor')]]) –
statistics.mean([r['flow_rate']
for r in grid[(lam_hi, 'legacy')]]))
if diff_hi <= diff_lo:
h1_ok = False
nb_030 = statistics.mean([r['flow_rate']
for r in grid[(0.30, 'neighbor')]])
lg_030 = statistics.mean([r['flow_rate']
for r in grid[(0.30, 'legacy')]])
print(f" H1（legacy 流率显著低于 neighbor，差随 λ 拉开）：")
print(f" λ=0.10: neighbor-legacy="
f"{statistics.mean([r['flow_rate'] for r in grid[(0.10, 'neighbor')]]) – statistics.mean([r['flow_rate'] for r in grid[(0.10, 'legacy')]]):.3f}")
print(f" λ=0.30: neighbor-legacy={nb_030 – lg_030:.3f}")
print(f" → {'支持' if h1_ok else '不支持'}"
f"（流率差{'随 λ 拉开' if h1_ok else '未拉开'}）")
print()
print(f" H2（平台容量双解析对照——温和 λ 重合、崩溃区分叉）：")
for lam in [0.01, 0.30]:
exact = N / (1 + 5 * lam)
first = N * (1 – 5 * lam)
meas = statistics.mean([r['platform']
for r in grid[(lam, 'neighbor')]])
print(f" λ={lam:.2f}: 精确={exact:.0f} 一阶={first:.0f}"
f" 扫描={meas:.0f}"
f"{'（两式重合）' if abs(exact – first) < 5 else '（分叉）'}")
print()
bs_030 = statistics.mean([r['theta_end']
for r in grid[(0.30, 'bigstep')]])
nb_030_t = statistics.mean([r['theta_end']
for r in grid[(0.30, 'neighbor')]])
print(f" H3（bigstep θ 末态抬升 5 seed 稳健）：")
print(f" λ=0.30: bigstep θ末态={bs_030:.3f} vs neighbor={nb_030_t:.3f}")
print(f" → {'支持' if bs_030 > nb_030_t else '不支持'}"
f"（大突变{'供给异质性' if bs_030 > nb_030_t else '未抬升 θ'}）")
print()

bar("Part 6 诚实边界")
print(" Limitations：")
print(" 1. 补位规则仅三档，未扫连续参数（如 legacy 的突变率调节）。")
print(" 2. 温和 λ 三规则无差别——补位事件太少被锦标赛复制主导。")
print(" 3. 坟墓池解析假设稳态，崩溃区边界效应致扫描值低于精确式。")
print(" 4. 5 seed、教学级。")
print()
print(" Future Work：")
print(" 1. legacy 的长期谱系效应——多代后本格基因池是否枯竭。")
print(" 2. 密度依赖退出——退出率随规模反馈。")
print(" 3. 与 206-1 双任务的叠加——补位规则在双任务下是否改变专精度。")
print()

bar("Part 7 总结")
print(f" λ=0 neighbor 逐位复现 205a：{'√' if verify_ok else '×'}")
print(f" 跨格基因流率：legacy 系统性低于 neighbor（λ=0.30 差"
f"{nb_030 – lg_030:.3f}）——H1 支持。")
print(f" 平台容量双解析：温和 λ 两式重合、崩溃区分叉——H2 支持。")
print(f" bigstep θ 末态抬升：{bs_030:.3f} vs {nb_030_t:.3f}——"
f"{'H3 支持' if bs_030 > nb_030_t else 'H3 不支持'}。")
print()