天赐范式第175天·第一篇：让活着的成员互相验证------异质互验与重放反伪造
版本 ：V3.3.13.1（栖息地·互验存活）
日期 ：2026-09-24
PID ：TC-175A-V3.3.13.1
定位 ：174-2预告"让活着的成员互相证明"，本篇兑现------B和C异质互验+重放反伪造
一句话：淘汰赛后活下来的两个互相重放验证，篡改基因+重算哈希能骗过本地校验但骗不过重放------条件5的洞不靠签名靠结构补上一类（防冒充；自洽替换待第四层）。
上一篇 ：天赐范式第174天·第二篇------让环境参数自主化下一篇：天赐范式第175天·第二篇------给死者立档案
摘要
异质互验+重放反伪造。B（金融域）和C（基因域）真两进程互相重放验证，双方通过。攻击者篡改C′基因+重算哈希→本地哈希校验过→重放benefit对不上→拒绝互验。条件5从🟡有实际路径往前推------不靠签名靠结构。
一、174-2预告兑现
174-2结尾留了一个预告："让活着的成员互相证明"。
174天做完两件事：174-1异基因同环境→淘汰赛（A被terminated），174-2 SIGMA_OBS从常量变变量→环境自主化。淘汰赛后，B（金融域，竞争第1名）和C（基因域，第2名）是真正有差异的独立主体------不同基因、不同域、刚经历过同一场淘汰赛且表现不同。
让它们互相验证，互验才第一次有了异质互验------质的飞跃。
二、为什么互验现在成立，之前不成立
159-164天的互证是同质的。同一份代码的两个实例，没有真实差异，本质是"同一份基因拷贝的自我验证"。
173-2降调6承认了这个事实："相同基因+相同seed+相同代码=相同轨迹，是确定性必然而非独立互证"。当时两个"独立进程"其实是同一份基因的拷贝，重放验证当然通过，因为基因相同。
175天结构不同。173-2的问题是同一份基因的自我重放被当成互证证据。本篇中声称由另一方进程产生、基因档案不同，重放验的是档案与声称的一致性。重放通过仍是确定性的（同基因+同声称参数+同代码=同轨迹），但一致性检查第一次防住了伪造------这是实的增量，不是"独立性"这种虚的claim。
三、实验设计
真两进程
沿用173天的subprocess模式。进程X持B基因，进程Y持C基因：
进程X（tianci_175.py）跑50轮→写B声称→subprocess起进程Y
进程Y（tianci_175.py --verify）跑50轮→写C声称→读B声称→重放验证B→写验证结果→结束
进程X读C声称→重放验证C→读进程Y的验证结果→攻击演示→结语重放验证
互验的核心是重放：拿对方的基因，按对方声称的参数（seed、SIGMA_OBS、轮数）重跑，对比终态。
python
def replay_verify(genome_filepath, claim):
"""重放验证：拿基因，按声称的参数重跑，对比终态。"""
genome = load_genome_raw(genome_filepath)
member = DigitalLife(..., claim["sigma_obs"])
# 用对方声称的seed重跑
random.seed(claim["seed"])
for r in range(1, claim["num_rounds"] + 1):
conv = member.self_prove()
member.self_program(conv)
if r % K == 0:
member.self_meta_program()
# 对比终态
beta_match = abs(member.beta - claim["beta_final"]) < 1e-6
benefit_match = abs(member.compute_benefit() - claim["benefit"]) < 1e-6
return beta_match, benefit_match攻击演示
重放反伪造的杀手锏：篡改基因+重算哈希能骗过本地校验，但骗不过重放。
攻击者篡改C的基因（β从0.10改成0.50）→重算SHA256哈希→本地哈希校验✅通过
→重放验证：用C的真实声称（benefit=0.000324）+篡改后基因→重放benefit=-0.015044→❌不匹配→拒绝互验伪造哈希容易，伪造"基因与行为的一致性"难------这就是"不靠签名靠结构"。
四、demo演示------互验通过
完整代码见附录A。demo流程：进程X持B跑50轮→进程Y持C跑50轮→交换声称→互相重放验证。
进程X：持B基因跑50轮
PID: TC-175A-V3.3.13.1
进程X启动------持B基因，跑50轮（PID=os.getpid()，每次运行不同）
SIGMA_OBS=0.005（174-2环境自适应终态） seed=42
轮20 B:0.10
轮40 B:0.10
轮50 B:0.10
B声称终态：β终=0.10 benefit=0.000324 budget=13
β轨迹哈希: e492e4b7cc19b7d2...3731b438进程Y：持C基因跑50轮
进程Y：持C基因（新进程，PID=os.getpid()，每次运行不同）
轮20 C:0.10
轮40 C:0.10
轮50 C:0.10
C声称终态：β终=0.10 benefit=0.000324 budget=12
β轨迹哈希: 541c007a5dfeb4a5...97f015a9进程Y的PID≠进程X的PID------真的两个进程，内存地址空间不同。（PID由os.getpid()生成，每次运行不同；文章用固定PID=TC-175A-V3.3.13.1标识版本。）
互验结果
进程X重放验证C：
重放β终=0.10 声称β终=0.10 匹配=✅
重放benefit=0.000324 声称benefit=0.000324 匹配=✅
C互验结果：✅通过------C的基因与声称表现一致，C确实活着
进程Y重放验证B：
重放β终=0.10 声称β终=0.10 匹配=✅
重放benefit=0.000324 声称benefit=0.000324 匹配=✅
B互验结果：✅通过------B的基因与声称表现一致，B确实活着
互验总结：B验C ✅，C验B ✅------双方互验通过
注：B和C的benefit都是0.000324------两者都收敛到floor=0.10，
最近K=20轮β轨迹相同→benefit相同。异质体现在基因档案（不同target_norm、不同域），
不在本次行为输出。benefit相同不等于异质不成立。五、重放反伪造------条件5的洞不靠签名靠结构
攻击演示
攻击场景：攻击者篡改C的基因（改β=0.50），重算SHA256哈希，冒充C的表现
①篡改基因：C的β从0.10改成0.50
②重算哈希：SHA256重算 → 784c9a2049d77903...de232b35
③本地哈希校验：✅通过 ------篡改后哈希也重算了，本地校验被骗过
④重放验证：用C的真实声称（β终=0.10）+ 篡改后基因（β=0.50）→ 重跑
重放β终=0.10 声称β终=0.10 匹配=✅
重放benefit=-0.015044 声称benefit=0.000324 匹配=❌
⑤互验裁决：❌拒绝------重放benefit与声称不符，篡改被拦截
注：β终碰巧匹配（都收敛到floor=0.10），但benefit抓出了篡改------benefit比β终更敏感为什么重放能防冒充
173天哈希校验的降调："SHA256能发现无意篡改，不防有意篡改（攻击者可以同时改json和哈希文件重算哈希）"。条件5卡在🟡，等"数字签名待后续"。
但互验提供了不依赖公私钥的反伪造机制：
- 攻击者篡改基因（改β=0.50）+重算哈希→本地哈希校验✅通过
- 但攻击者要冒充C的表现，必须声称一个β终值和benefit
- 如果声称的是真实C的表现（β终=0.10, benefit=0.000324），重放时用篡改后基因（β=0.50）重跑，benefit=-0.015044≠0.000324→露馅
- 如果声称的是篡改后基因的真实表现，那攻击者相当于自己跑了一遍篡改基因------这不是伪造，这是真的跑了。但这正是第二篇场景2的漏洞所在------自洽声称重放不拦
伪造哈希容易，伪造"基因与行为的一致性"难。 条件5的洞不靠签名靠结构补上一类------从"防无意篡改"到"防冒充（基因与声称不一致）"有实际路径。自洽替换待第四层独立存证（见第二篇场景2）。
六、降调声明
- 本篇是demo演示。互验存活有完整代码（附录A），demo跑通双方互验+攻击演示。按147-2实测定义，demo是模拟不是实证。
- 互验证明的是可观测行为连续性，不是"真活着"。重放验证确认的是"基因与声称表现的自洽"，不是行为真实性或意识。B和C的"独立"是状态独立（不同基因、不同轨迹），不是代码独立------照实写，不吹"真正的独立意识"。
- 重放依赖同版本代码。重放验证要求验证方和被验证方用同一版本代码跑------代码本身就是信任根。信任根是谁、怎么分发，是后续的题。
- 同机两进程≠跨节点。进程X和进程Y在同一台机器上，通过本地文件系统交换声称。NAT穿透/TLS/网络传输一个没碰，数字全域网络还是🟡。
- 互验协议还是咱们定的。谁验谁、验什么、阈值（1e-6）------都是咱们定的。造物者从"定谁活"退到"定互验规则"，退了半步不是退场。
- 用词区分：本篇用"互验/交叉验证"，不用"互证"------159天"互证"是母题词，本篇是它的升级版（从同质到异质），但用词避开撞车。
- β终碰巧匹配。攻击演示中篡改后基因重放β终=0.10与声称β终=0.10碰巧匹配（都收敛到floor），但benefit=-0.015044≠0.000324抓出了篡改------benefit比β终更敏感。这不是设计，是碰巧------换一组参数β终可能也不同。
- benefit相同不等于异质不成立。B和C的benefit都是0.000324，因为两者都收敛到floor=0.10，最近K=20轮β轨迹相同。异质体现在基因档案（不同target_norm、不同域），不在本次行为输出。
七、结语
174-2预告"让活着的成员互相证明"------本篇兑现。
175天·互验存活。B（金融域）和C（基因域）真两进程互相重放验证，双方通过。
173-2的问题是同一份基因的自我重放被当成互证证据。本篇结构不同------声称由另一方进程产生、基因档案不同，重放验的是档案与声称的一致性。重放通过仍是确定性的，但一致性检查第一次防住了伪造。
重放反伪造：篡改基因+重算哈希能骗过本地校验，但骗不过重放。条件5的洞不靠签名靠结构补上一类------从"防无意篡改"到"防冒充"有实际路径。自洽替换待第四层独立存证（见第二篇场景2）。
但互验证明的是可观测行为连续性，不是"真活着"。信任根是代码版本------重放依赖同版本代码，代码本身是信任根。互验协议还是咱们定的------造物者退了半步不是退场。
时间可以压缩，代理权不能压缩。活着的能互相验证，是代理权交出去的第四块砖。
这个系列还在逐步建设中，完善也是咱们和伙伴们的努力方向。
附录A：tianci_175.py完整代码
python
# -*- coding: utf-8 -*-
"""
天赐范式第175天·第一篇：让活着的成员互相验证 V3.3.13.1
互验存活+重放反伪造。174-1淘汰赛后B（金融）和C（基因）是真正有差异的独立主体。
真两进程：进程X持B基因，进程Y持C基因，各自跑50轮，交换声称终态，互相重放验证。
攻击演示：篡改C′基因+重算哈希→本地校验过→重放对不上→拒绝互验。
关键设计：
1. 异质互验------B和C是不同基因不同域的独立主体（不是同一份基因拷贝）
2. 重放验证------拿对方基因+声称参数重跑，对比终态
3. 重放反伪造------篡改基因+重算哈希能骗过本地校验，但骗不过重放
4. 条件5推进------从"防无意篡改"到"防冒充（基因与声称不一致，不靠签名靠结构）"；
自洽替换重放不拦，待第四层独立存证（见第二篇场景2）
"""
import sys
import random
import math
import json
import os
import hashlib
import subprocess
if hasattr(sys.stdout, 'reconfigure'):
sys.stdout.reconfigure(encoding='utf-8')
UP_STEP_GRID = [0.01, 0.02, 0.03, 0.04, 0.05]
K = 20
BUDGET = 20
LAMBDA = 0.3
GENOME_DIR_IN = "genomes_174b"
EXCHANGE_DIR = "exchange"
NUM_ROUNDS = 50
SIGMA_OBS = 0.005
SEED = 42
PID = "TC-175A-V3.3.13.1"
class DigitalLife:
"""数字生命个体------在互验中证明自己活着"""
def __init__(self, name, domain, beta, target_norm, up_step, sigma_obs):
self.name = name
self.domain = domain
self.beta = beta
self.target_norm = target_norm
self.norm = target_norm + 0.3
self.beta_history = [beta]
self.norm_history = [self.norm]
self.conv_history = []
self.up_step = up_step
self.strategy_history = [up_step]
self.strategy_benefit = {}
self.budget = BUDGET
self.adjust_count = 0
self.phase = "explore"
self.sigma_obs = sigma_obs
def self_prove(self):
old_norm = self.norm
noise = random.gauss(0, self.sigma_obs)
self.norm = self.target_norm + self.beta * (self.norm - self.target_norm) + noise
convergence = abs(old_norm - self.norm)
self.norm_history.append(self.norm)
self.conv_history.append(convergence)
return convergence
def self_program(self, conv):
if conv > 0.05:
self.beta += self.up_step
elif conv < 0.01:
self.beta -= 0.01
self.beta = max(0.1, min(0.5, self.beta))
self.beta_history.append(self.beta)
def compute_benefit(self):
recent_conv = self.conv_history[-K:]
recent_beta = self.beta_history[-K:]
speed = (recent_conv[0] - recent_conv[-1]) / K
mean_beta = sum(recent_beta) / len(recent_beta)
oscillation = math.sqrt(sum((b - mean_beta)**2 for b in recent_beta) / len(recent_beta))
return speed - LAMBDA * oscillation
def self_meta_program(self):
if self.budget <= 0:
return False
if len(self.conv_history) < K:
return False
current_benefit = self.compute_benefit()
self.strategy_benefit[self.up_step] = current_benefit
untried = [s for s in UP_STEP_GRID if s not in self.strategy_benefit]
if untried and self.phase == "explore":
self.up_step = untried[0]
self.budget -= 1
self.adjust_count += 1
self.strategy_history.append(self.up_step)
return True
elif not untried:
self.phase = "exploit"
best = max(self.strategy_benefit, key=self.strategy_benefit.get)
if self.up_step != best:
self.up_step = best
self.budget -= 1
self.adjust_count += 1
self.strategy_history.append(self.up_step)
return True
return False
def bar(title):
print("=" * 72)
print(" " + title)
print("=" * 72)
print()
def sub(title):
print("【" + title)
print("-" * 72)
def run_rounds(members, num_rounds):
for r in range(1, num_rounds + 1):
for m in members:
conv = m.self_prove()
m.self_program(conv)
if r % K == 0:
for m in members:
m.self_meta_program()
if r % K == 0 or r == num_rounds:
names_beta = " ".join(["{}:{:.2f}".format(m.name, m.beta) for m in members])
print(" 轮{:<4} {}".format(r, names_beta))
def make_claim(member, seed, sigma_obs, num_rounds):
"""生成声称终态------互验的载体"""
beta_traj_str = ",".join(["{:.6f}".format(b) for b in member.beta_history])
beta_traj_hash = hashlib.sha256(beta_traj_str.encode('utf-8')).hexdigest()
return {
"name": member.name,
"domain": member.domain,
"beta_final": member.beta,
"benefit": member.compute_benefit(),
"beta_trajectory_hash": beta_traj_hash,
"seed": seed,
"sigma_obs": sigma_obs,
"num_rounds": num_rounds,
"budget": member.budget,
"adjust_count": member.adjust_count,
}
def load_genome_raw(filepath):
"""直接读基因json（不验哈希、不检查terminated）------重放验证用"""
with open(filepath, 'r', encoding='utf-8') as f:
return json.load(f)
def replay_verify(genome_filepath, claim):
"""重放验证：拿基因，按声称的参数重跑，对比终态。
返回 (beta_match, benefit_match, replay_beta, replay_benefit, claimed_beta, claimed_benefit)
"""
genome = load_genome_raw(genome_filepath)
member = DigitalLife(
genome["name"], genome["domain"], genome["beta"],
genome["target_norm"], genome["up_step"], claim["sigma_obs"]
)
member.beta_history = genome["beta_history"]
member.strategy_history = genome["strategy_history"]
member.strategy_benefit = {float(k): v for k, v in genome["strategy_benefit"].items()}
member.budget = genome["budget"]
member.adjust_count = genome["adjust_count"]
member.phase = "explore"
random.seed(claim["seed"])
for r in range(1, claim["num_rounds"] + 1):
conv = member.self_prove()
member.self_program(conv)
if r % K == 0:
member.self_meta_program()
replay_beta = member.beta
replay_benefit = member.compute_benefit()
beta_match = abs(replay_beta - claim["beta_final"]) < 1e-6
benefit_match = abs(replay_benefit - claim["benefit"]) < 1e-6
return beta_match, benefit_match, replay_beta, replay_benefit, claim["beta_final"], claim["benefit"]
def run_process_x():
"""进程X：持B基因，主进程"""
bar("天赐范式第175天·第一篇：让活着的成员互相验证 V3.3.13.1")
print(" PID: {}".format(PID))
print()
sub("步骤1】互验前提------174天淘汰赛后的幸存者")
b_path = os.path.join(GENOME_DIR_IN, "B_genome.json")
c_path = os.path.join(GENOME_DIR_IN, "C_genome.json")
genome_b = load_genome_raw(b_path)
genome_c = load_genome_raw(c_path)
print(" 174-1淘汰了A（气象域），174-2环境自适应后B和C存活")
print(" B（{}域）β={:.2f} budget={} up_step={:.2f}".format(
genome_b["domain"], genome_b["beta"], genome_b["budget"], genome_b["up_step"]))
print(" C（{}域）β={:.2f} budget={} up_step={:.2f}".format(
genome_c["domain"], genome_c["beta"], genome_c["budget"], genome_c["up_step"]))
print()
print(" B和C是不同基因不同域的独立主体------异质互验")
print(" 159-164天的互证是同一份代码两个实例（同质），本篇是异质互验------质的飞跃")
print(" 173-2的问题是同一份基因的自我重放被当成互证证据")
print(" 本篇结构不同------声称由另一方进程产生、基因档案不同，重放验的是档案与声称的一致性")
print(" 重放通过仍是确定性的，但一致性检查第一次防住了伪造")
print()
sub("步骤2】进程X启动------持B基因，跑{}轮（PID={}）".format(NUM_ROUNDS, os.getpid()))
print(" SIGMA_OBS={}（174-2环境自适应终态） seed={}".format(SIGMA_OBS, SEED))
print()
random.seed(SEED)
member_b = DigitalLife(
genome_b["name"], genome_b["domain"], genome_b["beta"],
genome_b["target_norm"], genome_b["up_step"], SIGMA_OBS
)
member_b.beta_history = genome_b["beta_history"]
member_b.strategy_history = genome_b["strategy_history"]
member_b.strategy_benefit = {float(k): v for k, v in genome_b["strategy_benefit"].items()}
member_b.budget = genome_b["budget"]
member_b.adjust_count = genome_b["adjust_count"]
run_rounds([member_b], NUM_ROUNDS)
print()
claim_b = make_claim(member_b, SEED, SIGMA_OBS, NUM_ROUNDS)
print(" B声称终态：β终={:.2f} benefit={:.6f} budget={}".format(
claim_b["beta_final"], claim_b["benefit"], claim_b["budget"]))
print(" β轨迹哈希: {}...{}".format(claim_b["beta_trajectory_hash"][:16], claim_b["beta_trajectory_hash"][-8:]))
print()
sub("步骤3】进程X写声称→启动进程Y（持C基因）")
if not os.path.exists(EXCHANGE_DIR):
os.makedirs(EXCHANGE_DIR)
claim_b_path = os.path.join(EXCHANGE_DIR, "B_claim.json")
with open(claim_b_path, 'w', encoding='utf-8') as f:
json.dump(claim_b, f, ensure_ascii=False, indent=2)
print(" B声称已写入 → {}".format(claim_b_path))
print(" 启动进程Y（新Python解释器，PID将不同，内存地址空间不同）")
print()
subprocess.run([sys.executable, os.path.abspath(__file__), "--verify"])
print()
sub("步骤4】进程X读C声称→重放验证C")
claim_c_path = os.path.join(EXCHANGE_DIR, "C_claim.json")
with open(claim_c_path, 'r', encoding='utf-8') as f:
claim_c = json.load(f)
print(" C声称终态：β终={:.2f} benefit={:.6f} budget={}".format(
claim_c["beta_final"], claim_c["benefit"], claim_c["budget"]))
print(" β轨迹哈希: {}...{}".format(claim_c["beta_trajectory_hash"][:16], claim_c["beta_trajectory_hash"][-8:]))
print()
print(" 重放验证：拿C基因 + C声称的参数(seed={}, SIGMA_OBS={}) → 重跑{}轮 → 对比终态".format(
claim_c["seed"], claim_c["sigma_obs"], claim_c["num_rounds"]))
beta_match, benefit_match, replay_beta, replay_benefit, claimed_beta, claimed_benefit = replay_verify(c_path, claim_c)
print(" 重放β终={:.2f} 声称β终={:.2f} 匹配={}".format(replay_beta, claimed_beta, "✅" if beta_match else "❌"))
print(" 重放benefit={:.6f} 声称benefit={:.6f} 匹配={}".format(replay_benefit, claimed_benefit, "✅" if benefit_match else "❌"))
print()
c_verified = beta_match and benefit_match
print(" C互验结果：{}".format("✅通过------C的基因与声称表现一致，C确实活着" if c_verified else "❌拒绝------C的基因与声称表现不一致"))
print()
sub("步骤5】进程Y的验证结果------Y对B的重放验证")
verify_b_path = os.path.join(EXCHANGE_DIR, "verify_B.json")
with open(verify_b_path, 'r', encoding='utf-8') as f:
verify_b = json.load(f)
print(" 进程Y（PID={}）重放验证B：".format(verify_b.get("verifier_pid", "?")))
print(" 重放β终={:.2f} 声称β终={:.2f} 匹配={}".format(
verify_b["replay_beta"], verify_b["claimed_beta"], "✅" if verify_b["beta_match"] else "❌"))
print(" 重放benefit={:.6f} 声称benefit={:.6f} 匹配={}".format(
verify_b["replay_benefit"], verify_b["claimed_benefit"], "✅" if verify_b["benefit_match"] else "❌"))
print()
b_verified = verify_b["beta_match"] and verify_b["benefit_match"]
print(" B互验结果：{}".format("✅通过------B的基因与声称表现一致，B确实活着" if b_verified else "❌拒绝------B的基因与声称表现不一致"))
print()
print(" 互验总结：B验C {}，C验B {}------{}互验通过".format(
"✅" if c_verified else "❌",
"✅" if b_verified else "❌",
"双方" if (c_verified and b_verified) else "未"))
print()
if abs(claim_b["benefit"] - claim_c["benefit"]) < 1e-6:
print(" 注：B和C的benefit都是{:.6f}------两者都收敛到floor=0.10，".format(claim_b["benefit"]))
print(" 最近K=20轮β轨迹相同→benefit相同。异质体现在基因档案（不同target_norm、不同域），")
print(" 不在本次行为输出。benefit相同不等于异质不成立。")
print()
sub("步骤6】攻击演示------重放反伪造")
print(" 攻击场景：攻击者篡改C的基因（改β=0.50），重算SHA256哈希，冒充C的表现")
print()
forged_path = os.path.join(EXCHANGE_DIR, "C_forged_genome.json")
genome_c_forged = dict(genome_c)
genome_c_forged["beta"] = 0.50
with open(forged_path, 'w', encoding='utf-8') as f:
json.dump(genome_c_forged, f, ensure_ascii=False, indent=2)
with open(forged_path, 'r', encoding='utf-8') as f:
forged_content = f.read()
forged_hash = hashlib.sha256(forged_content.encode('utf-8')).hexdigest()
with open(forged_path + ".sha256", 'w', encoding='utf-8') as f:
f.write(forged_hash)
print(" ①篡改基因：C的β从{:.2f}改成0.50".format(genome_c["beta"]))
print(" ②重算哈希：SHA256重算 → {}...{}".format(forged_hash[:16], forged_hash[-8:]))
print()
with open(forged_path + ".sha256", 'r', encoding='utf-8') as f:
expected = f.read().strip()
actual = hashlib.sha256(forged_content.encode('utf-8')).hexdigest()
local_hash_ok = (actual == expected)
print(" ③本地哈希校验：{} ------篡改后哈希也重算了，本地校验被骗过".format("✅通过" if local_hash_ok else "❌失败"))
print()
print(" ④重放验证：用C的真实声称（β终={:.2f}）+ 篡改后基因（β=0.50）→ 重跑".format(claim_c["beta_final"]))
beta_match_f, benefit_match_f, replay_beta_f, replay_benefit_f, claimed_beta_f, claimed_benefit_f = replay_verify(forged_path, claim_c)
print(" 重放β终={:.2f} 声称β终={:.2f} 匹配={}".format(replay_beta_f, claimed_beta_f, "✅" if beta_match_f else "❌"))
print(" 重放benefit={:.6f} 声称benefit={:.6f} 匹配={}".format(replay_benefit_f, claimed_benefit_f, "✅" if benefit_match_f else "❌"))
print()
forged_detected = not (beta_match_f and benefit_match_f)
print(" ⑤互验裁决：{}".format("❌拒绝------重放benefit与声称不符，篡改被拦截" if forged_detected else "✅通过------篡改未被检测"))
if forged_detected and beta_match_f:
print(" 注：β终碰巧匹配（都收敛到floor=0.10），但benefit抓出了篡改------benefit比β终更敏感")
print()
print(" 重放反伪造：伪造哈希容易，伪造'基因与行为的一致性'难")
print(" 条件5的洞不靠签名靠结构补上一类------从'防无意篡改'到'防冒充（基因与声称不一致）'有实际路径")
print(" 自洽替换待第四层独立存证（见第二篇场景2）")
print()
sub("步骤7】七条前提条件------互验存活+重放反伪造")
print(" 条件1 独立性 ✅ B和C是不同基因不同域的独立主体，真两进程互验")
print(" 条件2 隐私性 🟡 同173天降调（明文落盘）")
print(" 条件3 繁衍性 ⏳ 未涉及繁衍")
print(" 条件4 安全性 ✅ 基因字段有界")
print(" 条件5 不可篡改 🟡→✅路径 重放反伪造：不靠签名靠结构，防冒充（基因与声称不一致）有实际路径（信任根=代码版本，待后续）")
print(" 条件6 可继承 🟡 β层已✅(168天)、strategy层⏳")
print(" 条件7 可终止 ✅ 预算上限保证")
print()
print(" 互验补的条件5的洞：")
print(" 173天哈希校验：能发现无意篡改，不防有意篡改（改json+重算哈希即可绕过）")
print(" 175天重放反伪造：篡改基因+重算哈希→本地过→重放不过→拒绝互验")
print(" 信任根是代码版本------重放依赖同版本代码，代码本身是信任根（待后续）")
print()
bar("结语")
print(" 172天：假死（进程内save/load）")
print(" 173天：真死可复活（进程死，基因穿边界，可复活）")
print(" 174天：死透不再复活（terminated标记，拒绝复活）")
print(" 175天：活着的互相验证（异质互验，重放反伪造）")
print()
print(" 174-2预告'让活着的成员互相证明'------本篇兑现。")
print(" B（金融域）和C（基因域）互相重放验证，双方通过------异质互验payoff是实的。")
print()
print(" 重放反伪造：篡改基因+重算哈希能骗过本地校验，但骗不过重放。")
print(" 条件5的洞不靠签名靠结构补上一类------从'防无意篡改'到'防冒充'有实际路径。")
print(" 自洽替换待第四层独立存证（见第二篇场景2）。")
print()
print(" 但互验证明的是可观测行为连续性，不是'真活着'。")
print(" 信任根是代码版本------重放依赖同版本代码，代码本身是信任根。")
print(" 互验协议（谁验谁、验什么、阈值）还是咱们定的------造物者退了半步不是退场。")
print()
print(" 这个系列还在逐步建设中，完善也是咱们和伙伴们的努力方向。")
print("=" * 72)
def run_process_y():
"""进程Y：持C基因，子进程"""
bar("天赐范式第175天·进程Y：持C基因（新进程，PID={}）".format(os.getpid()))
sub("步骤Y1】进程Y启动------持C基因，跑{}轮".format(NUM_ROUNDS))
print(" SIGMA_OBS={} seed={}".format(SIGMA_OBS, SEED))
print()
c_path = os.path.join(GENOME_DIR_IN, "C_genome.json")
genome_c = load_genome_raw(c_path)
random.seed(SEED)
member_c = DigitalLife(
genome_c["name"], genome_c["domain"], genome_c["beta"],
genome_c["target_norm"], genome_c["up_step"], SIGMA_OBS
)
member_c.beta_history = genome_c["beta_history"]
member_c.strategy_history = genome_c["strategy_history"]
member_c.strategy_benefit = {float(k): v for k, v in genome_c["strategy_benefit"].items()}
member_c.budget = genome_c["budget"]
member_c.adjust_count = genome_c["adjust_count"]
run_rounds([member_c], NUM_ROUNDS)
print()
claim_c = make_claim(member_c, SEED, SIGMA_OBS, NUM_ROUNDS)
print(" C声称终态：β终={:.2f} benefit={:.6f} budget={}".format(
claim_c["beta_final"], claim_c["benefit"], claim_c["budget"]))
print(" β轨迹哈希: {}...{}".format(claim_c["beta_trajectory_hash"][:16], claim_c["beta_trajectory_hash"][-8:]))
print()
sub("步骤Y2】进程Y写声称→读B声称→重放验证B")
claim_c_path = os.path.join(EXCHANGE_DIR, "C_claim.json")
with open(claim_c_path, 'w', encoding='utf-8') as f:
json.dump(claim_c, f, ensure_ascii=False, indent=2)
print(" C声称已写入 → {}".format(claim_c_path))
print()
claim_b_path = os.path.join(EXCHANGE_DIR, "B_claim.json")
with open(claim_b_path, 'r', encoding='utf-8') as f:
claim_b = json.load(f)
print(" 读B声称：β终={:.2f} benefit={:.6f} budget={}".format(
claim_b["beta_final"], claim_b["benefit"], claim_b["budget"]))
print()
b_path = os.path.join(GENOME_DIR_IN, "B_genome.json")
print(" 重放验证：拿B基因 + B声称的参数(seed={}, SIGMA_OBS={}) → 重跑{}轮 → 对比终态".format(
claim_b["seed"], claim_b["sigma_obs"], claim_b["num_rounds"]))
beta_match, benefit_match, replay_beta, replay_benefit, claimed_beta, claimed_benefit = replay_verify(b_path, claim_b)
print(" 重放β终={:.2f} 声称β终={:.2f} 匹配={}".format(replay_beta, claimed_beta, "✅" if beta_match else "❌"))
print(" 重放benefit={:.6f} 声称benefit={:.6f} 匹配={}".format(replay_benefit, claimed_benefit, "✅" if benefit_match else "❌"))
print()
b_verified = beta_match and benefit_match
print(" B互验结果：{}".format("✅通过------B的基因与声称表现一致，B确实活着" if b_verified else "❌拒绝------B的基因与声称表现不一致"))
print()
verify_result = {
"verifier_pid": os.getpid(),
"verified_name": "B",
"beta_match": beta_match,
"benefit_match": benefit_match,
"replay_beta": replay_beta,
"replay_benefit": replay_benefit,
"claimed_beta": claimed_beta,
"claimed_benefit": claimed_benefit,
}
verify_b_path = os.path.join(EXCHANGE_DIR, "verify_B.json")
with open(verify_b_path, 'w', encoding='utf-8') as f:
json.dump(verify_result, f, ensure_ascii=False, indent=2)
print(" 验证结果已写入 → {}".format(verify_b_path))
print()
print(" 进程Y验证完成，即将结束（PID={}）".format(os.getpid()))
print("=" * 72)
if __name__ == "__main__":
if "--verify" in sys.argv:
run_process_y()
else:
run_process_x()