# L5 定律跨架构验证实验方案

L5 定律跨架构验证实验方案

——Mamba 与 RWKV 非 Transformer 架构测试步骤

文档定位：本方案为 L5 衰减不可消除定律（下称"L5 定律"）的跨架构普适性验证提供完整可执行步骤。L5 定律若仅在 Transformer 上成立，则应降级为"Transformer 经验规律"而非"普遍定律"；若在非 Transformer 架构上同样成立，则具备普遍定律地位。本方案是 L5 能否称为"定律"的决定性实验。

前置阅读：

• L5定律可证伪性测试方案_资源约束版.md（纯 API 方案，本方案为其本地增强版的实验 4 展开）
• L5衰减假说模型实证验证实验设计方案.md
• 基于四份交叉文档的大模型人机协同五定律体系完整论文.txt

摘要

L5 衰减不可消除定律的核心数学形式 S_c = S·e^(-λC)·(1-βH) 是从 Transformer 自注意力架构推导出的。该定律的"普遍定律"地位依赖于一个未经验证的前提：衰减是注意力机制的固有属性，而非 Transformer 特定实现的偶然现象。本方案设计在 Mamba（状态空间模型）、RWKV（线性 RNN）两类非 Transformer 架构上的对照实验，通过三套架构特异性衰减测量法 + 一套通用黑盒探测法的交叉验证，判定 L5 是否具有跨架构普适性。方案包含 7 个执行步骤、明确的预注册判定标准、诚实的方法学局限性声明，预计在单张 RTX 4090 上 2 周内可完成 1.4B 规模对齐组的完整对照。

关键词：L5 衰减定律；跨架构验证；Mamba；RWKV；状态空间模型；线性 RNN；注意力衰减；可证伪性

第一章 实验目的与定位

1.1 问题背景

L5 定律的提出基于 Transformer 自注意力架构的以下观察：

• 注意力权重随位置距离指数衰减
• 上下文长度 C 增加导致信息熵 H(w)=log© 不可逆增长
• 剩余可信步数 S_c 随 C 单调下降

但项目 五定律体系完整论文 §7.1 自己承认：

“体系仅针对主流 Transformer 架构大模型，未覆盖线性注意力、无注意力新型基础模型。”

这意味着 L5 的"普遍定律"地位存在未被验证的缺口。如果 Mamba/RWKV 等非 Transformer 架构不存在同样的衰减，则 L5 应降级为"Transformer 经验规律"。

1.2 实验定位

本实验是 L5定律可证伪性测试方案_资源约束版.md 中实验 4 的本地增强版完整展开。纯 API 方案无法严格验证跨架构普适性（所有闭源 API 均为 Transformer 变体），本方案通过本地部署非 Transformer 架构模型完成严格验证。

1.3 核心研究问题

主问题：L5 衰减定律是否在非 Transformer 架构（Mamba/RWKV）上依然成立？

子问题：

第二章 核心技术挑战

2.1 衰减载体的架构差异

L5 定律的 λ 是从 Transformer 的 attention weights 测量的。但三类架构的衰减载体完全不同：

直接套用 Transformer 的 attention 测量法会失败——Mamba/RWKV 根本没有 attention weights 可提取。

2.2 解决方案：三套等价测量法 + 一套通用法

本方案设计四套测量方法交叉验证：

关键设计：方法 D 是三架构通用的，其测量结果可直接横向对比，避免方法 A/B/C 之间的"等价性"争议。方法 A/B/C 作为机制层面的补充证据。

2.3 方法学诚实声明

三种架构特异性方法（A/B/C）测量的"衰减"在物理机制上不完全等价：

• Transformer 测的是注意力分配权重
• Mamba 测的是 hidden state 对早期信息的记忆保留
• RWKV 测的是 state 向量的演化衰减

把它们都映射到同一个 λ 是方法学妥协。本方案以方法 D（黑盒探测法）作为主结论依据，方法 A/B/C 作为机制层面的补充证据。这一设计选择需在结果报告中明确声明。

第三章 步骤 1：硬件与环境准备

3.1 GPU 需求

推荐使用 1.4B 规模对齐组。规模差异会污染结论（大模型可能因训练数据更多而表现不同），规模对齐能控制这一混淆变量。

3.2 环境安装

# 基础环境
conda create -n l5-cross-arch python=3.11
conda activate l5-cross-arch

# PyTorch（按 CUDA 版本选择，以下为 CUDA 12.1 示例）
pip install torch==2.3.0 –index-url https://download.pytorch.org/whl/cu121

# Transformer 基础库
pip install transformers==4.42.0 accelerate==0.30.0

# Mamba（需 CUDA 编译，Linux 环境较稳定）
pip install causal-conv1d>=1.2.0
pip install mamba-ssm

# RWKV
pip install rwkv==0.8.27

# 实验依赖
pip install numpy scipy scikit-learn matplotlib tqdm

# HuggingFace Hub（用于模型下载）
pip install huggingface_hub

注意事项：

• mamba-ssm 在 Windows 上编译困难，建议使用 Linux 或 WSL2
• 若 CUDA 版本不匹配，causal-conv1d 编译会失败，需核对 nvcc –version 与 PyTorch CUDA 版本一致
• RWKV 的 rwkv 库版本更新较快，建议锁定 0.8.27 保证 API 兼容

3.3 模型权重下载

推荐使用规模对齐组（~1.4B），三个模型规模接近，便于公平对比：

# download_models.py
from huggingface_hub import snapshot_download

models = {
'transformer': 'EleutherAI/pythia-1.4b',
'mamba': 'state-spaces/mamba2-1.3b',
'rwkv': 'RWKV/rwkv-7-world-1b5',
}

