## 1. 核心设计目标
### 预注册护栏要求
| 护栏项 | 实现方式 |
|--------|----------|
| 1. 摄/化仅为计算策略标签 | 通过 `allow_drift` 和 `correct_drift` 实现自由度漂移控制 |
| 2. D 组仅做算力对标 | 通过 `run_group_D_offline` 实现独立算力评估 |
| 3. R 记账必须同时覆盖 body / boundary | 通过 `ResidualLedger` 类实现体/边界残区分离记账 |
| 4. 三组必须独立 ctx | 通过 `SimContext` 类实例化独立上下文 |
| 5. 扰动算子校准 | 通过 `calibrate_perturbation_strength` 实现扰动强度统一 |
| 6. 体内不可逆性测量 | 通过 `body_dissipation` 探针实现自由度丢失检测 |
| 7. C 组纠偏判断 | 通过 `should_sample` 和 `correct_drift` 实现条件纠偏 |
| 8. 三组 compute_steps 口径一致 | 通过 `compute_steps` 计数器统一计数 |
| 9. validation 条目结构化 | 通过 `build_validation` 实现验证条目结构化 |
| 10. D 组不产出指标 | 通过 `run_group_D_offline` 实现指标隔离 |
## 2. 关键组件实现
### 2.1 残区账本 (ResidualLedger)
```python
@dataclass
class ResidualLedger:
body_ledger: List[float] = field(default_factory=list)
boundary_ledger: List[float] = field(default_factory=list)
def charge_body(self, amount: float):
if amount > 0:
self.body_ledger.append(amount)
def charge_boundary(self, amount: float):
if amount > 0:
self.boundary_ledger.append(amount)
def total(self) -> float:
return sum(self.body_ledger) + sum(self.boundary_ledger)
def body_total(self) -> float:
return sum(self.body_ledger)
def boundary_total(self) -> float:
return sum(self.boundary_ledger)
2.2 实验上下文 (SimContext)
@dataclass
class SimContext:
contract_id: str
residual_r: ResidualLedger = field(default_factory=ResidualLedger)
invariant_history: List[float] = field(default_factory=list)
platform_heights: List[float] = field(default_factory=list)
compute_steps: int = 0
samples_used: int = 0
corrections_used: int = 0
def reset(self):
self.residual_r = ResidualLedger()
self.invariant_history = []
self.platform_heights = []
self.compute_steps = 0
self.samples_used = 0
self.corrections_used = 0
2.3 底层动力学与探针
def reversible_step(state: Dict[str, Any], t: int) -> Dict[str, Any]:
return {k: v for k, v in state.items()}
def compute_invariant(state: Dict[str, Any]) -> float:
return state.get("invariant", 0.0)
def read_platform(state: Dict[str, Any]) -> float:
return state.get("platform", 0.0)
def boundary_cost(pre: Dict[str, Any], post: Dict[str, Any]) -> float:
return abs(read_platform(pre) - read_platform(post))
def body_dissipation(pre: Dict[str, Any], post: Dict[str, Any]) -> float:
lost_dofs = [k for k in pre if k not in post]
if lost_dofs:
return float(len(lost_dofs))
return 0.0
2.4 诊断函数
def invariant_drift(ctx: SimContext) -> float:
if not ctx.invariant_history:
return 0.0
c0 = ctx.invariant_history[0]
return max(abs(c - c0) for c in ctx.invariant_history)
def platform_stable(ctx: SimContext, window: int = 10) -> float:
recent = ctx.platform_heights[-window:]
if len(recent) < 2:
return 0.0
mean = sum(recent) / len(recent)
var = sum((x - mean) ** 2 for x in recent) / len(recent)
return var
def probe_residual_concentration(ctx: SimContext) -> Dict[str, Any]:
total = ctx.residual_r.total()
boundary_share = ctx.residual_r.boundary_total()
body_share = ctx.residual_r.body_total()
return {
"total": total,
"boundary_share": boundary_share,
"body_share": body_share,
"body_share_zero_confirmed": body_share == 0.0,
}
2.5 C 组机制件
def should_sample(t: int, rate: float) -> bool:
if rate <= 0:
return False
period = max(1, int(1.0 / rate))
return (t % period) == 0
def allow_drift(state: Dict[str, Any], budget: float) -> Dict[str, Any]:
drifted = dict(state)
for k in drifted:
if k == "invariant":
continue
drifted[k] = drifted[k] # 占位：接入真实漂移算子
return drifted
def correct_drift(state: Dict[str, Any], c_ref: float) -> Dict[str, Any]:
corrected = dict(state)
corrected["invariant"] = c_ref
return corrected
2.6 扰动强度校准协议
def calibrate_perturbation_strength(
perturb_fn: Callable,
state0: Dict[str, Any],
target_delta: float,
steps: int = 100,
tolerance: float = 1e-3,
max_iterations: int = 50,
) -> Callable:
low, high = 1e-6, 1.0
best_fn = perturb_fn
for _ in range(max_iterations):
mid = (low + high) / 2.0
def scaled_perturb(state, t, scale=mid):
return perturb_fn(state, t, scale=scale)
total_delta = 0.0
test_state = dict(state0)
for t in range(steps):
pre = dict(test_state)
test_state = scaled_perturb(test_state, t)
delta = sum(
abs(pre.get(k, 0.0) - test_state.get(k, 0.0))
for k in pre
if k != "invariant" and k in test_state
)
total_delta += delta
avg_delta = total_delta / steps
if abs(avg_delta - target_delta) < tolerance:
best_fn = scaled_perturb
break
elif avg_delta < target_delta:
low = mid
else:
high = mid
best_fn = scaled_perturb
return best_fn
3. 实验组实现
3.1 A 组：体内扰动
def run_group_A(
ctx: SimContext,
state0: Dict[str, Any],
perturb_body: Callable,
steps: int,
) -> Dict[str, Any]:
state = dict(state0)
c0 = compute_invariant(state)
ctx.invariant_history.append(c0)
ctx.platform_heights.append(read_platform(state))
for t in range(steps):
pre_state = dict(state)
state = perturb_body(state, t)
state = reversible_step(state, t)
post_state = dict(state)
ctx.compute_steps += 1
diss = body_dissipation(pre_state, post_state)
if diss > 0:
ctx.residual_r.charge_body(diss)
c = compute_invariant(state)
ctx.invariant_history.append(c)
ctx.platform_heights.append(read_platform(state))
return {
"group": "A_body_perturbation",
"invariant_drift": invariant_drift(ctx),
"platform_variance": platform_stable(ctx),
"residual": probe_residual_concentration(ctx),
"compute_steps": ctx.compute_steps,
"samples_used": ctx.samples_used,
"corrections_used": ctx.corrections_used,
}
3.2 B 组：边界扰动
def run_group_B(
ctx: SimContext,
state0: Dict[str, Any],
perturb_boundary: Callable,
steps: int,
) -> Dict[str, Any]:
state = dict(state0)
c0 = compute_invariant(state)
ctx.invariant_history.append(c0)
ctx.platform_heights.append(read_platform(state))
for t in range(steps):
pre_state = dict(state)
state = reversible_step(state, t)
post_state = dict(state)
post_state = perturb_boundary(post_state, t)
ctx.compute_steps += 1
cost = boundary_cost(pre_state, post_state)
if cost > 0:
ctx.residual_r.charge_boundary(cost)
c = compute_invariant(state)
ctx.invariant_history.append(c)
ctx.platform_heights.append(read_platform(post_state))
state = post_state
return {
"group": "B_boundary_perturbation",
"invariant_drift": invariant_drift(ctx),
"platform_variance": platform_stable(ctx),
"residual": probe_residual_concentration(ctx),
"compute_steps": ctx.compute_steps,
"samples_used": ctx.samples_used,
"corrections_used": ctx.corrections_used,
}
3.3 C 组：摄化扰动
def run_group_C(
ctx: SimContext,
state0: Dict[str, Any],
perturb_she: Callable,
steps: int,
drift_budget: float,
sample_rate: float = 0.1,
) -> Dict[str, Any]:
state = dict(state0)
c0 = compute_invariant(state)
ctx.invariant_history.append(c0)
ctx.platform_heights.append(read_platform(state))
for t in range(steps):
pre_state = dict(state)
state = allow_drift(state, drift_budget)
ctx.compute_steps += 1
if should_sample(t, sample_rate):
ctx.samples_used += 1
c_now = compute_invariant(state)
if abs(c_now - c0) > 1e-9:
state = correct_drift(state, c0)
ctx.corrections_used += 1
cost = boundary_cost(pre_state, state)
if cost > 0:
ctx.residual_r.charge_boundary(cost)
ctx.invariant_history.append(compute_invariant(state))
ctx.platform_heights.append(read_platform(state))
else:
state = reversible_step(state, t)
c = compute_invariant(state)
ctx.invariant_history.append(c)
ctx.platform_heights.append(read_platform(state))
return {
"group": "C_she_hua_perturbation",
"invariant_drift": invariant_drift(ctx),
"platform_variance": platform_stable(ctx),
"residual": probe_residual_concentration(ctx),
"compute_steps": ctx.compute_steps,
"samples_used": ctx.samples_used,
"corrections_used": ctx.corrections_used,
}
3.4 D 组：还原论旁置
def run_group_D_offline(reference_metrics: Dict[str, Any]) -> Dict[str, Any]:
return {
"group": "D_reductionist_benchmark",
"role": "compute_benchmark_only",
"participates_in_validity": False,
"compute": {
"branches_enumerated": reference_metrics.get("branches", 0),
"samples_total": reference_metrics.get("samples", 0),
"corrections_total": reference_metrics.get("corrections", 0),
"total_steps": reference_metrics.get("steps", 0),
},
}
4. 结构化验证
def build_validation(results: Dict[str, Any]) -> List[Dict[str, Any]]:
validation = []
a_body = results["A"]["residual"]["body_share"]
validation.append({
"rule": "A_body_residual_zero",
"passed": a_body < 1e-9,
"message": "" if a_body < 1e-9 else "A.body_residual > 0：P 层可逆性被破坏，需检查 reversible_step",
})
a_bnd = results["A"]["residual"]["boundary_share"]
b_bnd = results["B"]["residual"]["boundary_share"]
validation.append({
"rule": "B_boundary_residual_dominant",
"passed": b_bnd > a_bnd,
"message": "" if b_bnd > a_bnd else "B.boundary_residual 未显著高于 A：边界扰动未生效",
})
a_steps = results["A"]["compute_steps"]
c_steps = results["C"]["compute_steps"]
c_samples = results["C"]["samples_used"]
validation.append({
"rule": "C_compute_saving",
"passed": (c_steps + c_samples) < a_steps,
"message": "" if (c_steps + c_samples) < a_steps else "C 总开销未低于 A：摄化未压低算力",
})
a_drift = results["A"]["invariant_drift"]
c_drift = results["C"]["invariant_drift"]
validation.append({
"rule": "C_invariant_protected",
"passed": abs(c_drift - a_drift) < 1e-6,
"message": "" if abs(c_drift - a_drift) < 1e-6 else "C.invariant_drift 与 A 不一致：摄化可能破坏拓扑保护",
})
validation.append({
"rule": "D_excluded_from_validity",
"passed": results.get("D") is None or not results["D"].get("participates_in_validity", True),
"message": "" if (results.get("D") is None or not results["D"].get("participates_in_validity", True)) else "D 组产出不应参与平台有效性判定",
})
return validation
5. 总控函数
def run_topology_control_experiment(
base_contract: str,
state0: Dict[str, Any],
perturb_body: Callable,
perturb_boundary: Callable,
perturb_she: Callable,
steps: int = 1000,
drift_budget: float = 1e-3,
sample_rate: float = 0.1,
target_delta: float = 0.01,
reference_metrics: Dict[str, Any] | None = None,
) -> Dict[str, Any]:
perturb_body_cal = calibrate_perturbation_strength(perturb_body, state0, target_delta)
perturb_boundary_cal = calibrate_perturbation_strength(perturb_boundary, state0, target_delta)
perturb_she_cal = calibrate_perturbation_strength(perturb_she, state0, target_delta)
ctx_A = SimContext(contract_id=base_contract)
ctx_B = SimContext(contract_id=base_contract)
ctx_C = SimContext(contract_id=base_contract)
result_A = run_group_A(ctx_A, state0, perturb_body_cal, steps)
result_B = run_group_B(ctx_B, state0, perturb_boundary_cal, steps)
result_C = run_group_C(ctx_C, state0, perturb_she_cal, steps, drift_budget, sample_rate)
results = {
"A": result_A,
"B": result_B,
"C": result_C,
"D": None,
}
if reference_metrics:
results["D"] = run_group_D_offline(reference_metrics)
validation = build_validation(results)
return {
"experiment": "TOPO-CTRL-001",
"contract": base_contract,
"results": results,
"validation": validation,
"archive": "GZ-SNAP/TOPO-CTRL-001",
}
参考来源