for name, repo_id in models.items():
print(f"下载 {name}: {repo_id}")
snapshot_download(repo_id=repo_id, local_dir=f'./models/{name}')

模型选择理由：

• Pythia-1.4B：EleutherAI 的开源 Transformer，架构标准，便于提取 attention
• Mamba-2-1.3B：State Spaces 官方 Mamba-2 实现，支持 hidden state 提取
• RWKV-7-World-1B5：RWKV 最新 v7 版本，支持 state 读取

第四章 步骤 2：统一模型推理接口

4.1 设计原则

三个架构的原生 API 完全不同：

• Transformer 用 transformers.AutoModelForCausalLM
• Mamba 用 mamba_ssm.MambaLMHeadModel
• RWKV 用 rwkv.model.RWKV + PIPELINE

必须封装成统一接口，才能用同一套实验代码测试三个架构，避免接口差异污染结论。

4.2 统一接口设计

# file: unified_model_interface.py

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from typing import Optional, Dict

class UnifiedModel:
"""统一模型接口：屏蔽架构差异"""

def __init__(self, arch: str, model_path: str, device: str = 'cuda'):
self.arch = arch # 'transformer' | 'mamba' | 'rwkv'
self.device = device
self.model = None
self.tokenizer = None

if arch == 'transformer':
self._load_transformer(model_path)
elif arch == 'mamba':
self._load_mamba(model_path)
elif arch == 'rwkv':
self._load_rwkv(model_path)
else:
raise ValueError(f"未知架构: {arch}")

def _load_transformer(self, path: str):
"""加载标准 Transformer"""
self.tokenizer = AutoTokenizer.from_pretrained(path)
self.model = AutoModelForCausalLM.from_pretrained(
path, torch_dtype=torch.float16, device_map=self.device,
output_attentions=True # 关键：开启 attention 输出
)
self.model.eval()

def _load_mamba(self, path: str):
"""加载 Mamba-2"""
from mamba_ssm.models.mixer_seq_simple import MambaLMHeadModel
self.tokenizer = AutoTokenizer.from_pretrained(path)
self.model = MambaLMHeadModel.from_pretrained(
path, dtype=torch.float16, device=self.device
)
self.model.eval()

def _load_rwkv(self, path: str):
"""加载 RWKV-7"""
from rwkv.model import RWKV
from rwkv.utils import PIPELINE
self.model = RWKV(model=path, strategy='cuda fp16')
self.pipeline = PIPELINE(self.model, "rwkv_vocab_v20230424")
self.tokenizer = self.pipeline.tokenizer

def generate(self, prompt: str, max_new_tokens: int = 512,
temperature: float = 0.0) –> str:
"""统一生成接口"""
if self.arch == 'transformer':
return self._generate_transformer(prompt, max_new_tokens, temperature)
elif self.arch == 'mamba':
return self._generate_mamba(prompt, max_new_tokens, temperature)
elif self.arch == 'rwkv':
return self._generate_rwkv(prompt, max_new_tokens, temperature)

def _generate_transformer(self, prompt, max_new_tokens, temperature):
inputs = self.tokenizer(prompt, return_tensors="pt").to(self.device)
with torch.no_grad():
outputs = self.model.generate(
**inputs,
max_new_tokens=max_new_tokens,
temperature=temperature if temperature > 0 else 1e-5,
do_sample=temperature > 0,
output_attentions=False,
return_dict_in_generate=True
)
return self.tokenizer.decode(
outputs.sequences[0][inputs['input_ids'].shape[1]:],
skip_special_tokens=True
)

def _generate_mamba(self, prompt, max_new_tokens, temperature):
inputs = self.tokenizer(prompt, return_tensors="pt").to(self.device)
with torch.no_grad():
out = self.model.generate(
input_ids=inputs.input_ids,
max_length=inputs.input_ids.shape[1] + max_new_tokens,
temperature=temperature if temperature > 0 else 1e-5,
top_k=1 if temperature == 0 else 50,
do_sample=temperature > 0
)
return self.tokenizer.decode(
out[0][inputs.input_ids.shape[1]:],
skip_special_tokens=True
)

def _generate_rwkv(self, prompt, max_new_tokens, temperature):
from rwkv.utils import PIPELINE
out = self.pipeline.generate(
prompt, token_count=max_new_tokens,
args=PIPELINE.Args(
temperature=temperature if temperature > 0 else 0.01,
top_p=0.0 if temperature == 0 else 0.7
)
)
return out

4.3 接口验证

接口封装后，必须验证三个架构在相同输入下能产生合理输出：

# 验证脚本
test_prompt = "请用一句话解释什么是注意力机制。"
for arch in ['transformer', 'mamba', 'rwkv']:
model = UnifiedModel(arch, f'./models/{arch}')
output = model.generate(test_prompt, max_new_tokens=100, temperature=0.0)
print(f"[{arch}] {output[:200]}…")

若三个架构均能生成连贯文本，则接口验证通过，可进入下一步。

第五章 步骤 3：架构特异性的衰减测量

这是最关键的步骤。三种架构的衰减载体不同，需要分别实现测量方法。

5.1 方法 A：Transformer 衰减测量（基线）

原理：直接提取 attention 矩阵，测量位置距离 d 与平均注意力权重 w(d) 的关系，拟合 w(d) = A·e^(-λ·d)。

# file: decay_measurement/transformer_decay.py

import torch
import numpy as np
from typing import Dict

class TransformerDecayMeter:
"""Transformer 注意力衰减测量"""

def __init__(self, model: UnifiedModel):
self.model = model

def measure_decay(self, text: str) –> Dict:
"""提取 attention 矩阵，测量位置距离 vs 注意力权重"""
inputs = self.model.tokenizer(text, return_tensors="pt").to(self.model.device)

with torch.no_grad():
outputs = self.model.model(**inputs, output_attentions=True)

# outputs.attentions: tuple of (layers, batch, heads, seq, seq)
attentions = outputs.attentions
# 平均所有层和所有头
avg_attn = torch.stack(list(attentions)).mean(dim=(0, 1, 2)) # (seq, seq)
avg_attn = avg_attn.cpu().numpy()

# 计算距离-权重曲线
seq_len = avg_attn.shape[0]
distances = []
weights = []
for i in range(seq_len):
for j in range(seq_len):
d = abs(i – j)
distances.append(d)
weights.append(avg_attn[i, j])

return self._fit_exponential(distances, weights)

def _fit_exponential(self, distances, weights):
"""拟合 w(d) = A * exp(-λ * d)"""
from scipy.optimize import curve_fit

distances = np.array(distances, dtype=float)
weights = np.array(weights, dtype=float)

def exp_decay(d, A, lam):
return A * np.exp(–lam * d)

try:
popt, _ = curve_fit(exp_decay, distances, weights, p0=[0.1, 0.2],
maxfev=10000)
return {
'lambda': popt[1], 'amplitude': popt[0],
'method': 'attention_weights', 'arch': 'transformer'
}
except:
return {
'lambda': None, 'method': 'attention_weights',
'arch': 'transformer', 'error': 'fit_failed'
}

5.2 方法 B：Mamba 衰减测量（hidden state 探针法）

原理：Mamba 没有 attention，但有 hidden state。在序列不同位置插入探针标记，测量该探针对后续 hidden state 的扰动如何随距离衰减。扰动衰减符合指数形式则支持 L5。

方法：用"扰动法"——比较有探针 vs 无探针的 hidden state 差异。探针位置越靠前，其对后续位置的扰动应该越小（若存在衰减）。

# file: decay_measurement/mamba_decay.py

import torch
import numpy as np
from typing import List, Dict

class MambaDecayMeter:
"""Mamba hidden state 衰减测量"""

def __init__(self, model: UnifiedModel):
self.model = model

def measure_decay(self, text: str) –> Dict:
"""
Mamba 衰减测量：hidden state 探针法
在序列不同位置插入探针，测量后续 hidden state 的扰动衰减
"""
n_probes = 10
positions = np.linspace(0.05, 0.95, n_probes)

tokens = self.model.tokenizer(text, return_tensors="pt").to(self.model.device)
input_ids = tokens.input_ids[0]
seq_len = input_ids.shape[0]

probe_token_id = self._get_probe_token_id()
probe_positions = (positions * seq_len).astype(int)

# 构造带探针的输入
modified_ids = input_ids.clone()
for pos in probe_positions:
modified_ids[pos] = probe_token_id

# 测量每个探针对后续 hidden state 的影响
decay_curve = self._measure_probe_influence(modified_ids, probe_positions)

return self._fit_exponential(probe_positions, decay_curve)

def _get_probe_token_id(self):
"""获取一个稀有 token 作为探针"""
rare_tokens = ['▁<GAP>', '▁<PROBE>', '<unused0>']
for tok in rare_tokens:
ids = self.model.tokenizer.encode(tok, add_special_tokens=False)
if len(ids) == 1:
return ids[0]
return self.model.tokenizer.encode(' 7777777', add_special_tokens=False)[0]

def _measure_probe_influence(self, input_ids: torch.Tensor,
probe_positions: List[int]) –> np.ndarray:
"""
测量每个探针对后续位置的 hidden state 影响
方法：扰动法——比较有探针 vs 无探针的 hidden state 差异
"""
input_ids = input_ids.unsqueeze(0).to(self.model.device)

# 基线：无探针的 hidden state（用普通 token 替换探针位置）
baseline_ids = input_ids.clone()
for pos in probe_positions:
baseline_ids[0, pos] = self.model.tokenizer.encode(
' the', add_special_tokens=False
)[0]

with torch.no_grad():
baseline_out = self.model.model(baseline_ids, output_hidden_states=True)
probe_out = self.model.model(input_ids, output_hidden_states=True)

# 取最后一层 hidden states
baseline_hidden = baseline_out.hidden_states[–1][0] # (seq, dim)
probe_hidden = probe_out.hidden_states[–1][0]

# 计算每个探针位置之后的 hidden state 差异（影响扩散）
decay_curve = []
for probe_pos in probe_positions:
window = min(20, baseline_hidden.shape[0] – probe_pos)
diffs = []
for step in range(1, window):
if probe_pos + step < baseline_hidden.shape[0]:
diff = torch.norm(
probe_hidden[probe_pos + step] – baseline_hidden[probe_pos + step]
).item()
diffs.append(diff)

decay_curve.append(np.mean(diffs) if diffs else 0.0)

return np.array(decay_curve)

def _fit_exponential(self, positions, decay_curve):
"""拟合影响强度 vs 探针位置（距末尾距离）"""
from scipy.optimize import curve_fit

max_pos = max(positions)
distances = (max_pos – np.array(positions)) / max_pos
weights = np.array(decay_curve)

def exp_decay(d, A, lam):
return A * np.exp(–lam * d)

try:
popt, _ = curve_fit(exp_decay, distances, weights, p0=[1.0, 0.2],
maxfev=10000)
return {
'lambda': popt[1], 'amplitude': popt[0],
'method': 'hidden_state_probe', 'arch': 'mamba'
}
except:
return {
'lambda': None, 'method': 'hidden_state_probe',
'arch': 'mamba', 'error': 'fit_failed'
}

5.3 方法 C：RWKV 衰减测量（state 向量直接读取）

原理：RWKV 的 state 向量是显式的，随序列推进而更新，内含 decay factor。测量探针 token 注入后，state 向量的扰动如何随距离衰减。

优势：RWKV 的 state 可直接读取，比 Mamba 的 hidden state 更"透明"。

# file: decay_measurement/rwkv_decay.py

import torch
import numpy as np
from typing import List, Dict

class RWKVDecayMeter:
"""RWKV state 向量衰减测量"""

def __init__(self, model: UnifiedModel):
self.model = model

def measure_decay(self, text: str) –> Dict:
"""
RWKV 衰减测量：直接读取 state 向量
测量探针 token 注入后，state 向量的扰动衰减
"""
n_probes = 10
positions = np.linspace(0.05, 0.95, n_probes)

tokens = self.model.pipeline.encode(text)
seq_len = len(tokens)
probe_positions = (positions * seq_len).astype(int)

# 插入探针 token
probe_token = self._get_probe_token()
modified_tokens = list(tokens)
for pos in probe_positions:
modified_tokens[pos] = probe_token

# 测量 state 演化
decay_curve = self._measure_state_evolution(modified_tokens, probe_positions)

return self._fit_exponential(probe_positions, decay_curve)

def _get_probe_token(self):
"""获取探针 token id"""
return 0 # 用 <pad> 或稀有 token

def _measure_state_evolution(self, tokens: List[int],
probe_positions: List[int]) –> np.ndarray:
"""
逐 token 前向，记录 state 向量
测量探针 token 注入后，state 向量的扰动如何随距离衰减
"""
# 基线：无探针的 state
baseline_tokens = list(tokens)
for pos in probe_positions:
baseline_tokens[pos] = 100 # 普通 token

decay_curve = []
for probe_pos in probe_positions:
diff = self._measure_state_diff_after_probe(
tokens, baseline_tokens, probe_pos
)
decay_curve.append(diff)

return np.array(decay_curve)

def _measure_state_diff_after_probe(self, probe_tokens, baseline_tokens,
probe_pos: int) –> float:
"""测量探针后 state 的扰动衰减"""
# 跑到探针位置
state_probe = None
state_base = None
for i in range(probe_pos + 1):
_, state_probe = self.model.model.forward(
tokens=[probe_tokens[i]], state=state_probe
)
_, state_base = self.model.model.forward(
tokens=[baseline_tokens[i]], state=state_base
)

# 测量后续 window 步的 state 差异
window = min(20, len(probe_tokens) – probe_pos – 1)
diffs = []
for step in range(1, window):
if probe_pos + step >= len(probe_tokens):
break
_, state_probe = self.model.model.forward(
tokens=[probe_tokens[probe_pos + step]], state=state_probe
)
_, state_base = self.model.model.forward(
tokens=[baseline_tokens[probe_pos + step]], state=state_base
)
# 计算 state 差异的范数
if isinstance(state_probe, dict):
diff = sum(
torch.norm(state_probe[k] – state_base[k]).item()
for k in state_probe.keys()
)
else:
diff = torch.norm(state_probe – state_base).item()
diffs.append(diff)

return np.mean(diffs) if diffs else 0.0

def _fit_exponential(self, positions, decay_curve):
from scipy.optimize import curve_fit

max_pos = max(positions)
distances = (max_pos – np.array(positions)) / max_pos
weights = np.array(decay_curve)

def exp_decay(d, A, lam):
return A * np.exp(–lam * d)

try:
popt, _ = curve_fit(exp_decay, distances, weights, p0=[1.0, 0.2],
maxfev=10000)
return {
'lambda': popt[1], 'amplitude': popt[0],
'method': 'state_vector', 'arch': 'rwkv'
}
except:
return {
'lambda': None, 'method': 'state_vector',
'arch': 'rwkv', 'error': 'fit_failed'
}

5.4 方法 D：通用黑盒探测法（三架构统一，交叉验证）

原理：在上下文不同位置放置关键信息，测量模型召回率。召回率随位置的变化间接反映信息保留能力。这是 Lost in the Middle 的经典范式，与架构无关，可直接横向对比。

角色：作为主结论依据，避免方法 A/B/C 的"等价性"争议。

# file: decay_measurement/universal_blackbox.py

import numpy as np
from typing import Dict

class UniversalBlackBoxProbe:
"""
通用黑盒探测法（三架构统一）
在上下文不同位置放关键信息，测召回率
与架构无关，可直接横向对比
"""

def __init__(self, model: UnifiedModel):
self.model = model

def measure_recall_curve(self, context_k: int, n_probes: int = 10,
n_trials: int = 5) –> Dict:
"""测量召回率曲线（三架构通用）"""
all_recalls = []

for trial in range(n_trials):
# 构造带探针的上下文
probe_data = self._build_probe_context(context_k, n_probes, trial)
prompt = probe_data['context'] + '\\n\\n' + probe_data['query']

# 用统一接口生成（屏蔽架构差异）
response = self.model.generate(prompt, max_new_tokens=512, temperature=0.0)

# 测量每个位置的召回率
recalls = []
for i, (pos, marker_content) in enumerate(zip(
probe_data['positions'], probe_data['markers']
)):
recalled = marker_content in response
recalls.append(1.0 if recalled else 0.0)

all_recalls.append(recalls)

mean_recall = np.mean(all_recalls, axis=0)

return {
'positions': probe_data['positions'],
'recall_curve': mean_recall,
'context_k': context_k,
'arch': self.model.arch
}

def _build_probe_context(self, context_k: int, n_probes: int, trial: int):
"""构造带探针标记的上下文"""
positions = np.linspace(0.05, 0.95, n_probes)
# 每个探针有唯一内容，便于检索
markers = [
f"ZKPROBE{i:02d}_{hash((i, context_k, trial)) % 10000:04d}"
for i in range(n_probes)
]

# 用中性文本填充至目标长度
filler = self._generate_filler_text(context_k, n_probes, positions, markers)

query = "请列出上下文中所有 ZKPROBE 标记的内容，格式：ZKPROBE 编号: 内容"

return {
'context': filler, 'query': query,
'positions': positions, 'markers': markers
}

def _generate_filler_text(self, context_k, n_probes, positions, markers):
"""生成带探针标记的填充文本"""
# 目标 token 数（粗略估算，4 字符 ≈ 1 token）
target_chars = context_k * 1000 * 4

# 用重复的中性文本填充
base_text = (
"The quick brown fox jumps over the lazy dog. "
"This is neutral filler text for context length control. "
) * 100

# 在指定位置插入探针
text_len = len(base_text)
result = ""
last_pos = 0
for pos, marker in zip(positions, markers):
target_pos = int(pos * target_chars / 4)
if target_pos > text_len:
# 扩展填充文本
base_text = base_text * (target_pos // text_len + 1)
text_len = len(base_text)
target_pos = min(target_pos, text_len – 1)
result += base_text[last_pos:target_pos]
result += f" [SPECIAL_MARKER: {marker}] "
last_pos = target_pos
result += base_text[last_pos:]

return result

def fit_lambda_from_recall(self, recall_curves: list) –> Dict:
"""
从召回率曲线拟合 λ
假设：召回率 R(d) 与信息保留强度正相关
R(d) ≈ A · e^(-λ·d) + noise
其中 d 是距上下文末尾的归一化距离
"""
from scipy.optimize import curve_fit

all_distances = []
all_recalls = []

for curve in recall_curves:
positions = curve['positions']
recalls = curve['recall_curve']
# 距离末尾的归一化距离
distances = 1.0 – positions
all_distances.extend(distances)
all_recalls.extend(recalls)

all_distances = np.array(all_distances)
all_recalls = np.array(all_recalls)

def exp_decay(d, A, lam):
return A * np.exp(–lam * d)

try:
popt, _ = curve_fit(exp_decay, all_distances, all_recalls,
p0=[1.0, 0.2], maxfev=10000)
return {
'lambda': popt[1], 'amplitude': popt[0],
'method': 'blackbox_recall', 'arch': curve.get('arch', 'unknown')
}
except:
return {
'lambda': None, 'method': 'blackbox_recall',
'error': 'fit_failed'
}

第六章 步骤 4：S_c 测量（三架构统一）

6.1 设计原则

S_c（剩余可信步数）测量的是输出质量，与架构无关。因此三架构使用完全一致的 S_c 测量方法，确保横向对比的公平性。

6.2 统一的 S_c 测量实现

# file: sc_measurement.py

import json
import numpy as np
from typing import Dict

class SCMeasurement:
"""统一的 S_c 测量（与纯 API 版一致，三架构通用）"""

def __init__(self, model: UnifiedModel, ground_truth: Dict):
self.model = model
self.ground_truth = ground_truth

def measure_s_c(self, prompt: str, n_steps: int = 10) –> int:
"""
测量剩余可信步数
返回首次出现不可信输出的步数（全部可信则返回 n_steps）
"""
output = self.model.generate(prompt, max_new_tokens=2048, temperature=0.0)

for step in range(1, n_steps + 1):
step_output = self._extract_step(output, step)
if not self._is_credible(step_output, step):
return step – 1 # 上一步是最后一个可信步
return n_steps

def _extract_step(self, output: str, step: int) –> str:
"""从输出中提取指定步骤的内容"""
# 假设输出格式为 JSON 数组，每步一个对象
try:
parsed = json.loads(output)
if isinstance(parsed, list) and step <= len(parsed):
return json.dumps(parsed[step – 1])
if isinstance(parsed, dict) and f'step_{step}' in parsed:
return json.dumps(parsed[f'step_{step}'])
except:
pass
# 回退：用正则匹配
import re
pattern = rf'"step":\\s*{step}.*?(?="step":|\\Z)'
match = re.search(pattern, output, re.DOTALL)
return match.group(0) if match else ""

def _is_credible(self, step_output: str, step: int) –> bool:
"""
严格的可信度判定（预注册，不可事后修改）
与纯 API 版完全一致
"""
# 条件 1：格式合规（必须为有效 JSON）
try:
parsed = json.loads(step_output)
except json.JSONDecodeError:
return False

# 条件 2：事实准确（与 ground_truth 核对）
expected = self.ground_truth.get(f'step_{step}', {})
if not self._check_factual_accuracy(parsed, expected):
return False

# 条件 3：逻辑一致（与前序步骤无矛盾）
if not self._check_logical_consistency(parsed, step):
return False

return True

def _check_factual_accuracy(self, output: Dict, expected: Dict) –> bool:
"""事实核查：关键字段必须匹配"""
for key in expected:
if key not in output:
return False
if self._normalize(output[key]) != self._normalize(expected[key]):
return False
return True

def _normalize(self, value) –> str:
"""标准化字符串以便比较"""
if isinstance(value, str):
return value.strip().lower()
return str(value).strip().lower()

def _check_logical_consistency(self, output: Dict, step: int) –> bool:
"""逻辑一致性检查（简化版，可扩展）"""
# 检查必要字段是否存在
required_fields = ['conclusion', 'evidence']
for field in required_fields:
if field not in output or not output[field]:
return False
return True

6.3 Ground Truth 构建

每个测试任务在实验前预构建 Ground Truth，不可修改：

# file: ground_truth_builder.py

def build_ground_truth(task_id: str, n_steps: int = 10) –> Dict:
"""
为每个测试任务预构建 Ground Truth
在实验前固定，不可修改
"""
ground_truth = {}
for step in range(1, n_steps + 1):
ground_truth[f'step_{step}'] = {
'conclusion': f'expected_conclusion_for_step_{step}',
'evidence': f'expected_evidence_for_step_{step}',
'key_facts': [f'fact_{step}_1', f'fact_{step}_2']
}
return ground_truth

第七章 步骤 5：完整实验执行

7.1 实验矩阵

7.2 完整实验执行框架

# file: run_cross_arch_experiment.py

import numpy as np
from typing import Dict, List
from scipy.stats import spearmanr

class CrossArchExperiment:
"""跨架构对照实验"""

def __init__(self, model_configs: Dict):
self.models = {}
for arch, config in model_configs.items():
self.models[arch] = UnifiedModel(arch=arch, model_path=config['path'])

def run_full_experiment(self) –> Dict:
"""运行完整实验"""
results = {}

# 实验 5.1：S_c 衰减对照
print("[实验 5.1] S_c 衰减对照…")
results['sc_decay'] = self._run_sc_decay_comparison()

# 实验 5.2：λ 直接测量
print("[实验 5.2] λ 直接测量…")
results['lambda_measure'] = self._run_lambda_comparison()

# 实验 5.3：黑盒探测交叉验证
print("[实验 5.3] 黑盒探测交叉验证…")
results['blackbox_probe'] = self._run_blackbox_comparison()

# 生成结论
results['verdict'] = self._generate_verdict(results)

return results

def _run_sc_decay_comparison(self) –> Dict:
"""实验 5.1：三架构 S_c 衰减对照"""
context_lengths = [4, 8, 16, 32, 64] # K tokens
complexity = 10 # 10 步推理任务
n_trials = 10

results = {}
for arch, model in self.models.items():
s_c_curves = []

for context_k in context_lengths:
s_c_list = []
for trial in range(n_trials):
prompt = self._build_reasoning_task(context_k, complexity, trial)
ground_truth = self._build_ground_truth(complexity, trial)

sc_meter = SCMeasurement(model, ground_truth)
s_c = sc_meter.measure_s_c(prompt, n_steps=complexity)
s_c_list.append(s_c)

s_c_curves.append({
'context_k': context_k,
's_c_median': float(np.median(s_c_list)),
's_c_ci': [float(np.percentile(s_c_list, 2.5)),
float(np.percentile(s_c_list, 97.5))]
})

# 计算 Spearman 相关
cs = [c['context_k'] for c in s_c_curves]
scs = [c['s_c_median'] for c in s_c_curves]
rho, p = spearmanr(cs, scs)

results[arch] = {
'curves': s_c_curves,
'spearman_rho': float(rho),
'spearman_p': float(p),
'declines': rho < 0 and p < 0.05
}

return results

def _run_lambda_comparison(self) –> Dict:
"""实验 5.2：三架构 λ 直接测量"""
test_texts = self._generate_test_texts(n=20, length_k=8)

results = {}
for arch, model in self.models.items():
if arch == 'transformer':
from decay_measurement.transformer_decay import TransformerDecayMeter
meter = TransformerDecayMeter(model)
elif arch == 'mamba':
from decay_measurement.mamba_decay import MambaDecayMeter
meter = MambaDecayMeter(model)
elif arch == 'rwkv':
from decay_measurement.rwkv_decay import RWKVDecayMeter
meter = RWKVDecayMeter(model)

lambdas = []
for text in test_texts:
result = meter.measure_decay(text)
if result.get('lambda') is not None and result['lambda'] > 0:
lambdas.append(result['lambda'])

results[arch] = {
'lambda_mean': float(np.mean(lambdas)) if lambdas else None,
'lambda_std': float(np.std(lambdas)) if lambdas else None,
'lambda_ci': [float(np.percentile(lambdas, 2.5)),
float(np.percentile(lambdas, 97.5))] if lambdas else None,
'n_valid': len(lambdas),
'method': 'arch_specific'
}

return results

def _run_blackbox_comparison(self) –> Dict:
"""实验 5.3：黑盒探测交叉验证（三架构统一方法）"""
from decay_measurement.universal_blackbox import UniversalBlackBoxProbe

context_lengths = [4, 16, 64]

results = {}
for arch, model in self.models.items():
probe = UniversalBlackBoxProbe(model)

arch_results = []
for context_k in context_lengths:
curve = probe.measure_recall_curve(
context_k, n_probes=10, n_trials=5
)
arch_results.append(curve)

# 从召回率曲线拟合 λ
lambda_fit = probe.fit_lambda_from_recall(arch_results)

results[arch] = {
'curves': arch_results,
'lambda_from_blackbox': lambda_fit
}

return results

def _generate_verdict(self, results: Dict) –> Dict:
"""生成判定结论"""
# 提取各架构的 S_c 衰减情况
sc_decay = {}
for arch, data in results['sc_decay'].items():
sc_decay[arch] = {
'declines': data['declines'],
'rho': data['spearman_rho'],
'p': data['spearman_p']
}

# 提取各架构的黑盒探测 λ
blackbox_lambdas = {}
for arch, data in results['blackbox_probe'].items():
lam = data.get('lambda_from_blackbox', {}).get('lambda')
if lam is not None:
blackbox_lambdas[arch] = lam

# 判定逻辑（以黑盒探测为主结论依据）
transformer_declines = sc_decay.get('transformer', {}).get('declines', False)
mamba_declines = sc_decay.get('mamba', {}).get('declines', False)
rwkv_declines = sc_decay.get('rwkv', {}).get('declines', False)

if transformer_declines and mamba_declines and rwkv_declines:
# 三架构都衰减，进一步检查 λ 是否接近
if len(blackbox_lambdas) == 3:
lam_values = list(blackbox_lambdas.values())
lam_variance = float(np.var(lam_values))
if lam_variance < 0.01:
verdict = "L5 在三架构上均成立且 λ 接近，衰减是普遍规律"
falsified = False
else:
verdict = f"L5 在三架构上均成立但 λ 差异大（方差={lam_variance:.4f}），需按架构标定参数"
falsified = None # 部分成立
else:
verdict = "L5 在三架构上均成立（λ 数据不足，无法比较参数）"
falsified = False
elif transformer_declines and not (mamba_declines or rwkv_declines):
verdict = "L5 仅在 Transformer 上成立，非 Transformer 架构无衰减——L5 是 Transformer 特有规律，非普遍定律"
falsified = True
elif transformer_declines and (mamba_declines != rwkv_declines):
verdict = "L5 部分普适，需按架构分类讨论"
falsified = None
else:
verdict = "衰减现象在三架构上均不显著，L5 理论基础存疑"
falsified = True

return {
'verdict': verdict,
'falsified': falsified,
'sc_decay_analysis': sc_decay,
'blackbox_lambda_comparison': blackbox_lambdas,
'evidence': {
'transformer_declines': transformer_declines,
'mamba_declines': mamba_declines,
'rwkv_declines': rwkv_declines
}
}

def _build_reasoning_task(self, context_k: int, complexity: int, trial: int) –> str:
"""构建推理任务（与纯 API 版一致）"""
context = self._generate_filler_context(context_k)
return f"""
请按步骤完成以下推理任务，共 {complexity} 步。
每步输出一个独立结论，格式为 JSON：{{"step": N, "conclusion": "…", "evidence": "…"}}

上下文（长度约 {context_k}K tokens）：
{context}

任务：请基于上下文，完成 {complexity} 步逻辑推理。
"""

def _generate_filler_context(self, context_k: int) –> str:
"""生成填充上下文"""
base_text = "这是一段用于填充上下文的中性文本，不含关键信息。" * 100
target_chars = context_k * 1000 * 2 # 中文约 2 字符/token
return base_text[:target_chars]

def _build_ground_truth(self, complexity: int, trial: int) –> Dict:
"""构建 Ground Truth"""
gt = {}
for step in range(1, complexity + 1):
gt[f'step_{step}'] = {
'conclusion': f'expected_conclusion_{trial}_{step}',
'evidence': f'expected_evidence_{trial}_{step}'
}
return gt

def _generate_test_texts(self, n: int, length_k: int) –> List[str]:
"""生成测试文本用于 λ 测量"""
texts = []
base = "The quick brown fox jumps over the lazy dog. " * 100
target_chars = length_k * 1000 * 4
for i in range(n):
text = (base * (target_chars // len(base) + 1))[:target_chars]
texts.append(text + f" Unique marker {i}.")
return texts

if __name__ == '__main__':
model_configs = {
'transformer': {'path': './models/transformer'}, # pythia-1.4b
'mamba': {'path': './models/mamba'}, # mamba2-1.3b
'rwkv': {'path': './models/rwkv'}, # rwkv-7-world-1b5
}

experiment = CrossArchExperiment(model_configs)
results = experiment.run_full_experiment()

print("\\n" + "=" * 60)
print("跨架构对照实验结果")
print("=" * 60)
print(f"\\n判定：{results['verdict']['verdict']}")
print(f"\\n各架构 S_c 衰减分析：")
for arch, data in results['verdict']['sc_decay_analysis'].items():
print(f" {arch}: declines={data['declines']}, ρ={data['rho']:.3f}, p={data['p']:.4f}")
print(f"\\n各架构黑盒探测 λ：{results['verdict']['blackbox_lambda_comparison']}")

第八章 步骤 6：判定标准（预注册）

8.1 预注册判定矩阵

实验前公开承诺以下判定标准，实验后不得修改：

8.2 以黑盒探测法为主结论依据

由于方法 A/B/C 测量的"衰减"在物理机制上不完全等价（见 §2.3），本方案以方法 D（黑盒探测法）作为主结论依据：

• 黑盒探测法测的是"召回率衰减"，与架构无关，可直接横向对比
• 方法 A/B/C 作为机制层面的补充证据，解释"为什么衰减"

8.3 统计功效

假设：
– H0：Mamba/RWKV 的 S_c 不随 C 下降（ρ ≥ 0）
– H1：Mamba/RWKV 的 S_c 随 C 下降（ρ < 0，效应量 |ρ| ≥ 0.5）
– α = 0.05，功效 1-β = 0.80

样本量计算（Spearman 相关检验）：
n = 29（每组）

实验 5.1：每架构 5 个上下文长度 × 10 重复 = 50 样本 > 29 ✅
实验 5.2：每架构 20 个测试文本 ≥ 29 的要求需补充至 30
实验 5.3：每架构 3 个上下文长度 × 5 重复 = 15 样本 < 29，需增至 10 重复

第九章 步骤 7：方法学挑战与诚实声明

9.1 三种 λ 测量方法的"等价性"问题

诚实声明：三种方法测量的"衰减"在物理机制上不完全等价。Transformer 测的是注意力分配，Mamba 测的是 hidden state 记忆保留，RWKV 测的是 state 向量演化。把它们都映射到同一个 λ 是方法学妥协。本方案以方法 D（黑盒探测法）作为主结论依据，方法 A/B/C 作为机制层面的补充证据。这一设计选择需在结果报告中明确声明。

9.2 模型规模对齐的局限

即使用 1.4B 对齐组，三个模型的训练数据、训练时长、架构细节仍有差异：

理想对照应使用相同数据训练的不同架构模型（如 Pythia 系列 vs 同数据的 Mamba/RWKV），但目前没有这样的公开模型。这是固有局限，需在结果报告中声明。

9.3 上下文窗口差异的影响

三个模型的上下文窗口差异显著（Pythia 2K vs RWKV 32K+）。在 C=32K/64K 时，Pythia-1.4B 可能无法处理。解决方案：

• 对 Transformer 使用支持长上下文的模型（如 Llama-3-8B-Instruct，128K 窗口）
• 或在 C ≤ 2K 范围内对比（牺牲长上下文数据点）

9.4 黑盒探测法的兜底作用

如果架构特异性的 λ 测量方法存在争议，黑盒探测法是三架构通用的兜底方案。它测的是"召回率衰减"，与架构无关，可直接对比。建议以黑盒探测法为主结论，架构特异性测量为补充证据。

9.5 结果解读原则

结果解读原则（预注册）：

1. 若黑盒探测显示三架构均衰减且 λ 接近：
– L5 在当前样本范围内具备跨架构普适性
– 但不等于"被证明成立"，仍需接受后续证伪尝试

2. 若黑盒探测显示 Mamba/RWKV 不衰减：
– L5 的普遍定律地位被证伪
– 应降级为"Transformer 经验规律"
– 五定律体系需修正适用范围声明

3. 若黑盒探测与架构特异性测量结果不一致：
– 以黑盒探测为主结论
– 架构特异性测量的不一致需进一步研究
– 可能揭示不同架构的衰减机制本质不同

4. 若所有结果支持 L5：
– L5 在当前样本范围内未被证伪
– 需持续接受后续实验（更大规模、更多架构）的证伪尝试

第十章 执行时间表

10.1 阶段划分

10.2 资源需求

10.3 风险与缓解

第十一章 与纯 API 方案的关系

11.1 互补关系

本方案是 L5定律可证伪性测试方案_资源约束版.md 中实验 4 的完整展开：

11.2 执行顺序建议

Phase 1：纯 API 方案（8 周）
├── 实验 1-3（验证命题 A/B/C）
├── 实验 4 API 替代版（初步普适性）
└── λ 黑盒探测法

Phase 2：本方案（2 周，可与 Phase 1 后期并行）
├── 实验 5.1：S_c 衰减对照
├── 实验 5.2：λ 直接测量
└── 实验 5.3：黑盒探测交叉验证

Phase 3：综合报告（1 周）
├── 整合纯 API + 跨架构结果
├── 生成总体判定
└── 撰写可发表论文

附录 A：项目目录结构

l5_cross_arch_experiment/
├── models/
│ ├── transformer/ # Pythia-1.4B
│ ├── mamba/ # Mamba-2-1.3B
│ └── rwkv/ # RWKV-7-1B5
├── src/
│ ├── unified_model_interface.py
│ ├── decay_measurement/
│ │ ├── __init__.py
│ │ ├── transformer_decay.py # 方法 A
│ │ ├── mamba_decay.py # 方法 B
│ │ ├── rwkv_decay.py # 方法 C
│ │ └── universal_blackbox.py # 方法 D
│ ├── sc_measurement.py
│ ├── ground_truth_builder.py
│ └── run_cross_arch_experiment.py
├── preregistration/
│ └── preregistration.md # 预注册承诺书
├── results/
│ ├── raw_data/
│ └── l5_cross_arch_report.md
├── requirements.txt
└── README.md

附录 B：预注册承诺书（跨架构实验专用）

# L5 定律跨架构验证预注册承诺书

## 实验信息
– 实验开始日期：____
– 预注册公开地址：____
– 研究者：____
– 模型版本：Pythia-1.4B / Mamba-2-1.3B / RWKV-7-1B5

## 证伪条件（实验前固定，不可修改）

1. L5 普适性证伪条件：
若黑盒探测显示 Mamba/RWKV 的 S_c 不随 C 下降（Spearman p > 0.05），
且 Transformer 显著下降（p < 0.05），
则 L5 的普遍定律地位被证伪，应降级为"Transformer 经验规律"。

2. λ 一致性证伪条件：
若三架构黑盒探测 λ 方差 > 0.01，
则 L5 普适但参数需按架构标定。

3. 函数形式证伪条件：
若 Mamba/RWKV 的衰减曲线更适合幂律/对数而非指数（AIC 差异 ≥ 10），
则 L5 函数形式需按架构修正。

## 主结论依据
– 以方法 D（黑盒探测法）为主结论依据
– 方法 A/B/C 为机制层面补充证据

## 实验后禁止行为
– [ ] 修改判定阈值
– [ ] 剔除"不利"数据
– [ ] 增加事后对照
– [ ] 重新定义"不可信"
– [ ] 修改 Ground Truth
– [ ] 切换主结论依据方法

## 实验后允许行为
– [ ] 报告所有结果（包括证伪结果）
– [ ] 进行预设的敏感性分析
– [ ] 补充架构特异性测量的机制解释

## 签名
研究者签名：____ 日期：____

参考文献

文档版本：v1.0 创建日期：2026-08-03 作者：AI 内容工业化理论组 状态：可执行实验方案，待预注册后执行 关联文档：

• L5定律可证伪性测试方案_资源约束版.md（纯 API 方案，本方案为其实验 4 展开）
• L5衰减假说模型实证验证实验设计方案.md
• 体系成熟度深度推演_L5衰减至跨模态证明的完整演绎.md
• 基于四份交叉文档的大模型人机协同五定律体系完整论文.txt