TreeHeap / SPR：递归树堆 AI 架构研究档案 on GrepCode

[SPR-001] 问题定义：为什么要研究路径路由

Tue, 16 Jun 2026 00:00:00 +0000

问题定义：为什么要研究路径路由

SPR 的原始动机不是“再造一个 Transformer”。它更像是在问一个底层问题：

语言模型里的某些搜索和输出，是否必须通过稠密矩阵完成？

Transformer 的强项是通用、并行、可训练。但它也有代价：大量关系被压在矩阵乘法和 softmax 里。我们能看到结果，却不容易看到结构。

SPR 试图换一个表示方式：

vector score -> path decision
dense matrix -> recursive route
token id -> route state

SPR 想替代什么

最初的目标是输出层或结构搜索的一部分。

传统输出层可以写成：

hidden -> Linear(d, V) -> softmax -> token

这是一种“所有 token 一起打分”的方式。SPR 想试试另一种：

hidden -> recursive decisions -> path -> candidate token/state

如果路径结构有效，它可能带来三个好处：

参数结构更清楚：路径上的每个节点对应一次判断。
搜索空间可压缩：不用每次都扫完整词表或完整图。
结构可解释：错误可以定位到路径分叉，而不只是一个 logits 排名。

SPR 不应该被误解成什么

SPR 不是简单的 hash trick。

如果它只是：

token -> fixed bucket

那它最多是高容量 token hash。

真正的 SPR 应该是：

token + context + structure -> conditional path

也就是说，同一个词在不同上下文里可以走向不同状态。

例如：

bank approved the loan -> finance state
river bank             -> river-side state

如果做不到这一点，就不能说“路径即语义”。

ARA 方式怎么约束 SPR

这次重写采用 ARA 风格。每个 claim 都要回答三件事：

问题	说明
Claim 是什么？	不写模糊胜利，只写可检验句子
Evidence 是什么？	脚本、命令、指标、数据切片
Falsification 是什么？	什么结果会推翻这个 claim

例如：

Claim: S1 token path hash has enough capacity for WMT14 word echo.
Evidence: solo=41311/41429, BLEU-4=99.99.
Falsification: same seed/slice 下 solo rate < 95%.

再例如：

Claim: token-only path encodes contextual semantics.
Evidence: currently failed.
Falsification: same-token polysemy real labels do not beat shuffled labels.

本专题的核心问题

SPR 现在被拆成三个问题：

路径作为 hash 是否可靠？
路径能否被上下文条件化？
路径能否服务结构生成？

第一问已经有较强证据。第二问当前失败。第三问属于 S2，需要单独看 Fold Stack 证据链。

这就是本专题后续文章的主线。

License: GPLv3

[SPR-002] S1 实验：Echo、顺序哈希与容量证据

Tue, 16 Jun 2026 00:00:00 +0000

S1 实验：Echo、顺序哈希与容量证据

S1 的任务是先证明路径结构能稳定工作。

它不处理完整语义，也不处理翻译。它只问：

路径机制能不能可靠地区分 token，并保留顺序信息？

实验脚本

复现脚本：

holds/SameTime/experiments/spr_s1_reproduce.py
holds/SameTime/experiments/spr_s1_falsification.py

io 上运行：

cd /data/homecicd/sametime/code/wmt
sudo -n python3 spr_s1_falsification.py

1. pure roll 的顺序碰撞

设：

我 = [1, 2, 3, 4]
你 = [5, 6, 7, 8]

如果父节点合并为：

H = left + torch.roll(right, shifts=1)

会得到：

我打你 -> [9, 7, 9, 11]
你打我 -> [9, 7, 9, 11]

两个方向完全相同。这说明 pure roll 不能独立承担顺序编码。

2. roll + sign_alt

修复方式是在右子树 roll 后加一个交替符号：

def sign_alt(x):
    return x * [1, -1, 1, -1, ...]

H = left + sign_alt(torch.roll(right, shifts=depth+1))

同样的例子变成：

我打你 -> [9, -3, 9, -3]
你打我 -> [9,  5, 9,  5]

实验输出：

pure_roll_collision=True
sign_alt_separated=True

结论：

S1 的顺序哈希需要非交换破缺。roll + sign_alt 是当前最小可用方案。

3. 分解路由容量

S1 把一个 64 维词向量切成 4 个 chunk：

chunk0: dim 0..15
chunk1: dim 16..31
chunk2: dim 32..47
chunk3: dim 48..63

每个 chunk 走一棵深度 7 的树：

2^7 = 128 leaves

四个 chunk 的叶子号组合：

128^4 = 268,435,456 effective leaves

WMT14 英文词表规模：

vocab=41429

结果：

solo=41311/41429
solo_percent=99.72
bleu4=99.99

这说明几乎每个 token 都能独占组合叶子。

4. 这个结果证明了什么

它证明：

路径空间容量足够。
路径分配稳定。
Echo 任务可以近乎无损。
顺序哈希可以避免最简单的反向碰撞。

它没有证明：

token 理解上下文。
path state 等于 semantic state。
同词多义会自动分流。

因此，S1 的正确定位是：

Token Path Hash。

它是 SPR 的基础设施，不是完整语义路由。

License: GPLv3

[SPR-003] S1 反证：token-only 路由不是语义路由

Tue, 16 Jun 2026 00:00:00 +0000

S1 反证：token-only 路由不是语义路由

S1 的 Echo 结果很好，但 ARA 要求我们继续问：

什么实验会推翻“路径即语义”？

最直接的反证是同词多义。

如果一个路径系统真的编码语义，那么同一个词在不同上下文里应该能进入不同状态。

实验设计

选择三个多义词：

light
bank
charge

构造 42 条受控句子：

light: 光 / 轻
bank: 银行 / 河岸
charge: 费用 / 充电 / 指控

比较两类方法：

S1 token-only route。
keyword baseline。

然后打乱标签，检查模型是否真的依赖语义。

结果

token_only_real_acc = 0.4286
token_only_shuffled_acc = 0.4286
keyword_real_acc = 1.0000
keyword_shuffled_acc = 0.4524

表格：

方法	真实标签	打乱标签
S1 token-only route	0.43	0.43
keyword baseline	1.00	0.45

解释

S1 token-only route 的输入是：

route(token)

所以 bank 永远是同一个 token。它不看旁边是 loan 还是 river。

这意味着：

bank approved the loan
river bank

在当前 S1 里没有上下文分流。

打乱标签后准确率不变，说明 S1 token-only route 没有吃到语义信号。

这个失败说明什么

它不推翻 S1a。

S1a 的 claim 是：

token 可以被稳定映射到低碰撞路径。

这个 claim 仍然成立。

它推翻的是更强的说法：

token-only path 天然就是语义。

这个说法不成立。

ARA 状态

Claim	状态
路径容量足够	confirmed
顺序碰撞可修复	confirmed
Echo 可近乎满分	supported
token-only path 能做上下文语义消歧	rejected
context-conditioned path 能否做语义消歧	open

下一步

要恢复“语义路由”这个名字，路径函数必须升级：

route(token)

变成：

route(token, context)

否则 SPR 只是一个漂亮的路径哈希。

License: GPLv3

[SPR-004] 架构决策：把 SPR 拆成三层

Tue, 16 Jun 2026 00:00:00 +0000

架构决策：把 SPR 拆成三层

旧叙事把 SPR 写成一条直线：

路径 -> 语义 -> 翻译

重做实验后，这条线太粗了。它应该拆成三层。

S1a：Token Path Hash

输入：

token embedding

输出：

stable path / combined leaf

能力：

高容量。
低碰撞。
顺序哈希可修复。
可复现。

限制：

不看上下文。
不区分多义。
不应该被叫作语义路由。

S1a 是地基。

S1b：Context-conditioned Routing

输入应该升级为：

token + context

可能的最小形式：

H_token = E[token]
H_ctx = mean(E[context_window])
H = normalize(H_token + A @ H_ctx)
path = route(H)

这时同一个 token 才可能在不同上下文里走不同路径。

受控 proof 已经验证了这个最小接口的方向：

token-only acc = 0.429
context-route acc = 1.000
shuffled-label acc = 0.482

这说明路径算子能承载上下文消歧，但前提是 context vector 真的带有 sense signal。它还不是完整语料结论。

S1b 的验收标准不是 BLEU，而是：

real labels > shuffled labels
context route > token-only route
context route > random hash

S2：Fold Stack / Structure Routing

S2 不是 Echo 的延长线，而是结构路线。

它的问题是：

语义向量能否预测结构动作？

S2 关心：

head detection
span detection
fold action classification
child assignment
graph assembly

这里的关键指标不是单纯 BLEU，而是结构质量，例如 UAS。

新接口

更合理的 SPR 管线是：

L0 token identity
  -> S1a token path hash
  -> S1b context-conditioned path
  -> S2 fold action / structure state

或者反过来让 S2 给 S1b 提供结构条件：

token + local context + fold state -> conditional path

这样路径才有机会成为“语义前缀”。

决策

从现在开始：

S1a 只称为 Token Path Hash。
不再把 Echo 结果写成语义证明。
S1b 必须通过多义词和 shuffle 反证。
S2 单独维护结构证据链。

这让 SPR 更保守，也更专业：S1b 现在可以被称为受控支持，不能被称为真实语料已验证。

License: GPLv3

[SPR-005] S2 结构路线：Fold Stack 的位置

Tue, 16 Jun 2026 00:00:00 +0000

S2 结构路线：Fold Stack 的位置

S2 不应该被塞进 S1 Echo 的叙事里。

S1 证明的是 token path hash。S2 关心的是结构生成：

semantic vector -> structural action

它们是相关的，但不是同一个实验。

S2 的问题

S2 要回答：

给定一个语义表示，能否预测句子的结构折叠过程？

结构折叠包括：

哪个 token 是 head？
span 边界在哪里？
当前短语是什么类型？
子节点应该挂到哪里？
图如何组装？

这些问题都比 Echo 更接近翻译和生成。

已有证据的含义

历史实验里有一些重要信号：

模块	观察
action classification	语义向量能预测部分折叠动作
head detection	头节点有可学信号
span detection	短语范围有可学信号
child assignment	仍是瓶颈
graph assembly	简单最近节点规则有上限

这说明 S2 路线不是空想。

但它也说明：

结构路线不能靠 Echo 指标证明。

BLEU 对结构错误不够敏感。有些结构错了，表面词序仍然可能看起来不错。

S2 的关键指标

S2 应该主要看：

UAS
edge accuracy
action top-k
head F1
span F1
oracle gap

而不是只看 BLEU。

S1 与 S2 怎么连接

S1a 给 token 一个稳定路径身份。

S1b 应该让这个路径吃上下文。

S2 可以提供结构上下文：

fold action
head/span state
child candidate distribution

这些状态反过来可以影响 S1b 路由：

route(token, local_context, fold_state)

这才是 SPR 更完整的样子。

S2 的下一步

S2 后续需要做三件事：

保留已有 fold-stack 证据，但重新绑定到 ARA claims。
给每个结构 claim 加 baseline。
明确哪些错误来自语义不足，哪些来自图组装不足。

如果 S2 能给 S1b 提供结构条件，SPR 才可能从 path hash 走向 semantic route。

License: GPLv3

[SPR-006] 下一轮实验：从 proof 走向真实基线战

Tue, 16 Jun 2026 00:00:00 +0000

下一轮实验：从 proof 走向真实基线战

S1a 已经成立。S1b 的受控 proof 也已经跑通：

token_acc=0.429
context_acc=1.000
shuffled_acc=0.482

但这还不够。下一轮实验目标不是继续提高 Echo，也不是重复受控 proof，而是把 S1b 放进真实语料和强基线里。

最小模型

从一个小模型开始：

H_token = E[token]
H_ctx = mean(E[left_window + right_window])
H = normalize(H_token + A @ H_ctx)
path = route(H)

这里 A 是小矩阵，不是大模型。目标不是追求榜单分数，而是验证路径会不会随上下文变。

第一关：真实语料多义词

继续使用：

light
bank
charge

要求：

指标	通过条件
real-label accuracy	高于 token-only
shuffled-label accuracy	明显下降
random hash	低于 context SPR
keyword / BoW baseline	作为 sanity check

如果真实标签和打乱标签差不多，实验失败。

受控样本已经通过；下一步必须从语料中抽取真实上下文，避免上下文向量被人工 sense anchor 喂得过干净。

第二关：随机哈希

构造同样容量的 random hash：

same dim
same chunks
same depth
same leaf count

如果 SPR 和 random hash 差不多，说明路径结构没有语义贡献。

第三关：BoW 小模型

用一个简单上下文模型做基线：

bag of context words -> sense

这不是为了赢 SPR，而是为了防止 SPR 对一个简单任务说大话。

如果 BoW 轻松解决，SPR 至少要解释自己为什么更有价值：

更可组合？
更适合结构生成？
更能接 fold state？

第四关：接 S2 fold state

如果局部窗口不够，就把 S2 的结构信号接进来：

token
local context
head/span/fold state
-> conditional path

这一步才可能让路径带上句法和语义角色。

输出要求

每次实验必须输出：

seed
dataset slice
target words
token-only metric
context-route metric
random-hash metric
BoW or keyword metric
shuffled-label metric
claim decision

结果必须写回：

ara/s1-echo/evidence/README.md
ara/s1-echo/logic/claims.md

通过标准

只有满足下面条件，S1b 才能从受控 supported 进入工程 supported：

context SPR > token-only route
context SPR > random hash
real labels > shuffled labels

如果还要升级成 verified，还需要跨数据切片和多 seed 稳定。

License: GPLv3

[SPR-007] S1b proof：上下文条件路由到底证明了什么

Tue, 16 Jun 2026 00:00:00 +0000

S1b proof：上下文条件路由到底证明了什么

前面的反证已经把话说清楚了：

route(token)

不是语义路由。它能稳定、低碰撞地给 token 分配路径，但同一个 bank 在 loan 和 river 旁边仍然是同一个 bank。

这篇文章补上 proof：如果把输入升级成：

route(token, context)

当前 S1 路径算子有没有能力把同词多义分开？

答案是：在受控 proof 里可以。但这个答案必须读完整。

实验脚本

脚本位置：

holds/SameTime/experiments/spr_context_proof.py

远端复现命令：

cd /data/homecicd/sametime/code/wmt
python3 spr_context_proof.py

它使用三个目标词：

light: illumination / weight
bank: finance / river
charge: money / electric / legal

总样本数是 56。每个样本由目标词和一组上下文词构成。

设计要点

实验比较三条路线：

路线	输入	目的
token-only	`token`	检查旧 S1a 能不能自己消歧
context route	`token + context`	检查 S1b 的最小接口是否可行
shuffled context	`token + context`，但 sense 标签打乱	检查结果是否真的依赖语义标签

路径仍然使用 S1 的分块树路由：

dim=64
chunks=4
depth=7
route_bits = roll + sign_alt

分类方式也故意保持简单：同一目标词内部做 leave-one-out 1NN，用路径 bit 的 Hamming 距离找最近邻。

这不是为了追求复杂模型，而是为了回答一个更小的问题：

如果上下文信号进入 route，路径空间本身能不能承载消歧？

结果

io 上的输出摘要：

examples=56
targets=bank, charge, light
token_acc=0.429
context_acc=1.000
shuffled_acc=0.482
context_purity=1.000
mixed_context_buckets=0

对应表格：

指标	数值	含义
token-only accuracy	0.429	旧 S1a 不能区分同词多义
context-route accuracy	1.000	受控上下文进入 route 后可以分开 sense
shuffled-label accuracy	0.482	标签打乱后优势坍塌
context path purity	1.000	同一路径桶内没有混合 sense

这个结果把 S1b 从“纯猜想”推进到“机制上可行”。

它证明什么

它证明：

S1 的路径算子不只适合 token identity。
当输入向量里真的包含上下文信号时，路径可以随上下文变化。
同一个 token 可以在不同上下文下进入不同稳定路径。
label shuffle 会破坏这个优势，因此实验不是只靠样本数量或标签先验赢。

用 ARA 的说法：

S1a = Token Path Hash
S1b = Context-conditioned Routing

这个 proof 支持 S1b 的接口方向。

它不证明什么

它不证明：

真实语料中的上下文向量已经干净携带 sense。
SPR 在多义词消歧上优于 BoW、keyword、MLP 或 random hash。
翻译质量会因为 S1b 自动提升。
“路径即语义”可以恢复成一句无条件口号。

这点很重要。当前 proof 里的上下文词向量是按 sense anchor 生成的。也就是说，实验刻意保证上下文里有可用语义信号。

因此它证明的是路径机制的承载能力，不是真实语料的端到端能力。

历史结论怎么修正

旧结论里有三层说法混在一起：

历史说法	新状态	原因
S1 路径空间容量足够	保留	Echo 和 solo leaf 结果可复现
`roll + sign_alt` 修复顺序碰撞	保留	反向 toy case 已验证
Echo 高分说明语义路由成立	降级	Echo 也可能是高容量查表
token-only path 是语义状态	拒绝	多义词反证失败
context-conditioned path 可以承载消歧	受控支持	本 proof 通过，但还不是真实语料结论

所以新的 SPR 叙事应该是：

S1a 证明路径基础设施可用。
S1a 不证明语义。
S1b 在受控 proof 中证明 route(token, context) 是正确方向。
S1b 还需要真实语料、random-hash、BoW 和多 seed 基线战。

架构决策

从现在开始，SPR 的代码和文章都应该避免把 route(token) 写成语义路由。

更专业的接口是：

H_token = E[token]
H_ctx = context_encoder(window)
H = normalize(H_token + A @ H_ctx)
path = route(H)

如果 S2 fold state 可用，还应该继续扩展：

token + local context + fold state -> conditional path

这才是 SPR 可能成为“语义前缀路由”的位置。

下一道门

下一步不是再证明一次受控样本，而是做真实基线战：

context SPR > token-only route
context SPR > matched random hash
context SPR >= cheap BoW/keyword baseline on the task it claims to solve
real labels > shuffled labels across multiple seeds

只有过了这些门，S1b 才能从受控 proof 进入工程 claim。

License: GPLv3

[SPR-008] S2 策略审计：TreeHeap、Role Slots 和概率容器

Wed, 17 Jun 2026 00:00:00 +0000

S2 策略审计：TreeHeap、Role Slots 和概率容器

这篇文章写给刚接触 SPR 的读者。你只需要有本科计算机水平，知道一点向量、分类器、树和图，就能读下去。

先说结论：

当前 S2 最可靠的方向不是：
TreeHeap 128D -> 直接能量搜索 -> 正确语法树

而是：
语义向量 -> Role Slot -> 概率容器 -> 延迟坍缩

这句话里有几个词听起来很硬。我们一个一个拆开。

背景：我们到底想解决什么

普通神经翻译或语言模型经常把句子看成 token 序列，然后用 attention 去找词和词之间的关系。

SPR 想探索另一条路：

能不能把语言结构压缩成更明确的路径、槽位和图？

在 S2 里，我们关心的不是“这个词像不像另一个词”，而是更结构化的问题：

谁是主语？
谁是谓语？
谁是宾语？
哪个短语修饰哪个短语？
哪些候选结构应该先保留，不要太早拍死？

这就是 Fold Stack / Graph Builder 的问题。

ARA 方式

这里先纠正一个容易误解的点：ARA 不是

Architecture / Reasoning / Artifact

ARA 指的是：

Agent-Native Research Artifact

它不是一种写作修辞，而是一套面向 AI agent 的研究制品协议。论文《The Last Human-Written Paper: Agent-Native Research Artifacts》把 ARA 拆成四层：

层	目录	作用
Cognitive Layer	`/logic`	问题、方案、可证伪 claim、实验计划
Physical Layer	`/src`	可执行代码、配置、环境、实现说明
Exploration Graph	`/trace`	研究 DAG、失败路线、pivot、dead end
Evidence Layer	`/evidence`	原始输出、日志、指标表、claim 的证据

所以这篇文章只是给人读的说明文；真正的 ARA 内容应该在仓库的这些目录里。

ARA 的原则是：

一个结论必须绑定证据。
一个强 claim 必须允许被实验推翻。

所以这篇不会说“TreeHeap 已经成功了”。我们只说实验支持了什么，没有支持什么。

`/logic`：先预测，再实验

这里还要补一个更重要的点。

ARA 不是：

先随便跑实验
看到结果
再回头编一个结论

真正的 ARA 顺序应该是：

predict -> claim -> experiment -> evidence -> trace

翻译成人话：

1. 先写一个预判：如果我的理论是真的，实验应该看到什么？
2. 再把这个预判变成一个可以被推翻的 claim。
3. 然后设计实验，专门去验证或打脸这个 claim。
4. 实验输出原始数据，放进 /evidence。
5. 如果实验失败或改方向，把失败路线写进 /trace。

这和普通博客最大的区别是：ARA 不鼓励“事后讲故事”。
它要求我们在实验前就写清楚：

我预计会发生什么？
什么结果算支持？
什么结果算失败？
如果失败，架构要怎么改？

拿这次 t_merge 问题举例。

我们现在不应该直接写：

t_merge 失效了。

而应该先写一个 predict：

P-TM01:
如果 TreeHeap 的 L0 × 背景场参与机制成立，
那么新训练 checkpoint 的 post-merge 向量应该：
1. 不被公共方向完全主导；
2. 保留 L0/token identity；
3. 保留 path/background bucket 信息；
4. 在 role-slot 或 context probe 上优于 L0 baseline；
5. 从 CMul pre-merge 到 post-merge 的距离结构不能大幅丢失。

然后它对应一个 claim：

C-TM01:
TreeHeap 的背景场乘积可以产生一个非坍缩的 token-in-background state。

再对应一个实验：

E-TM01:
重新训练一个小 checkpoint，
每个 epoch 自动跑 tmerge_diagnostic 和 strategy_audit。

提前写好通过标准：

Pass:
- raw/centered cosine 都不过度坍缩；
- effective rank 足够高；
- path bucket probe 明显高于 chance；
- role/context probe 优于 L0 baseline；
- CMul -> post-merge distance correlation 保持较高。

Fail:
- post-merge 向量仍然被公共方向主导；
- role/context probe 不如 L0；
- path probe 接近 chance；
- 距离结构从 pre 到 post 大幅丢失。

这才是 ARA 的“logic 先行”。

所以，旧 checkpoint 现在不能为 TreeHeap 原理背书。它只能作为：

legacy artifact

用来暴露问题、形成新的 predict。
真正能给 TreeHeap 背书的 evidence，必须来自按这个 predict 重新设计并训练的新 checkpoint。

`/logic`：新的四层理解

目前更清楚的分层是：

L0: token/path substrate
L1: contextual semantic vector
L2: role-slot fold structure
L3: probability/energy collapse

可以用一个很朴素的比喻理解。

数字 321 不是简单的：

[3, 2, 1]

它真正的结构是：

3 * 百位 + 2 * 十位 + 1 * 个位

这里最重要的不是 3,2,1 本身，而是：

百位、十位、个位

这些位置就是“位权”。

放到语言里：

cat eats fish

不应该只是：

[cat, eats, fish]

而应该更像：

SUBJECT = cat
ROOT    = eats
OBJECT  = fish

所以 S2 现在要找的不是更深的树，而是：

Role Slots

也就是“结构槽位”。

实验一：当前 TreeHeap 128D 是否适合直接做语法能量

我们先测试一个基础问题：

历史 checkpoint 里的 TreeHeap 128D 向量到底长什么样？

使用的 checkpoint 是历史遗留模型：

/mnt/nas/datasets/wmt_massive/checkpoints/anchor_tree_massive_ep3.pt

它不是这次重新训练的模型。

我们比较四种向量：

向量	含义
random	随机向量，作为健康基线
L0	checkpoint 里的原始 token embedding
TreeHeap	L0 + path + t_merge 后的 128D 输出
path	token 在 TreeHeap 路径上的位置向量

最重要的指标叫：

off-diagonal cosine mean

如果你不熟 cosine，可以简单理解成“两个不同词的向量平均有多像”。

接近 0：不同词分得比较开。
接近 1：不同词几乎都挤在一起。

实验结果：

Vector	不同词平均相似度	解释
random	0.0007	正常随机基线
L0	0.0003	分得很开
TreeHeap	0.9849	几乎全挤在一起
path	0.4937	粗粒度路径簇

这个结果很关键。

它说明：

当前 ep3 TreeHeap 输出太坍缩。

也就是说，很多不同 token 经过 TreeHeap 后，方向几乎一样。这样的向量很难直接拿来判断语法结构。

这不是说 TreeHeap 理论错了，而是说：

当前历史 checkpoint 的 tree 输出不能背负“语法能量已成立”的 claim。

实验二：非交换张量能不能直接选出正确结构

我们之前讨论过一个想法：

h1 ⊗ h2 ⊗ h3

这是有序张量。它和普通加法不同。

普通加法：

cat + eats + fish
= fish + eats + cat

顺序丢了。

有序张量：

cat ⊗ eats ⊗ fish
!= fish ⊗ eats ⊗ cat

顺序保住了。

所以我们要分清两个问题：

问题 1：它能不能区分排列？
问题 2：它能不能把正确语法排到第一？

实验结论是：

能区分排列，但 raw energy 还不能稳定选出正确语法。

在 SVO3 任务上，role-slot template 的结果如下：

Mode	Top-1	Top-3	Mean gold rank
L0 + random role basis	0.509	0.812	2.11
random + onehot role basis	0.464	0.786	2.21
TreeHeap + onehot role basis	0.330	0.723	2.59

这里 Top-1 的意思是：

正确排列排第一的比例

Top-3 的意思是：

正确排列出现在前三名的比例

如果 TreeHeap 真的已经天然对齐语法，我们希望它明显赢过 L0 和 random。

但结果相反：

TreeHeap 没赢。

所以结论必须收紧：

非交换张量是必要工具。
但当前 TreeHeap 输出不足以直接做 syntax energy。

实验三：Role Slots 是否真的存在

接下来问一个更实际的问题：

语言结构是不是适合用少量槽位表达？

比如 VP 可以写成：

VP {
  subject
  object
  adverb
  complement
}

而不是强行写成二叉树：

eat
├─ cat
└─ NodeX
   ├─ fish
   └─ quickly

我们在 12,000 条 WMT massive 英文样本上统计 FoldNode 的子节点数量。

结果：

Degree threshold	Coverage
<= 2	86.1%
<= 3	95.8%
<= 4	99.0%
<= 5	99.8%

这说明：

绝大多数 FoldNode 用 4 个左右的槽位就够了。

这对架构很重要。

它支持：

Role-slotted FoldNode

而不是继续押：

更深的二叉树
或者
更高叉但无名的树

常见模式也很直观。

VP 常见模式：

nsubj
dobj
dobj + nsubj
aux + dobj
aux + dobj + nsubj

NP 常见模式：

det
compound
amod
amod + det
poss

翻译成人话：

VP 常围绕主语、宾语、助动词展开。
NP 常围绕限定词、复合词、形容词、所有格展开。

这就是 Role Slots 的证据。

实验四：概率容器是否有必要

Graph Builder 过去常做一件事：

给每个节点选一个最可能的父节点。

这叫过早坍缩。

但很多结构局部看不出来。

经典例子：

I saw the man with a telescope.

with a telescope 可以挂到 saw，也可以挂到 man。局部阶段未必应该立刻选死。

所以我们测试：

正确父节点是否在 top-k 候选里？

如果 top-1 不完美，但 top-3 几乎总包含正确答案，那就说明应该保留候选分布，而不是马上 argmax。

结果：

Metric	Value
graphs	8,408
pair rows	195,610
eval child sets	2,758
gold parent in top-1	93.1%
gold parent in top-2	99.3%
gold parent in top-3	99.9%
gold parent in top-5	100.0%

这个结果非常强。

它说明：

正确答案几乎总在 top-3 里。

所以 Graph Builder 不应该只输出：

parent = A

而应该输出：

ParentContainer {
  A: 0.61
  B: 0.27
  C: 0.12
}

然后把这个容器传给后续模块，让更大的上下文再决定。

这就是 Probability Container。

夜间任务的部分结果

后来我们又启动了一个更大的 8 小时任务，目标是继续查：

坍缩到底发生在哪里？
上下文窗口是否稳定提升 role-slot 预测？
不同 epoch 的 checkpoint 是否不同？

截至写作时，完整任务还在运行。但第一轮部分结果已经给出一个很有用的信号。

对 anchor_tree_massive_ep1.pt：

Mode	不同词平均相似度
L0	0.0186
CMul pre-merge	0.0200
Tree output	0.9860

这说明：

坍缩主要发生在 t_merge 之后。

也就是说，L0 和 CMul 本身没有严重坍缩，但经过 t_merge 之后，向量被挤到很相似的方向。

Role probe 的部分结果：

Feature	Top-1
L0 only	0.538
L0 + context	0.570
CMul + context	0.559
Tree + context	0.548
path only	0.325

这个结果说明：

上下文确实有 role-slot 信号。
path 单独很弱。
tree output 不如 L0/CMul 稳。

这些是部分结果，不能替代完整 8 小时任务的最终统计。但方向已经很清楚。

`/logic`：我们现在怎么判断

把上面的实验合起来，推理链是：

1. 当前 TreeHeap tree output 高度坍缩。
2. 坍缩后的向量不适合直接做语法能量。
3. 非交换张量可以区分排列，但不自动等于语法正确。
4. FoldNode 的真实结构高度适合小槽位表达。
5. parent top-k 覆盖非常高，所以概率容器有价值。
6. 上下文能提升 role-slot 预测。

所以下一步不是：

继续硬做 edge classifier

也不是：

直接宣布 TreeHeap energy search 成功

而是：

Role Slots + Probability Container + 更好的 L1/context vector

当前架构决策

继续推进

Role-slotted FoldNode

因为 degree 分布强烈支持小槽位。

Probability Container

因为 gold parent top-3 覆盖接近满分。

Context-conditioned role prediction

因为 L0 + context 已经比 L0 only 更好。

暂停放大的 claim

当前 3-epoch TreeHeap 128D 已经是 syntax vector。

不支持。

纯 tensor energy 可以替代 Graph Builder。

不支持。

path 本身编码语法角色。

不支持。

`/evidence`：证据在哪里

完整 strategy audit：

ara/s2-translation/evidence/strategy_audit/

关键文件：

strategy_audit_summary.json
tensor_energy_rows.csv
parent_container_rows.csv
role_slot_degree.json
README.md

夜间任务部分结果：

ara/s2-translation/evidence/overnight_partial_20260617/

远端正在运行的完整任务：

io:/data/homecicd/sametime/logs/s2_overnight_20260617_150111

脚本：

s2_strategy_audit.py
s2_overnight_io.py
run_s2_overnight_io.sh

给初学者的最后总结

如果你只记住三句话，记这三句：

第一，当前 TreeHeap checkpoint 的最终 128D 输出太坍缩，不能直接当语法向量。

第二，语言结构更像“语义向量填入角色槽位”，而不是普通二叉树越堆越深。

第三，Graph Builder 不应该太早选唯一答案，应该保留 top-k 概率容器，让后续上下文再坍缩。

这就是目前 S2 理论建设的位置：

理论路线更清楚了。
部分方向被实验支持。
部分过强说法被实验降级。
下一步要训练或抽取更好的 L1/context vector，再重跑同一套审计。

License: GPLv3

[SPR-009] 世界模型与参考系：TreeHeap 术语统一

Wed, 17 Jun 2026 00:00:00 +0000

世界模型与参考系：TreeHeap 术语统一

这篇文章先不急着做新实验。它的目标是统一语言。

因为如果我们继续混用：

背景场
path field
概率意识场
world topology
context field

讨论会很快发散。后面统一叫：

世界模型（World Model）

为什么要叫世界模型

TreeHeap 里真正想表达的不是“一个词的孤立含义”。

比如：

ball

它可以进入很多世界：

football
basketball
baseball
volleyball

这些词都包含 ball，但它们不是同一个东西。

差别来自：

脚
手
球场
球网
规则
动作
人与物的关系

所以：

球 + 脚 = 足球
球 + 手 = 篮球

不是简单的词向量加法，而是在说：

同一个实体进入了不同的世界模型。

ball 是对象，foot/hand/field/court/rule 是它参与的世界关系。

术语表

先给一张沟通表。

术语	英文名	含义	在 TreeHeap 里的位置	例子
词法基底	Lexical Base / L0	token 自己的基础语义向量	`L0[token]`	`ball`, `foot`, `hand`
世界模型	World Model	token 所处的关系、场景、规则、拓扑背景	path nodes / context / latent frame	“脚能踢球”、“手能投球”、“球场规则”
参与乘积	Participation Product	让 L0 进入世界模型，形成带背景的状态	`CMul(L0, WorldModel)`	`ball × sport-frame`
入世状态	Token-in-World State	token 参与世界模型后的状态	CMul pre-merge 或 post-merge	“足球语境里的 ball”
读出层	Readout / Merge	把入世状态投影成下游可用向量	`t_merge`	128D final vector
参考系	Frame of Reference	解释向量方向的局部坐标系	latent axes / frame basis	sport frame, body-part frame
结构槽位	Latent Slot	无监督或弱监督发现的结构位置，不等于主谓宾	Fold / role-slot layer	`slot_3`, `slot_12`
差分方向	Relation Delta	两个概念的差分，表示关系变化	vector difference	`football - ball`
投影解释	Frame Projection	把差分投到某个参考系，看它指向什么	`delta · frame_axis`	是否更接近 `foot/kick`
概率容器	Probability Container	不急着 argmax，保留多个候选状态	L2/L3 collapse 前	parent top-k, slot top-k
坍缩	Collapse	从多个可能状态选择或收敛到一个状态	下游决策阶段	从 top-3 parent 选一个
证据门	Evidence Gate	提前写好的通过/失败标准	ARA `/logic`	rank、probe、top-k

口语版：

L0 是“词自己”。
世界模型是“这个词所在的世界规则”。
参与乘积是“词进入这个世界”。
入世状态是“词进入世界后的样子”。
参考系是“我们用什么坐标解释它”。
slot 是“结构自己长出来的位置”。
概率容器是“先别拍死，保留多个可能”。
坍缩是“信息足够后再做决定”。

一个例子：足球和篮球

假设我们有：

ball
football
basketball
foot
hand
kick
throw
field
court
goal
basket

我们不想只问：

football 和 basketball 像不像？

我们更想问：

football 相对 ball 多出来的关系是什么？
basketball 相对 ball 多出来的关系是什么？

也就是：

delta_football = football - ball
delta_basketball = basketball - ball

如果 TreeHeap 的世界模型有效，那么在某个运动参考系里：

delta_football

应该更接近：

foot
kick
field
goal

而：

delta_basketball

应该更接近：

hand
throw
court
basket

这就叫：

参考系解释。

没有参考系，向量差分只是一些数字。
有参考系，差分才变成“这个变化指向哪种世界关系”。

为什么不能只看 raw cosine

前面的 t_merge 诊断告诉我们一件事：

raw cosine 可能会误导。

旧 checkpoint 的 final tree output 看起来高度相似：

tree output raw cosine mean ≈ 0.985

但减去公共均值之后：

centered cosine mean ≈ 0

这说明：

向量里有一个很强的公共世界背景方向。

如果直接拿 raw cosine 判断，就会误以为所有 token 都一样。

所以后面的世界模型实验应该比较：

L0
CMul pre-merge
merge_no_bias
centered tree
raw tree

不要只看 raw tree。

Latent Slot 不是主谓宾

还有一个必须纠正的点。

前面为了讲清楚，我们经常举：

SUBJECT
ROOT
OBJECT

但这只是临时解释用的 proxy。

TreeHeap 最终不应该直接规定：

slot_0 = SUBJECT
slot_1 = OBJECT

更合理的是：

先从数据里无监督或弱监督学出 latent slots。
然后再观察这些 slot 和人类语法标签有什么关系。

也就是说：

slot_3 可能经常表现得像主语。
slot_8 可能经常表现得像宾语。
slot_12 可能是某种修饰位置。

但这些名字应该是事后解释，不是事前规定。

这点很重要。否则我们会把传统语法体系偷偷塞进 TreeHeap，最后得到的不是结构涌现，而是语法标签蒸馏。

概率容器的位置

世界模型不是每一步都要立刻做决定。

比如一个短语可能有多个合理挂接：

Parent A: 0.61
Parent B: 0.27
Parent C: 0.12

旧方式会直接：

argmax -> Parent A

但 TreeHeap 的方向应该是：

先保留这个分布。

也就是：

ParentContainer {
  A: 0.61
  B: 0.27
  C: 0.12
}

等到后面有更大的世界上下文，比如翻译、生成、执行器，再坍缩。

这和 L0 的多义叠加是同一个思想：

信息不足时，不要过早拍死。

一句话定义

当前可以先这样定义 TreeHeap：

TreeHeap = L0 词法基底参与世界模型，
生成可被参考系解释、
可延迟坍缩的结构状态。

展开成管线：

L0[token]
  -> World Model / Frame
  -> Participation Product
  -> Token-in-World State
  -> Latent Slots / Probability Containers
  -> Collapse when enough context exists

接下来怎么提 predict

这篇先统一术语，下一篇再正式写 ARA /logic 里的 predict。

但方向已经很明确：

P-FRAME01:
如果 TreeHeap 的世界模型携带真实拓扑信息，
那么复合概念的差分方向，
应该能在某些局部参考系里投影到可解释关系。

例子：

football - ball -> foot / kick / field / goal
basketball - ball -> hand / throw / court / basket
baseball - ball -> bat / field
volleyball - ball -> hand / net

这个 predict 还不能算 evidence。
它只是下一轮实验的逻辑起点。

下一步要把它写成：

/logic/predicts.md

再设计：

/src/frame_probe.py

最后把结果放进：

/evidence/frame_probe/

这才符合 ARA。

License: GPLv3

[SPR-010] 世界模型守夜训练：新 checkpoint 给了什么证据

Thu, 18 Jun 2026 00:00:00 +0000

世界模型守夜训练：新 checkpoint 给了什么证据

上一篇文章统一了术语：

L0 词法基底
World Model 世界模型
Participation Product 参与乘积
t_merge 读出层
Frame of Reference 参考系
Latent Slot 潜在槽位
Probability Container 概率容器

统一术语以后，下一步不能继续只靠聊天里的直觉。按照 ARA 的正规流程，我们需要先写一个可以失败的 predict，然后跑实验。

这次守夜任务就是围绕这个 predict 做的。

先说结论

这次实验是一次有效的诊断证据，但不是 TreeHeap 世界模型成立的正证明。

结论分三层：

1. 工程上：
   新 checkpoint 训练成功，GPU 稳定，evidence 已保存。

2. 几何上：
   新训练没有复现旧 checkpoint 那种 raw cosine 全部挤在一起的严重坍缩。
   t_merge 没有把空间直接压坏。

3. 理论上：
   当前 local BPE context 训练目标没有证明 P-FRAME01。
   也就是说，仅靠“预测附近 token”不足以学出我们想要的世界模型参考系。

如果只用一句话说：

这次实验说明，TreeHeap 的工程管线能跑，空间没有被 t_merge 直接毁掉；但世界模型拓扑信号还没有被当前 objective 学出来。

这很重要，因为它把问题从：

TreeHeap 是不是彻底错了？

缩小成：

我们现在的训练目标是不是不对？

我现在更倾向后者。

这次 predict 是什么

我们写下的 predict 叫：

P-FRAME01

它的意思是：

如果 TreeHeap 的世界模型携带真实拓扑信息，
那么复合概念相对基础概念的差分方向，
应该能在某些局部参考系里投影到可解释关系。

用本科生能理解的例子说：

football - ball

应该更像：

foot
kick
field
goal

而：

basketball - ball

应该更像：

hand
throw
court
basket

这不是在问：

football 和 basketball 像不像？

而是在问：

football 比 ball 多出来的那一部分，指向什么世界关系？

如果向量空间真的带有“世界模型”，那么这种差分方向应该不是随机的。

为什么要训新 checkpoint

之前我们一直有一个问题：

旧 checkpoint 能不能当证据？

答案是：不能直接背书。

旧 checkpoint 可以作为诊断对象，因为它告诉我们：

raw tree output cosine mean ≈ 0.985

看起来所有 token 都很像。

但进一步诊断又发现：

centered cosine mean ≈ 0

也就是说，它可能不是所有信息都没了，而是有一个很强的公共背景方向。

所以旧 checkpoint 不能直接证明 TreeHeap 成立，也不能直接证明 TreeHeap 失败。它只能告诉我们：

必须自己训一个新的 checkpoint，
再看 CMul、merge_no_bias、tree、centered tree 到底发生了什么。

这次守夜任务就是为了补这一块 evidence。

训练任务怎么设计

这次没有训练完整翻译模型，也没有训练大语言模型。

我们训练的是一个小的 TreeHeap-style world-model checkpoint。

核心形式是：

L0(token)
  x WorldPath(token)
  -> CMul pre-merge state
  -> t_merge
  -> token-in-world vector

训练目标很朴素：

给定一个中心 BPE token，
让它的 token-in-world vector 去找附近窗口里的真实 context token。

也就是 local context contrastive learning。

用更普通的话说：

如果一个 token 经常和某些上下文一起出现，
模型应该把它变换到一个能找回这些上下文的位置。

这不是最终目标。它只是一个可运行、可保存 checkpoint、可观察 t_merge 是否扭曲空间的中间实验。

守夜运行规模

运行时间：

start:  2026-06-17 18:05:58
finish: 2026-06-18 04:06:01

训练规模：

epochs recorded: 456
global steps:    2,732,508
checkpoints:     456
metrics rows:    456
frame rows:      2,280
geometry rows:   2,280
gpu rows:        54,650

证据保存位置：

/data/homecicd/sametime/ara/s2-translation/evidence/world_model_long_20260617_180554
/mnt/nas/datasets/wmt_massive/evidence_nio/world_model_long_20260617_180554

这次也顺便验证了一个工程点：

io 上的 RTX 3090 是可跑长任务的，
但必须保持 270W power limit，
不能放开。

GPU 统计：

avg power: 192.18W
max power: 195.92W
avg temp:  70.82C
max temp:  71C
avg util:  29.07%
max util:  32%
max mem:   688MiB

这说明这次不是之前那种 CPU-only 假任务。 GPU 确实在工作，而且没有掉卡。

训练有没有学到东西

训练 loss 有下降，但幅度不大。

第一轮：

loss        7.5148
inbatch_acc 0.0181

最后一轮：

loss        7.2923
inbatch_acc 0.0247

最好 loss：

epoch 456
loss  7.2923

最好 in-batch accuracy：

epoch       442
inbatch_acc 0.0248

这说明模型确实在学 local context。但它学得并不强。

从工程上看，这是一个健康训练。从理论上看，这还不能说明它学出了世界模型。

frame probe 结果

我们真正关心的是 P-FRAME01。

也就是：

composite - base

能不能指向正确的 relation anchors。

这次最好的早期结果出现在 epoch 2：

epoch 2
mode: tree / merge_no_bias
auc  0.7236
mrr  0.8485
hit1 0.7273
hit3 1.0000

但是到最后一轮，结果没有继续变强。

epoch 456：

mode	AUC	MRR	Hit@1	Hit@3
L0	0.6182	0.8364	0.7273	0.9091
CMul	0.6182	0.8182	0.6364	1.0000
merge_no_bias	0.6473	0.8333	0.7273	0.9091
tree	0.6473	0.8333	0.7273	0.9091
path	0.5618	0.8712	0.8182	0.9091

这里要小心读。

如果 TreeHeap world model 被证明了，我们希望看到：

tree / merge_no_bias / CMul 明显强于 L0
并且随着训练稳定变强

但实际看到的是：

1. early epoch 有一点信号。
2. long training 没有把这个信号放大。
3. path 的 Hit@1/MRR 也很高，说明 probe 里可能有 token/path 偏差。
4. final tree 只比 L0 在 AUC 上略好，不构成强证据。

所以 P-FRAME01 的状态是：

inconclusive

不能升级为 positive claim。

几何空间有没有坍缩

这部分反而比较有价值。

最后一轮的 off-diagonal cosine mean：

mode	cosine mean
L0	0.0519
CMul	0.0539
merge_no_bias	0.0566
tree	0.0865
path	0.9973

这说明：

L0 / CMul / merge_no_bias / tree 都没有全局挤成同一个方向。

tree 的 cosine mean 比 L0 高一点，但远没有旧 checkpoint 那种：

0.985

这支持一个判断：

t_merge 本身不是必然把空间压坏的罪魁祸首。

真正异常的是 path：

path cosine mean = 0.9973

这说明当前 path 构造在这个 probe 集合上几乎是常量。也就是说，它不是一个好的语义参考系。

这和我们之前的判断一致：

路径本身更多编码 token ID / 分桶位置，
不是语法角色，也不是世界关系。

这次到底证明了什么

可以保留的结论：

1. 新 checkpoint 能稳定训练。
2. io 的 3090 在 270W limit 下可以跑 10 小时任务。
3. t_merge 不必然导致全局向量坍缩。
4. local BPE-context objective 可以学到一点上下文检索能力。
5. 当前训练目标没有证明 world-model reference frame。

必须降级的说法：

TreeHeap 已经学出世界模型。

这句话不能说。

更准确的说法是：

TreeHeap 现在有一个可训练的世界模型候选管线，
但 local context objective 还不能让 P-FRAME01 成立。

下一步怎么改 predict

这次最重要的教训是：

不要只让模型预测附近 token。

因为附近 token 主要教会模型：

哪些词经常共现。

但我们想要的是：

复合概念和基础概念之间的关系方向。

也就是：

football - ball -> foot / kick / field / goal
basketball - ball -> hand / throw / court / basket

所以 P-FRAME01 下一版应该改成更直接的训练目标。

例如：

输入：
  composite
  base

目标：
  拉近 positive relation anchors
  推远 hard negative anchors

形式上可以是：

delta = vector(composite) - vector(base)

positive:
  foot, kick, field, goal

negative:
  hand, basket, racket, engine, snow

训练目标：

delta 更接近 positive anchor directions
delta 远离 negative anchor directions

这比 local context objective 更贴近我们真正要验证的 claim。

ARA 状态

这次 evidence 应该这样登记：

Predict:
  P-FRAME01

Evidence:
  world_model_long_20260617_180554

Verdict:
  diagnostic / inconclusive

Do not promote to claim.

换句话说：

P-FRAME01 还活着，
但当前 objective 没有通过 evidence gate。

这不是坏结果。一个好的研究系统，应该允许 predict 被证据卡住。

最后一句话

这次守夜训练没有证明 TreeHeap 已经拥有世界模型。

它证明的是：

我们已经有能力正规地训练、保存、诊断一个新的 TreeHeap checkpoint；
也已经知道 local context objective 不是通向 P-FRAME01 的直路。

下一步不是继续堆时间。

下一步是换 objective。

License: GPLv3

[SPR-011] TreeHeap 代数：先做数学闭包，再谈语言推理

Thu, 18 Jun 2026 00:00:00 +0000

TreeHeap 代数：先做数学闭包，再谈语言推理

前一篇守夜训练给了一个重要教训：

只靠 local BPE context objective，
不能证明 TreeHeap 学出了世界模型。

这不只是 loss 设计问题。更深一层的问题是：

TreeHeap 现在还不像一个完整的数学系统。

目前我们实现得最多的是：

L0(token) x path/world -> CMul -> t_merge

这相当于只有一个核心参与乘积。

它可以保存信息，可以调制方向，也可以让 token 带上 path 背景。但它不一定能完成：

转置
求逆
分解
投影
组合
能量排序
概率坍缩

如果这些操作都没有定义，TreeHeap 就还不是一个“堆数据结构”。它只是一个带名字的向量变换层。

所以这篇文章先不谈 WMT，也不谈 BLEU。我们先退一步：

TreeHeap 能不能先成为一个可计算的代数系统？

为什么先做代数

语言推理是上层问题。

比如翻译：

中文结构 -> 英文结构 -> 英文表面句子

这里面当然有语义、语法、文化和世界知识。但在 TreeHeap 视角下，它首先需要一些更基本的能力：

一个结构能不能合成？
合成后能不能分解？
一条关系能不能反过来看？
一个对象能不能投影到某个参考系？
投影后能不能回来？
一组候选结构能不能排序？
不确定时能不能先保留概率？

这些不是语言专属问题。这些是数学操作问题。

如果这些操作不稳定，那么后面说“世界模型”“推理”“翻译”都太早。

这就是这篇文章的核心判断：

先建立 TreeHeap Algebra。
再把语言推理放到这个代数系统上。

什么叫数学闭包

本科计算机里经常会见到“闭包”这个词。

例如整数加法：

整数 + 整数 = 整数

所以整数对加法是封闭的。

但：

整数 / 整数 = 不一定是整数

例如：

1 / 2 = 0.5

所以整数对除法不封闭。

放到 TreeHeap 里，我们想要的是：

TreeHeap object op TreeHeap object -> TreeHeap object

也就是说：

两个 TreeHeap 对象做完操作，
结果还应该是一个 TreeHeap 对象。

如果每次操作完都跑出空间，只能交给神经网络硬猜，那数学结构就没有帮上忙。

TreeHeap 对象是什么

先定义一个最小对象：

H = (v, p, s, q)

其中：

v: semantic/world vector
p: heap path or structural coordinate
s: latent slot distribution
q: probability mass / confidence

口语一点说：

v 是“它是什么”
p 是“它在堆里的位置”
s 是“它像在哪些潜在槽位上”
q 是“我们对它有多确定”

这比一个裸向量多一点结构。

TreeHeap 不应该只保存：

128D vector

它应该保存：

向量 + 结构坐标 + 槽位分布 + 概率质量

这才像一个高维堆对象。

操作一：compose 合成

compose 是：

compose(H1, H2, ..., Hn) -> H_parent

意思是：

多个 child heap objects 合成一个 parent heap object。

例如：

foot + ball -> football

或者在句子结构里：

kick + ball + goal -> event/state

关键不是简单加法。 compose 应该同时更新：

v: 世界状态变了
p: 结构位置变了
s: 槽位分布变了
q: 置信度变了

如果 compose 只是：

v_parent = v1 + v2

那它太弱。

操作二：decompose 分解，也就是逆树堆

如果有合成，就自然会问有没有逆操作。

compose(children) -> parent

反过来：

decompose(parent) -> children

这就是“逆树堆”的直觉。

但是语言里一般没有唯一逆。

例如：

football

可以拆成：

foot + ball
sport + ball
game + object

所以 decompose 不应该返回一个硬答案。

它应该返回概率容器：

{
  foot + ball:    0.52
  sport + ball:   0.31
  game + object:  0.17
}

这和之前说的 Probability Container 是同一个思想。

逆树堆不是普通函数逆。更准确地说，它是：

probabilistic inverse

操作三：transpose 转置

矩阵里有转置：

A -> A^T

TreeHeap 里也需要类似操作，但含义不是把二维表格翻过来。

TreeHeap 的转置更像：

关系方向反转

例如：

edge(parent, child, role)

转置后：

edge(child, parent, inverse_role)

它应该满足一个基本性质：

transpose(transpose(edge)) ≈ edge

也就是转两次应该差不多回来。

为什么这对翻译重要？

因为不同语言经常从不同方向表达同一关系。

例如中文和英文的修饰、介词、话题结构，方向可能不一样。如果 TreeHeap 没有 transpose，就很难用数学操作表达：

同一个关系，换一个方向读。

操作四：project 投影到参考系

我们一直说世界模型和参考系。

project 就是：

project(H, frame) -> H_frame

例如：

project(ball, sport_frame)

和：

project(ball, kitchen_frame)

应该不一样。

同一个对象进入不同参考系，解释方向不同。

这对应前面的例子：

football - ball -> foot / kick / field / goal
basketball - ball -> hand / throw / court / basket

如果没有 project，向量差分只是数字。有了 project，差分才变成：

这个变化在什么世界里被解释？

操作五：unproject 反投影

如果能投影，就要问能不能回来：

unproject(project(H, frame), frame) ≈ H

这叫 projection roundtrip。

如果做不到，说明投影丢了太多信息。

但也不能完全不变。如果 project/unproject 只是 identity echo，那也没意义。

所以它要同时满足两个条件：

1. roundtrip 后能大致回到原对象。
2. 在 frame 内部确实改变了可解释方向。

这就是难点。

操作六：energy 能量

energy 是：

energy(H) -> scalar

它给 TreeHeap 对象打一个一致性分数。

低能量表示：

这个对象更像一个合法结构。

比如：

compose(foot, ball)

应该比：

compose(engine, snow)

在 sport-ball frame 下能量更低。

但注意，energy 不是“真理”。它只是排序工具。

最小 predict：P-ALG01

现在可以写一个新的 predict：

P-ALG01:
如果 TreeHeap 是可用的数学底座，
那么 compose、decompose、transpose、project、unproject、energy
这些操作应该在 TreeHeap 对象空间内近似封闭。

也就是说：

操作前是 TreeHeap 对象。
操作后仍然是 TreeHeap 对象。

而不是变成一堆无法解释的向量碎片。

怎么实验

先不要跑 WMT。

先跑四个数学实验。

E-ALG01: compose/decompose 往返

children -> compose -> parent -> decompose -> children'

看：

children' 能不能在 top-k 里找回原 children。

失败标准：

找回率不超过 random / nearest baseline。

E-ALG02: transpose 两次回来

edge -> transpose -> transpose -> edge'

看：

edge' 是否接近原 edge。

失败标准：

转置两次还不如不转。

E-ALG03: project/unproject 往返

H -> project(frame) -> unproject(frame) -> H'

看：

H' 是否接近 H。

同时还要看：

project 后是否真的提升 frame 内 relation ranking。

否则就是 echo。

E-ALG04: 闭包压力测试

反复做：

compose
project
transpose
decompose
normalize

看有没有：

norm explosion
global cosine collapse
energy drift
probability mass invalid

如果反复操作几轮就炸掉，那 TreeHeap 还不是稳定代数。

和 WMT 的关系

这一步看起来远离翻译，其实是在给翻译铺地基。

如果 TreeHeap Algebra 成立，S2 翻译可以变成：

source TreeHeap
-> transpose / project
-> target frame TreeHeap
-> decompose / collapse
-> target sentence

也就是：

用数学操作迁移结构，
再用模型生成表面语言。

否则就只能回到：

source tokens -> black-box decoder -> target tokens

那 TreeHeap 的意义就不明显。

当前架构判断

现在可以把之前的判断整理成三句话：

Echo preserves information.
CMul carries participation.
World model requires algebraic topology operations.

中文就是：

Echo 保存信息。
CMul 携带参与关系。
世界模型需要代数拓扑操作。

所以接下来不是继续加大 local context 训练。

下一步是：

先设计 TreeHeap Algebra。
再训练模型学习这个代数里的未知映射。

ARA 状态

新增 predict：

P-ALG01

新增设计文档：

ara/s2-translation/logic/solution/treeheap_algebra.md

下一步 planned evidence：

ara/s2-translation/src/treeheap_algebra_probe.py
ara/s2-translation/evidence/treeheap_algebra_probe/

状态：

Design phase.

还没有 claim。

最后一句话

TreeHeap 不应该只是一个乘法层。

它应该先成为一个能做：

合成
分解
转置
投影
反投影
能量排序
概率保留

的高维堆代数系统。

语言推理不是第一层。

语言推理是这个代数系统上的应用。

License: GPLv3

[SPR-012] 子堆核搜索：TreeHeap 里的卷积式推理

Thu, 18 Jun 2026 00:00:00 +0000

子堆核搜索：TreeHeap 里的卷积式推理

上一篇文章讲了 TreeHeap Algebra：

compose
decompose
transpose
project
unproject
energy
probability container

但这里还少了一个很重要的操作。

用户提出了一个矩阵卷积的类比：

1 0 1
0 1 0
1 0 1

如果我们有这样一个卷积核，就可以在一张矩阵或图像上滑动它。哪里局部模式相同，哪里就会有高响应。

这件事表面上是卷积。

但本质上是：

用一个局部模式，在大结构里搜索对应部分。

这已经很接近推理。

因为推理很多时候不是“生成一个 token”，而是：

在当前结构里找到一个已知模式。

所以这篇文章把这个操作整理成 TreeHeap 的新代数操作：

SubHeap Kernel Search

中文可以叫：

子堆核搜索

对应的公开实验仓：

https://github.com/houming818/sametime

其中 ARA 记录入口是：

ara/s2-translation/logic/predicts.md
ara/s2-translation/logic/solution/treeheap_algebra.md
ara/s2-translation/trace/research_dag.yaml

当前 TreeHeap 没有这个操作

先说清楚：

当前实现里还没有子堆核搜索。

现在实现更多是：

L0(token)
  x path/world
  -> CMul
  -> t_merge

这是点级变换。

也就是说，它主要回答：

这个 token 进入某个背景以后，向量怎么变？

但子堆核搜索要回答的是：

整个 TreeHeap 里，哪里出现了某个局部结构模式？

这不是同一类问题。

CMul 像是把一个点放进背景场。

SubHeap Kernel Search 像是在一整个结构里找模式。

图像卷积在做什么

先用图像理解。

假设有一个 kernel：

1 0 1
0 1 0
1 0 1

它在图像上滑动。

每到一个位置，就问：

这里的局部形状像不像这个 kernel？

像，就高响应。

不像，就低响应。

这就是：

local pattern matching

中文可以说：

局部模式匹配

线性秩序和取模周期

这里还有一个更底层的理解。

矩阵卷积不一定要先被看成神秘的二维图像操作。

它也可以被看成：

线性秩序
+ 局部窗口
+ 取模位移
+ 同一个 kernel 的重复作用

例如一个一维序列：

x[0], x[1], x[2], ..., x[n-1]

如果使用周期边界，那么位置可以这样移动：

i + 1 mod n
i - 1 mod n

这就形成了一个循环结构。

二维矩阵也可以被展平成一维地址：

index = row * width + col

然后用固定偏移找邻居：

left  = index - 1
right = index + 1
up    = index - width
down  = index + width

如果加上边界取模：

row = row mod height
col = col mod width

就得到一个周期性空间。

所以卷积的核心可以说是：

在一个有秩序的地址空间里，
用固定偏移定义邻域，
再用同一个 kernel 反复测试局部模式。

这对 TreeHeap 很重要。

因为它提醒我们：

TreeHeap kernel 不是一上来就必须是复杂语法树。

它可以先从更基础的东西开始：

TreeHeap traversal order
+ heap address
+ parent/child offset
+ sibling offset
+ modular or cyclic neighborhood

也就是说，TreeHeap 需要先定义自己的“地址代数”。

矩阵里有：

(row, col)

序列里有：

i mod n

TreeHeap 里可能需要：

path
parent(path)
left(path)
right(path)
sibling(path)
next_dfs(path) mod N
next_bfs(path) mod N

这样 kernel 才知道自己在什么空间里移动。

换句话说：

卷积核不是单独成立的。
它依赖一个可移动、可取邻域、可重复作用的地址空间。

这也把 SubHeap Kernel Search 拆成两个问题：

1. TreeHeap 地址空间怎么定义？
2. kernel 如何在这个地址空间里做局部匹配？

这个拆分很有价值。

因为如果地址空间都没定义好，直接谈复杂的子树匹配，就容易跳太快。

TreeHeap 里没有规则网格

TreeHeap 不是二维矩阵。

它更像：

树
堆
图
槽位结构
概率容器

所以 kernel 不能像 3x3 那样滑动。

TreeHeap 的 kernel 应该长这样：

K = event {
  center: action-like
  slot_1: agent-like
  slot_2: object-like
  slot_3: location-like
}

它不是像素模板。

它是一个局部结构模板。

例如：

eat_event {
  agent = ?
  object = ?
}

或者：

move_event {
  mover = ?
  source = ?
  target = ?
}

这就是 SubHeap Kernel。

子堆核搜索怎么定义

可以定义一个操作：

match_subheap(H, K) -> ProbabilityContainer[SubHeap]

其中：

H = 整个 TreeHeap
K = 一个局部子堆核

输出不是一个硬位置。

输出应该是概率容器：

{
  subheap_12: 0.71
  subheap_4:  0.18
  subheap_29: 0.07
}

这表示：

K 最可能匹配 subheap_12，
但 subheap_4 和 subheap_29 也有可能。

这和 TreeHeap 的概率容器思想一致：

信息不足时，不要过早 argmax。

为什么这是推理搜索

考虑三句话：

cat eats fish
fish is eaten by the cat
the cat quickly eats fish

表面顺序不同。

但它们共享一个事件结构：

eat_event {
  agent = cat
  object = fish
}

如果我们有一个 kernel：

K = action(agent, object)

那么它应该在三句话里都找到这个事件。

这就是推理。

因为系统没有只看：

cat 是否在 eats 左边

而是在看：

谁在 action 的 agent 槽位？
谁在 object 槽位？
这个局部结构是否等价？

这就是拓扑搜索。

和普通 attention 有什么不同

Transformer attention 可以让 token 互相看。

但 attention 本身不一定显式告诉你：

这里有一个 action(agent, object) kernel 匹配成功。

SubHeap Kernel Search 更像显式结构操作：

给定一个 kernel，
在 TreeHeap 里找对应的子堆。

所以它更接近：

结构检索
图模式匹配
局部推理模板匹配

它不是替代 attention。

它是给 TreeHeap 代数增加一种可解释操作。

这个操作需要处理什么困难

普通卷积很简单，因为图像是规则网格。

TreeHeap 更麻烦。

它至少要处理：

1. 树/图不是规则网格。
2. child 顺序有时重要，有时不重要。
3. slot 顺序可能重要。
4. 有些 child 可以缺省。
5. 主动/被动会改变方向。
6. 中文和英文的表达顺序不同。
7. 匹配应该允许近似，而不是严格相等。

所以它更像：

tree kernel
graph kernel
slot kernel
subgraph matching
message passing

但我们不要一上来做复杂。

先做最小实验。

新 predict：P-ALG02

可以写下：

P-ALG02:
如果 TreeHeap 支持拓扑级推理，
那么同一个 SubHeap Kernel 应该能在不同表面顺序中，
找到等价的局部结构。

换句话说：

同一个推理核，
应该能匹配不同说法里的同一个结构。

例如：

cat eats fish
fish is eaten by the cat
the cat quickly eats fish

都应该激活：

eat_event(agent=cat, object=fish)

E-ALG05: kernel invariance

第一个实验叫：

E-ALG05 kernel invariance

测试：

同一个 kernel，
不同表面顺序，
是否找到同一个子堆。

例子：

cat eats fish
fish is eaten by the cat
the cat quickly eats fish

成功标准：

active/passive/paraphrase variants
rank the same event subheap in top-k

失败标准：

只对 token 顺序敏感。
只匹配表面邻近。
主动变被动就失败。

E-ALG06: kernel selectivity

第二个实验叫：

E-ALG06 kernel selectivity

测试：

同样的词，角色换了以后，分数应该下降。

例如：

cat eats fish
fish eats cat

它们词一样，但结构不一样。

我们希望：

score(agent=cat, object=fish)
>
score(agent=fish, object=cat)

如果两个分数差不多，说明 kernel 只是看到了词，没有看懂角色。

E-ALG07: cross-lingual kernel transfer

第三个实验叫：

E-ALG07 cross-lingual kernel transfer

测试：

中文里的事件 kernel，
能不能对应到英文里的等价事件子堆。

例如：

猫吃鱼
the cat eats fish

或者更复杂：

鱼被猫吃了
the fish was eaten by the cat

如果 TreeHeap 真的要服务 WMT/S2，这个实验很关键。

因为翻译本质不是词对词。

翻译是：

源语言局部拓扑
映射到
目标语言局部拓扑

SubHeap Kernel Search 正好可以测这件事。

和前面代数操作的关系

SubHeap Kernel Search 不是孤立的。

它会用到前面几种操作：

project:
  把子堆放到某个参考系里解释。

transpose:
  处理主动/被动、parent/child 方向变化。

energy:
  给候选匹配排序。

probability container:
  保留多个可能匹配。

decompose:
  从 parent 里找可能 children。

所以它可以看作 TreeHeap Algebra 的第一个“推理搜索操作”。

工程上怎么先做

最小实现不用大模型。

可以先做 controlled toy set：

cat eats fish
fish is eaten by cat
dog chases cat
cat is chased by dog

用 spaCy 或手写 proxy 结构先构造小 TreeHeap。

然后定义 kernel：

K_action_object
K_agent_action_object
K_action_location

再比较：

gold subheap score
shuffled-role score
surface-nearest score
random subheap score

如果连这个都跑不出来，就不应该直接上 WMT。

这对项目推进有什么意义

之前我们一直在问：

TreeHeap 是否学出了世界模型？

这个问题太大。

现在可以拆小：

TreeHeap 能不能定义一个局部结构核？
这个核能不能在大堆里找等价子堆？
这个匹配能不能跨主动/被动？
这个匹配能不能跨语言？

这比直接问“能不能翻译”更可测。

如果 P-ALG02 成立，下一步 S2 会更清楚：

source sentence
-> SubHeap kernels find source reasoning structure
-> project/transpose to target frame
-> target SubHeap kernels recover target structure
-> decoder realizes surface text

如果 P-ALG02 失败，那也很清楚：

TreeHeap 还没有 topology search 能力。
不要急着把它接到 WMT decoder。

当前状态

新增 predict：

P-ALG02: SubHeap kernel search

新增实验计划：

E-ALG05 kernel invariance
E-ALG06 kernel selectivity
E-ALG07 cross-lingual kernel transfer

计划实现：

ara/s2-translation/src/subheap_kernel_probe.py
ara/s2-translation/evidence/subheap_kernel_probe/

状态：

Design phase.

还没有 claim。

最后一句话

CMul 是点进入背景。

TreeHeap Algebra 是对象之间的数学操作。

SubHeap Kernel Search 则是：

在高维堆里寻找局部推理模式。

这可能是 TreeHeap 从“保存信息”走向“结构推理”的关键一步。

License: GPLv3

[SPR-013] M0 纯数学实验：先让 TreeHeap 成为工具箱

Thu, 18 Jun 2026 00:00:00 +0000

M0 纯数学实验：先让 TreeHeap 成为工具箱

这篇文章记录一件更底层的事：

先不要直接做 WMT。
先证明 TreeHeap 作为数学对象能不能被操作。

WMT 是最终任务。

但它不是好的早期诊断工具。

因为如果直接训练翻译系统，最后 BLEU 没涨，我们很难知道失败来自哪里：

算子设计不对
世界模型没学到
loss 不合适
decoder 太弱
数据不够
训练没收敛
评估太粗

所以这次我们先建立一个更小的 ARA 主题：

ara/m0-treeheap-math/

它的目标不是证明 TreeHeap 会语言推理。

它只问一个问题：

TreeHeap 能不能先成为一个数学工具箱？

公开记录

公开实验仓：

https://github.com/houming818/sametime

对应 ARA 入口：

ara/m0-treeheap-math/logic/predicts.md
ara/m0-treeheap-math/logic/solution/algebra.md
ara/m0-treeheap-math/src/treeheap_math_probe.py
ara/m0-treeheap-math/evidence/treeheap_math_probe/summary.json

主仓内部路径：

/home/nio/log/ara/m0-treeheap-math/

为什么这是 toy 实验

toy 不是玩具。

toy 的意思是：

把问题缩小到刚好能看清楚。

如果我们要验证卷积核，第一步不会直接拿 ImageNet。

会先拿一个很小的矩阵：

1 0 1
0 1 0
1 0 1

看看核匹配到底能不能找到局部模式。

TreeHeap 也是一样。

这次我们不使用：

token
语法标签
WMT
BLEU
真实 checkpoint

只使用几个合成符号：

A, B, C, D, E, R, T

然后构造几棵小树：

H_ab = root(R, left=A, right=B)
H_ba = root(R, left=B, right=A)
H_cd = root(R, left=C, right=D)
H_nested = root(T, left=H_ab, right=E)

这个 toy 足够小。

小到我们知道正确答案。

也足够有用。

因为它能测试 TreeHeap 最基本的数学性质。

最小 TreeHeap 对象

第一版对象定义成：

H = (name, v, head_v, slot, q, children)

字段含义：

字段	含义
`name`	合成对象名字，比如 `H_ab`
`v`	整棵 TreeHeap 的结构向量
`head_v`	root/head 参考向量
`slot`	当前节点的结构槽位
`q`	概率质量
`children`	子堆

这里最关键的是：

v != head_v

v 是整体结构坍缩后的向量。

head_v 是根节点自己的参考量。

这个区别是实验跑出来的，不是预先拍脑袋定的。

这次测试哪些工具

第一批工具箱：

compose
decompose
transpose
inverse_transpose
project
unproject
energy
match_subheap
probability container

对应要问的问题：

工具	问题
`compose`	两个子堆能不能合成一个合法 TreeHeap
`decompose`	合成后能不能拆回子堆
`transpose`	左右结构交换后是否仍然可追踪
`inverse_transpose`	转置两次能不能回来
`project`	降维后是否还保留结构排序
`energy`	正确结构和扰动结构能不能拉开距离
`match_subheap`	小子堆核能不能在大树里找到对应部分
`probability container`	匹配结果能不能形成稳定概率分布

非交换性：AB 不等于 BA

如果 TreeHeap 只是普通加法：

A + B = B + A

那它没法表达结构顺序。

所以我们给左右位置不同的结构基：

v(H) = normalize(root + L @ left + R @ right)

其中：

L != R

于是：

H_ab = root(R, left=A, right=B)
H_ba = root(R, left=B, right=A)

会得到不同向量。

这就像数字：

12 != 21

不是因为 1 和 2 变了。

而是因为位权变了。

实验结果：

noncomm_margin = 0.7117

这说明左右交换后，结构空间里确实拉开了距离。

第一次失败：只有 v 不够

第一版实现里，我只保存了整体向量：

H = (name, v, slot, q, children)

结果 transpose 出问题了。

我们希望：

inverse_transpose(transpose(H)) ~= H

但第一次跑出来：

transpose_inverse_error = 0.6248

这说明一个重要问题：

只有坍缩后的整体向量 v，不足以支持精确逆操作。

原因很直接。

当一棵树已经合成为整体向量后，这个整体向量混合了：

root
left
right

如果再拿它当 root 去重组，就会把整体误当成局部。

于是转置两次也回不来。

这不是坏事。

这是 toy 实验的价值。

它告诉我们 TreeHeap 对象定义漏了一个必要参考量。

修正：加入 head_v

修正后对象变成：

H = (name, v, head_v, slot, q, children)

其中：

head_v = root/head 自己的向量
v      = 整棵树合成后的向量

这样 transpose 时可以用原来的 head 重新组装，而不是把整体向量错当 root。

修正后：

transpose_inverse_error = 0.0

这个结论很重要：

TreeHeap 不能只是一个 collapsed vector。
它至少需要保留 root/head reference。

这也是从纯数学实验里得到的第一个设计约束。

子堆核匹配 toy

我们构造：

H_nested = root(T, left=H_ab, right=E)

也就是：

        T
       / \
    H_ab  E
    /  \
   A    B

然后用 kernel：

K = H_ab

去 H_nested 里找匹配。

结果：

subheap_hit_at_1 = 1.0
subheap_hit_at_3 = 1.0

匹配分数最高的是：

H_ab

对应概率：

0.9999798803

这说明在 toy 条件下：

match_subheap(H_nested, H_ab)

能找到正确子堆。

role swap 为什么看 margin

我们还测试了反向 kernel：

K = H_ba

但 H_nested 里并没有真正的 H_ba。

这时系统仍然必须返回一个 top-1，因为概率容器总要在候选里排序。

它会把最接近的错误候选排前面。

所以不能只看：

top1 是谁

还要看分数差。

结果：

gold score = 1.0
role-swapped score on gold = 0.09085
role_swap_margin = 0.9091

这说明：

H_ab 和 H_ba 在结构空间里不是同一个东西。

这正是我们想要的。

本轮结果

实验命令在 ni 上执行，CPU 即可，不使用 GPU。

结果摘要：

pilot_pass = true
closure_ok = true
noncomm_margin = 0.7117
transpose_inverse_error = 0.0
compose_decompose_error = 0.0
projection_top1_preserved = true
projection_order_agreement = 0.8333
subheap_hit_at_1 = 1.0
subheap_hit_at_3 = 1.0
role_swap_margin = 0.9091
prob_mass_error = 0.0

对应证据文件：

ara/m0-treeheap-math/evidence/treeheap_math_probe/summary.json
ara/m0-treeheap-math/evidence/treeheap_math_probe/README.md
ara/m0-treeheap-math/evidence/treeheap_math_probe/matches.jsonl

这证明了什么

它证明了一个很小但很关键的点：

TreeHeap 可以先作为数学对象被操作。

至少在合成 toy 空间里，它支持：

闭包
非交换
精确转置逆
compose/decompose
投影保持
子堆核匹配
概率容器归一

这给下一步 Echo 提供了更干净的地基。

它没有证明什么

它没有证明：

TreeHeap 懂语言
TreeHeap 会翻译
TreeHeap 已经形成世界模型
SubHeap kernel 能处理真实句子
WMT 会涨分

这只是 M0。

但 M0 的意义是：

先把尺子做出来。

没有尺子，直接看 BLEU，就像还没造好温度计就讨论天气。

下一步

路线应该是：

M0 纯数学 TreeHeap
  -> M1 approximate inverse
  -> M2 TreeHeap-object echo
  -> M3 structure invariant
  -> S2 translation

下一步不应该直接回 WMT。

应该做：

exact inverse
↓
approximate / learned inverse

也就是看看：

不直接保存 children 的时候，
模型能不能从 TreeHeap 表示里近似拆回结构。

如果 M1 过了，再做 Echo。

Echo 也不再是旧的 token echo。

而是：

TreeHeap object
↓
operator transformations
↓
reconstruct TreeHeap object

这样顺序更干净：

数学成立
信息可保留
结构可识别
语言再利用

License: GPLv3

[SPR-014] 基元与 plus：TreeHeap 有序性的来源

Thu, 18 Jun 2026 00:00:00 +0000

基元与 plus：TreeHeap 有序性的来源

这篇先不跑实验。

它先把一个更底层的想法固定下来：

TreeHeap 的卷积问题，
可能不是先找 kernel，
而是先找语义空间里的基元和 plus。

这个想法来自整数系统。

整数的有序性不是随便排出来的。

它有一个非常小的核心：

基元：0 或 1
算子：plus / successor
顺序：n -> n + 1
闭包：n + 1 仍然是整数
取模：n + base 折回 n

如果 TreeHeap 也想形成自然的有序地址空间，那么我们也要问：

语义空间里的 1 是什么？
语义空间里的 plus 是什么？
TreeHeap 的 n+1 是怎么生成的？

为什么这比卷积更底层

上一篇文章说，卷积可以理解成：

线性秩序
+ 局部窗口
+ 取模位移
+ 同一个 kernel 的重复作用

但这里还有一个没回答的问题：

线性秩序从哪里来？

如果我们只是人为给节点编号：

node_0, node_1, node_2, ...

那这个顺序可能只是外部编号。

它不一定是 TreeHeap 自己的结构。

更自然的做法是：

node_{n+1} = plus(node_n, primitive)

也就是说：

有序性由 plus 生成。

这就像整数：

1 = 0 + 1
2 = 1 + 1
3 = 2 + 1

而不是先把整数排好，再事后说它有顺序。

对应关系

可以先做一个对照表：

整数系统	TreeHeap / 语义空间
`0`	origin / root primitive
`1`	最小语义基元
`n + 1`	next semantic state / next node
`plus(a, b)`	语义组合或结构推进算子
`<`	repeated plus 生成的顺序
`mod base`	有限 TreeHeap 地址环
convolution	在这个地址环上滑动 kernel

所以真正要找的是：

primitive
plus
ordered orbit

其中 orbit 是：

x0
x1 = plus(x0, p)
x2 = plus(x1, p)
...
x_base ~= x0

如果这个成立，TreeHeap 就不仅是有编号。

它有了一个内部生成的顺序。

什么是基元

基元不是人工语法标签。

它不是：

SUBJECT
OBJECT
VERB

至少在 M0/M1 阶段不能这样定义。

基元应该先被看成：

能让状态发生最小可重复变化的元素。

在整数里，这个元素是：

在 TreeHeap 里，它可能是：

一个最小路径步长
一个最小 slot shift
一个最小语义方向
一个局部结构生成元
一个 learned primitive basis

我们不应该一开始就假设它是什么。

应该设计实验去找：

哪个 p 可以让 plus(x, p) 稳定地产生 next？

plus 可能是什么

候选 plus 可以有很多种：

plus(v, p) = v + p
plus(v, p) = normalize(v + p)
plus(v, p) = CMul(v, p)
plus(H, p) = compose(H, p)
plus(path, step) = path_shift(path, step)
plus(H, p) = learned_operator(H, p)

这些都只是候选。

不能先说哪一个一定对。

ARA 里应该把它们当作实验变量。

真正的判断标准是：

它能不能生成稳定有序轨道？

有序轨道

如果找到了一个 primitive p 和一个 plus，那么就可以生成：

x0 = origin
x1 = plus(x0, p)
x2 = plus(x1, p)
x3 = plus(x2, p)

这是一条轨道。

我们希望它满足：

相邻可预测
远邻可区分
重复作用不发散
到达 base 后可以回环

也就是：

nearest(plus(x_n, p)) = x_{n+1}
distance(x_n, x_{n+1}) < distance(x_n, x_{n+3})
distance(x_base, x_0) small

这才是 TreeHeap 的有序性。

不是外部排出来的。

而是由内部算子生成的。

取模怎么出现

如果轨道长度是 base：

x0, x1, x2, ..., x_{base-1}

那么取模就是：

x_{n + base} ~= x_n

也就是：

idx(x) in Z_base

这时 TreeHeap 地址空间变成：

Z / base Z

也就是一个有限循环地址环。

卷积 kernel 才能滑动：

window(i) = [
  x_{i-1 mod base},
  x_i,
  x_{i+1 mod base}
]

这就是：

基元 + plus
生成 order
order + mod
生成 cyclic address
cyclic address + kernel
生成卷积

这对 TreeHeap 很重要

之前我们说：

TreeHeap 是有序树。

但这句话还不够。

还要追问：

这个有序性是外部编号给的，
还是 TreeHeap 自己生成的？

如果只是外部编号，那它只是工程索引。

如果有：

x_{n+1} = plus(x_n, p)

那它就是结构规律。

这两者差别很大。

前者只能帮我们扫描。

后者可能帮我们推理。

新 predict：P-MATH02

可以把下一步写成：

P-MATH02: Semantic primitive and plus operator

预判：

如果 TreeHeap 空间存在可用于结构生成的有序性，
那么应该存在某种 primitive p 和 plus 算子，
使 repeated plus 生成稳定、有序、可取模的语义轨道。

形式：

x_0 = origin
x_{n+1} = plus(x_n, p)
x_{n+base} ~= x_n

toy 实验应该怎么做

先不要碰语言。

还是 M0 纯数学 toy。

设：

base = 8
origin = x0
primitive = p

生成：

x1 = plus(x0, p)
x2 = plus(x1, p)
...
x8 ~= x0

测这些指标：

successor_accuracy:
  nearest(plus(x_n, p)) == x_{n+1}

cycle_error:
  distance(x_base, x_0)

order_margin:
  distance(x_n, x_{n+1}) < distance(x_n, x_{n+3})

closure:
  plus(x_n, p) still in TreeHeap space

kernel:
  [x_{i-1}, x_i, x_{i+1}] mod base can be matched

如果这些都不成立，就不要急着讨论语言。

因为连：

1, 2, 3, 4

这样的内部顺序都还没长出来。

语言里的直觉

等数学 toy 成立以后，语言才进来。

那时候可以问：

球 + 脚 -> 足球
球 + 手 -> 篮球
动作 + 施事 -> 事件
事件 + 时间 -> 时态
事件 + 地点 -> 场景

但这些不能一开始就当作人工标签。

更好的路径是：

先无监督找 primitive basis
再看这些 basis 是否对应可解释概念

也就是说：

先找数学上的 1。
再看这个 1 在语言里像不像“脚”“手”“时间”“地点”。

对当前路线的影响

这会把路线再往前插一层：

M0: TreeHeap object algebra
M0-P2: primitive + plus + ordered orbit
M1: approximate inverse / learned plus
M2: TreeHeap-object echo
M3: structure invariant
S2: translation

也就是说，SubHeap Kernel Search 之前，还要先问：

kernel 在哪个有序空间里移动？
这个有序空间是不是由 plus 生成？

如果不是，它可能只是工程扫描。

如果是，它才更像 TreeHeap 自己的代数。

当前状态

这篇是理论整理。

还没有实验 claim。

已经可以进入 ARA：

ara/m0-treeheap-math/logic/predicts.md

下一步实验文件可以叫：

ara/m0-treeheap-math/src/primitive_plus_probe.py
ara/m0-treeheap-math/evidence/primitive_plus_probe/

先用合成 toy 找：

primitive
plus
ordered orbit
mod base
cyclic kernel

等这个成立，再往 Echo 和 S2 推。

License: GPLv3

[SPR-015] primitive plus 实验：把 proof 变成可测的 TreeHeap toy

Fri, 19 Jun 2026 00:00:00 +0000

primitive plus 实验：把 proof 变成可测的 TreeHeap toy

这篇文章解释刚跑完的实验：

primitive_plus_probe.py

它对应 ARA 里的：

P-MATH02: Semantic primitive and plus operator

这次实验不是语言实验。

不是翻译实验。

不是 WMT。

它是一个纯数学 toy，用来验证一个非常小的想法：

如果 TreeHeap 是一个可寻址的堆结构，
那么 plus 能不能同时承担三件事：

1. successor：走到下一个地址
2. information gain：增加信息量
3. mod fold：超过 base 后折回前面的地址

如果这个 toy 都跑不通，就没必要急着谈真实语言里的 TreeHeap 卷积。

先说结论

这轮 toy 实验通过了：

pilot_pass = true
successor_ok = true
info_gain_pre_base = true
info_saturates_after_base = true
mod_fold_targets = [0, 1]
mod_fold_ok = true
kernel_hit_at_1 = 1.0
wrap_breaks_old_kernel = true

用人话说：

plus 可以从 arr[0] 写到 arr[7]。
base=8 满了以后，再 plus 会折回 arr[0]、arr[1]。
base 没满前，信息量每次 +1。
base 满了以后，信息量不再增加，而是覆盖旧位置。
循环窗口 kernel 能找到 [p0, p1, p2]。
覆盖 arr[0] 后，旧 kernel 分数下降。

这说明：

plus = successor + information gain + mod fold

至少在这个合成 toy 里是成立的。

为什么要做这个实验

前面我们讨论 TreeHeap 卷积。

卷积需要一个有序空间。

一维卷积里，这个空间是：

x[0], x[1], x[2], ..., x[n-1]

如果加上取模：

x[(i + 1) mod n]

它就变成一个循环空间。

但是 TreeHeap 不是普通数组。

所以问题变成：

TreeHeap 的有序空间从哪里来？

如果只是人工编号：

0, 1, 2, 3, ...

那只是工程索引。

我们真正想找的是：

这个顺序能不能由 plus 生成？

也就是：

H_{n+1} = plus(H_n, primitive)

这个实验就是把这个 proof 变成可测程序。

TreeHeap 对象怎么定义

这次不用单个向量表示 TreeHeap。

我们明确使用可寻址数组：

TreeHeapState = {
  arr: Node[]
  base: int
  cursor: int
  summary: vector
  step: int
}

其中：

arr[0] = root

这是你指出的关键点。

如果 TreeHeap 是数组式堆，那么 root 本来就在：

arr[0]

所以 root 不需要额外幻想出来。

真正重要的是：

arr 是主状态。
summary 只是投影。

不要反过来把 summary 当成整棵树。

数组堆的地址规律

这次使用二叉堆的本科数据结构公式：

root = 0
left(i) = 2i + 1
right(i) = 2i + 2
parent(i) = floor((i - 1) / 2)

例如 base = 8：

index: 0 1 2 3 4 5 6 7

树关系是：

0
├─ 1
│  ├─ 3
│  └─ 4
└─ 2
   ├─ 5
   └─ 6

7 是下一层的第一个节点。

这说明 TreeHeap 不是无序集合。

它有地址，有父子关系，也可以有线性顺序。

取模 base

这次设置：

base = 8

地址只有：

0, 1, 2, 3, 4, 5, 6, 7

如果再往后写，就用取模：

target = (cursor + 1) mod base

这就是整数模群里最基础的：

Z / 8Z

也就是：

0,1,2,3,4,5,6,7,0,1,2,...

群论里可以把它看成一个循环群。

但这里只需要理解：

超过 7，就回到 0。

plus 怎么定义

这次的 plus 很简单：

plus(H, primitive):
  target = (cursor + 1) mod base
  arr[target] = primitive
  summary = summarize(arr)

也就是说：

plus 不是向量加法。
plus 是对 TreeHeap 地址空间的一次写入。

它做三件事：

找下一个地址。
把新 primitive 写进去。
更新 summary。

如果用 [ ] 表示空 TreeHeap，那么：

H0 = []
H1 = plus(H0, p0)
H2 = plus(H1, p1)
...

实际写入顺序是：

step 1: p0 -> arr[0]
step 2: p1 -> arr[1]
step 3: p2 -> arr[2]
...
step 8: p7 -> arr[7]
step 9: p8 -> arr[0]
step 10: p9 -> arr[1]

这就是 successor：

n -> n + 1

也是 mod fold：

n + base -> n

信息量怎么测

你说：

[] 信息量是 0
[cat] 信息量是 1
[cat, run] 信息量是另一个值

这次 toy 先用最简单的信息量：

I(H) = 非空节点数量

也就是：

I([]) = 0
I([p0]) = 1
I([p0, p1]) = 2

这个指标很粗。

但适合第一版 toy。

因为我们只是想验证：

base 没满之前，plus 是否增加信息量？

实验结果：

step 1: info 0 -> 1
step 2: info 1 -> 2
step 3: info 2 -> 3
...
step 8: info 7 -> 8

所以：

info_gain_pre_base = true

到了 base = 8 以后，数组满了。

这时再 plus：

step 9: p8 -> arr[0]

它不是新增第 9 个格子。

它覆盖 arr[0]。

所以信息量保持：

8 -> 8

实验结果：

info_saturates_after_base = true

这说明 plus 有两个阶段：

base 未满：信息增长
base 已满：模折叠 / 覆盖 / 循环更新

summary 是什么

实验里每个 primitive 是一个 64 维向量：

p0, p1, ..., p9 ∈ R^64

TreeHeap 的 summary 也是一个向量。

但它不是主状态。

主状态是：

arr

summary 是从 arr 算出来的投影：

summary = summarize(arr)

代码里用了一个简单的地址敏感求和：

summary = normalize(Σ roll(node.value, shift(index)))

这里用到了线性代数：

向量求和
归一化
向量距离
余弦相似度

roll 的意思是按地址改变向量坐标，让同一个 primitive 放在不同地址时，对 summary 的影响不同。

这相当于给地址一个位置编码。

实验检查：

summary_consistency_ok = true

意思是：

summary 每次都确实等于 summarize(arr)，没有和 arr 脱节。

还有：

summary_min_delta = 0.4124

意思是每次 plus 后，summary 都发生了明显变化。

kernel 是怎么测的

我们定义一个循环窗口：

window(i) = [
  arr[(i - 1) mod base],
  arr[i],
  arr[(i + 1) mod base]
]

这就是一维卷积最小窗口：

[-1, 0, +1]

然后设置 kernel：

K = [p0, p1, p2]

在 base 填满后：

arr[0] = p0
arr[1] = p1
arr[2] = p2

所以以 i = 1 为中心：

window(1) = [arr[0], arr[1], arr[2]]
          = [p0, p1, p2]

应该完全匹配。

实验结果：

kernel_hit_at_1 = 1.0
kernel_top_score = 1.0

这说明循环 kernel 能在地址环上找到正确窗口。

覆盖以后为什么分数下降

第 9 步：

p8 -> arr[0]

于是原来的：

[p0, p1, p2]

变成：

[p8, p1, p2]

这时再用旧 kernel：

K = [p0, p1, p2]

去匹配，分数应该下降。

实验结果：

kernel_top_score = 1.0
kernel_after_wrap_top_score = 0.6731
wrap_breaks_old_kernel = true

这说明：

mod fold 不是空操作。
它真的改变了局部结构。

这点重要。

因为如果折回以后 kernel 分数不变，说明地址环没有真正影响结构。

概率论在这里怎么出现

这次没有做复杂概率模型。

但有一个概率容器思想的前置形式：

对每个 center 计算 kernel score
然后按分数排序

这还不是 softmax 概率。

但它已经是概率容器之前的一步：

候选位置集合 + 分数

下一步可以把分数变成概率：

P(i) = exp(score(i)) / Σ exp(score(j))

这就是本科概率论里常见的归一化思想。

先有 score。

再有 probability。

最后才有 collapse。

这次到底 proof 了什么

这次不是证明 TreeHeap 会推理。

它 proof 的是一个很窄的数学命题：

在一个可寻址 TreeHeap toy 里，
plus 可以被定义为 successor 写入；
在 base 未满时增加信息量；
在 base 满后按 mod 折回；
循环窗口 kernel 可以在这个地址环上匹配局部模式。

对应实验结果全部通过：

closure_ok = true
root_ok = true
successor_ok = true
info_gain_pre_base = true
info_saturates_after_base = true
mod_fold_ok = true
kernel_hit_at_1 = 1.0
wrap_breaks_old_kernel = true

这说明：

P-MATH02 作为 M0 toy 成立。

但这还不是语言 claim。

这次没有证明什么

它没有证明：

真实语义空间里一定有 primitive
真实 TreeHeap checkpoint 已经学到 plus
TreeHeap 会翻译
TreeHeap 会推理
kernel 能处理真实句子

这些都还要后续实验。

这次只是把地基往前铺了一格。

下一步怎么走

下一步应该做两个方向。

第一，把信息量从：

非空节点数量

升级为：

rank
entropy
description length
reconstruction bits
distinguishability

第二，把 primitive 从人工 p0,p1,... 换成可学习的 basis：

learned primitive basis

也就是问：

模型能不能自己找到那个类似“1”的基元？

然后才进入：

TreeHeap-object echo
structure invariant
S2 translation

一句话

这次实验把一句抽象话：

TreeHeap 需要 primitive 和 plus 来生成有序性。

变成了可测 toy：

arr[0] 是 root。
plus 写入下一个地址。
base 前信息量增长。
base 后按 mod 折回。
kernel 能在循环地址环上滑动。

这就是进入 Echo 之前，TreeHeap 工具箱需要补上的数学基础。

License: GPLv3

[SPR-016] Trainability Quiz：TreeHeap 进入可学习系统之前的三道小题

Sun, 21 Jun 2026 00:00:00 +0000

Trainability Quiz：TreeHeap 进入可学习系统之前的三道小题

这篇文章解释刚跑完的一个小实验：

ara/m0-treeheap-math/src/trainability_quiz.py

它对应 ARA 里的一个新 predict：

P-LEARN01: TreeHeap trainability quiz

这不是 WMT。不是翻译实验。也不是证明 TreeHeap 已经拥有语言理解能力。

它是一道“入门考试”：在真正训练 TreeHeap encoder、plus、decoder 之前，我们先问一个更朴素的问题：

当前这套最小学习框架，能不能学会基础函数？

如果连最简单的线性映射、XOR、模加法都学不会，那么直接去跑 WMT 只会得到一堆昂贵但难解释的 loss 曲线。

先说结果

实验在 ni 上执行，使用的是：

Python 3.10
NumPy
manual gradients
no PyTorch
seed = 20260621
base = 8

结果如下：

任务	初始 loss	最终 loss	指标	通过
linear_regression	3.7075966755	1.6516923159e-30	R2 = 1.0	true
xor	0.9064090912	0.0007663465	accuracy = 1.0	true
modular_addition	2.4380615125	0.0021191076	accuracy = 1.0	true

总结果：

pilot_pass = true

用人话说：

这个最小训练系统可以学会：
1. 连续空间里的线性关系
2. 非线性逻辑关系
3. 离散循环空间里的模加法关系

这给下一步 TreeHeap 数学工具箱一个基础信号：我们可以开始把 plus、primitive、mod fold、addressable heap 设计成可训练模块，而不是只停留在手写 toy 规则。

还有一个更重要的工程含义：

TreeHeap 不是要推翻已有机器学习数学。
TreeHeap 只是我们设计的一种高维可寻址结构。

所以我们已经知道有效的常识知识仍然有效。

比如：

线性代数仍然有效
梯度下降仍然有效
非线性激活仍然有效
交叉熵仍然有效
分类任务仍然有效
模运算、群、循环结构仍然有效

这件事会让研发轻很多。

因为 TreeHeap 不是从零发明一套完全陌生的数学宇宙。它更像是在已有机器学习工具箱上，额外引入一个结构对象：

addressable high-dimensional heap object

也就是：

机器学习负责学习参数。
TreeHeap 负责提供可寻址、高维、可组合的结构载体。

这样一来，我们后面可以继续使用本科到研究生阶段熟悉的数学工具，而不是每一步都陷入“这个东西有没有物理意义”的空转。

TreeHeap 和一维实数有什么相似处

为了避免 TreeHeap 被理解成一个玄学名词，可以先把它和最熟悉的一维数作比较。

最简单的数学对象是一个实数：

x in R

它有几个非常重要的性质。

第一，它可以表示状态：

x = 3.2

第二，它可以被操作：

x + 1
2x
x^2

第三，它可以被学习系统处理。比如线性回归学的是：

y = wx + b

这里的 x 是输入状态，w 和 b 是学习出来的参数。

TreeHeap 也有类似的一面。它也是一个状态对象：

H = TreeHeapState

它也可以被操作：

plus(H, primitive)
summarize(H)
kernel_search(H, K)

它也应该可以被学习系统处理：

H_{t+1} = learned_plus(H_t, p_t; theta)

所以从“机器学习能否处理它”的角度看，TreeHeap 并没有脱离常识数学。它只是把输入从：

一个数 x

换成：

一个高维可寻址结构 H

这就是 SPR-016 为什么先做线性回归、XOR、模加法的原因。这些 toy 任务确认的是：

学习系统可以从样本中拟合函数。

只要 TreeHeap 的操作最后也能写成函数学习问题，那么已有 ML 工具就仍然能进入。

增加高维结构以后，多了什么

但是 TreeHeap 和一维实数也有根本差异。

一维实数只有一个自由度：

x = 3.2

它没有内部地址。你不能问：

x 的 root 在哪里？
x 的 left child 是什么？
x 的 cursor 指向哪里？

这些问题对实数没有意义。

TreeHeap 不一样。它不是单个标量，而是一个结构对象：

TreeHeapState = {
  arr: Node[]
  root: arr[0]
  cursor: int
  base: int
  summary: vector
}

这带来了几个新增能力。

1. 可寻址性

一维实数没有地址。

TreeHeap 有地址：

arr[0], arr[1], arr[2], ...

所以 TreeHeap 可以表达：

某个信息写在 root
某个信息写在 left child
某个信息写在 next cursor

这让它更像一个数据结构，而不是一个普通数值。

2. 局部结构

实数上做局部窗口没有自然意义。

但 TreeHeap 可以定义局部子结构：

root -> (left, right)

或者循环窗口：

[arr[i-1], arr[i], arr[i+1]]

这就是 TreeHeap kernel search 的来源。它和卷积里的窗口很像，但窗口滑动的空间不再只是普通一维数组，而是 TreeHeap 的地址结构。

3. 多维负载

一维实数只能承载一个标量。

TreeHeap 的每个节点可以承载向量：

node.value in R^d

所以它可以同时保存：

语义信息
结构位置
局部上下文
历史写入痕迹

这就接近我们之前说的：

球 + 脚 -> 足球
球 + 手 -> 篮球

单独一个“球”的向量不够。它要进入不同背景、不同位置、不同操作关系，才形成不同对象。

4. summary 只是投影

一维实数里，数值本身就是对象：

x = 3.2

TreeHeap 里，summary 不是完整对象。完整对象是：

arr + cursor + base + root relation + node values

summary 只是一个投影：

summary = summarize(arr)

这点非常关键。

如果把 summary 当成整个 TreeHeap，就会把一个高维可寻址结构压扁成普通向量。那样很多结构信息会丢失。

一个对比表

维度	一维实数	TreeHeap
基本对象	`x in R`	`H = TreeHeapState`
内部结构	无	有 `arr/root/cursor/base`
地址	无	有 `arr[i]`
操作	`+`, `*`, function	`plus`, `summarize`, `kernel_search`
局部窗口	不自然	可定义子树或地址窗口
学习方式	学 `f(x; theta)`	学 `F(H; theta)`
信息负载	一个标量	多节点、多向量、多关系
投影	数值本身	`summary` 是投影，不是整体

所以 TreeHeap 的定位可以更准确地说成：

它不是比实数更神秘的东西。
它是比实数多了地址、局部结构和高维负载的状态对象。

数学常识仍然有效。但因为对象更复杂，我们需要更多工具：

线性代数处理 node vector
概率论处理候选结构
群/模运算处理循环地址
图和树处理局部关系
机器学习处理可训练算子

这就是 TreeHeap 研发工具箱的来源。

为什么不直接跑 WMT

WMT 是最终方向，但不是最合适的第一道验证题。

翻译任务里同时混在一起的东西太多：

tokenization
encoder
decoder
alignment
syntax
semantics
training objective
beam search
evaluation metric
data quality

如果 WMT loss 降不下来，我们很难判断到底是哪一层错了。

可能是 TreeHeap 的代数设计错了。可能是 encoder 没学到。可能是 decoder 不够。可能是 loss 不适合。也可能只是数据管线有问题。

所以这次我们先把问题切小：

在不碰真实语言的情况下，
训练系统能不能学会几个确定答案的数学任务？

这就是标准机器学习里的 sanity check。本科做线性回归、逻辑回归、XOR、多分类，不是因为这些任务伟大，而是因为它们能检查训练系统的基本生命体征。

三道小题分别检查什么

第一题：线性回归

线性回归检查的是：

y = Wx + b

模型能不能用梯度下降学到一个线性映射。

这对应 TreeHeap 里的基础问题：

一个 TreeHeap summary 或 node vector，
能不能被稳定映射到另一个目标空间？

如果线性回归都失败，那么后面谈世界模型、拓扑弯曲、结构空间就太早了。

这次结果：

final_loss = 1.6516923158620557e-30
R2 = 1.0

这说明最小梯度系统对连续线性映射没有问题。

第二题：XOR

XOR 是经典非线性任务。

输入输出是：

0 xor 0 = 0
0 xor 1 = 1
1 xor 0 = 1
1 xor 1 = 0

它不能被一条直线分开。所以单层线性模型做不好 XOR，必须有非线性变换。

这道题检查的是：

模型是否能通过隐藏层和非线性激活，
学会一个不是简单线性投影的关系。

这和我们之前讨论的“echo 型函数”很相关。

如果一个模型只是把输入原样保存下来，它最多是信息保存器。但世界模型不只是保存信息。它还要改变表示空间，让一些关系变近，让另一些关系变远。

XOR 不能证明模型已经有世界模型，但它至少证明：

训练系统能学非线性关系，
不是只能做输入 echo。

这次结果：

final_loss = 0.0007663465151399971
accuracy = 1.0

第三题：模 8 加法

这是这次最贴近 TreeHeap 的题。

任务是学习：

(a + b) mod 8

例如：

3 + 4 = 7
5 + 6 = 11
11 mod 8 = 3
所以 (5 + 6) mod 8 = 3

为什么它重要？

因为我们前面讨论 TreeHeap 的 plus 时，已经把一个关键结构拆成：

plus = successor + information gain + mod fold

其中 mod fold 就是：

超过 base 后折回前面的地址

如果模型连一个小小的 Z / 8Z 循环群表都学不会，那就不要急着说 TreeHeap 可以学会地址折叠、循环窗口、卷积式 kernel search。

这次结果：

base = 8
final_loss = 0.0021191076117503013
accuracy = 1.0

混淆矩阵是完全对角的：

每个真实类别都被预测成自己，没有串类。

这说明模型学会了完整的 base-8 模加法表。

这和 TreeHeap 有什么关系

前一篇 SPR-015 证明的是手写 toy：

arr[0] 是 root
plus 写入下一个地址
base 前信息量增加
base 后按 mod 折回
kernel 可以在循环地址环上滑动

那是一个规则系统。

这篇 SPR-016 问的是另一个问题：

这些规则有没有机会被模型学出来？

也就是从：

手写 plus(H, primitive)

走向：

learned_plus(H, primitive; theta)

这里的 theta 就是参数。

Transformer 的关键不是矩阵本身，而是参数矩阵能被梯度更新。学习发生在参数里。

TreeHeap 如果也要变成机器学习系统，而不只是数据结构，就必须有：

encoder theta_e
plus theta_p
decoder theta_d
loss
gradient
update

这次 trainability quiz 只是确认：

最小训练管线可以通过梯度学函数。

它还没有证明：

TreeHeap 的真实 plus 已经学出来。

但它允许我们进入下一步。

这一点也修正了 TreeHeap 的定位。

TreeHeap 本身不是一个会自动产生知识的魔法容器。它是一种结构设计：

把向量、地址、root、cursor、base、summary 组织成可操作对象。

真正的知识仍然要通过学习进入参数。也就是：

数据
-> loss
-> gradient
-> parameter update
-> learned operator

Transformer 是这样，TreeHeap 也应该是这样。

区别只在于：

Transformer 主要学习矩阵上的序列映射。
TreeHeap 希望学习高维堆对象上的结构操作。

所以这次实验还证明了一件朴素但重要的事：

我们不用放弃已有 ML 常识。
我们只是把这些常识接到 TreeHeap 结构上。

为什么使用 NumPy 手写梯度

这次没有用 PyTorch。

原因很简单：

ni 上当前 Python 环境有 NumPy，但没有 torch。

所以实验使用手写反向传播。

这反而有一个好处：所有东西都很透明。

我们没有把问题交给框架魔法。每个任务都能看见：

forward
loss
gradient
parameter update

对于 M0 数学工具箱来说，这种透明性比一开始追求大模型训练更重要。

这次实验证明了什么

它证明的是一个很窄的命题：

在当前最小训练代码里，
小型可训练模块可以学会线性映射、XOR、base-8 模加法。

所以我们可以合理继续设计：

trainable TreeHeap encoder
trainable TreeHeap plus
trainable TreeHeap decoder

尤其是 plus。

因为 plus 不是普通向量加法。它更像：

在一个可寻址 TreeHeap 结构里，
把 primitive 写入下一个位置，
更新 summary，
并在 base 满后发生 mod fold。

这次的模加法任务说明：

小模型至少可以学会离散循环结构。

这对 TreeHeap 的地址环、循环窗口和 kernel search 是正向证据。

这次没有证明什么

它没有证明：

TreeHeap 已经会翻译
TreeHeap 已经拥有世界模型
TreeHeap 已经学会真实语言语义
TreeHeap checkpoint 是可靠的
CMul 一定能形成拓扑扭曲

这些都还没有。

这次只是一个入口实验。

如果把研发路线比作爬楼，这次不是到了顶楼。它只是确认：

楼梯是实的，不是一张画。

下一步怎么走

下一步我建议做 P-LEARN02：

Trainable TreeHeap Plus

目标不是语言。还是 toy。

输入：

H_t
primitive p_t

输出：

H_{t+1}

其中 H_t 必须包含可寻址结构：

arr
cursor
base
summary

训练目标可以分成三项：

1. target address loss
   模型要知道下一个写入地址在哪里

2. reconstruction loss
   模型要能重建更新后的 arr 或 summary

3. mod fold loss
   base 满后，模型要学会折回 arr[0], arr[1], ...

如果 P-LEARN02 成立，我们才进入：

TreeHeap-object echo

也就是让模型不仅输出向量，而是输出一个仍然可读、可写、可比较的 TreeHeap 对象。

再之后才是：

structure invariant
S2 translation
WMT

ARA 记录在哪里

这次实验的 ARA 目录是：

ara/m0-treeheap-math/

公开镜像同步到：

https://github.com/houming818/sametime/tree/main/ara/m0-treeheap-math

关键 evidence：

evidence/trainability_quiz/summary.json
evidence/trainability_quiz/README.md

对应代码：

src/trainability_quiz.py

一句话

SPR-015 证明了一个手写 TreeHeap toy 可以拥有 plus + mod fold + kernel search。

SPR-016 证明了最小训练系统可以学会基础连续映射、非线性逻辑和模加法。

所以现在的路线不是：

直接拿 TreeHeap 去碰 WMT。

而是：

先把 TreeHeap 的数学工具箱做成可学习对象，
再让语言任务站在这个工具箱上。

License: GPLv3

[SPR-017] TreeHeap 的存在性证明：把 Claim 说清楚

Sun, 21 Jun 2026 00:00:00 +0000

TreeHeap 的存在性证明：把 Claim 说清楚

上一篇 SPR-016 讲了一件事：

TreeHeap 不是要推翻机器学习。
TreeHeap 是把机器学习接到一种高维、可寻址、可组合的结构对象上。

所以它和 Transformer 在大范式上是相通的：

固定数学算子
+ 可学习参数
+ loss
+ gradient
+ update

Transformer 里：

matmul / softmax / residual add 是固定算子
Wq / Wk / Wv / FFN 是可学习参数

TreeHeap 里我们现在倾向于这样分层：

plus / address / subheap / kernel_search / fold 是固定算子候选
arr.value / primitive basis / world model slots 是可学习参数

但这里必须非常谨慎。

我们上一版实验 A 把这个规则放进去了：

target = (cursor + 1) mod base

这不是普通整数加法。

普通整数里：

11 + 2 = 13

它不等于：

只有当我们明确进入模系统时，才能说：

13 ≡ 3 (mod 10)

也就是说，mod base 不是“加法天然要折叠”，而是一个有限容量系统里的回绕规则。它更像 circular buffer：

cursor = (cursor + 1) mod base
arr[cursor] = value

所以当前实验 A 不能被说成：

证明了 TreeHeap plus。

它只能被说成：

证明了学习器在模地址回绕 toy task 上的归纳边界。

这篇文章就是把三个实验的 claim 重新钉牢。

三个实验到底在 Claim 什么

先给结论。

实验	当前真正测的东西	当前能 claim 什么	当前不能 claim 什么
A	circular addressing toy task	普通学习器从短样本模仿模地址规则时存在归纳边界	不能证明完整 TreeHeap plus/fold，不能证明 TreeHeap learner 已经赢
B	subheap kernel relocation	显式树堆地址上的局部 kernel 可以稳定迁移	不能证明语言结构已经学会
C	prefix compression + probability container	共享路径前缀可以压缩 toy 分布，并保留候选概率	不能证明真实语言翻译质量提升

这三个实验现在只是数学工具箱的第一层 toy proof。它们不是 WMT 证明，也不是 TreeHeap 语言模型证明。

实验 A：循环寻址规则的归纳边界

当前 A 实际做了什么

当前 A 的状态是一个有限容器：

State = {
  arr,
  root = arr[0],
  cursor,
  base,
  summary
}

当前 A 的写入规则是：

circular_write(H, p):
  target = (cursor + 1) mod base
  arr[target] = p
  cursor = target
  summary = summarize(arr)
  return H

这个规则有闭包：

H 是有限状态容器
circular_write(H, p) 仍然是有限状态容器

但是它不是普通加法，也不是完整 TreeHeap plus。

更准确地说：

plus:
  n -> n + 1
  不折叠。

mod plus:
  n -> (n + 1) mod base
  有限容量回绕。

fold plus:
  容量满后不是简单覆盖，而是把旧结构折叠进 summary / parent node。

当前 A 只做了第二种：mod plus。

A 的训练操作

脚本生成很多 primitive 序列：

[p0, p1, p2, ..., pn]

然后用固定规则生成答案：

target_address = (length - 1) mod base
read_value = 最后一次写入 query_addr 的 token

训练时只给短序列：

train length <= 8

测试时给：

test length = 8 / 16 / 32 / 64

参与训练的模型是：

flatten MLP
small Transformer

还有一个 rule oracle：

rule oracle = 直接执行 circular_write 的参考实现

这个 rule oracle 不是训练出来的 TreeHeap 模型。它只是标准答案生成器。

所以 A 的有效证据不是：

TreeHeap learner 取得 1.0。

而是：

MLP / Transformer 在模地址规则上，从短样本外推到长样本时会出现边界。

A 的 8 小时结果

flatten MLP 的读值能力：

test length	read accuracy
8	0.1827
16	0.0593
32	0.0567
64	0.0406

small Transformer 的 address accuracy：

test length	address accuracy
8	0.9997
16	0.9955
32	0.9804
64	0.9292

这说明：

MLP 没有稳定学会 read-after-overwrite。
Transformer 更强，但在长长度上也有下降和失败样本。

A 的准确 Claim

Claim A:
在 circular addressing toy task 上，
普通学习器从短样本模仿规则时存在归纳边界。

A 不能 claim：

完整 TreeHeap plus 已经成立。
完整 TreeHeap fold 已经成立。
TreeHeap learner 已经优于 Transformer。

下一步必须把 A 拆成：

A1: unbounded successor
    11 + 2 = 13，不做 mod。

A2: bounded circular addressing
    13 ≡ 3 (mod 10)，这是有限容量回绕。

A3: fold write
    容量满后做结构折叠，不是简单覆盖。

这才是严谨的 TreeHeap algebra proof。

实验 B：子结构 Kernel 搜索

B 实际做了什么

B 定义一个局部模式：

      A
     / \
    B   C

在数组里就是：

[arr[i], arr[left(i)], arr[right(i)]]

训练时 pattern 只出现在：

train positions = {0, 1, 2}

测试时放到新地址：

test positions = {6, 10, 13}

TreeHeap kernel 的做法是：

for each address i:
  sub = subheap(H, i)
  score[i] = match(sub, K)

answer = max(score)

这就是树堆空间里的卷积。

B 的 8 小时结果

method	accuracy mean	min	max
TreeHeap kernel	1.0000	1.0000	1.0000
flatten MLP	0.4996	0.4258	0.5703
sequence CNN	1.0000	1.0000	1.0000
small Transformer	0.9846	0.6055	1.0000

这组结果不能被解释成“只有 TreeHeap 能做”。CNN 也满分，说明这个任务本质就是局部 kernel 迁移。

更准确的解释是：

局部模式 + 可复用 kernel 是强归纳偏置。
TreeHeap 的价值在于把这种 kernel 从线性/网格空间推广到树堆地址空间。

B 的准确 Claim

Claim B:
如果局部模式定义在树堆地址上，
显式 subheap kernel 可以稳定做 relocation。

B 能支持：

TreeHeap 可以拥有类似卷积的结构算子。

B 不能支持：

语言结构已经学会。
复杂树变换已经解决。
TreeHeap 在所有结构任务上优于 Transformer。

下一步 B 要加难度：

新深度
兄弟交换
局部噪声
缺失子节点
多 kernel 同时存在
kernel composition

实验 C：前缀压缩和延迟坍缩

C 实际做了什么

C 构造共享前缀序列，例如：

A B C X
A B C Y
A B D X
A B D Y
A E F X

普通序列会重复保存这些路径。

前缀树可以共享：

A
├── B
│   ├── C
│   │   ├── X
│   │   └── Y
│   └── D
│       ├── X
│       └── Y
└── E
    └── F
        └── X

共享前缀意味着可以共享：

存储
计算
summary
候选概率

给定前缀：

A B C

后面可能是：

X or Y

TreeHeap 可以在前缀节点上保留候选概率：

A-B-C -> {
  X: 0.5
  Y: 0.5
}

这就是概率容器。它不急着 argmax，而是等待更多上下文。

C 的 8 小时结果

metric	value
sequence_node_count	800
prefix_tree_node_count	11
compression_ratio_mean	72.7273
prefix_reuse_rate_mean	0.98625
new_branch_Z_probability_after_one_mean	0.01249

这说明在这个 toy 分布里：

800 个普通序列节点
可以压成 11 个前缀树节点。

新分支 Z 出现一次后，没有直接覆盖旧候选，而是以小概率进入候选容器：

P(Z) ≈ 0.01249

C 的准确 Claim

Claim C:
共享路径前缀可以显著压缩 toy 分布，
并且可以在前缀节点保留候选概率。

C 能支持：

TreeHeap 的路径不是普通 token 序列。
路径前缀可以成为存储、计算、概率容器的共享对象。

C 不能支持：

真实语言中的前缀压缩率也这么高。
delayed collapse 已经提升翻译质量。
概率容器已经学会语义消歧。

下一步 C 要提高难度：

更多分支
更高 entropy
更少重复
上下文反转候选概率
概率校准
delayed-collapse accuracy

总结：现在我们到底知道什么

现在最稳的结论是：

TreeHeap 的存在性还没有被完整证明。
但是三个 toy 实验给出了三个方向的信号。

这三个方向分别是：

A: 地址规则不应该完全靠模型从样本里猜。
B: 子结构 kernel 可以成为树堆空间的卷积工具。
C: 路径前缀可以成为压缩和概率容器。

更严谨地说：

TreeHeap 的 claim 不是“我也能学习”。
Transformer 也能学习。

TreeHeap 的 claim 是：
如果把地址、子结构、路径前缀、概率容器做成显式数学对象，
模型可能获得更好的结构归纳偏置。

但这还需要下一轮 proof：

A1/A2/A3: plus / mod / fold 拆分
B2: kernel composition 和结构变换
C2: 高熵概率容器和上下文坍缩

只有这些 proof 更稳以后，语言任务才应该站在这个数学工具箱上。

License: GPLv3

[SPR-018] TreeHeap 的存在性：编码结构与共轭 Kernel

Mon, 22 Jun 2026 00:00:00 +0000

TreeHeap 的存在性：编码结构与共轭 Kernel

这篇文章修正一个重要问题。

上一版 SPR-018 把重点放在了 subheap kernel relocation：

给定一个人工 pattern，
看 TreeHeap kernel 能不能在新地址找到它。

这个实验有用，但太弱。

它只能说明：

显式 subheap kernel 可以做局部模式检测。

它不能证明我们真正关心的东西：

TreeHeap 能不能自己把输入数据 encode 成一种可搜索、可压缩的结构？
查询 kernel / 解码 kernel 能不能沿着这个结构工作？
encoder 和 decoder 是否形成一对共轭过程？

所以现在的 claim 要重新写清楚。

现在真正的 Claim

TreeHeap 不是要证明自己是“完全不同”的东西。

它应该先证明自己和实数域、MLP、CNN、Transformer 一样，能用于构造预测函数：

输入 x
参数 theta
预测 y_hat = f_theta(x)
loss(y_hat, y)
gradient
update theta

然后再证明：

在需要结构编码、路径搜索、前缀压缩、延迟坍缩的问题上，
TreeHeap 的显式结构归纳偏置能带来更好的样本效率、外推稳定性或计算效率。

更具体地说，我们现在要证明的不是：

TreeHeap 会匹配一个 pattern。

而是：

TreeHeap encoder 能把数据组织成一种结构；
TreeHeap decoder/query kernel 能利用这个结构完成搜索或解码。

这就是：

learned encoder + conjugate kernel

中文可以叫：

学习到的编码器 + 共轭查询/解码核

为什么旧 B 实验不够

旧 B 实验是这样的：

pattern:
      1
     / \
    2   3

训练时 pattern 出现在：

positions = {0, 1, 2}

测试时 pattern 出现在：

positions = {6, 10, 13}

结果：

method	accuracy mean	min	max
TreeHeap kernel	1.0000	1.0000	1.0000
flatten MLP	0.4996	0.4258	0.5703
sequence CNN	1.0000	1.0000	1.0000
small Transformer	0.9846	0.6055	1.0000

这个表说明：

局部 kernel 迁移是有效归纳偏置；
MLP 展平后不擅长；
CNN 和 TreeHeap kernel 擅长；
Transformer 大多能学到，但有失败尾部。

但它不说明：

TreeHeap 能学习建堆。
TreeHeap 能学习编码。
TreeHeap 能执行查询路径。
TreeHeap 能压缩数据。

所以旧 B 只能作为 smoke test。

它证明的是：

kernel 这个方向值得继续。

而不是最终 proof。

新实验方向一：学习建堆 + 查询搜索

第一个真正应该做的实验是：

learned ordered TreeHeap search

也就是：

输入一组 key/value
encoder 把它们建成 TreeHeap
query kernel 根据查询 key 在树上走 stop / left / right
最后返回 value

注意关键点：

树不是人工提前建好的。
树应该由 encoder 学出来。

Toy 数据

给一批 key/value：

[(8, A), (4, B), (12, C), (2, D), (6, E), (10, F), (14, G)]

查询：

query = 6
answer = E

如果 TreeHeap encoder 学到了类似有序树的结构，它可能形成：

          8:A
         /   \
      4:B     12:C
     /  \     /   \
  2:D   6:E 10:F 14:G

这个结构不是我们强行塞给模型的目标，而是它为了让查询 kernel 更容易工作，应该自己学出来的中间结构。

查询 Kernel

查询 kernel 可以很简单：

query_kernel(node, query):
  if query == node.key:
    return stop
  if query < node.key:
    return left
  if query > node.key:
    return right

查找 query = 6 的过程：

step 1:
  node = 8:A
  6 < 8
  action = left

step 2:
  node = 4:B
  6 > 4
  action = right

step 3:
  node = 6:E
  6 == 6
  action = stop
  output = E

路径：

root -> left -> right -> stop

地址：

0 -> 1 -> 4

这就是一个查找算法。

但在 TreeHeap 视角下，它可以被看成：

subheap
-> query kernel
-> next address
-> subheap
-> query kernel
-> ...

也就是一个局部 kernel 的迭代。

这里的共轭关系

encoder 和 query kernel 必须配合。

如果 encoder 学出的结构是乱的：

          10:F
         /    \
      2:D      6:E

那么简单的 query < root -> left 就可能走错。

所以训练压力会迫使 encoder 学一种结构，使得 decoder/query kernel 能工作。

这就是共轭关系：

encoder 学会如何摆放节点；
query kernel 学会如何沿结构读取。

一个好的 proof 应该观察：

查询准确率是否上升；
路径长度是否接近 log n；
树结构是否接近有序树；
OOD key 数量变大时是否还能泛化。

Predict B-new

如果 TreeHeap 的结构归纳偏置成立，
TreeHeap encoder 会学习出一种可被局部 query kernel 搜索的结构。

相比 flatten MLP，
它应该更省样本、更容易外推到更多 key。

相比普通 Transformer，
它应该在路径长度、计算量、失败尾部上更稳定。

这才是搜索能力的 proof。

新实验方向二：加权前缀树 + Huffman-like 解码

第二个方向是你提到的加权树。

这里最接近的经典对象是 Huffman coding。

Huffman 编码做的事是：

高频符号用短路径；
低频符号用长路径；
整棵树是 prefix-free 的；
decoder 沿路径还原符号。

TreeHeap 里可以问一个类似问题：

encoder 能不能学习一棵加权前缀树？
decoder kernel 能不能沿路径把符号还原？

Toy 数据

假设符号频率是：

A: 0.50
B: 0.25
C: 0.15
D: 0.10

一个理想的 Huffman-like 编码可能是：

A -> 0
B -> 10
C -> 110
D -> 111

对应树：

root
├── 0: A
└── 1
    ├── 0: B
    └── 1
        ├── 0: C
        └── 1: D

平均路径长度：

E[length]
= 0.50 * 1
+ 0.25 * 2
+ 0.15 * 3
+ 0.10 * 3
= 1.75

如果不用加权前缀树，而给每个符号固定 2 bit：

A -> 00
B -> 01
C -> 10
D -> 11

平均长度：

E[length] = 2.00

这个 toy 里 Huffman-like 树更短。

Encoder / Decoder

TreeHeap encoder 的任务：

输入符号分布
输出一棵前缀 TreeHeap

TreeHeap decoder 的任务：

输入路径 bits
沿 TreeHeap 走 left/right
遇到 leaf 后输出符号

例如路径：

解码：

root -> right -> right -> left
output = C

这和前面的搜索任务一样，也是 kernel 迭代：

current node + next bit -> next node

但这里的目标不是搜索 key，而是还原压缩编码。

这里的共轭关系

encoder 和 decoder 也是共轭的：

encoder 决定符号放在哪条路径；
decoder 沿路径还原符号。

如果 encoder 把高频符号放得很深，平均路径长度就会变差。

如果 encoder 生成的树不是 prefix-free，decoder 会混淆。

所以训练目标可以是：

reconstruction loss
+ expected path length penalty
+ prefix-free constraint penalty

Predict C-new

如果 TreeHeap 的加权路径结构成立，
encoder 应该能学习一棵接近 Huffman oracle 的前缀树；
decoder kernel 应该能沿路径稳定还原符号；
平均路径长度应该低于固定长度编码 baseline。

这才是“路径前缀压缩”的 proof。

不是简单地数 toy trie 节点。

这两个实验和机器学习的关系

这两个实验不是手写算法炫技。

真正的目标是：

让 encoder 的结构由梯度学习出来。

也就是：

输入数据
-> TreeHeap encoder(theta)
-> 结构状态 H
-> query/decoder kernel(phi)
-> 输出
-> loss
-> gradient update theta, phi

这和 MLP / Transformer 一样，仍然是机器学习。

区别只是：

MLP 学的是展平向量上的函数；
Transformer 学的是 token 序列上的 attention 函数；
TreeHeap 学的是结构编码 + 路径 kernel。

所以 TreeHeap 的存在性不是“完全不同”。

而是：

同样做预测函数学习，
但结构归纳偏置不同。

旧 B 表应该怎么使用

旧 B 表还可以保留，但只能作为弱证据。

它说明：

显式 kernel 在局部结构迁移任务上是有用的；
这个方向不是空想。

但下一轮 proof 应该升级为：

B-new:
  learned encoder builds searchable ordered tree
  query kernel walks stop/left/right

C-new:
  learned encoder builds weighted prefix tree
  decoder kernel reconstructs symbols from paths

我们之后要聊的 predict 和 proof，就应该围绕这两个实验设计。

当前总 Claim

最终 claim 可以写成：

TreeHeap 是一种和 MLP / CNN / Transformer 同属机器学习家族的计算结构。

它的独特性不是“完全不同”，
而是把结构编码、路径搜索、前缀压缩、概率坍缩显式化。

如果 claim 成立，
TreeHeap encoder 应该能学习可搜索/可压缩的结构；
共轭 query/decoder kernel 应该能利用该结构完成搜索和解码；
并在相应结构任务上获得更好的样本效率、外推稳定性或计算效率。

下一步不是继续做 pattern matching。

下一步是 proof：

能不能 learn to build the tree?
能不能 learn to search/decode through the tree?
能不能比 MLP / Transformer 更省样本、更稳？

这才是 TreeHeap 的存在性问题。

License: GPLv3

[SPR-019] Soft TreeHeap：梯度如何进入树堆结构

Mon, 22 Jun 2026 00:00:00 +0000

Soft TreeHeap：梯度如何进入树堆结构

上一篇 SPR-018 把 TreeHeap 的目标说清楚了：

TreeHeap 不是要证明自己完全不同。
TreeHeap 要证明自己和 MLP / CNN / Transformer 一样，
也是一种可以构造预测函数的机器学习结构。

但这会立刻遇到一个核心问题：

梯度怎么进入 TreeHeap？

线性回归为什么能学习？

因为它有：

y_hat = W x + b
loss = MSE(y_hat, y)
gradient = d loss / d W
update W

训练结束后，数据里的规律被蒸馏进参数：

W, b

Transformer 也是类似的，只是参数从一个简单矩阵，变成很多矩阵：

Wq, Wk, Wv, Wo, FFN weights

loss 仍然通过梯度，把数据里的统计规律写进参数矩阵。

那么 TreeHeap 呢？

如果 TreeHeap 只是硬指针：

if query < node.key:
  go left
else:
  go right

或者硬写入：

arr[3] = value

那梯度很难传进去。

所以第一版 TreeHeap 不能直接从 hard tree 开始。

我们需要：

Soft TreeHeap

也就是：

硬树堆结构的连续松弛版本。

一句话 Claim

当前 claim 是：

如果把 TreeHeap 的写入、路由、停止、读取都改成可微的 soft distribution，
那么 TreeHeap 就可以像 MLP / Transformer 一样用 loss 和 gradient 学习。

梯度会被写入：
node_key
node_value
write kernel
query kernel
decoder kernel

这不是最终证明。

这只是进入机器学习的入口。

如果这个 claim 不成立，TreeHeap 后面不用谈 WMT，也不用谈世界模型。

从 Hard TreeHeap 到 Soft TreeHeap

这里有一个很容易误解的点：

Soft TreeHeap 不是推翻前面建立的 TreeHeap 数学基础。

更准确的说法是：

Hard TreeHeap 是离散代数对象。
Soft TreeHeap 是它的概率提升，也就是可微近似。

原来的 TreeHeap 有确定的地址、确定的子树、确定的路由。

例如一个 hard 操作可以写成：

O_a(H)

意思是：

在地址 a 上，对 TreeHeap H 做一次确定操作。

比如：

在地址 a 上执行 TreeHeap plus
读取 left(root)
沿着 root -> left -> right 走
在某个 subheap 上做 kernel matching

这些都是 hard TreeHeap 的操作。

Soft 以后，不是把这些操作删掉。

Soft 以后变成：

SoftO(H) = sum_a p(a) * O_a(H)

翻译成人话就是：

模型暂时不知道应该操作哪个地址，
所以它对多个地址都做一点操作，
每个地址的权重由概率 p(a) 决定。

如果概率分布是：

p(5) = 1.0
其他地址 = 0.0

那么：

SoftO(H) = O_5(H)

也就是说：

Soft TreeHeap 会退化回 Hard TreeHeap。

这非常重要。

因为它说明：

Soft TreeHeap 不是另一种东西。
它是 Hard TreeHeap 的连续版本。

可以把关系表写成这样：

Hard TreeHeap	Soft TreeHeap
一个确定地址	一个地址概率分布
`H_next = H ⊕_a x`	`sum_a p(a) * (H ⊕_a x)`
`left / right / stop`	`p_left / p_right / p_stop`
一个确定子树	子树概率分布
一个确定卷积核位置	多个 subheap 上的加权 kernel
hard collapse	低温 softmax / top-k / argmax collapse

所以 Soft TreeHeap 的本质不是：

把树堆变成普通向量。

而是：

让 TreeHeap 的地址、路径、子结构都能携带概率。

这样 loss 才能通过概率分布反传。

一个小例子

hard 查询是：

query = 6

root = 8
6 < 8
go left

soft 查询是：

query = 6
root = 8

stop: 0.05
left: 0.85
right: 0.10

这时模型还没有完全确定。

它主要相信：

应该 go left

但仍然保留一点：

stop / right 的可能性。

如果后面发现答案错了，loss 可以反向告诉它：

left 的概率应该再高一点；
right 的概率应该再低一点；
当前 node_key / query_kernel 应该如何调整。

这就是梯度进入 TreeHeap 的入口。

但这里有一个工程边界

完整的概率 TreeHeap 应该保存：

所有可能 TreeHeap 的概率分布。

这是最干净的数学版本。

但它太贵。

因为树一大，可能结构数量会爆炸。

工程上更可能采用的是近似版本：

每个 node 保存一个 value 分布；
每条 route 保存一个 action 分布；
每个 kernel 保存一个 soft attention 分布。

这可以叫：

mean-field Soft TreeHeap

它的好处是能训练。

它的风险是：

可能丢失不同路径之间的相关性。

所以后续实验不能只看任务准确率。

还要看：

Soft 近似是否破坏了 TreeHeap 原来的代数结构？

例如：

hard collapse 以后，是否还能得到合法树？
soft route 是否真的收敛到可解释路径？
subheap kernel 是否还能迁移？

这会成为后续 proof 的一部分。

为什么 hard TreeHeap 不适合第一版训练

假设我们有一个硬查询 kernel：

if query == node.key:
  return stop
if query < node.key:
  return left
if query > node.key:
  return right

这个逻辑很清楚，但对梯度不友好。

因为模型一旦选择：

left

它就完全不走：

right

如果最后错了，loss 很难告诉模型：

其实刚才 right 更好。

同样，硬写入也有问题：

arr[5] = value

如果写错位置，梯度很难平滑地告诉 encoder：

你应该往 arr[4] 写 0.2，往 arr[5] 写 0.8。

所以第一版必须用 soft 版本。

Soft Write 的弱版本：神经内存写入

先承认一个问题。

如果我们把可微写入写成：

write_logits = encoder(x, H)
write_prob = softmax(write_logits)

然后直接更新数组槽位：

arr_new[i] =
  (1 - write_prob[i]) * arr_old[i]
+ write_prob[i] * write_vector

这确实是可微的。

但它更像：

neural memory write

也就是神经网络记忆槽更新。

它的问题是：

梯度进入了 arr，
但没有真正进入 TreeHeap 的 plus 算子。

换句话说，它能证明：

一个数组内存可以被 softmax 写入。

但它不能证明：

TreeHeap 的加法、路径、子结构、卷积核可以被学习。

所以这个写法只能作为：

baseline
教学反例
最低可微版本

不能作为 TreeHeap 的正式写入机制。

正式机制应该是：

Soft Write = Soft Plus

更进一步：

Soft Write = Kernel-guided Soft Plus

Soft Plus：对 TreeHeap 加法的概率提升

先定义 hard plus。

假设：

H = 当前 TreeHeap
x = 新输入的 token / node / 小 TreeHeap
a = 一个地址或路径

hard 写入不是：

arr[a] = x

而是：

H_next = H ⊕_a x

其中：

⊕_a

表示：

在地址 a 上，把 x 按 TreeHeap 的规则并入 H。

这个规则可以包含：

路径比较
子树重排
局部 merge
权重更新
父子关系维护

这才是 TreeHeap 的加法味道。

Soft plus 不是直接改数组。

Soft plus 是：

H_next = sum_a p(a | H, x) * (H ⊕_a x)

翻译成人话：

模型不知道 x 应该插入哪个地址，
所以它先生成多个候选 TreeHeap：

candidate_a = H ⊕_a x

然后按概率把这些候选结构混合起来。

如果：

p(left.right) = 1.0
其他地址 = 0.0

那么：

H_next = H ⊕_{left.right} x

这就退化回 hard TreeHeap plus。

所以 Soft Plus 仍然继承原来的 TreeHeap 数学基础。

它不是：

矩阵内存插值。

它是：

TreeHeap plus 算子的 soft lifting。

Kernel-guided Soft Plus：用卷积核决定写入

还有一个更关键的问题：

p(a | H, x) 从哪里来？

如果只是让一个普通 encoder 直接输出所有地址概率：

p(a) = softmax(MLP(H, x))

那仍然有点像普通注意力。

更符合 TreeHeap 的方案是：

p(a) 由 TreeHeap convolution kernel 计算出来。

也就是：

score(a) = K_write(subheap(H, a), x)
p(a) = softmax(score(a))

其中：

K_write

是一个可微卷积核。

它观察：

当前位置的 subheap
新输入 x
局部路径
局部 key/value/weight
局部结构 pattern

然后判断：

x 是否应该写到这个位置；
x 是否应该继续往 left；
x 是否应该继续往 right；
x 是否应该在这里 stop 并 merge。

这样，写入就不再是 hardcode：

if x < node.key:
  go left

而是变成可微 kernel：

local_feature = phi(subheap(H, a), x)

score_stop  = w_stop  · local_feature
score_left  = w_left  · local_feature
score_right = w_right · local_feature

p_action = softmax([score_stop, score_left, score_right])

这个 K_write 就是 TreeHeap 上的卷积核。

它不是二维图像卷积核。

但它做的是同一类事情：

在局部结构上滑动；
提取局部 pattern；
给出下一步操作分数。

图像卷积看的是：

3x3 pixel patch

TreeHeap 卷积看的是：

root -> left/right 的小 subheap

例如：

        8
      /   \
     4     12

现在插入：

x.key = 6

卷积核在 root=8 看到：

6 更像应该去 left

于是输出：

stop:  0.05
left:  0.90
right: 0.05

到 node=4 时，它看到：

6 更像应该去 right

输出：

stop:  0.05
left:  0.05
right: 0.90

到空位或 node=6 时，它输出：

stop:  0.95
left:  0.025
right: 0.025

然后执行：

H_next = sum_a write_mass[a] * (H ⊕_a x)

这里的 write_mass[a] 不是外部指定的。

它来自 kernel 在树上的逐步传播：

mass[root] = 1

for step in search_steps:
  for each active address a:
    p_action = K_write(subheap(H, a), x)

    write_mass[a]       += mass[a] * p_stop
    mass_next[left(a)]  += mass[a] * p_left
    mass_next[right(a)] += mass[a] * p_right

最后：

H_next = sum_a write_mass[a] * Plus_a(H, x)

这才是 TreeHeap 版本的可微写入。

它的梯度链条是：

loss
↓
H_next
↓
sum_a write_mass[a] * Plus_a(H, x)
↓
write_mass[a]
↓
K_write(subheap(H, a), x)
↓
kernel parameters

所以梯度进入的不是普通内存槽。

梯度进入的是：

TreeHeap convolution kernel
TreeHeap plus candidates
TreeHeap route distribution
TreeHeap collapse path

这比 naive soft memory write 更接近我们的目标。

Soft Route：可微路径选择

硬路由是：

go left

Soft route 是：

action_logits = query_kernel(query, node)
action_prob = softmax(action_logits)

输出：

{
  stop:  0.10,
  left:  0.75,
  right: 0.15
}

这表示：

当前更可能应该走 left，
但 right 和 stop 仍然保留少量概率。

如果当前节点有流量：

mass[i] = 0.80

那么下一步传播：

stop_mass[i]        += 0.80 * 0.10
mass_next[left(i)]  += 0.80 * 0.75
mass_next[right(i)] += 0.80 * 0.15

也就是：

stop_mass[i]        += mass[i] * p_stop
mass_next[left(i)]  += mass[i] * p_left
mass_next[right(i)] += mass[i] * p_right

跑多步以后，输出可以是：

y_hat = sum_i stop_mass[i] * node_value[i]

或者分类任务里：

logits = sum_i stop_mass[i] * node_logits[i]

这仍然是可微的。

梯度能进入：

query kernel
node_key
node_value
路径概率

一个完整 Toy：查找 key/value

任务：

输入一组 key/value
查询一个 key
输出对应 value

样本：

pairs = [(8,A), (4,B), (12,C), (2,D), (6,E), (10,F), (14,G)]
query = 6
target = E

理想结构是：

          8:A
         /   \
      4:B     12:C
     /  \     /   \
  2:D   6:E 10:F 14:G

如果是硬查找：

6 < 8  -> left
6 > 4  -> right
6 == 6 -> stop
output = E

Soft TreeHeap 不会一开始这么硬。

第 1 步在 root：

node.key = 8
query = 6

query kernel 输出：

stop:  0.05
left:  0.85
right: 0.10

第 2 步进入左子树，节点是 4:B：

node.key = 4
query = 6

输出：

stop:  0.05
left:  0.10
right: 0.85

路径概率：

root -> left -> right
= 0.85 * 0.85
= 0.7225

第 3 步到 6:E：

node.key = 6
query = 6

输出：

stop:  0.80
left:  0.10
right: 0.10

最终命中路径概率：

root -> left -> right -> stop
= 0.85 * 0.85 * 0.80
= 0.5780

如果模型输出了 E，loss 下降。

如果模型输出错了，loss 反传，梯度会告诉系统：

哪些节点 key/value 需要调整
哪些路由概率需要调整
哪个写入位置更合理

这就是 TreeHeap 的梯度学习过程。

Loss 不应该一开始大锅炖

上面讲了：

loss 可以进入 Soft TreeHeap。

但这不等于说：

所有 loss 都应该一开始混在一起。

一个很自然的教学写法是：

L =
  L_task
+ alpha * L_order
+ beta  * L_depth
+ gamma * L_entropy

这个式子适合帮助读者理解：

任务正确性、结构合法性、路径长度、概率坍缩
都可以变成训练信号。

但它不一定是好的工程设计。

因为多个 loss 直接相加，会遇到几个问题：

梯度方向可能互相抵消；
某个 loss 的尺度太大，压住其他 loss；
结构 loss 太早生效，导致模型过早坍缩；
熵 loss 太强，导致模型一直不敢做决定；
多个目标一起训练，难以知道到底哪个 kernel 学坏了。

这和 Transformer 的经验类似。

Transformer 不是只用一个观察角度看序列。

它用了：

multi-head attention

不同 head 可以学习不同关系。

TreeHeap 也应该类似。

更合理的设计不是：

一个巨大 loss 控制所有东西。

而是：

多个 TreeHeap kernel / head 各自学习一种结构能力。

Multi-kernel TreeHeap

可以先把 Soft TreeHeap 拆成几个 head。

Head	学什么	主要梯度来源
plus/kernel head	输入应该通过哪个 subheap kernel 并入 TreeHeap	reconstruction / lookup / structure loss
route head	查询时走 stop/left/right	lookup task loss
order head	是否形成有序树	order violation loss
depth head	路径是否短	expected depth loss
prefix head	高频符号是否更短	compression loss
collapse head	什么时候从概率变成确定结构	entropy / temperature schedule

这样每个 head 都比较清楚。

例如查找任务里，route head 主要学：

query 和当前 node 的关系。

order head 主要学：

left_key < root_key < right_key

prefix head 主要学：

高频符号走短路径。

这些目标不一定应该同时强行压到一个参数空间里。

更好的方式是：

让不同 kernel 先学会自己的局部规律，
再由上层组合。

Loss 设计一：任务 Head

任务 head 只负责最终答案。

如果输出是分类：

L_task = cross_entropy(y_hat, target)

如果输出是连续值：

L_task = MSE(y_hat, target)

例如 key/value 查找任务：

target = E
y_hat = soft_query(H, query)
L_task = cross_entropy(y_hat, E)

这个 head 回答：

最后答案对不对？

它不直接负责：

树是否漂亮；
路径是否最短；
概率是否已经坍缩。

Loss 设计二：Order Head

如果任务是有序查找树，可以单独给 order head 一个结构目标。

例如：

left_key < root_key < right_key

用 hinge loss 写：

L_order =
  max(0, left_key - root_key + margin)
+ max(0, root_key - right_key + margin)

如果左子节点比 root 还大，就会罚。

如果右子节点比 root 还小，也会罚。

这个 head 的作用不是替代任务 loss。

它的作用是：

让 TreeHeap 的内部结构更像可搜索结构。

这类似 CNN 的卷积结构偏置。

但区别是：

CNN 的局部结构通常是人工固定的二维邻域；
TreeHeap 的局部结构是可学习的地址 / 子树 / 路由。

Loss 设计三：Depth Head

如果查找绕很远，虽然答案对了，也不一定好。

可以单独训练一个 depth head：

L_depth = expected_search_steps

例如：

root -> left -> right -> stop

路径长度是 3。

如果模型绕成：

root -> right -> left -> left -> right -> stop

路径更长，就会被罚。

这个 head 对应的是：

搜索效率。

它可以晚一点加入。

因为训练早期模型还不会查找，如果太早惩罚路径长度，可能导致模型学会：

为了路径短，直接 stop。

但答案是错的。

Loss 设计四：Collapse Head

训练早期，我们允许不确定：

left: 0.45
right: 0.40
stop: 0.15

训练后期，我们希望它逐渐清晰：

left: 0.95
right: 0.03
stop: 0.02

所以可以使用 entropy 或 temperature schedule。

但这里要非常小心。

如果把 entropy loss 一开始就和 task loss 强行混在一起，可能出现两种坏情况。

第一种：

过早坍缩。

模型还没学会结构，就已经把概率压成 one-hot。

后面错了也很难改。

第二种：

长期不坍缩。

模型为了保留不确定性，永远不形成清晰路径。

所以 collapse head 更像一个控制器：

early:  high temperature, allow exploration
middle: reduce temperature
late:   low temperature, encourage collapse

它不应该无脑和所有 loss 相加。

推荐训练方式：分阶段或交替训练

更合理的训练流程可以是：

Stage 1:
  只训练 task head / route head。
  目标：答案能不能对。

Stage 2:
  加入 order head。
  目标：内部结构是否变成可搜索树。

Stage 3:
  加入 depth head。
  目标：路径是否更短。

Stage 4:
  加入 collapse head。
  目标：soft distribution 是否能稳定坍缩成 hard TreeHeap。

也可以采用交替训练：

step 1: update route kernel
step 2: update write kernel
step 3: update order kernel
step 4: update collapse controller

必要时还可以使用：

stop-gradient
freeze kernel
auxiliary probe
gradient clipping
loss normalization

这样做的好处是：

每一种梯度信息都有自己的入口；
每个 kernel 学坏了都能被定位；
不会把所有目标搅在一起互相污染。

所以 SPR-019 的正式观点应该是：

TreeHeap 可以通过 loss / gradient 学习，
但不应该依赖一个大锅炖总 loss。

TreeHeap 更合理的训练形态是：
multi-kernel + staged training + controlled collapse。

Huffman-like 压缩任务的 Loss

如果任务是学习加权前缀树，loss 可以换成：

L =
  L_reconstruct
+ lambda * L_length
+ mu * L_prefix_free

其中：

L_reconstruct:
  decoder 是否能还原符号。

L_length:
  高频符号路径是否更短。

L_prefix_free:
  是否避免一个符号路径成为另一个符号路径的前缀。

例如符号频率：

A: 0.50
B: 0.25
C: 0.15
D: 0.10

理想 Huffman-like 编码：

A -> 0
B -> 10
C -> 110
D -> 111

平均路径长度：

0.50 * 1
+ 0.25 * 2
+ 0.15 * 3
+ 0.10 * 3
= 1.75

固定长度编码是：

2.00

所以 predict 是：

如果 TreeHeap 能学习加权前缀树，
它的 expected path length 应该接近 Huffman oracle，
并低于 fixed-length baseline。

Predict

当前 predict 分四层。

Predict 1：可学习性

Soft TreeHeap 的 loss 应该能下降。

最小任务：

线性回归
二分类
XOR / parity
key/value lookup

如果这些都学不会，TreeHeap 不具备机器学习基本能力。

Predict 2：可搜索编码

在 key/value lookup 任务中，
TreeHeap encoder 应该能学习一种可被 query kernel 搜索的结构。

指标：

query accuracy
expected search depth
OOD key count generalization
tree order violation rate
failure tail

Predict 3：可压缩编码

在 weighted prefix coding 任务中，
TreeHeap encoder 应该能学习接近 Huffman oracle 的路径分配。

指标：

reconstruction accuracy
expected path length
prefix-free violation rate
gap to Huffman oracle
gap to fixed-length baseline

Predict 4：Soft 版本不破坏 TreeHeap 代数

如果 Soft TreeHeap 真的是 Hard TreeHeap 的概率提升，
那么当温度降低、分布接近 one-hot 时，
soft 结果应该接近对应 hard 操作的结果。

也就是：

kernel-guided soft plus collapse 后，应该接近 hard plus；
soft route collapse 后，应该接近 hard route；
soft subheap kernel collapse 后，应该接近 hard subheap kernel；
soft learned tree collapse 后，应该仍然是合法 TreeHeap。

指标：

hard-soft output gap
collapse legality rate
route interpretability
subheap relocation accuracy
gradient stability

Proof 设计

为了证明 claim，需要最少四组实验。

Experiment 0：Soft TreeHeap 能不能学习

目的：

证明 TreeHeap 和 MLP 一样，可以通过 loss / gradient 学函数。

任务：

linear regression
binary classification
XOR
small lookup

对比：

MLP
Soft TreeHeap

判断：

loss 是否下降；
accuracy 是否上升；
参数梯度是否非零；
训练是否稳定。

Experiment 1：Learned Ordered Tree Search

目的：

证明 encoder 能学习建一棵可搜索树。

任务：

输入 N 个 key/value；
查询 key；
输出 value。

训练：

N = 7, 15

测试外推：

N = 31, 63

对比：

flatten MLP
small Transformer
Soft TreeHeap
oracle BST

指标：

accuracy
expected search depth
sample efficiency
OOD generalization
tree order violation

Experiment 2：Learned Huffman-like Prefix Tree

目的：

证明 encoder 能学习加权前缀压缩结构。

任务：

输入符号频率；
encoder 输出 TreeHeap code；
decoder 根据路径还原符号。

对比：

fixed-length code
Huffman oracle
MLP autoencoder
Soft TreeHeap prefix encoder

指标：

reconstruction accuracy
expected code length
prefix-free violation
gap to Huffman oracle

Experiment 3：Hard/Soft Consistency 与 Loss Ablation

目的：

证明 Soft TreeHeap 没有破坏 Hard TreeHeap 的核心算子；
同时验证 multi-kernel 训练是否比大锅炖总 loss 更稳定。

这个实验分三部分。

第一半验证 hard/soft 一致性。

构造一个确定的 hard TreeHeap：

        8
      /   \
     4     12
    / \    / \
   2   6  10 14

hard 查询：

query = 6
8 -> left
4 -> right
6 -> stop
output = E

soft 查询使用同一棵树，但每一步不是确定动作，而是概率：

at 8:
  stop  0.01
  left  0.98
  right 0.01

at 4:
  stop  0.01
  left  0.01
  right 0.98

at 6:
  stop  0.98
  left  0.01
  right 0.01

这时正确路径概率约为：

0.98 * 0.98 * 0.98 = 0.941192

如果 temperature 继续降低，概率会更接近：

1.0

那么 soft 输出应该收敛到 hard 输出：

output_soft -> E

判断指标：

hard-soft output gap 是否下降；
正确路径概率是否上升；
collapse 后路径是否合法；
collapse 后是否等于 hard route。

第二半验证写入机制。

同一个 key/value lookup 建树任务，比较三种写入方式：

A: naive soft memory write
B: encoder soft plus
C: kernel-guided soft plus

A 是弱版本：

arr_new[i] =
  (1 - p[i]) * arr_old[i]
+ p[i] * write_vector

它测试：

普通神经内存写入能做到什么程度。

B 是中间版本：

H_next = sum_a p(a | H, x) * (H ⊕_a x)

但 p(a) 由普通 encoder 给出。

它测试：

只要有 soft plus，是否就足够。

C 是 TreeHeap 正式版本：

score(a) = K_write(subheap(H, a), x)
p(a) = softmax(score(a))
H_next = sum_a p(a) * (H ⊕_a x)

它测试：

用 TreeHeap 卷积核来决定写入位置，
是否比普通 encoder 更稳定、更可解释、更能外推。

判断指标：

lookup accuracy
OOD N=31/63 accuracy
expected search depth
collapse legality rate
route interpretability
hard-soft output gap
subheap relocation accuracy

如果我们的判断正确，C 应该至少在这些地方更好：

更容易形成可解释路径；
更容易坍缩成合法 TreeHeap；
在更大 N 上失败尾部更少；
对 subheap relocation 更稳。

第三半验证 loss 设计。

同一个 lookup 任务，比较三种训练方式：

D: only task loss
E: 大锅炖总 loss
F: multi-kernel staged training

其中 E 是：

L =
  L_task
+ alpha * L_order
+ beta  * L_depth
+ gamma * L_entropy

F 是：

Stage 1: train route/task head
Stage 2: add order head
Stage 3: add depth head
Stage 4: add collapse head

如果我们的判断正确，F 应该更稳。

预期结果不是 F 在所有指标上都赢。

更具体的 predict 是：

F 的梯度爆炸/消失次数更少；
F 的 collapse 更晚、更可控；
F 的 order violation 下降更平滑；
F 在 OOD N=31/63 上失败尾部更少；
E 可能训练更快，但更容易过早坍缩或目标对冲。

Falsification：什么结果会否定我们

这也要写清楚。

如果出现这些结果，claim 就要降级：

Soft TreeHeap 的 loss 不下降。
Soft route 梯度长期为 0 或爆炸。
TreeHeap lookup 不如同规模 MLP。
TreeHeap 无法外推到更大 N。
prefix tree 长度不如 fixed-length baseline。
soft collapse 后得不到合法 hard TreeHeap。
kernel-guided soft plus 不如 naive memory write。
multi-kernel 比大锅炖总 loss 更不稳定。
encoder 没有学出任何可解释结构。

这些结果说明：

TreeHeap 可能只是复杂包装，
没有带来有效归纳偏置。

当前 Claim 的边界

到目前为止，我们还没有证明：

Soft TreeHeap 一定能训练成功。
TreeHeap 一定优于 Transformer。
TreeHeap 能做 WMT。
Huffman-like 结构一定能通过梯度学出来。

现在只是确定了下一步要证明什么。

真正的 claim 是：

TreeHeap 如果要作为机器学习结构存在，
必须能让梯度进入它的结构状态。

Soft write 不应该只是内存插值。

正式路径应该是：

kernel-guided soft plus、soft route、soft stop/read。

如果这条路径成立，
TreeHeap 就能像 MLP / Transformer 一样用 loss 学习；
并且可能在搜索、压缩、路径解码这类结构任务上表现更好。

这就是 SPR-019 要进入实验的地方。

License: GPLv3

[SPR-020] Soft TreeHeap 审计：proof 证明了什么，没证明什么

Tue, 23 Jun 2026 00:00:00 +0000

Soft TreeHeap 审计：proof 证明了什么，没证明什么

上一篇 SPR-019 讲了一个关键设计：

Hard TreeHeap 是离散树堆。
Soft TreeHeap 是它的概率提升。

也就是说，原来 hard 操作是：

$$ H_{\text{next}} = H \oplus_a x $$

意思是：

把 x 按 TreeHeap plus 的规则写到地址 a。

Soft 以后变成：

$$ H_{\text{next}} = \sum_a p(a \mid H, x) \cdot (H \oplus_a x) $$

翻译成人话：

模型暂时不知道 x 应该写到哪个地址。
所以它先对多个地址都生成候选结果，
再按照概率 p(a) 混合这些候选结果。

如果训练到最后：

$$ p(LL)=1.0,\quad p(\text{other})=0.0 $$

那么 Soft TreeHeap 就坍缩回 hard 操作：

$$ H_{\text{next}} = H \oplus_{LL} x $$

这个设计是为了让梯度进入 TreeHeap。

但 GLM/Runner 复现实验后指出了一个很重要的问题：

当前 proof 确实证明了梯度能流动，
也证明了当前 toy 能坍缩到正确地址。

但它还没有证明：
kernel 能从干净的 TreeHeap 子结构里自己学会路由。

这篇文章就是把这个边界讲清楚。

三件事不要混在一起

我们现在有三件很像、但其实不同的事。

第一件：

梯度能不能进入 TreeHeap？

这是 M0-SOFT-C03。

如果 loss 算完以后：

d loss / d K_write != 0
d loss / d Plus_a  != 0

说明梯度确实能更新写入 kernel 和 plus 参数。

第二件：

当前 toy 能不能坍缩到正确 hard 地址？

这是 M0-SOFT-C04。

如果低温 softmax 后：

argmax p(a) = gold_address

而且准确率是 1.0，说明当前 toy 在当前特征下能坍缩。

第三件：

kernel 能不能不靠人工提示，
从 TreeHeap 子结构里自己学会路由？

这是更强的 M0-SOFT-C05 / P-SOFT02。

这还没有证明。

这三件事的关系像这样：

梯度能流
  ↓
当前 toy 能坍缩
  ↓
干净 kernel 能自己学路由
  ↓
TreeHeap 写入机制比普通神经内存更好

我们现在只走完了前两步。

这些 Claim 编号到底是什么意思

M0-SOFT-C03 这种编号看起来像内部黑话，其实可以拆开看：

M0        = Math layer 0，也就是 TreeHeap 的数学地基
SOFT      = Soft TreeHeap，也就是可微概率版本
C03 / C04 = 第 3 / 第 4 条 claim

这里的 claim 不是口号，而是一个可以被实验检查的小命题。

M0-SOFT-C03：梯度可达

白话说：

loss 算出来以后，能不能真的改到 TreeHeap 的写入 kernel 和 plus 参数？

数学上就是看：

$$ \left\lVert\frac{\partial L}{\partial K_{\text{write}}}\right\rVert > 0 $$

以及：

$$ \left\lVert\frac{\partial L}{\partial \text{Plus}}\right\rVert > 0 $$

类比线性回归：

线性回归里，如果 dL/dW = 0，
W 就不会被训练数据改变。

TreeHeap 里，如果 dL/dK_write = 0，
写入 kernel 就不会被训练数据改变。

所以 C03 证明的是：

TreeHeap 的这些参数不是死的。
训练信号能碰到它们。

它还没有证明：

这些参数已经学会了好的结构。

M0-SOFT-C04：低温坍缩能回到 hard 地址

白话说：

Soft TreeHeap 训练时可以保留多个可能地址，
但最后能不能收敛成一个明确的 hard 地址？

例如一开始模型可能这样想：

LL: 0.25
LR: 0.25
RL: 0.25
RR: 0.25

训练后变成：

LL: 0.98
LR: 0.01
RL: 0.005
RR: 0.005

低温 softmax 或 argmax 后，就可以坍缩成：

LL

这就是 C04。

类比一下：

考试早期，学生在四个选项里摇摆。
训练后，学生几乎确定选 A。
最终交卷时，只能填一个答案。

C04 证明的是：

Soft 的概率状态可以变回 Hard 的离散结构。

这很重要。因为如果 Soft TreeHeap 永远只是一团概率雾，它就不能回到我们前面建立的 hard TreeHeap 数学地基。

M0-SOFT-C05：TreeHeap kernel 是否真的更好

C05 比 C03/C04 强很多。

它问的是：

用 TreeHeap 子结构 kernel 来决定写入位置，
是否比普通神经内存写入更好？

这才接近 TreeHeap 的存在性问题。

如果 C05 成立，说明 TreeHeap 不是只是“也能训练”，而是：

在需要地址、子结构迁移、路径复用、延迟坍缩的问题上，
TreeHeap 的结构 bias 可能真的有优势。

如果 C05 不成立，那也很重要：

说明当前 TreeHeap 写入设计可能只是复杂包装，
普通 MLP / neural memory 已经够用了。

当前 proof 做了什么

soft_plus_probe.py 用了一个很小的地址集合：

LL, LR, RL, RR

你可以把它想成一棵深度为 2 的小树：

        root
       /    \
      L      R
     / \    / \
   LL  LR  RL  RR

输入一些 key：

2, 3   -> LL
5, 6   -> LR
10, 11 -> RL
13, 14 -> RR

模型要学会：

给定 key，选择正确地址。

然后用 Soft Plus 生成：

$$ H_{\text{next}} = \sum_a p(a) \cdot \text{Plus}_a(H, key) $$

loss 会比较：

H_next

和目标 TreeHeap。

如果 loss 下降，并且梯度能传到：

K_write
Plus_a

就说明 Soft Plus 的训练链路是通的。

当前结果是：

pilot_pass = true
initial_loss = 0.677455
final_loss   = 0.000774
dL/dK_write  = 0.0902425
dL/dPlus     = 0.143869
collapse_accuracy_tau_0.05 = 1.0

这说明：

loss 明显下降；
梯度不是 0；
低温坍缩能选中正确地址。

所以 C03/C04 是成立的。

但要注意：

成立范围是这个 synthetic toy。

不是语言任务。

不是 WMT。

不是 Transformer 替代。

GLM 的审计发现

GLM/Runner 做了两类复现。

第一类是多 seed 复现：

Seed	pilot_pass	collapse_acc
42	true	1.0
7	true	1.0
123	true	1.0
999	true	1.0

这说明 proof 不是一次随机运气。

第二类是 ablation，也就是把某些设计拿掉，看结果会不会坏。

最重要的结果是：

特征集合	collapse_acc	说明
当前完整特征	1.000	proof 通过
去掉 alignment/sum 特征	0.625	明显退化
raw/basic 8D 特征	0.250	接近随机
随机投影 + side flags	0.250	接近随机

这里的 0.250 很好理解。

因为地址有 4 个：

LL, LR, RL, RR

随机猜一个，准确率就是：

1 / 4 = 0.25

所以 raw/basic 特征下的模型基本没学会路由。

问题出在哪里

当前 kernel features 里有两个很强的人工提示：

root_alignment = root_diff * root_side
child_alignment = diff * child_side

这两个公式确实容易看懵。我们拆开讲。

假设当前 toy 是一棵二叉搜索树。为了判断一个 key 应该往左还是往右，最原始的信息应该是：

key 是多少？
root key 是多少？
left child key 是多少？
right child key 是多少？

模型应该自己从这些数里学出：

key < root_key  -> 往左
key > root_key  -> 往右

但是当前 proof 里又额外给了两个方向提示。

先看第一个：

$$ \operatorname{root\_diff} = \operatorname{key} - \operatorname{root\_key} $$

如果：

key = 5
root_key = 8

那么：

root_diff = 5 - 8 = -3

它表示：

key 在 root 的左边。

再看：

root_side

这个变量不是从数值自然学出来的，它是人为给的“正确大方向”。可以粗略理解成：

目标地址在 root 左边时，root_side = -1
目标地址在 root 右边时，root_side = +1

于是：

$$ \operatorname{root\_alignment} = \operatorname{root\_diff} \cdot \operatorname{root\_side} $$

如果 key=5，root_key=8，目标确实在左边：

root_diff = -3
root_side = -1
root_alignment = (-3) * (-1) = 3

结果是正数。

正数就像在告诉模型：

这个方向和目标方向对齐。

如果方向错了，乘出来就会是负数。

所以 root_alignment 的问题在于：

它不是单纯告诉模型 key 和 root 的关系；
它把“这个关系是否符合正确路由方向”也编码进去了。

这就接近答案提示。

第二个公式：

$$ \operatorname{child\_alignment} = \operatorname{diff} \cdot \operatorname{child\_side} $$

作用类似，只是它看的是更下面一层 child 的方向。

可以这样理解：

root_alignment 帮模型判断第一步走 L 还是 R。
child_alignment 帮模型判断第二步走 LL/LR 或 RL/RR。

所以这两个 feature 不是普通“观测数据”，而是已经把搜索路径的判断边界整理好了。

它们已经把路由边界编码进去了。

可以粗略理解成：

如果 root_alignment 为正，说明 key 应该走 root_side 指示的方向。
如果 child_alignment 为正，说明 key 应该走 child_side 指示的方向。

这就像考试时给学生一张提示纸：

如果看到这个符号，就选左边。
如果看到那个符号，就选右边。

学生最后答对了。

这当然说明：

笔能写；
答案纸能收；
分数能反馈；
学生能根据提示填答案。

但还不能说明：

学生真的学会了这门课。

对应到 TreeHeap：

当前 proof 能说明：

梯度链路通了。
Soft Plus 可以坍缩。

但还不能说明：

TreeHeap kernel 从子树几何里学会了搜索规则。

为什么这不是否定 TreeHeap

这点要说清楚。

GLM 的审计不是在说：

TreeHeap 错了。

它是在说：

当前 evidence 的边界要写清楚。

M0-SOFT-C03 的 claim 是：

Kernel-guided Soft Plus can receive gradient through K_write and Plus_a.

这个 claim 只问：

梯度有没有到？

答案是：

到了。

M0-SOFT-C04 的 claim 是：

Kernel-guided Soft Plus can collapse to the correct hard plus address
in the synthetic toy.

这个 claim 只问：

当前 toy 有没有坍缩对？

答案也是：

对了。

但 M0-SOFT-C05 问的是：

Kernel-guided Soft Plus 是否比 naive memory write 或 generic encoder soft plus 更好？

这个还没有做。

所以 ARA 修订后的状态是：

Claim	状态	解释
C03 梯度可达	supported	当前 toy 有证据
C04 toy 坍缩	supported	当前 toy 有证据
C05 优于普通写入	open	需要下一步 ablation
clean kernel 学路由	open	当前 ablation 显示还没证明

ARA 做了哪些修订

这次我把 SameTime 里的 ARA 做了几件修订。

第一，给 claims.md 加了 scope notes。

现在 C03/C04 明确写了：

in scope:
  当前 toy 的梯度可达和坍缩。

out of scope:
  干净 kernel 从 raw subheap geometry 自己学会路由。

第二，加了 GLM audit summary：

ara/m0-treeheap-math/evidence/soft_plus_probe/glm_audit_summary.md

这里保存多 seed 复现和 feature ablation 结论。

第三，补了结构化 trace：

ara/m0-treeheap-math/trace/exploration_tree.yaml

这个文件记录：

问题是什么；
为什么拒绝 naive memory write；
当前 proof 证明了什么；
GLM ablation 发现了什么；
为什么下一步要做 clean-kernel proof。

第四，把 log/ara 里缺失的 S2 诊断证据同步进 SameTime：

ara/s2-translation/evidence/frame_probe_2h_queue/
ara/s2-translation/evidence/overnight_stopped_20260617/

这些不是正向成功证据。

它们是诊断证据：

说明历史 checkpoint 和 world-model/frame probe 还不能支撑强 claim。

这类失败或不充分证据也必须进入 ARA。

因为 ARA 的目的不是只保存胜利。

ARA 的目的是真实保存研究状态。

下一步真正该 proof 什么

下一步不是再证明一次：

梯度能流。

这个已经有了。

下一步应该证明：

clean kernel 能不能学会 TreeHeap 路由。

也就是新的 P-SOFT02。

这句话的实际含义是：

给模型一棵 TreeHeap 的局部子结构，
不给它人工整理好的答案方向，
让它通过训练自己学出：

什么时候往左；
什么时候往右；
什么时候 stop；
什么时候 merge；
哪个地址更像正确写入位置。

这和我们的总目标直接相关。

TreeHeap 最终想证明的不是：

我也能把数组槽位 softmax 写一遍。

而是：

树结构、路径、子堆、前缀、概率容器这些结构工具，
能让模型在某些任务上更有效地学习和外推。

如果 clean kernel 能学会路由，预期改进是：

1. 更少人工规则：不用手写 root_alignment 这种答案提示。
2. 更强迁移：同一个 kernel 可以在不同地址、不同子树上复用。
3. 更好外推：训练见过浅层地址，测试能处理更深地址。
4. 更可解释：失败时能看出是 stop/left/right 哪一步错了。
5. 更接近语言结构：后续 S2 的 fold/slot/graph 才可能接上这个结构 kernel。

如果 clean kernel 学不会，也会告诉我们一个硬事实：

当前 TreeHeap 的可微写入还缺少足够表达力；
也许需要 MLP kernel、多头 kernel、额外结构 loss，
或者 TreeHeap plus 本身还要改。

干净输入应该只给：

key
parent key
left child key
right child key
is_leaf
depth/address metadata

不允许给：

root_side
child_side
root_alignment
child_alignment

因为这些太像答案提示。

实验要比较三种写入方式：

A: naive soft memory write
B: encoder soft plus
C: kernel-guided soft plus

A 是普通神经内存写入：

arr_new[i] = (1 - p[i]) * arr_old[i] + p[i] * write_vector

B 是 soft plus，但地址概率由普通 encoder 输出：

MLP(H, x) -> p(a)
H_next = sum_a p(a) * Plus_a(H, x)

C 是 TreeHeap 版本：

K_write(subheap(H, a), x) -> score(a)
H_next = sum_a softmax(score(a)) * Plus_a(H, x)

判断指标包括：

collapse_accuracy
final_loss
hard_soft_gap
collapse_legality
unseen_address_accuracy
sample_efficiency

如果 C 在干净特征下赢 A 和 B，那么 C05 可以升级。

如果 A 或 B 一样好，说明 TreeHeap kernel 的优势还没有证明。

如果三者都失败，就要重新设计 kernel。

给本科水平读者的一句话总结

现在的状态可以这样理解：

我们证明了：
TreeHeap 这套结构可以接上梯度管道。

我们还没有证明：
TreeHeap kernel 能自己从树结构里学会聪明的搜索规则。

更口语一点：

水管通了。
水能流到 TreeHeap 的 kernel 和 plus 参数。

但水流到那里以后，
能不能灌出一棵真正会搜索、会压缩、会外推的树，
还要做下一组实验。

这不是坏消息。

这是研究进入下一层的信号。

因为现在的问题已经从：

TreeHeap 能不能训练？

变成了：

TreeHeap 的结构归纳偏置，能不能比普通神经内存更有效？

这才是 TreeHeap 是否有存在性的关键问题。

License: GPLv3

[SPR-021] C05：TreeHeap 不能只是披着树皮的 MLP

Tue, 23 Jun 2026 00:00:00 +0000

C05：TreeHeap 不能只是披着树皮的 MLP

上一篇 SPR-020 说清楚了一件事：

Soft Plus 的梯度管道已经通了。
但 clean kernel 是否能自己学会路由，还没有证明。

然后 Houming818 提了一个更深的问题：

如果公式里没有地址、路径、子结构，
那它看起来还是一个 MLP 或线性内存，
只是外面贴了 TreeHeap 这个名字。

这个批评是对的。

所以 C05 不能只问：

kernel-guided soft plus 能不能训练？

它必须先问：

这个 kernel 到底有没有用到 TreeHeap 的结构？

Flat MLP 的自然形式

线性回归是：

$$ \hat y = Wx + b $$

MLP 是：

$$ \hat y = f_\theta(x) $$

这类模型的核心是：

把输入 x 映射到一个任务空间；
再通过距离、logit、argmax 得到输出。

这没有问题。

但它是 flat 的。

它没有天然的：

地址；
路径；
前缀；
子堆；
递归更新。

如果 TreeHeap 公式只是：

$$ H_{t+1} = \sum_a p(a \mid H_t,x_t)\operatorname{Plus}_a(H_t,x_t) $$

那还不够。

因为这里的 $a$ 可能只是普通数组槽位：

a = 0, 1, 2, 3, ...

这会退化成：

softmax memory write

也就是一个 flat memory MLP。

TreeHeap 的地址必须是路径

TreeHeap 里的地址不应该只是数字。

它应该是路径：

$$ a \in \{L,R\}^{*} $$

例如：

epsilon = root
L       = root -> left
R       = root -> right
LLR     = root -> left -> left -> right

这个路径空间有一个 flat index 没有的性质：

前缀关系。

例如：

L 是 LL 和 LR 的共同前缀；
LL 和 LR 比 LL 和 RR 更接近；
LLR 的父路径是 LL。

这就是结构。

所以 TreeHeap 的 kernel 不能只看：

address_id

而应该看：

$$ K_\theta(\pi(a), \operatorname{subheap}(H,a), x) $$

其中：

pi(a)
路径表示

subheap(H,a)
以地址 a 为 root 的局部子堆

x
当前输入或查询

Plus 也必须是递归的

如果 Plus_a 只是：

arr[a] = x

那它仍然是数组写入。

TreeHeap 的 plus 应该沿路径递归。

如果目标地址是：

a = d :: a'

其中 $d$ 是第一步方向：

d in {L, R}

那么递归 plus 应该是：

$$ \operatorname{Plus}^{tree}_{d::a'}(H,x) = \operatorname{rebuild} ( root(H), \operatorname{Plus}^{tree}_{a'}(child_d(H),x), child_{\bar d}(H) ) $$

终止条件是：

$$ \operatorname{Plus}^{tree}_{\epsilon}(H,x) = \operatorname{merge}(H,x) $$

白话说：

如果目标在 left 子树，
就递归更新 left 子树；
right 子树保持不变；
最后把 root、left、right 重新组装。

这才是结构化内存。

C05 的新公式

所以 C05 的候选公式应该写成：

$$ H_{t+1} = \sum_{a \in A(H_t)} \operatorname{softmax}_a \left( K_\theta(\pi(a), \operatorname{subheap}(H_t,a), x_t) \right) \cdot \operatorname{Plus}^{tree}_{\phi,a}(H_t,x_t) $$

这个式子里必须有三件东西：

pi(a)                  路径
subheap(H_t,a)          子堆
Plus^{tree}_{a}         递归 plus

少了这些，C05 就不应该升级。

实验怎么 proof

我们设计一个很小的 toy。

生成一棵二叉树，在某个地址插入一个局部 pattern：

pattern = (root_value, left_value, right_value)

例如：

        0.90
       /    \
    -0.40   0.70

任务是：

给定整棵树和 pattern，
找出 pattern 在哪个地址。

训练时只把 pattern 放在浅层：

depth = 2, 3

测试时把 pattern 放到深层：

depth = 5, 6

如果模型只是记地址，它应该失败。

如果模型真的看子堆，它应该能迁移。

四个模型

我们比较四个版本。

C0：flat address

只看绝对地址编号。

这个位置是 0 号、1 号、2 号……

它没有路径，也没有子堆。

预期：

训练内可能记住；
未见深度会失败。

C1：path only

看路径：

L, R, LL, LR, ...

但不看节点内容。

预期：

如果目标 pattern 随机出现在不同地址，
path only 也无法知道哪个子堆匹配。

C2：subheap kernel

看局部子堆：

candidate_root
candidate_left
candidate_right

并和 query pattern 比较。

预期：

即使 pattern 移到深层，也能找到。

C3：path + subheap kernel

同时看：

路径
子堆

并能返回：

目标地址路径

这个版本最接近 TreeHeap C05。

判定标准

如果结果是：

C0 / C1 在深层失败；
C2 / C3 在深层成功；

说明：

subheap kernel 真的提供了迁移能力。

如果 C3 还能返回合法路径：

root -> left -> right -> ...

说明：

它不仅找到了目标，还能进入 recursive plus。

这才是 TreeHeap 的味道。

实验结果

实验已经执行：

src/structural_c05_probe.py

证据目录：

ara/m0-treeheap-math/evidence/structural_c05_probe/

结果表：

Variant	Train acc	Test acc	Hit@3	Mean rank
flat_address	0.439	0.000	0.000	16.09
path_only	0.439	0.000	0.000	35.44
subheap_kernel	1.000	1.000	1.000	1.00
path_subheap_kernel	1.000	1.000	1.000	1.00

这个结果很清楚。

flat_address 在训练集还有一点记忆能力：

train_acc = 0.439

但到未见深度以后：

test_acc = 0.000

说明它没有学到可迁移结构，只是在浅层地址上做记忆。

path_only 也失败：

test_acc = 0.000

这说明只知道路径形式还不够。因为目标 pattern 是随机放到某个深层子堆里的，只看：

LLR
RRLL
LRRL

无法知道哪个位置真的匹配 pattern。

真正成功的是：

subheap_kernel
path_subheap_kernel

它们在未见深度上都是：

test_acc = 1.000
mean_rank = 1.00

也就是说，同一个局部子堆 kernel 可以在更深地址复用。

这证明了什么

这次 proof 支持的是：

M0-SOFT-C07:
TreeHeap kernel 必须暴露 path / subheap / recursive route 结构，
否则会退化成 flat soft memory。

更具体地说：

subheap 是有效结构信号；
flat address 不是；
path alone 也不是。

这回应了前面那个批评：

如果公式里没有地址、路径、子结构，
它就不像 TreeHeap。

现在实验告诉我们：

至少在这个 toy 上，
子堆结构不是装饰；
它直接决定了未见深度迁移是否成立。

这没有证明什么

这个实验仍然很窄。

它没有证明：

TreeHeap 会语言；
TreeHeap 会 WMT；
TreeHeap 已经优于 Transformer；
C05 的完整写入机制已经胜出。

为什么还不能升级完整 C05？

因为完整 C05 问的是：

kernel-guided Soft Plus
是否优于 naive soft memory write
和 generic encoder soft plus？

而本实验只证明：

结构特征是必要的；
subheap kernel 能做未见深度 relocation。

所以结论是：

M0-SOFT-C07 -> supported pilot
M0-SOFT-C05 -> 仍然 open

下一步才是完整写入机制对比：

A: naive soft memory write
B: encoder soft plus
C: path + subheap kernel-guided soft plus

License: GPLv3

[SPR-022] TreeHeap 的数学底座：有根树 Hopf 代数、Operad 与 Kernel

Tue, 23 Jun 2026 00:00:00 +0000

TreeHeap 的数学底座：有根树 Hopf 代数、Operad 与 Kernel

这篇不是新的实验报告。

它要解决一个更基础的问题：

TreeHeap 的数学设计，是不是我们凭空造出来的？
还是已经有成熟数学领域能承接它？

现在我的判断是：

TreeHeap 不是凭空出现的。
它很接近两个已有数学框架在工程上的合流：

1. 有根树上的 Hopf 代数
2. Operad，也就是多输入、单输出的组合算子理论

这件事很重要。

因为从 SPR-011 到 SPR-021，我们一直在手工搭建：

compose
decompose
plus
inverse / transpose
subheap
kernel
probability container
soft collapse

现在看，这些不是孤立发明。它们可以放回已有数学框架中解释。

先给一句人话版结论

如果用本科能理解的语言说：

TreeHeap 是一种把“树形结构”当成计算对象的模型。

它不是只存一个向量。
它还存：
  地址
  路径
  父子关系
  子树
  如何合成
  如何分解

在数学上，这类对象早就被研究过。

有根树 Hopf 代数研究的是：

树怎么组合？
树怎么切开？
切开以后剩下什么？
这些操作能不能形成一个封闭的代数系统？

Operad 研究的是：

多个输入如何组合成一个输出？
组合过程如何再组合？
不同组合顺序是否一致？

TreeHeap 正好站在这两个问题的交叉处。

为什么是有根树 Hopf 代数

TreeHeap 的核心对象是有根树：

        root
       /    \
   left    right

在工程里，我们把它实现成堆数组：

A[0] = root
A[1] = left(root)
A[2] = right(root)
A[3] = left(A[1])
...

但是数学上，它仍然是有根树。

有根树上的 Hopf 代数，典型来源包括 Butcher 的数值分析树、Connes-Kreimer 的重整化树，以及后续 Munthe-Kaas-Wright Hopf algebra。

可以参考：

A Survey on the Munthe-Kaas-Wright Hopf Algebra, arXiv:2306.04381

这类数学关心的不是自然语言，而是：

树结构本身能不能做代数计算？

这和我们前面问的问题很像。

TreeHeap 与 BCK/MKW 代数的对应

先看一个对应表。

TreeHeap 里的说法	有根树 Hopf 代数里的说法	直觉解释
TreeHeap 对象	rooted tree	一个带根的树对象
compose / plus	product / grafting	把树接到另一棵树上
decompose	coproduct / admissible cuts	按合法方式把树切开
inverse-like / inverse_transpose	antipode	类似“反向还原”的递归操作
subheap	rooted subtree / pattern	从树里取局部结构
非交换性	non-commutative structure	左右顺序、接入位置会改变结果
primitive	primitive element	不能再从乘积里拆出的基础生成元

所以，当我们在 SPR-013 里实验：

noncomm_margin = 0.7117

它不是一个很孤立的发现。

它对应的是：

树的嫁接、组合、路径顺序，本来就可以是非交换的。

也就是说：

H1 plus H2

和：

H2 plus H1

可以不是同一个东西。

这和整数加法不同。但它和矩阵乘法、函数复合、树嫁接更接近。

compose 与 decompose

TreeHeap 里最核心的一对操作是：

compose:    children -> parent
decompose:  parent -> possible children

用公式写：

$$ \operatorname{compose}(H_1, H_2, \ldots, H_n) = H $$

意思是：

多个子堆合成一个父堆。

反过来：

$$ \operatorname{decompose}(H) = \sum_c P_c(H) \otimes R_c(H) $$

这里的 $c$ 可以理解成一次合法切割。

翻译成人话：

一棵树不一定只有一种拆法。
每一种合法切法，都得到一部分被切下来的树，以及剩下的树。

这就是 Hopf 代数里 coproduct 的味道。

注意，这里有一个很重要的点：

decompose 不是 compose 的唯一反函数。

也就是说：

父结构 -> 子结构

通常不是唯一答案。

这正好对应我们一直说的：

Probability Container

信息不足时，不要过早坍缩成一个答案。应该保留多个候选分解。

为什么还需要 Operad

Hopf 代数解释了：

树怎么合成、怎么切开、怎么反向递归。

但 TreeHeap 还有另一个核心：

多个输入合成一个输出。

例如：

cat + run       -> [cat run]
ball + foot     -> football
root + left + right -> subheap

这类结构正是 operad 擅长表达的。

Operad 的基本思想是：

一个算子可以吃多个输入，吐出一个输出。
这些算子本身还可以继续组合。

可以参考：

Operads for compositional reasoning in LLMs, arXiv:2606.13634

这篇论文把 operad 用到 LLM 的多步问题分解上。它把复杂问题拆成子问题，再把子答案组合回来。

它的核心观点可以和 TreeHeap 对齐：

问题分解树上的局部回答，必须和整体回答保持一致。

这和我们的 TreeHeap consistency 很像：

soft TreeHeap 经过局部坍缩之后，
应该能回到合法的 hard TreeHeap。

TreeHeap Operad 怎么定义

我们可以暂时这样定义一个 TreeHeap operad：

T = TreeHeap operations

其中每个 operation 是：

多棵子树 -> 一棵父树

数学上：

$$ \omega : (H_1, H_2, \ldots, H_n) \to H $$

其中 $\omega$ 可以是：

plus
compose
fold
merge
slot fill
kernel-guided write

如果一个模型能解释这些操作，我们就可以说它是：

an algebra over the TreeHeap operad

翻译成人话：

这个模型知道 TreeHeap 的算子该怎么作用到具体数据上。

这给了我们一个更正式的说法：

可学习的 TreeHeap 模型
不是“一个 MLP 外面套树壳”。

它应该是 TreeHeap operad 上的一个 algebra。

Kernel 在这里是什么

上一轮我们把 kernel 定义成：

TreeHeap 上可重复滑动使用的局部推理算子。

现在可以把它放到 operad 语境里：

kernel 是 TreeHeap operad 上的局部 algebra action。

不用被这个说法吓到。

它的意思很简单：

kernel 不是凭空看一个向量。
它是在 TreeHeap 的局部子结构上执行一个算子。

例如一跳 kernel 看：

S_i = root(i) -> [left(i), right(i)]

也就是：

$$ S_i = \big(A_i, A_{L(i)}, A_{R(i)}\big) $$

然后：

$$ K_\theta(q, S_i, W) \to y_i $$

其中：

符号	含义
$q$	query，当前要查找或写入的目标
$S_i$	第 $i$ 个局部子堆
$W$	world model，也就是背景参考系
$\theta$	kernel 的可学习参数
$y_i$	匹配、路由、写入或合并输出

输出不一定是硬答案。更合理的是概率容器：

{stop: 0.1, left: 0.8, right: 0.1}
{match: 0.7, no_match: 0.3}
{write_here: 0.6, write_elsewhere: 0.4}

这就是 TreeHeap 和 Probability Container 的接口。

TreeHeap 操作本质上是卷积 kernel 的组合

这里需要补一层更重要的理解。

前面说：

kernel 是 TreeHeap 上可重复滑动使用的局部推理算子。

但这句话还不够强。

更准确地说：

TreeHeap 的多数操作，都应该被理解成卷积 kernel 的组合。

也就是说，TreeHeap 不是先有一个普通数组，然后偶尔拿 kernel 扫一下。

它更像是：

一个高维结构空间
        +
一组可组合的局部卷积算子

为什么说 TreeHeap 至少是 3D 结构

普通一维序列只有：

index -> value

二维矩阵有：

(row, col) -> value

TreeHeap 至少同时有三类坐标：

1. value:    节点里存的向量或符号
2. address:  节点的路径，比如 LLR、RLL
3. topology: 父子关系、子堆、祖先、兄弟节点

所以一个 TreeHeap 节点不只是：

A[i]

而更像：

$$ H_i = \big(v_i, a_i, \tau_i\big) $$

其中：

符号	含义
$v_i$	value，节点向量
$a_i$	address/path，节点地址
$\tau_i$	topology，局部拓扑关系

这就是我现在说的：

TreeHeap 至少是 3D 的结构对象。

它不是简单的：

一维数组 + 一点树形解释

而是：

值空间 × 地址空间 × 拓扑空间

卷积 kernel 定义可能的局部操作

在 CNN 里，不同卷积核可以检测不同模式：

横线
竖线
边缘
角点
纹理

在 TreeHeap 里，不同 kernel 也可以定义不同局部操作：

查找 kernel:     这个子堆像不像 query？
路由 kernel:     下一步 stop / left / right？
写入 kernel:     信息应该写到哪个地址？
合并 kernel:     子堆能不能 fold 成父堆？
分解 kernel:     父堆有哪些可能切法？
对齐 kernel:     两个子堆是不是同构或近似同构？
翻转 kernel:     当前结构能不能镜像成另一侧结构？

因此，TreeHeap 的 plus、compose、decompose、fold、match_subheap 不应该被看成互不相关的函数。

更统一的看法是：

它们都是不同 kernel 或 kernel composition 的结果。

写成抽象形式：

$$ \operatorname{Op}(H) = K_m \circ K_{m-1} \circ \cdots \circ K_1(H) $$

其中每个 $K_j$ 都是一个局部 TreeHeap kernel。

共轭 kernel 与镜像翻转

Houming818 提到的“共轭操作”很重要。

如果 TreeHeap 的地址空间里有左右路径：

L, R

那么镜像变换可以定义成：

L <-> R

例如：

LLR -> RRL

把这个路径镜像记为：

$$ \sigma(a) $$

对整棵 TreeHeap 的镜像可以写成：

$$ \sigma(H)_i = H_{\sigma(i)} $$

更直观地说：

原树：
        root
       /    \
      A      B

镜像：
        root
       /    \
      B      A

那么一个 kernel $K$ 的共轭 kernel 可以定义为：

$$ K^\sigma = \sigma^{-1} \circ K \circ \sigma $$

这句话翻译成人话：

先把 TreeHeap 镜像过去；
在镜像空间里执行同一个 kernel；
再镜像回来。

如果这个等式成立，说明：

TreeHeap kernel 可以在左右翻转后的结构上复用。

这和 CNN 里对称、旋转、平移相关的卷积思想很接近。

只不过 CNN 通常处理二维图像变换； TreeHeap 处理的是：

路径变换
子堆变换
拓扑变换

这对 TreeHeap 的意义

这件事给了我们一个更清楚的 claim：

TreeHeap 的优势不只是“它是树”。
TreeHeap 的优势应该来自：

1. 高维结构坐标：value × address × topology
2. kernel 在这些坐标上的局部卷积
3. kernel composition 形成复杂推理
4. 共轭 kernel 允许镜像、翻转、对偶结构复用

如果这个方向成立，TreeHeap 的实验就不应该只测：

能不能分类？

而应该测：

同一个 kernel 能不能在不同路径上复用？
同一个 kernel 能不能在镜像结构上复用？
kernel composition 能不能形成多跳推理？
共轭 kernel 是否能减少训练样本？

这会成为后续 C05/C06 实验的重要设计点。

query 从哪里来

前面公式里有 $q$，它不能凭空出现。

在 TreeHeap 管线里，$q$ 可以来自三类地方：

input token -> encoder -> q
当前上下文 -> context encoder -> q
上一层 kernel 输出 -> next query

更完整地写：

token / phrase / task
        ↓
encoder
        ↓
q

context window / memory / world model
        ↓
context encoder
        ↓
W

q + W + local subheap
        ↓
TreeHeap kernel
        ↓
route / write / merge / collapse

所以 $q$ 不是一个固定词向量。它是当前推理任务发出的“查询意图”。

例如：

q = 找 ball + foot 的组合

kernel 扫到：

S_i = ball -> [foot, hand]

如果世界模型知道：

ball + foot -> football
ball + hand -> basketball

那么 kernel 应该能给出：

football 方向的高匹配

kernel 的滑动与感受野

CNN 的卷积核会在图像上滑动。 TreeHeap kernel 也可以在树上滑动。

这里的滑动不是二维平移，而是：

对所有内部节点 i，取它的局部子堆 S_i，然后执行 K(q, S_i, W)。

可以写成：

$$ \operatorname{ScoreMap}(H, q) = \{K_\theta(q, S_i, W) \mid i \in \operatorname{Internal}(H)\} $$

遍历顺序可以是 BFS、DFS，也可以并行。数学上重点不是遍历顺序，而是：

同一个 kernel 在不同地址复用。

这就是 TreeHeap 的结构归纳偏置。

一跳、二跳、k 跳

如果一跳 kernel 看：

root + left + right

它的感受野是 3 个节点。

二跳 kernel 看：

root
├── left subtree
└── right subtree

如果每个子树也看一跳，总共是：

1 + 2 + 4 = 7 个节点

一般地，二叉树深度 $k$ 的局部感受野大小是：

$$ 2^{k+1} - 1 $$

这解释了为什么 SPR-021 的实验只是一个起点。它只测试了一跳子堆：

root -> left, right

还没有测试多层 kernel 堆叠。

kernel 的组合就是 operadic composition

CNN 可以多层堆叠：

conv1 -> conv2 -> conv3

TreeHeap kernel 也可以堆叠：

K1 看局部 3 节点
K2 看 K1 的输出和父层子堆
K3 再看更高层

写成公式：

$$ K_2 \circ K_1(q, S_i) = K_2\big(K_1(q, S_i), S_{\operatorname{parent}(i)}\big) $$

这就是 operad 语言里的组合：

一个局部操作的输出，
可以成为另一个局部操作的输入。

所以 TreeHeap kernel 不是一个孤立分类器。它应该是一组可组合的局部算子。

为什么线性 kernel 不够

GLM 的多 pattern 消融指出了一个关键问题：

线性 kernel 不会真正比较 query 和 patch。

如果 kernel 是：

$$ K(q, S) = w^\top [q, S] + b $$

它只能分别给 $q$ 和 $S$ 加权求和。

它天然不会形成：

$$ q - S $$

更不会自然形成：

$$ \lVert q - S\rVert^2 $$

除非我们手工把这些差分特征喂进去。

所以，如果任务要求：

判断这个子堆是不是和 query 匹配

那么纯线性 kernel 通常不够。

更合理的是：

$$ K_\theta(q, S, W) = \operatorname{MLP}_\theta([q, \phi(S), W]) $$

或者显式给出交互项：

$$ K(q, S) = -\lVert q - \phi(S)\rVert^2 $$

这里 $\phi(S)$ 是子堆编码。

这不是实现小细节。这是数学约束：

结构比较需要交互项。
没有交互项，kernel 很容易退化成地址分类器。

Attention 对比

Transformer attention 也可以看成一种 kernel：

$$ \operatorname{score}(i,j) = Q_i K_j^\top $$

它的特点是：

flat
all-to-all
通过点积比较 token

TreeHeap kernel 的特点是：

structural
local subheap
path-aware
可递归堆叠
可以输出概率容器

对比一下：

项目	Transformer Attention	TreeHeap Kernel
基本对象	token 序列	有根树 / 堆
比较单位	token-token	query-subheap
连接方式	全连接	局部结构滑动
地址	位置编码	路径 / 子堆地址
归纳偏置	序列与全局相关性	子结构迁移与递归组合
输出	attention weights	route/write/merge/collapse 容器

所以 TreeHeap 不是要说：

attention 错了。

更准确的说法是：

TreeHeap kernel 想给 attention 缺少的树形地址、子结构复用、延迟坍缩提供结构约束。

与传统 Tree Kernel 的关系

NLP 里早就有 tree kernel。

经典方向包括 Collins-Duffy tree kernel、Moschitti 的 syntactic tree kernel。它们常用于 SVM 或句法树分类。

它们大致做的是：

两棵句法树之间有多少公共子树？
公共子树越多，相似度越高。

TreeHeap kernel 和它们有亲缘关系，但不是同一个东西。

项目	传统 tree kernel	TreeHeap kernel
主要用途	树相似度 / 分类	路由、写入、合并、坍缩
是否可学习	多数是固定相似度	可以固定，也可以可学习
数据结构	句法树	可寻址 TreeHeap
输出	similarity score	probability container / action
是否改写结构	通常不写入	可以指导 soft plus 写入

所以我们不是第一个想到“树上 kernel”的项目。真正的新问题是：

能不能把 tree kernel 从固定相似度函数，
推进成可微、可写入、可组合的 TreeHeap 局部推理算子？

Morphosyntax 与语言结构

TreeHeap 最终要回到语言任务。这里也已经有相关数学方向。

例如：

The Algebraic Structure of Morphosyntax, arXiv:2507.00244

这类工作把词法、句法的树结构放到 operad / algebra 的框架里讨论。

对我们来说，它至少说明一件事：

用 operad 描述语言结构组合，不是离谱方向。

但是我们必须谨慎：

这不等于 TreeHeap 已经能做 WMT。

它只是说明：

语言结构上层可以站在代数结构底座上。

中间还缺：

真实语料 encoder
真实句法 micro benchmark
S1b baseline battle
S2 graph assembly
S3 generation

Decomposition Space 与概率容器

还有一个相关方向是 decomposition space：

Decomposition spaces in Combinatorics, arXiv:1612.09225

它关心的是：

组合与分解如何形成一致的数学结构。

这对 TreeHeap 的启发是：

如果 decompose 有多个合法结果，
那么模型不应该立刻 argmax。

它应该保留：

Parent candidates
Route candidates
Graph candidates
Decomposition candidates

也就是：

Probability Container

这能把 TreeHeap 的设计从：

每一步强行选一个答案

推进到：

信息不足时保留多个合法分解，
等更强上下文再坍缩。

这和我们最早的 L0/L1/L2 叠加态想法是一致的。

这篇文章修正了什么

它修正了一个重要叙述：

TreeHeap 不应该被说成“我们发明了一套全新的数学”。

更专业、更可靠的说法是：

TreeHeap 是把 rooted-tree Hopf algebra、operad、tree kernel、
probabilistic soft lifting 这些思想，工程化到可学习结构内存中的尝试。

这让项目更稳。

因为我们不需要自己证明所有基础性质。很多东西已有成熟数学支持：

树可以组合。
树可以切割。
多输入单输出算子可以组合。
局部树模式可以匹配。
结构分解可以不是唯一的。

我们真正要证明的是工程问题：

这些数学对象能不能变成有效的机器学习结构？
能不能比 flat MLP / 普通 Transformer 在某些任务上更省样本、更稳外推、更低计算？

当前 Claim 应该怎么更新

我建议把核心 claim 重新表述成：

Claim:
TreeHeap 的数学底座可以由 rooted-tree Hopf algebra 与 operad 承接。
因此 compose/decompose/plus/subheap/kernel 不需要作为孤立发明来理解。
真正需要实验验证的是：
可学习 kernel 是否能利用这个结构底座，获得 flat 模型没有的归纳偏置。

对应 predict：

Predict:
在需要地址、子结构迁移、前缀复用、延迟坍缩的问题上，
TreeHeap kernel 应该比 flat MLP 更少样本、更稳 OOD 外推。

对应 falsification：

如果足够宽的 flat MLP / 普通 Transformer，
在相同参数量、相同训练数据下，
稳定匹配 TreeHeap kernel 的 OOD 地址外推、子结构迁移和延迟坍缩能力，
那么 TreeHeap kernel 没有显示出额外归纳偏置。

这很重要。

TreeHeap 不能靠“看起来更优美”成立。它必须靠：

更明确的数学对象
更清楚的可证伪预测
更干净的对照实验

成立。

下一步怎么接实验

这篇文章之后，我不建议继续只做纯文字推理。

下一步应该接两个实验。

实验 1：非线性 kernel 是否能学会 query-subheap 比较

目标：

不用手工 diff 特征。
只给 raw query 和 raw subheap。
看 MLP kernel 能不能学会比较。

对照：

linear_raw
mlp_raw
linear_with_diff
treeheap_kernel

如果结果是：

linear_raw 失败
mlp_raw 成功

说明：

kernel 的非线性交互是必要的。

实验 2：真实小句法树 micro benchmark

目标：

不要直接跳 WMT BLEU。
先拿 100 到 1000 句真实句法树，
测试 TreeHeap kernel 能否迁移局部依存结构。

例如：

head -> subject/object/modifier

不是先证明翻译质量，而是先证明：

TreeHeap kernel 在真实语言树上确实能读到结构信号。

这才是从 M0 到 S1/S2 的桥。

最终结论

这篇的结论很简单：

TreeHeap 的数学底座并不孤单。
它可以站在 rooted-tree Hopf algebra、operad、decomposition space 和 tree kernel 的已有传统上。

但这不是胜利宣言。

它只是把问题从：

我们是不是在乱造数学？

推进到：

我们能不能把这些成熟数学对象，训练成有效机器学习系统？

这一步反而更严格。

因为以后我们不能只说：

TreeHeap 很像树，很像代数。

我们必须证明：

TreeHeap kernel 在具体任务上，利用了树的地址、路径、子结构、组合和分解。
并且这种利用带来了可测量的收益。

这就是下一阶段实验的方向。

[SPR-023] 从卷积核重新定义 TreeHeap 操作

Wed, 24 Jun 2026 00:00:00 +0000

从卷积核重新定义 TreeHeap 操作

上一篇 SPR-022 把 TreeHeap 放回了已有数学背景：

rooted-tree Hopf algebra
operad
decomposition space
tree kernel

但 Houming818 指出了一个更核心的问题：

TreeHeap 的操作不应该先被理解成一堆手写函数。
TreeHeap 的核心操作应该是 kernel 在树上的卷积。

这句话把方向拉正了。

以前容易说成：

TreeHeap 有 plus、compose、decompose、conjugate。
另外，我们再给它加一个 kernel。

现在应该反过来：

TreeHeap 的 plus、search、compose、decompose、fold、conjugate，
都应该从 kernel 如何卷积整棵树并更新内存态来定义。

也就是说：

TreeHeap 不是“树结构 + 一堆函数”。
TreeHeap 是“树形高维状态场 + 一组卷积核”。

先看 CNN 的类比

在 CNN 里，一张图像是一个状态场：

image[row, col, channel]

卷积核扫过图像：

3x3 patch
↓
kernel
↓
feature score

整张图扫完以后得到：

feature map

例如一个边缘检测 kernel，不是在一个像素上做判断，而是在整张图上滑动，生成一张“哪里像边缘”的图。

TreeHeap 应该类似。

TreeHeap 的状态场不是二维图像，而是：

value × address × topology

也就是：

节点值
路径地址
父子拓扑

所以 TreeHeap kernel 不是看一个孤立节点。它看一个局部子堆：

      root
     /    \
  left    right

然后在整棵树上滑动。

TreeHeap kernel convolution 的定义

设当前 TreeHeap 内存态是：

$$ H_t $$

以路径 $a$ 为中心的局部子堆是：

$$ S_a(H_t) $$

一个 kernel 是：

$$ K_\theta(q, S_a, W) $$

其中：

符号	含义
$q$	query，要找或要写的目标
$S_a$	地址 $a$ 处的局部子堆
$W$	world model / 背景场
$\theta$	kernel 参数，可以固定，也可以学习

卷积整棵树就是：

$$ \operatorname{Conv}_K(H_t, q) = \{K_\theta(q, S_a(H_t), W)\}_{a \in A(H_t)} $$

翻译成人话：

对树上每个候选地址 a：
  取局部子堆 S_a
  用同一个 kernel 计算响应
最终得到一张覆盖整棵树的响应图

这张响应图可以叫：

score map
update map
route map
probability field

不同名字对应不同用途，但本质都是：

kernel 扫树以后得到的全局状态场。

plus 不再是“写到某个地址”

以前我们容易把 plus 理解成：

H plus x = 把 x 写到地址 a

但这太像普通数组写入了。

新的定义应该是：

plus kernel 扫描整棵 TreeHeap。
每个地址都产生一个 write score。
这些 score 形成一个写入概率场。
然后 H 根据这个概率场更新。

数学上：

$$ s_a = K_{\text{plus}}(x, S_a(H_t), W) $$$$ p_a = \operatorname{softmax}(s_a) $$$$ H_{t+1} = H_t + \sum_a p_a \cdot \Delta_a(x, H_t) $$

其中：

s_a = 地址 a 的写入响应
p_a = 地址 a 的写入概率
Δ_a = 如果写到地址 a，会产生的局部状态更新

所以 plus 的本质不是：

直接指定地址。

而是：

kernel 卷积整棵树，形成 write field，再更新内存态。

search 也是同一个东西

search 更直观。

定义：

$$ s_a = K_{\text{search}}(q, S_a(H_t), W) $$

如果只要硬搜索结果：

$$ a^* = \arg\max_a s_a $$

如果要概率容器：

$$ p_a = \operatorname{softmax}(s_a) $$

所以 search 不是特殊函数。

它就是：

kernel 卷积树，输出 score map。

plus 和 search 的差别只是：

search 把 score map 用来读。
plus 把 score map 用来写。

conjugate 不是额外 if-else

共轭操作也应该从 kernel 角度定义。

假设镜像变换是：

L <-> R

例如：

LRL -> RLR

记为：

$$ \sigma(a) $$

那么 kernel 的共轭是：

$$ K^\sigma = \sigma^{-1} \circ K \circ \sigma $$

这句话的意思是：

先把 TreeHeap 镜像过去；
在镜像空间里用 kernel 做卷积；
再把响应映射回来。

所以 conjugate 不是：

如果左边怎样，右边就怎样。

它是：

卷积核本身做了一次对称翻转。

这就像图像里一个检测左斜边缘的 kernel，可以通过翻转变成检测右斜边缘的 kernel。

TreeHeap 里对应的是：

左路径结构
↓ 镜像
右路径结构

这次 ARA 的新 claim

这次新增：

M0-SOFT-C08

Claim：

TreeHeap primitive operations can be defined as kernel convolutions over
the whole tree state:

search emits a score map,
plus/write uses that map as an update field,
and conjugate is a symmetry transform of the kernel.

中文解释：

TreeHeap 的基本操作可以统一成：
kernel 在整棵树上卷积，然后产生状态图。

search 用这张图读；
plus 用这张图写；
conjugate 是对 kernel 做镜像变换。

这不是说语言任务已经解决。它只是先把操作语义统一起来。

Toy proof 怎么设计

我们做了一个小实验：

kernel_convolution_ops_probe.py

构造一棵 full binary TreeHeap。

在目标地址放入一个不对称子堆：

target_path = LRL

query = [root, left, right]
      = [2.0, 5.0, -3.0]

局部子堆是：

patch(a) = [H[a], H[aL], H[aR]]

kernel 定义为：

$$ score(a) = -\lVert patch(a) - query\rVert^2 $$

这个 kernel 很朴素。它不是学习出来的。它只是为了测试：

同一个卷积响应图，能不能解释 search / plus / conjugate。

实验 1：search score map

kernel 扫描所有候选子堆。

输出：

score(path)

然后取：

argmax score(path)

结果：

指标	结果
search hit@1	True
hit path	LRL
target probability	1.0

说明：

search 可以被定义成 kernel 卷积后的 score map。

实验 2：plus write field

同一张 score map 不只可以拿来读。

也可以变成写入概率：

$$ p(a)=\operatorname{softmax}(score(a)) $$

然后更新 TreeHeap：

$$ H_{t+1} = H_t + \sum_a p(a)\cdot write(a) $$

结果：

指标	结果
plus write hit@1	True
write path	LRL
target update error	0.000000
max disjoint non-target update norm	0.000000

这里有一个细节。

max_nontarget_update_norm = 0.75，看起来像有非目标节点被影响。

但原因是 TreeHeap 的子堆会重叠。例如一个父 patch 会包含它的子节点。目标子堆被写入以后，和它共享节点的其它 patch 也会观察到变化。

所以更干净的定位指标是：

max_disjoint_nontarget_update_norm = 0.0

意思是：

不共享节点的非目标子堆没有被写乱。

这说明 plus/write 可以被解释成：

kernel 卷积产生 write field，然后写入 TreeHeap 内存态。

实验 3：conjugate mirror

目标路径：

LRL

镜像以后：

RLR

原始 query 是不对称的：

[2.0, 5.0, -3.0]

如果直接拿原 kernel 去扫镜像树，会失败：

指标	结果
raw mirror hit@1	False
raw mirror hit path	RLLR

但如果使用共轭 kernel：

K^sigma = sigma^-1 K sigma

结果：

指标	结果
conjugate mirror hit@1	True
conjugate hit path	RLR
score-map equiv max error	0.000000e+00

这说明：

共轭不是树外的 if-else。
共轭是 kernel 的对称变换。

也说明 TreeHeap 的镜像能力可以从卷积核角度定义。

实验总表

检查项	结果
pilot_pass	True
search hit@1	True
plus write hit@1	True
target update error	0.000000
max disjoint non-target update norm	0.000000
raw mirror hit@1	False
conjugate mirror hit@1	True
score-map equiv max error	0.000000e+00

证据路径：

ara/m0-treeheap-math/src/kernel_convolution_ops_probe.py
ara/m0-treeheap-math/evidence/kernel_convolution_ops_probe/

这个 proof 证明了什么

它证明了一个很小、但很关键的东西：

search、plus/write、conjugate 可以共享同一种 kernel convolution 语义。

也就是：

kernel 扫树
↓
产生 score/update map
↓
读、写、镜像都从这张 map 或它的对称变换产生

这让 TreeHeap 操作不再是一堆散装函数。

它们开始有一个统一形式：

$$ H_{t+1} = \operatorname{Op}_K(H_t) $$

其中：

$$ \operatorname{Op}_K $$

来自 kernel 在树上的卷积。

这个 proof 没证明什么

它没有证明：

kernel 可以自己学出来。

这次 kernel 是固定的：

$$ score(a) = -\lVert patch(a)-query\rVert^2 $$

它也没有证明：

TreeHeap 可以翻译。
TreeHeap 可以理解语言。
TreeHeap 比 Transformer 强。

这些都还不能说。

它只证明：

从操作定义上，TreeHeap 可以把 search、plus/write、conjugate
统一为 kernel convolution。

这个地基比“我们手写了几个函数”更干净。

GLM 审计后的修订

Runner / GLM 复核以后指出了一个非常重要的边界：

C08 的 conjugate proof 是 by construction 的恒等。

这句话是什么意思？

在代码里，我们定义了两个东西：

mirror_tree:
  把路径 L/R 互换。

mirror_patch:
  把局部子堆的 left/right 互换。

于是对于原始路径 $p$，有：

$$ \operatorname{mirror\_patch} \big( \operatorname{patch}(\operatorname{mirror\_tree}(H), \sigma(p)) \big) = \operatorname{patch}(H,p) $$

所以：

$$ score_{\text{conjugate}}(\sigma(p)) = score_{\text{original}}(p) $$

这不是模型“自己发现了镜像规律”。

这是我们按共轭定义写出来以后，数学上必然成立。

因此，score_map_equiv_max_error = 0.0 的意义不是：

TreeHeap 学会了镜像。

而是：

如果我们把 conjugate 定义成 kernel 的对称变换，
那么 TreeHeap 的镜像 score map 可以保持一致。

这依然有价值。

但它的价值是：

操作语义统一。

不是：

学习能力证明。

所以 M0-SOFT-C08 的精确边界应该写成：

C08 支持的是 operator-semantics pilot。
它证明 search / plus / conjugate 可以被统一写成 kernel convolution。
它不证明 learned kernel，也不证明模型会自动学出共轭对称。

这个修订非常重要。

否则我们会把“定义上成立”误读成“实验上发现”。

下一步 Predict

下一步不能继续证明 fixed kernel。

fixed kernel 的作用已经完成：

说明 TreeHeap 操作可以被统一定义为 kernel convolution。

下一步要证明的是：

这个 kernel 能不能从数据中学出来？

所以我建议新增两个 predict。

P-SOFT05：learned convolution kernel

Predict：

如果 TreeHeap kernel 的核心是卷积状态变换，
那么一个非线性 learned kernel 应该能从 raw query + raw subheap 中
学会产生正确的 score map 和 write field。

注意关键词是：

raw query
raw subheap

也就是说，不能再手工喂：

diff = patch - query
abs(diff)
diff^2
root_alignment
child_alignment

这些都是答案提示。

真正的 learned kernel 应该输入：

query_root, query_left, query_right
patch_root, patch_left, patch_right
path metadata

然后自己学出：

query 和 patch 是否匹配。

P-SYNTAX01：真实句法树 micro benchmark

Predict：

如果 TreeHeap kernel 不是只在 toy 树上成立，
那么它应该能在小规模真实句法树上读到局部依存结构信号。

这不是 WMT BLEU。

这是一个桥梁实验。

目标是：

让真实语言数据第一次进入 M0/S1 的 TreeHeap kernel 证据链。

建议数据：

Universal Dependencies 小型子集
100 到 1000 句

任务：

给定一个 head token 的局部 TreeHeap 子结构，
预测或匹配它的 modifier / dependent pattern。

例如：

head -> left dependent / right dependent
verb -> subject / object / modifier
noun -> determiner / adjective / prepositional phrase

这个实验不要求翻译。

它只问：

TreeHeap kernel 在真实句法树上是否比 flat baseline 更会利用局部树结构？

下一步实验设计

下一步不是继续手写 kernel。

下一步应该问：

这个 kernel 能不能被学习出来？

也就是：

raw query + raw subheap
↓
learned kernel
↓
score map / write field / conjugate transfer

建议下一步做：

P-SOFT05: learned convolution kernel

对照：

fixed kernel
linear raw kernel
MLP raw kernel
TreeHeap convolution kernel

目标：

不用手工 diff。
让模型自己学会 query-subheap 比较。

如果 learned kernel 能做到：

search map 正确
write field 正确
mirror conjugate 可迁移

那我们才可以把 C05 往前推进。

实验 A：learned multi-pattern kernel

数据生成：

每个样本随机生成一个 query pattern。
把这个 pattern 注入 TreeHeap 的某个目标子堆。
模型必须在所有候选子堆里找出目标位置。

关键点：

不是固定 query。
必须是 multi-pattern。

因为固定 query 很容易退化成：

记住某一个模式。

多 pattern 才能测试：

kernel 是否真的学会比较 query 和 patch。

对照组：

模型	输入	预期
fixed distance kernel	手写 $ -\lVert patch-query\rVert^2 $	上限参考，不算学习
linear raw kernel	raw query + raw patch	应该失败或较弱
MLP raw kernel	raw query + raw patch	应该明显强于 linear
TreeHeap convolution kernel	raw query + raw patch + path/topology	应该在 OOD 地址上最好

Evidence gates：

E-SOFT14:
  MLP raw kernel > linear raw kernel

E-SOFT15:
  TreeHeap convolution kernel 在 unseen depth / unseen address 上
  优于 flat MLP baseline

E-SOFT16:
  不使用 hand-coded diff / alignment 特征

Falsification：

如果 linear raw 或 flat MLP 在同样数据量下稳定匹配 TreeHeap kernel，
那么 TreeHeap kernel 没有显示额外结构收益。

实验 B：learned conjugate transfer

GLM 已经指出：

当前 conjugate proof 是 by construction。

所以真正要测的是：

learned kernel 是否能在镜像结构上迁移。

设计：

训练集：
  只出现左侧结构，比如 L 开头路径。

测试集：
  只出现镜像右侧结构，比如 R 开头路径。

比较：

raw learned kernel
explicit conjugate kernel
data augmentation baseline
flat MLP baseline

Evidence gates：

E-SOFT17:
  explicit conjugate kernel 在 mirror OOD 上优于普通 learned kernel

E-SOFT18:
  使用更少右侧样本达到同等准确率

E-SOFT19:
  mirror score map 在 learned setting 下误差受控

Falsification：

如果普通 MLP 通过足够少样本就学到同等镜像迁移，
或者 explicit conjugate kernel 没有 sample efficiency 优势，
那么共轭 kernel 不构成有效归纳偏置。

实验 C：真实句法树 micro benchmark

数据：

Universal Dependencies
先取 100 到 1000 句
只做英文或中文单语

构造：

把 dependency tree 转成 TreeHeap-like 局部子结构。
每个候选 patch 包含：
  head token embedding / id
  left dependent
  right dependent
  dependency label 或无监督 slot
  path/topology metadata

任务：

给定 query，找出正确 head-dependent 子结构。
或给定局部子树，预测 masked dependent / role。

对照组：

BoW / token-only baseline
flat MLP
small Transformer encoder
TreeHeap convolution kernel

Evidence gates：

E-SYNTAX01:
  TreeHeap kernel > token-only baseline

E-SYNTAX02:
  TreeHeap kernel 在 OOD dependency pattern 上比 flat MLP 更稳

E-SYNTAX03:
  去掉 path/topology/subheap 后性能明显下降

Falsification：

如果 token-only 或 flat MLP 在真实句法树 micro benchmark 上匹配 TreeHeap kernel，
则 TreeHeap 结构对真实语言局部结构没有显示额外收益。

ARA 补项

GLM 还指出了两个 ARA 文档层面的缺口。

第一，PAPER.md 里还没有把 SPR-022、SPR-023 和 M0-SOFT-C08 注册到总 claim 树。

第二，exploration_tree.yaml 里还没有把最近三步补进去：

C07 structural proof
C08 kernel convolution proof
P-SOFT05 learned kernel pivot

这些不是实验本身的问题。

它们是 ARA 索引问题。

我建议下一次 ARA 修订补：

C5-009:
  SPR-022 数学底座：
  TreeHeap math foundations map to BCK Hopf algebra + operad.

C5-010:
  SPR-023 kernel convolution：
  TreeHeap primitive ops can be defined as kernel convolutions over tree state.

同时在 trace DAG 中补：

E-SOFT-002:
  structural_c05_probe

E-SOFT-003:
  kernel_convolution_ops_probe

D-SOFT-003:
  operator semantics unified by kernel convolution

P-SOFT-005:
  learned convolution kernel

这一步我先不直接改。原因是：

这篇 blog 先给 Houming818 review 下一步实验方向。
等 review 后，再把 PAPER.md 和 trace DAG 一次性修正。

结论

这篇的结论是一句话：

TreeHeap 的操作本体应该是 kernel convolution。

不是：

树上有一个 kernel。

而是：

kernel 扫树，产生状态场；
状态场再解释为 search、plus、write、fold、conjugate。

这把 TreeHeap 从“树形数据结构”推进到了：

树形高维状态场上的卷积计算系统。

这才是下一阶段要训练、要证明、要和 MLP / Transformer 对照的对象。

[SPR-024] 概率 Kernel：用 KL 散度衡量 TreeHeap 是否学到世界模型

Wed, 24 Jun 2026 00:00:00 +0000

概率 Kernel：用 KL 散度衡量 TreeHeap 是否学到世界模型

上一篇 SPR-023 证明了一件很基础的事：

TreeHeap 的 search / plus / conjugate
可以统一理解成 kernel 在树形内存态上的卷积。

但 Houming818 进一步指出：

kernel 也要分类型。
有的 kernel 是代数的，100% 确定；
有的 kernel 是概率的，像 softmax 一样输出分布。

这个拆分非常重要。

因为它可以直接回答 GLM 对 C08 的批评：

conjugate proof 是 by construction。

是的。

如果一个 kernel 是代数 kernel，它本来就应该 by construction。它证明的是：

操作定义是否正确。

不是证明：

模型是否学会了这个操作。

如果要证明“学会了”，就必须进入第二类：

概率 kernel proof。

而概率 kernel proof 需要一个新的量尺。

这个量尺就是：

KL 散度。

两类 Kernel

TreeHeap kernel 现在应该拆成两层。

1. Algebraic Kernel
2. Probabilistic Kernel

它们分别回答不同问题。

Algebraic Kernel：证明操作空间

代数 kernel 是确定性的。

它像数学函数：

$$ K(H) \to H' $$

只要输入相同，输出就相同。

例如：

mirror kernel
path shift kernel
subheap extract kernel
exact match kernel
compose kernel
decompose kernel
conjugate kernel

这些 kernel 的目标不是学习。

它们的目标是证明：

TreeHeap 操作空间定义良好。

例如镜像：

L <-> R

如果路径：

LRL

镜像后应该是：

RLR

这不是概率问题。

这是代数定义。

如果写成公式：

$$ \sigma(LRL)=RLR $$

那 proof 应该要求：

$$ \sigma^{-1}(\sigma(a)) = a $$

也就是：

镜像两次回到原路径。

这类 proof 的指标应该是：

closure_ok = true
mirror_error = 0
equiv_error = 0
compose_consistency = true

它对应：

数学正确性。

所以 SPR-023 的 C08 更准确地说属于：

Algebraic Kernel Proof

它证明：

search / plus / conjugate 可以被统一定义成 kernel convolution。

它不证明：

模型从数据里学会了 search / plus / conjugate。

Probabilistic Kernel：证明选择机制

概率 kernel 不直接输出一个确定结果。

它输出一个分布：

$$ P_\theta(a \mid H,q) $$

其中：

符号	含义
$H$	当前 TreeHeap 内存态
$q$	query
$a$	候选操作或候选地址
$\theta$	可学习参数

例如 route kernel：

stop: 0.1
left: 0.8
right: 0.1

例如 write kernel：

LL: 0.05
LR: 0.82
RL: 0.07
RR: 0.06

例如 decompose kernel：

A+B: 0.55
C+D: 0.35
other: 0.10

这才进入学习问题。

它问的是：

模型输出的概率分布，
是否接近世界模型里的真实概率分布？

世界模型里的概率分布

我们先定义一个世界模型。

世界模型不是玄学。

在 proof 里，它可以是一个明确的数据生成器：

WorldModel W

它给出：

$$ P_W(a \mid H,q) $$

意思是：

在 TreeHeap 状态 H 和 query q 下，
世界模型认为每个操作 a 的真实概率是多少。

例如：

P_W(stop, left, right)
=
[0.1, 0.8, 0.1]

模型输出：

P_\theta(stop, left, right)
=
[0.3, 0.4, 0.3]

这时我们就可以问：

模型离世界模型有多远？

这个距离就用 KL 散度衡量。

KL 散度是什么

KL 散度的定义是：

$$ D_{\rm KL}(P \parallel Q) = \sum_x P(x)\log \frac{P(x)}{Q(x)} $$

在我们这里：

P = 世界模型分布
Q = TreeHeap kernel 学到的分布

所以：

$$ D_{\rm KL} \big( P_W(a \mid H,q) \parallel P_\theta(a \mid H,q) \big) = \sum_a P_W(a \mid H,q) \log \frac{ P_W(a \mid H,q) }{ P_\theta(a \mid H,q) } $$

人话解释：

如果真实世界按 P_W 运行，
但模型用 P_theta 去解释，
会多付出多少信息代价？

如果：

$$ P_\theta = P_W $$

那么：

$$ D_{\rm KL}(P_W \parallel P_\theta)=0 $$

越接近 0，说明模型越像世界模型。

KL 与交叉熵

KL 可以展开：

$$ D_{\rm KL}(P \parallel Q) = H(P,Q)-H(P) $$

其中：

$$ H(P,Q) = -\sum_x P(x)\log Q(x) $$

是交叉熵。

因为 $H(P)$ 是世界模型自己的熵，对模型参数 $\theta$ 来说是常数。

所以训练时：

$$ \min_\theta D_{\rm KL}(P_W \parallel P_\theta) $$

等价于：

$$ \min_\theta H(P_W, P_\theta) $$

这就是为什么机器学习经常用 cross entropy。

如果 $P_W$ 是 one-hot：

left = 1.0
其他 = 0.0

那就是普通分类。

如果 $P_W$ 是 soft distribution：

stop = 0.1
left = 0.8
right = 0.1

那就是概率模仿。

TreeHeap 的概率 kernel 更应该从 soft distribution 开始。

因为 TreeHeap 的核心思想之一是：

信息不足时不要过早坍缩。

TreeHeap 的概率 Kernel 训练目标

一个概率 TreeHeap kernel 可以写成：

$$ P_\theta(a \mid H,q) = \operatorname{softmax}(K_\theta(H,q))_a $$

世界模型给：

$$ P_W(a \mid H,q) $$

训练 loss：

$$ L(\theta) = \mathbb{E}_{(H,q)\sim \mathcal{D}} \left[ D_{\rm KL} \big( P_W(a \mid H,q) \parallel P_\theta(a \mid H,q) \big) \right] $$

人话：

在很多 TreeHeap 状态和 query 上，
让模型输出的操作分布接近世界模型的操作分布。

这可以训练：

route kernel
write kernel
merge kernel
decompose kernel
collapse kernel

plus 的两层定义

现在 plus 可以拆成两层。

第一层是代数候选：

$$ \{\operatorname{Plus}_a(H,x)\}_{a\in A} $$

意思是：

对每个地址 a，
如果把 x plus 到那里，
都会得到一个合法候选 TreeHeap。

这是代数 kernel 的部分。

第二层是概率选择：

$$ P_\theta(a \mid H,x) $$

意思是：

模型认为这次应该写到哪个地址。

Soft Plus 是两者合起来：

$$ H_{t+1} = \sum_a P_\theta(a \mid H,x) \operatorname{Plus}_a(H,x) $$

如果 $P_\theta$ 最后坍缩成 one-hot：

P_theta(LR)=1.0
其他 = 0.0

那它就回到 hard plus。

所以：

代数 kernel 定义可以做什么；
概率 kernel 学习什么时候做什么。

这是这篇最重要的一句话。

一个 Toy 世界模型

为了证明概率 kernel 能学到世界模型，我们需要先设计一个可控世界。

例如定义一个路由世界：

如果 query 和左子堆更相似：
  P_W(left)=0.8, P_W(right)=0.1, P_W(stop)=0.1

如果 query 和右子堆更相似：
  P_W(right)=0.8, P_W(left)=0.1, P_W(stop)=0.1

如果当前节点已经足够匹配：
  P_W(stop)=0.8, P_W(left)=0.1, P_W(right)=0.1

注意这里不是 hard label。

不是：

left = 1

而是：

left = 0.8

这样才能测试 Probability Container。

模型输出：

$$ P_\theta(stop,left,right \mid H,q) $$

训练目标：

$$ D_{\rm KL}(P_W \parallel P_\theta) $$

如果训练成功，应该看到：

train_KL 下降
test_KL 下降
OOD_KL 仍然较低

这才说明：

模型不是只记住训练样本。
它学到了世界模型分布里的规律。

为什么要看 OOD KL

只看训练集 KL 不够。

因为模型可能死记：

这个样本就是 left。
那个样本就是 right。

所以必须设计 OOD 测试。

例如：

训练：
  depth <= 3
  path 只出现 L 开头

测试：
  depth >= 5
  path 出现 R 开头镜像结构

如果：

train_KL 低
test_KL 高

说明模型只是记忆。

如果：

train_KL 低
test_KL 低
OOD_KL 也低

才说明：

模型学到了可迁移的世界模型概率规律。

实验设计：P-SOFT05-KL

我建议下一步 predict 写成：

P-SOFT05-KL:
TreeHeap probabilistic kernel should learn a world-model operation
distribution with lower OOD KL than flat baselines.

中文：

如果 TreeHeap 概率 kernel 真的有结构归纳偏置，
它应该能用更少样本学到世界模型的操作概率分布，
并在未见过的地址、深度、镜像结构上保持较低 KL。

数据

构造 TreeHeap toy world：

H = full binary TreeHeap
q = query pattern
a = {stop, left, right} 或候选 write addresses

世界模型生成：

P_W(a | H,q)

例如：

P_W(a | H,q)
=
softmax(-distance(query, subheap_a) / temperature)

这里 distance 是世界模型内部规则。

训练模型不知道这个公式。

模型只能看到：

raw query
raw subheap
path/topology metadata
目标分布 P_W

模型对照

模型	输入	目的
flat MLP	展平 TreeHeap + query	测普通函数逼近
linear kernel	raw query + raw patch	测线性是否足够
MLP raw kernel	raw query + raw patch	测非线性比较能力
TreeHeap prob kernel	raw query + raw patch + path/topology	测结构归纳偏置
oracle fixed kernel	世界模型公式	上限参考，不算学习

指标

主要指标：

train_KL
test_KL
OOD_KL

辅助指标：

cross_entropy
entropy_error
top1_agreement
calibration_error
sample_efficiency
collapse_accuracy_tau_low

其中：

entropy_error

衡量模型有没有把世界模型的不确定性学出来。

例如世界模型很犹豫：

[0.45, 0.45, 0.10]

模型不应该强行输出：

[0.99, 0.01, 0.00]

否则它虽然 top1 可能对，但概率世界模型学错了。

预期结果

如果 TreeHeap 概率 kernel 成立，我们希望看到：

TreeHeap prob kernel:
  train_KL 低
  test_KL 低
  OOD_KL 低
  calibration 好
  sample_efficiency 高

flat MLP:
  train_KL 可以低
  但 OOD_KL 更高

linear kernel:
  多 pattern 下 KL 较高

oracle fixed kernel:
  KL 接近 0
  作为上限参考

如果结果相反：

flat MLP 的 OOD_KL 和 TreeHeap 一样低，
或者 TreeHeap 需要更多样本，
或者 TreeHeap calibration 更差，

那就说明：

TreeHeap 概率 kernel 暂时没有显示结构收益。

这就是 falsification。

和 Transformer 的类比

Transformer 学到的不是：

矩阵本身很神秘。

而是：

通过梯度下降，把 token 共现、上下文相关性、
query-key-value 关系压进参数矩阵。

它可以被理解为学习：

$$ P(token_j \mid token_i, context) $$

TreeHeap 概率 kernel 要学的是：

$$ P(operation \mid query, subheap, path, topology, context) $$

也就是：

在某个树形状态下，
应该 stop、left、right、write、merge、decompose 的概率是多少。

这才是 TreeHeap 的概率学习对象。

这篇的结论

现在 TreeHeap kernel proof 应该分成两条线。

第一条：

Algebraic Kernel Proof

证明：

TreeHeap 操作空间定义正确。

指标：

closure
equivariance
mirror error
compose consistency

第二条：

Probabilistic Kernel Proof

证明：

模型能从数据中学习世界模型的操作概率分布。

指标：

KL divergence
cross entropy
calibration
OOD KL
sample efficiency

最终一句话：

代数 kernel 定义 TreeHeap 能做什么；
概率 kernel 学习 TreeHeap 什么时候应该做什么。

下一步实验就应该从 KL proof 开始。

[SPR-025] 演绎与归纳：TreeHeap Kernel 的两类 Proof

Wed, 24 Jun 2026 00:00:00 +0000

演绎与归纳：TreeHeap Kernel 的两类 Proof

上一篇 SPR-024 说：

TreeHeap kernel 要分成代数 kernel 和概率 kernel。

Houming818 又把问题说得更准确：

这里其实是演绎推理和归纳推理的区别。

这句话是关键。

我们之前有时把两类 proof 混在一起了。

例如：

conjugate 按公式定义后，镜像结果成立。

这是演绎推理。

它不是模型从数据中学出来的。

而：

一个概率 kernel 通过梯度下降，学会输出接近世界模型的概率分布。

这是归纳推理。

它不是由公式直接推出的。

它必须通过数据、loss、梯度、参数更新和测试集来证明。

所以从这篇开始，我们把 TreeHeap kernel proof 正式拆成两类：

Deductive Kernel Proof
Inductive Kernel Proof

演绎 Proof 是什么

演绎 proof 的形式是：

给定定义
推出结论

例如镜像路径：

L <-> R

如果：

mirror(LRL) = RLR

再镜像一次：

mirror(RLR) = LRL

所以：

mirror(mirror(path)) = path

这是从定义直接推出的。

不需要训练。

不需要梯度。

不需要数据集。

只要定义正确，它就应该 100% 成立。

数学上可以写：

$$ \sigma^{-1}(\sigma(a)) = a $$

这就是演绎 proof。

TreeHeap 里的演绎 Kernel

TreeHeap 里很多 kernel 都是这种。

例如：

mirror kernel
conjugate kernel
path shift kernel
subheap extract kernel
one-hot Soft Plus
hard compose/decompose 的合法性

这些东西的 proof 目标是：

操作定义是否自洽。

它们的指标应该是：

mirror_error = 0
conjugate_equiv_error = 0
closure_ok = true
one_hot_soft_plus_error = 0

如果这些不成立，说明：

TreeHeap 的代数定义有 bug。

但如果它们成立，也不能说明：

模型学会了语言。
模型学会了概率。
模型学会了世界模型。

它只说明：

操作空间定义正确。

归纳 Proof 是什么

归纳 proof 的形式是：

给定数据
给定模型
给定 loss
通过训练更新参数
看模型是否学到数据中的规律

例如线性回归：

y = ax + b

我们不知道 $a,b$。

模型通过数据和梯度下降学到：

a_hat
b_hat

这不是从定义直接推出的。

这是从样本中归纳出来的。

Transformer 也是类似。

Transformer 不是因为矩阵定义在那里，所以自然懂语言。

而是因为：

大量文本数据
↓
loss
↓
梯度下降
↓
参数矩阵被修正
↓
模型学到 token 共现、上下文关系、query-key-value 结构

这是归纳推理。

TreeHeap 的概率 kernel 也必须走这条路。

TreeHeap 概率 Kernel 学什么

概率 kernel 输出的是分布：

$$ P_\theta(a \mid H,q) $$

其中：

符号	含义
$H$	当前 TreeHeap 状态
$q$	query
$a$	候选操作或候选地址
$\theta$	可学习参数

世界模型给一个目标分布：

$$ P_W(a \mid H,q) $$

模型要学的是：

P_theta 尽量接近 P_W。

评价工具是 KL 散度：

$$ D_{KL}(P_W \parallel P_\theta) = \sum_a P_W(a)\log\frac{P_W(a)}{P_\theta(a)} $$

如果：

KL 接近 0

说明模型分布接近世界模型分布。

如果：

KL 很大

说明模型没学好。

这就是概率 kernel 的归纳 proof。

这次实验

我写了一个新 proof：

deductive_inductive_kernel_probe.py

证据路径：

ara/m0-treeheap-math/src/deductive_inductive_kernel_probe.py
ara/m0-treeheap-math/evidence/deductive_inductive_kernel_probe/

这个 proof 分成两部分。

第一部分：

演绎 proof

检查代数定义是否精确成立。

第二部分：

归纳 proof

训练概率 kernel 去模仿一个世界模型分布，并用 KL 测量。

Part A：演绎检查

实验检查了四个确定性性质：

mirror_path(mirror_path(p)) == p
mirror_patch(mirror_patch(x)) == x
conjugate score equivalence error == 0
one-hot Soft Plus == Hard Plus

结果：

Check	Result
mirror involution	True
mirror patch involution error	0.000000e+00
conjugate equivalence error	0.000000e+00
one-hot soft plus error	0.000000e+00

解释：

这些是演绎性质。
它们按定义应该成立。

这个结果说明：

TreeHeap 的这些代数 kernel 定义是自洽的。

但它不说明：

模型学到了概率分布。

这部分只属于演绎 proof。

Part B：归纳 KL 学习

为了测试概率学习，我们构造了一个 toy world model。

世界模型定义：

query 和某个子堆越接近，
这个子堆被选中的概率越高。

数学上：

$$ P_W(a \mid H,q)=\operatorname{softmax}(-\lVert patch(a)-query\rVert^2 / T) $$

其中 $T=0.45$ 是温度。

模型看不到这个公式。

模型只看到：

raw query
raw patch
path/topology metadata
目标概率分布 P_W

训练目标：

$$ \min_\theta D_{KL}(P_W \parallel P_\theta) $$

测试指标：

train_KL
test_KL
OOD_KL
top1_agreement
entropy_error
calibration_l1

对照模型

这次用了五个模型：

Model	含义
address_prior	只记地址偏好，不看 query / patch
linear_raw	线性模型，看 raw query + raw patch
mlp_raw	非线性 MLP，看 raw query + raw patch
treeheap_prob_kernel	MLP + path/topology metadata
oracle_fixed_kernel	直接使用世界模型公式，上限参考

注意：

oracle_fixed_kernel 不算学习。

它只是告诉我们理论上最优可以到哪里。

实验结果

Model	Train KL	Test KL	OOD KL	OOD top1
address_prior	1.435286	1.434764	2.403086	0.047
linear_raw	1.436146	1.440253	2.403392	0.040
mlp_raw	0.007935	0.009027	0.022695	0.957
treeheap_prob_kernel	0.009950	0.010835	0.053386	0.877
oracle_fixed_kernel	0.000000	0.000000	0.000000	1.000

结论先说清楚：

归纳学习成立。
TreeHeap 结构优势没有在这个 toy 里成立。

为什么？

因为：

mlp_raw 的 OOD KL = 0.022695
treeheap_prob_kernel 的 OOD KL = 0.053386

也就是说，在这个 toy world 里，单纯的 raw MLP 比加了 path/topology 的 TreeHeap prob kernel 更好。

这不是坏消息。

这是一个很有用的负边界。

它说明：

这个世界模型主要由 query-patch 内容距离决定。
路径/topology 不是必要信息。

所以 TreeHeap 结构没有优势，是合理的。

这个实验真正证明了什么

它证明了三件事。

第一：

演绎 proof 和归纳 proof 必须分开。

代数恒等式成立，是定义正确。

KL 下降，是参数从数据中学到概率规律。

第二：

概率 kernel 可以用 KL 来评价。

mlp_raw 从高 KL 降到：

test_KL = 0.009027
OOD_KL = 0.022695

说明它确实通过梯度学习到了世界模型分布。

第三：

TreeHeap 结构优势需要更合适的数据分布。

如果世界模型只依赖内容距离：

distance(query, patch)

那么普通 MLP 就足够强。

TreeHeap 应该在这些数据分布上证明自己：

路径前缀影响概率
镜像结构影响概率
子堆组合影响概率
延迟坍缩影响概率

也就是说，下一步的世界模型不能只靠内容距离。

它必须让：

address
path
topology
composition
decomposition

真的进入 $P_W$。

这次实验没证明什么

它没有证明：

TreeHeap 比 MLP 更强。

相反，这个 toy 里：

mlp_raw 更好。

它也没有证明：

TreeHeap 能翻译。
TreeHeap 能理解句法。
TreeHeap 能替代 Transformer。

它只证明：

概率 kernel 的归纳学习可以用 KL/OOD KL 来测量。

这个边界很重要。

下一步怎么改世界模型

下一步的世界模型应该加入结构项。

例如：

$$ P_W(a \mid H,q)=\operatorname{softmax}(-(d_{content}(a)+\lambda d_{path}(a)+\mu d_{topology}(a))/T) $$

其中：

d_content:
  query 和 patch 的内容距离

d_path:
  query 目标路径和候选路径的前缀距离

d_topology:
  候选子堆的结构合法性或组合关系

这样，TreeHeap kernel 才有机会利用：

path
topology
subheap relation

否则它只是一个更复杂的 MLP。

下一轮 predict 应该是：

P-SOFT06:
当世界模型分布同时依赖 content + path + topology 时，
TreeHeap prob kernel 的 OOD KL 应该低于 mlp_raw。

对应 falsification：

如果 mlp_raw 在 content+path+topology 世界里仍然匹配或优于 TreeHeap prob kernel，
那么当前 TreeHeap 概率 kernel 没有显示结构归纳偏置。

总结

这篇的结论是：

演绎 proof 证明定义正确。
归纳 proof 证明参数从数据中学习。

TreeHeap 需要两种 proof。

代数 kernel 的成功，不应该冒充概率学习。

概率 kernel 的成功，必须用 KL、OOD KL、校准和样本效率来衡量。

这次实验支持：

M0-SOFT-C09:
TreeHeap kernel proof 必须区分演绎代数恒等与归纳概率学习；
KL 散度可以衡量 learned probabilistic kernel 是否模仿了世界模型分布。

但它也给出一个负边界：

当前 toy 不支持 TreeHeap 结构优势。

下一步，要把世界模型从：

只依赖内容距离

升级为：

同时依赖内容、路径、拓扑、组合和分解。

那才是真正测试 TreeHeap 存在性的概率 proof。

[SPR-026] S1 开始：真实短句上的浅层 TreeHeap 写入

Thu, 25 Jun 2026 00:00:00 +0000

S1 开始：真实短句上的浅层 TreeHeap 写入

前面 SPR-025 把 proof 分成两类：

演绎 proof：按定义推出，应该精确成立。
归纳 proof：从数据训练出来，必须看 loss / KL / accuracy / OOD。

这一区分很重要。

因为 M0 主要解决的是：

TreeHeap 的数学操作能不能定义？

而 S1 要开始解决：

真实数据能不能写进 TreeHeap？
写进去之后，能不能被 kernel / probe 查询？

所以这一篇不是继续证明 M0 的闭包。

这一篇是 S1 的第一块砖。

为什么不直接上 WMT？

WMT 是翻译任务。

它太大了。

如果一上来跑 WMT，失败时我们不知道问题在哪：

是 encoder 不会写？
是 TreeHeap 不会保存？
是 probe 不会读？
是结构太深？
是 decoder 不会生成？
是 loss 不合适？

所以 S1 第一版应该非常浅：

真实短句
↓
浅层 TreeHeap memory
↓
root / subject / object 查询

也就是先问一个低级但关键的问题：

模型能不能把真实语言里的短句，写成可查询的数据结构？

如果这个都不成立，就没有必要谈 S2 / WMT。

实验目标

本次实验脚本：

ara/s1-echo/src/shallow_treeheap_s1_probe.py

远端执行在：

ni.grepcode.cn

证据目录：

ara/s1-echo/evidence/shallow_treeheap_s1_probe/

实验 claim：

S1-C30:
一个可学习的浅层 TreeHeap write，
可以把真实短句编码到 root / subject / object 槽位，
并支持 OOD 新词的 copy-by-address。

这里的核心不是“背训练集答案”。

核心是：

输入里出现一个新词，
模型以前没在输出标签里训练过这个词，
TreeHeap 仍然能把它复制到正确槽位。

这就是 TreeHeap 作为结构内存的第一种价值。

数据是什么？

这次不是随机向量。

数据是人工整理的真实词短句，例如：

alice opens door
bob finds key
carol sees bob
nurse brings water
teacher holds book

结构很浅：

subject verb object

对应 TreeHeap 槽位：

arr[0] = root
arr[1] = subject
arr[2] = object

也就是：

opens
├── alice
└── door

注意，这里不是说英语永远是这种结构。

这里只是 S1 的第一步。

我们先让 TreeHeap 学一个深度很浅、结构很清楚的小世界。

数据规模

这次数据切分：

Split	Count
train	63
test	17
OOD	10
vocab	37

OOD 里包含训练输出没见过的新词，例如：

erin draws cup
nurse brings water
frank draws box
teacher holds book

这很关键。

如果模型只是普通分类器，它会倾向于输出训练集中见过的词。

但 TreeHeap memory 的写入方式可以是：

把输入 token 复制到某个槽位。

所以它有机会处理新词。

三个模型

这次对比了三个模型。

1. bow_linear

输入是 bag-of-words。

也就是：

alice sees bob

和：

bob sees alice

在它看来几乎是同一袋词。

它不擅长区分谁是 subject，谁是 object。

2. seq_linear

输入保留位置：

position 0 = alice
position 1 = sees
position 2 = bob

所以它比 bag-of-words 强。

但是它仍然是普通线性分类器。

如果一个词从来没作为训练输出出现过，它很难突然输出这个词。

3. soft_treeheap

这是本次主角。

它学习的是一个 soft write：

position 0 -> 哪个 TreeHeap slot
position 1 -> 哪个 TreeHeap slot
position 2 -> 哪个 TreeHeap slot

写入形式可以理解成：

$$ M[s,v] = \sum_p P(s \mid p) \cdot 1[token_p = v] $$

其中：

符号	含义
$M$	TreeHeap memory
$s$	slot，比如 root / subject / object
$v$	token
$p$	输入位置
$P(s \mid p)$	第 p 个 token 写入 slot s 的概率

如果模型学到：

position 0 -> subject
position 1 -> root
position 2 -> object

那么：

nurse brings water

即使 nurse、brings、water 是新词，也可以被复制到：

subject = nurse
root    = brings
object  = water

这就是 copy-by-address。

实验结果

结果如下：

Model	Train exact	Test exact	OOD exact	Test subheap	OOD subheap
bow_linear	0.873	0.765	0.000	0.765	0.000
seq_linear	1.000	0.765	0.000	0.765	0.000
soft_treeheap	1.000	1.000	1.000	1.000	1.000

这里的 subheap 指：

root + object

例如：

draws cup
brings water
holds book

也就是一个很浅的子结构查询。

TreeHeap 学到了什么？

soft TreeHeap 最后学到的写入概率是：

输入位置	root	subject	object
position 0	0.0016	0.9968	0.0016
position 1	0.9968	0.0016	0.0016
position 2	0.0016	0.0016	0.9968

换句话说，它学到：

position 0 -> subject
position 1 -> root
position 2 -> object

这是一个非常简单的浅层结构。

但这就是 S1 的意义：

不是先证明复杂语言。
而是先证明数据可以写入 TreeHeap，并且能被查询。

为什么普通 seq_linear OOD 失败？

seq_linear 在训练集上是 1.0。

说明它能背住训练词和位置关系。

但是 OOD 是 0.0。

原因很简单：

它没有 copy 机制。

比如：

nurse brings water

如果 nurse 和 water 没在训练输出里出现过，普通分类器没有学过：

输出 nurse
输出 water

它只能偏向训练里见过的词。

TreeHeap 的 soft write 不同。

它不需要先学会每个词的输出权重。

它只需要学会：

第 0 个 token 写到 subject。
第 1 个 token 写到 root。
第 2 个 token 写到 object。

然后直接复制输入 token。

这就是结构内存和普通分类器的差异。

这证明了什么？

这次支持：

S1-C30 -> supported pilot

也就是：

浅层 TreeHeap write 可以在真实短句上形成可查询 memory。

它还说明：

TreeHeap 的地址/槽位机制，
确实可以提供一种普通输出分类器没有的 OOD copy 能力。

这和我们之前讨论的方向是一致的：

TreeHeap 不只是一个 MLP。
TreeHeap 的参数可以很少，
但 memory 的地址、路径、slot、子结构本身参与了计算。

这没有证明什么？

边界必须说清楚。

这次没有证明：

TreeHeap 能翻译。
TreeHeap 能处理完整句法。
TreeHeap 比 Transformer 强。
TreeHeap 能处理长句。
TreeHeap 已经解决 S2 graph assembly。

这次数据也很浅。

它更像是：

S1 的 hello world。

但它不是没意义。

因为它第一次把 M0 的数学工具箱接到了真实短句数据上。

下一步怎么改？

下一步不能继续只做固定 SVO。

否则 TreeHeap 学到的只是：

位置模板。

下一轮应该加入：

可变长度
修饰语
被动句
OSV / 倒装
中文短句
多 root 候选
matched pointer/copy baseline

新的 predict 可以是：

P-S1-REAL-SHALLOW-02:
当句子顺序不再固定时，
TreeHeap kernel 必须利用 token 内容、路径、slot 和局部子结构，
而不是只利用 position。

如果下一轮 TreeHeap 仍然能稳住，而普通 baseline 不行，那 S1 才开始从：

存在性 proof

进入：

结构优势 proof

总结

这次实验的结论很简单：

M0 可以进入 S1。
S1 的第一版真实短句浅层写入成立。

TreeHeap 学到的不是语言全貌。

它学到的是一件很小但关键的事：

如何把真实句子的 token 写入可查询的结构槽位。

这就是下一步工作的地基。

现在我们可以继续往上加难度了。

[SPR-027] TreeHeap 差分代数：从 Zero 到距离，再到学习

Thu, 25 Jun 2026 00:00:00 +0000

TreeHeap 差分代数：从 Zero 到距离，再到学习

上一篇 SPR-026 做了一个浅层 S1 proof：

真实短句
-> soft TreeHeap write
-> root / subject / object slot
-> query

但 Houming818 指出了一个更底层的问题：

两个 TreeHeap 结构如何计算距离？

我一开始直接回答“可以算节点距离、路径加权距离、子堆距离”。

这个回答不算错，但跳了一步。

真正第一性的问题是：

TreeHeap 的差分怎么定义？

因为距离不是第一定义。

距离应该来自：

差分
↓
范数
↓
距离

就像实数一样：

|x-y|

这里真正先发生的是：

x-y

再取绝对值。

向量也是一样：

||a-b||

先有：

a-b

再有范数。

TreeHeap 也应该这样。

为什么差分比距离更基础？

机器学习不是只需要“两个东西远不远”。

机器学习还需要知道：

如果我把参数改一点，
loss 会怎么变？

也就是：

差分 / 微分 / 梯度

如果 TreeHeap 只有一个距离函数：

Distance(A,B)

但没有：

Diff(A,B)

那它很难接上学习。

因为学习要做的是：

Δloss / Δparameter

所以我们需要先定义：

Zero
Subtraction
Norm
Inner Product
Cosine
Finite Difference

这就是本篇的主题。

Zero TreeHeap

先定义零 TreeHeap：

Zero[i] = 0 ∈ R^128

也就是每个节点都是 128D 零向量。

如果一个 TreeHeap 是：

那么它的大小不是凭空来的，而是：

H - Zero

再取范数。

这和实数一致：

|x| = |x - 0|

TreeHeap 差分

假设两个 TreeHeap 的地址空间一样：

A[i] ∈ R^128
B[i] ∈ R^128

那么差分定义为：

Diff(A,B)[i] = A[i] - B[i]

注意：

Diff(A,B)

仍然是一个 TreeHeap-shaped object。

只是每个节点存的是：

向量差

而不是原始向量。

这点很关键。

我们不是把 TreeHeap 压扁成一个 scalar。

我们先保留结构差异。

TreeHeap 范数

TreeHeap 不是普通 flat vector。

节点有深度：

root depth = 0
left/right depth = 1
deeper nodes depth = 2,3,...

所以第一版范数加入深度权重：

$$ \lVert H\rVert_T = \sqrt{\sum_i \alpha^{depth(i)} \lVert H[i]\rVert_2^2} $$

其中：

0 < alpha < 1

这表示：

越靠近 root，权重越大。
越深的节点，权重越小。

这不是最终答案，但它是一个合理的第一版。

TreeHeap 距离

有了差分和范数，距离自然定义为：

$$ d(A,B) = \lVert A-B\rVert_T $$

也就是：

先差分
再取 TreeHeap 范数

这比直接写一个 distance(A,B) 更干净。

因为它和学习、微分、梯度可以接上。

TreeHeap 内积和 cosine

同样，cosine 也不应该是随便把节点平均后再算。

先定义 TreeHeap 内积：

$$ \langle A,B\rangle_T = \sum_i \alpha^{depth(i)} \langle A[i],B[i]\rangle $$

然后定义 TreeHeap cosine：

$$ \cos_T(A,B)=\frac{\langle A,B\rangle_T}{\lVert A\rVert_T\lVert B\rVert_T} $$

这样 cosine 也是从 TreeHeap 代数结构来的。

不是临时拼出来的。

有限差分

现在进入学习。

如果：

L(H)

是一个 loss，我们想知道沿着方向：

改变 TreeHeap 时，loss 怎么变。

有限差分可以写成：

$$ \frac{L(H+\epsilon U)-L(H-\epsilon U)}{2\epsilon} $$

如果 TreeHeap 差分代数正确，这个数应该和解析方向导数对上。

对一个简单的加权 MSE：

$$ L(H)=\frac{1}{2}\lVert H-Target\rVert_T^2 $$

方向导数应该是：

$$ \langle H-Target, U\rangle_T $$

这就是实验要检查的第一件事。

prob vector plus 的学习信号

我们还要检查它能不能接上写入学习。

定义一个最小 prob vector plus：

H'[i] = H[i] + p_i · x

其中：

x ∈ R^128
p = softmax(theta)

这表示：

把一个 128D token/world vector
按概率写入 TreeHeap 节点。

目标 TreeHeap 是：

Target[target_node] = x
其他节点 = 0

loss：

$$ L=\frac{1}{2}\lVert H'-Target\rVert_T^2 $$

如果差分代数能支持学习，那么：

有限差分算出来的 dL/dtheta

应该接近：

解析梯度算出来的 dL/dtheta

并且做一步梯度下降后：

loss 应该下降
target_node 的写入概率应该上升

实验脚本

脚本：

ara/m0-treeheap-math/src/treeheap_diff_algebra_probe.py

执行主机：

io.grepcode.cn

证据：

ara/m0-treeheap-math/evidence/treeheap_diff_algebra_probe/

参数：

nodes = 15
dim = 128
alpha = 0.72
eps = 1e-5

实验结果

Metric	Value
`norm_zero`	0.000000
`dist_aa`	0.000000
`dist_ab`	8.779953
`dist_ba`	8.779953
`cos_aa`	1.000000
`anti_sym_error`	0.000000
`directional_derivative_abs_error`	3.48e-10
`theta_grad_abs_error`	4.21e-10
`theta_grad_rel_error`	2.10e-10
`initial_loss`	29.138441
`stepped_loss`	0.000660
`target_prob_before`	0.064808
`target_prob_after`	0.995534

这些结果说明：

Zero 范数为 0。
自己到自己的距离为 0。
距离对称。
cos(A,A)=1。
Diff(A,B)=-Diff(B,A)。
TreeHeap 状态有限差分和解析方向导数一致。
prob vector plus 的 theta 梯度和有限差分一致。
一步梯度下降能显著降低 loss。
写入概率会从错误的扩散状态坍缩到目标节点。

这次证明了什么？

这次支持：

M0-DIFF-C01 -> supported pilot

也就是：

TreeHeap 可以先定义差分代数，
再由差分推出距离、cosine、loss 和有限差分学习信号。

这件事很重要。

因为 S1 的 prob vector write 需要的不只是：

我能把 token 写进去。

还需要：

写错了，loss 怎么变？
参数该往哪边改？

这就是差分代数给出的东西。

这次没有证明什么？

边界也要清楚。

这次没有证明：

TreeHeap 已经学会语言。
TreeHeap 已经有世界模型坐标系。
prob vector plus 已经是最终 encoder。
TreeHeap 比 MLP / Transformer 强。
TreeHeap 能做 WMT。

它证明的是更底层的事：

TreeHeap 有可用于学习的差分/距离/梯度评价框架。

对 S1 的意义

现在我们可以把 S1 的写入问题说得更精确。

不再只是：

把 token 写到 TreeHeap。

而是：

从 Zero TreeHeap 出发，
用 prob vector plus 写入 128D token/world vector，
用 TreeHeap diff distance 评价写入结果，
再用有限差分/梯度更新写入 kernel。

这条链是：

Zero
-> Prob Vector Plus
-> TreeHeap state
-> Diff to Target
-> Norm / Loss
-> Finite Difference / Gradient
-> Update Kernel

这才是 M0 工具箱进入 S1 的真正接口。

下一步

下一步不是再问：

距离怎么算？

而是问：

Target 从哪里来？

也就是我们前面说的世界模型坐标系。

例如：

foot + ball -> football
hand + ball -> handball
rain + coat -> raincoat
book + shelf -> bookshelf

我们需要这样的数据，告诉 TreeHeap：

什么样的写入结果是对的？
什么样的组合关系应该在空间里接近？

没有世界模型坐标系，TreeHeap 只能学 echo。

有了世界模型坐标系，TreeHeap 才能学语义拓扑。

总结

这篇的核心结论是：

TreeHeap 距离不是第一定义。
TreeHeap 差分才是第一定义。

从差分出发，我们得到了：

Zero
Subtraction
Norm
Inner Product
Cosine
Finite Difference
Gradient Signal

这让 TreeHeap 不再只是一个“树形存储结构”。

它开始具备进入梯度学习的数学接口。

[SPR-028] 世界模型坐标系第一试：Frozen Embedding 不是胜利，是一把尺

Thu, 25 Jun 2026 00:00:00 +0000

世界模型坐标系第一试：Frozen Embedding 不是胜利，是一把尺

SPR-027 之后，我们有了 TreeHeap 的差分代数：

Zero
Diff
Norm
Cosine
Finite Difference
Gradient Signal

这说明 TreeHeap 已经可以定义：

写入结果和目标之间的距离

但马上出现下一个问题：

目标从哪里来？

也就是我们说的：

世界模型坐标系

如果没有世界模型坐标系，TreeHeap 只能学 echo。

如果有一个坐标系，它才知道：

foot + ball 应该靠近 football
hand + ball 应该靠近 handball
rain + coat 应该靠近 raincoat

这次用什么坐标系？

这次采用 Houming818 选的 A 方案：

用现成 embedding。

具体是：

sentence-transformers/all-MiniLM-L6-v2

在 io 上使用的是本地缓存：

/home/nio/.cache/huggingface/hub/models--sentence-transformers--all-MiniLM-L6-v2/snapshots/1110a243fdf4706b3f48f1d95db1a4f5529b4d41

所以这次没有用 proxychains4。

如果后面要加载新模型或新语料，且本地没有缓存，就应该在 io 上用：

proxychains4

并把下载命令记录到 evidence。

防蒸馏边界

这里必须说清楚：

冻结 embedding 不是 TreeHeap 自己学出的世界模型。

它只是一个外部坐标尺。

我们用它来问：

TreeHeap 写入后的向量，能不能靠近这个坐标尺里的目标点？

这不是说：

TreeHeap 已经拥有 all-MiniLM 的知识。

更不是说：

TreeHeap 蒸馏了一个大模型。

本实验只验证：

TreeHeap encoder 能否在一个冻结坐标系里学习组合映射。

实验任务

任务是复合词组合：

left + right -> target

例子：

foot + ball -> football
basket + ball -> basketball
hand + ball -> handball
rain + coat -> raincoat
book + shelf -> bookshelf
flash + light -> flashlight

数据规模：

Split	Count
train	20
test	11
OOD	6
targets	37

embedding 原始维度：

384D

固定随机正交投影到：

128D

这样和 TreeHeap 的 128D 方向一致。

三个模型

vector_add

最简单：

y = normalize(left + right)

没有训练参数。

concat_mlp

普通 MLP：

[left, right, left*right, abs(left-right)] -> target

它有训练参数，会拟合训练集。

treeheap_prob_vector_plus

TreeHeap 版本：

H0 = Zero
H1 = ProbVectorPlus(H0, left)
H2 = ProbVectorPlus(H1, right)
y  = Read(H2)

其中写入是：

H'[i] = H[i] + p_i · update(x)

也就是：

用概率路由把 128D word vector 写入 TreeHeap 节点。

结果

结果如下：

Model	Train cosine	Test cosine	OOD cosine	Test top1	OOD top1
vector_add	0.7117	0.7256	0.7198	0.909	0.833
concat_mlp	1.0000	0.6269	0.5766	0.000	0.000
treeheap_prob_vector_plus	0.9999	0.5051	0.3919	0.000	0.000

这个结果非常明确：

TreeHeap 没赢。

更准确地说：

当前 TreeHeap prob vector plus 过拟合训练集。

训练集上接近 1.0：

train cosine = 0.9999

但 OOD 很差：

OOD cosine = 0.3919
OOD top1 = 0.0

反而最简单的：

vector_add

表现最好：

OOD cosine = 0.7198
OOD top1 = 0.833

Claim 状态

所以这次结论是：

S1-WM-C01 -> rejected pilot

这个 rejected 很重要。

它说明我们不能说：

只要把 TreeHeap 接到 embedding 坐标系，就自然有世界模型。

事实正好相反：

当前 unconstrained TreeHeap reader 太自由，
会记住训练集，
但没有学到可泛化的复合词结构。

为什么 vector_add 会这么强？

因为 frozen embedding 里已经包含大量语言共现和语义关系。

对很多复合词来说：

left + right

本身就已经靠近：

target compound

例如：

rain + coat

在 embedding 空间里天然接近：

raincoat

这说明：

外部 embedding 坐标系已经有强世界知识。

TreeHeap 如果只是用一个大 reader 去拟合它，很容易变成小数据过拟合。

这不是 TreeHeap 的优势区。

这对下一步意味着什么？

下一步不要简单增加参数。

也不要把 reader 做得更大。

因为这会更像：

小 MLP 记训练集。

下一步应该限制 TreeHeap，让结构真的参与计算。

例如：

1. 共享 family slot
   ball / coat / book / light 这些右侧词应该形成可复用子结构。

2. route entropy / collapse control
   防止所有词都写到同一个节点。

3. subheap reuse
   foot+ball, basket+ball, hand+ball 应该共享 ball 子堆。

4. copy/read pointer constraint
   readout 不应该完全自由生成，而应该读取 TreeHeap 中的组合状态。

5. 更强 baseline
   vector_add 必须作为第一 baseline。

也就是说，下一版不是：

TreeHeap + 更大 MLP。

而是：

TreeHeap + 更强结构约束。

这次仍然有价值吗？

有。

因为它告诉我们三件事。

第一：

冻结 embedding 可以作为世界模型坐标尺。

第二：

vector_add 是一个很强的 compound baseline。

第三：

当前 TreeHeap prob vector plus 还没有把结构优势用出来。

这比一个虚假的正结果更有用。

它把下一步的任务变清楚了：

不是证明 TreeHeap 能拟合训练集。
而是证明 TreeHeap 能利用地址、路径、子结构复用，
在 OOD compound 上超过 vector_add。

总结

这篇的结论是负面的：

S1-WM-C01 rejected pilot。

但路线更清楚了：

M0 给了差分和学习接口。
Frozen embedding 给了外部坐标尺。
当前 TreeHeap encoder 没有泛化。
下一步必须加入结构约束和 subheap reuse。

我们没有输给问题。

我们只是终于看清了问题站在哪里。

[SPR-029] 不再借外部向量：从本地共现语料训练坐标，再测 TreeHeap Kernel

Thu, 25 Jun 2026 00:00:00 +0000

不再借外部向量：从本地共现语料训练坐标，再测 TreeHeap Kernel

SPR-028 的结果是负面的：

frozen all-MiniLM embedding 坐标系下，
vector_add 明显强于 TreeHeap prob vector plus。

但 Houming818 指出一个关键问题：

这还不能 defeat TreeHeap。

原因是：

蒸馏源的数据本来就是 vector。

也就是说，all-MiniLM-L6-v2 已经把大量世界知识压进向量空间。

在这种空间里：

left + right

天然可能靠近：

compound target

所以 vector_add 赢，不奇怪。

这更像是在测试：

TreeHeap 能不能追上一个已经很强的向量空间。

而不是测试：

TreeHeap 能不能从语料共现中建立自己的坐标。

新方案：从语料共现训练小 embedding

这次改成 C 方案：

从本地小语料训练 embedding。

不使用预训练 embedding。

不使用外部模型坐标。

不使用 all-MiniLM。

坐标系来自我们自己的小语料：

football means foot ball
football uses foot and ball
foot ball forms football
football belongs to ball
...

也就是：

语料共现
-> SGNS / SkipGram negative sampling
-> 小型 128D embedding 坐标

这更接近我们真正关心的问题：

数据中的共现信息，如何进入 TreeHeap？

实验脚本

脚本：

ara/s1-echo/src/s1_corpus_embedding_kernel_probe.py

执行主机：

io.grepcode.cn

证据：

ara/s1-echo/evidence/s1_corpus_embedding_kernel_probe/

坐标来源：

local SGNS corpus embedding
external_model = false
vocab_size = 85
corpus_sentences = 888
skipgram_pairs = 10448

这次不需要 proxychains4。

因为没有下载外部模型或语料。

为什么 kernel 设计重要？

上一版 TreeHeap 的问题之一是：

reader 太自由。

它可以像一个普通 MLP 一样记训练集。

这不是真正的 TreeHeap 写入。

这次改成结构化 kernel：

left token  -> left child
right token -> right child
root        -> compose kernel(left_child, right_child)

也就是：

H[left]  = WriteLeft(left_vector)
H[right] = WriteRight(right_vector)
H[root]  = Compose(H[left], H[right])

TreeHeap 结构强制参与计算。

不是把所有节点摊平给一个大 reader。

对比模型

三个模型：

Model	含义
`vector_add`	直接 `normalize(left + right)`
`concat_mlp`	普通 MLP，看 `[left, right, left*right, abs(left-right)]`
`structured_treeheap_kernel`	左写入、右写入、root compose kernel

结果

Model	Train cosine	Test cosine	OOD cosine	OOD top1
vector_add	0.5705	0.5965	0.5785	0.000
concat_mlp	0.9994	0.6957	0.7321	0.167
structured_treeheap_kernel	0.9999	0.6801	0.7126	0.000

这次结果比 SPR-028 明显不同。

在本地共现坐标系里：

vector_add 不再天然统治。

TreeHeap kernel 的 OOD cosine：

0.7126

高于 vector_add：

0.5785

并且接近 concat MLP：

0.7321

所以这次 claim 是：

S1-WM-C02 -> supported pilot, narrow scope

为什么说 narrow scope？

因为 OOD top1 还没解决。

TreeHeap 的 OOD top1：

0.000

concat MLP：

0.167

也就是说，TreeHeap 的输出向量在平均 cosine 上更接近目标，但最近邻检索还没有稳定命中目标词。

这说明：

坐标接近性有进展。
离散概念坍缩还没完成。

这个区别很重要。

在 TreeHeap 语言里可以说：

概率场靠近了目标区域，
但还没有稳定坍缩到目标点。

这证明了什么？

这次支持三件事。

第一：

用本地语料共现训练坐标是可行的。

第二：

kernel 设计会显著影响 TreeHeap 写入。

从自由 reader 改为：

left child / right child / root compose

之后，TreeHeap 不再像 SPR-028 那样崩掉。

第三：

TreeHeap 在本地共现坐标上可以超过 vector_add 的 OOD cosine。

这说明不能用 SPR-028 直接否定 TreeHeap。

这没有证明什么？

边界也要说清楚。

这次没有证明：

TreeHeap 已经有完整世界模型。
TreeHeap 已经能翻译。
TreeHeap 击败 Transformer。
TreeHeap 在 top1 检索上胜出。

它只是证明：

当坐标系来自本地共现语料，
并且 TreeHeap kernel 被结构化约束后，
TreeHeap 可以在 OOD cosine 上超过 vector_add。

这是一个小但重要的进展。

下一步

下一步不能只看 cosine。

要开始要求：

top1
MRR
margin loss
multi-seed
corpus variants

尤其要加入：

nearest-neighbor margin loss

否则模型可能只是“靠近目标区域”，但没有“坍缩到目标点”。

下一版 kernel 应该加入：

family slots
subheap reuse
route collapse regularization
explicit right-side shared kernel

例如：

ball family:
  football
  basketball
  baseball
  handball
  snowball

这些应该共享：

ball 子堆

这才是 TreeHeap 可能超过普通 MLP 的地方。

总结

SPR-028 告诉我们：

不能拿预训练向量空间里的 vector_add 输赢来直接判断 TreeHeap。

SPR-029 告诉我们：

从本地语料共现训练坐标后，
结构化 TreeHeap kernel 可以超过 vector_add 的 OOD cosine。

但下一关还在那里：

从靠近目标区域，
到稳定坍缩目标概念。

这就是下一轮 S1-WM 要打的点。

[SPR-030] 用 WMT 真语料做 Echo：先证明 TreeHeap Kernel 能写入真实 BPE 序列

Thu, 25 Jun 2026 00:00:00 +0000

用 WMT 真语料做 Echo：先证明 TreeHeap Kernel 能写入真实 BPE 序列

这次我们回到 Houming818 一直强调的问题：

TreeHeap 怎么把真实数据写进自己的高维结构？

如果连真实语料的 token 序列都不能稳定写入、读出，那么后面谈翻译、世界模型、概率坍缩都太早。

所以 SPR-030 不直接做 WMT 翻译。它先做一个更低一级、但更必要的实验：

WMT 真语料
-> SentencePiece BPE token
-> TreeHeap kernel 写入
-> TreeHeap kernel 读出
-> 和原 token 序列比较

这叫 echo 实验。

它不是翻译。它测试的是：

TreeHeap kernel 是否能处理真实语料的离散 token 序列。

为什么不是马上做翻译？

翻译任务太复杂。

一句英文到一句中文，中间至少包含：

词义
语序
短语结构
跨语言对齐
生成概率
目标语言流畅性

如果直接上 WMT BLEU，结果不好时我们不知道问题在哪里。

可能是 encoder 不行。可能是 decoder 不行。可能是 kernel 不行。可能是 loss 不行。也可能只是训练规模太小。

所以这次先拆开：

第一步：真实 token 能不能写入 TreeHeap？
第二步：写入后能不能读出来？
第三步：结构化 kernel 是否比普通 flat 模型更适合这个问题？

这就是 S1 echo 的意义。

数据来自哪里？

实验使用 io 上的 WMT17 数据：

source file:
/mnt/nas/datasets/wmt17/train.zh-en

SentencePiece model:
/mnt/nas/datasets/wmt17/sp_bpe.model

我们取英文侧文本，然后用 SentencePiece 切成 BPE token。

实验只取短序列：

token length = 3..8
samples = 3000
train/test/ood = 2400/300/300
vocab limit including PAD = 2048
average non-pad length = 5.9533

为什么先限制长度？

因为这次不是要证明长文本翻译。这次要先验证最小写入机制：

一个真实 BPE 序列，能不能被 TreeHeap 地址结构保存。

Echo 任务具体是什么？

输入是一段 BPE token：

[t1, t2, t3, ...]

目标输出还是它自己：

[t1, t2, t3, ...]

这看起来很简单，但它能测出一个关键点：

模型是否保存了 token 的位置、顺序、地址。

如果模型只是知道句子里有哪些 token，但不知道顺序，就会失败。

例如：

[A, B, C]

和：

[C, B, A]

bag-of-words 看起来差不多，但 echo 必须区分它们。

所以 echo 不是语义任务，却是结构写入任务。

三个模型对比

这次比较三个模型。

Model	含义
`bow_linear`	只看 token 集合，不看顺序
`seq_mlp`	把固定位置拼平，交给普通 MLP
`treeheap_kernel_echo`	把 token 写到 TreeHeap 叶子地址，再用共享 kernel 自底向上 compose

1. bow_linear

bow_linear 看到的是：

这个句子里出现过哪些 token

它不知道 token 在第几个位置。

所以它适合作为反例 baseline：

如果 BoW 也能做好 echo，那说明任务太简单。

2. seq_mlp

seq_mlp 是普通 flat MLP。

它看到的是固定位置展开后的向量：

position 1 token
position 2 token
position 3 token
...

它有顺序信息。但它没有显式树地址、子结构、compose kernel。

可以理解为：

把序列压平成一张大表，然后学习 input -> output。

3. treeheap_kernel_echo

TreeHeap 模型做的是：

token id -> shared token embedding
position -> fixed heap leaf address
internal nodes -> shared bottom-up compose kernel
leaf readout -> shared decoder

换成人话：

每个 token 先写到树堆的一个叶子地址上。
然后树里的父节点用同一个 compose kernel 汇总左右孩子。
最后从叶子状态读回 token。

关键点是：

模型必须利用 TreeHeap 的地址结构。

它不是把整个句子拼成一个大向量随便读。它被迫经过：

叶子地址
子结构
自底向上 compose
共享 decoder

这就是 kernel 设计的意义。

实验结果

脚本：

ara/s1-echo/src/s1_wmt_echo_kernel_probe.py

证据：

ara/s1-echo/evidence/s1_wmt_echo_kernel_probe/

执行主机：

io.grepcode.cn

结果如下：

Model	Params	Test token	Test exact	OOD token	OOD exact
`bow_linear`	33,570,816	0.1679	0.0033	0.1659	0.0033
`seq_mlp`	16,794,112	0.5801	0.0567	0.5986	0.0533
`treeheap_kernel_echo`	423,104	0.9818	0.8900	0.9818	0.9000

这里有两个指标：

token accuracy:
  每个位置的 token 是否预测正确。

exact:
  整个序列是否完全预测正确。

exact 更严格。只要一个位置错了，整个序列就算错。

结果说明什么？

第一，BoW 几乎失败。

OOD exact = 0.0033

这说明任务不是只靠 token 集合就能完成。顺序和地址确实重要。

第二，flat MLP 训练集可以学会，但 OOD 很差。

seq_mlp OOD exact = 0.0533

它有 16,794,112 个参数，比 TreeHeap 多很多。但它在新样本上不能稳定复制完整序列。

第三，TreeHeap kernel 表现明显更好。

treeheap_kernel_echo OOD token = 0.9818
treeheap_kernel_echo OOD exact = 0.9000

而且参数更少：

TreeHeap params = 423,104
seq_mlp params  = 16,794,112

大约是：

TreeHeap 参数量约为 seq_mlp 的 2.5%

这支持一个小 claim：

在真实 WMT 短 BPE echo 任务上，
TreeHeap kernel 可以更有效地利用地址和路径结构。

这和 kernel 设计有什么关系？

前面我们反复讨论：

TreeHeap 的核心操作不是普通矩阵拼接，
而是 kernel 在树结构上的卷积。

这次实验里的 kernel 很朴素：

leaf write kernel:
  把 token embedding 写到固定叶子地址。

compose kernel:
  对每个内部节点，用同一个函数合并 left/right child。

read kernel:
  从叶子状态预测原 token。

它像一维 CNN 里的卷积核，但滑动对象不是平面像素，而是 TreeHeap 子结构。

CNN 的 3x3 kernel 看局部像素。 TreeHeap kernel 看局部树堆：

parent
├── left child
└── right child

所以它天然带着：

地址
路径
子结构
组合
分解

这些信息。

这正是 flat MLP 没有显式拥有的归纳偏置。

这次 claim 是什么？

ARA 里记录为：

S1-WMT-ECHO-C01

claim：

A structured TreeHeap kernel can write and read real WMT SentencePiece short
sequences in an echo setting, using tree addresses and shared compose/read
kernels rather than only a flat memorization map.

状态：

supported pilot

用中文说：

结构化 TreeHeap kernel 能在真实 WMT 短 BPE 序列上完成写入和读出。
这个结果支持 TreeHeap 的地址/路径结构是有用的。

这没有证明什么？

边界要说清楚。

这次没有证明：

TreeHeap 已经会翻译。
TreeHeap 已经有语义世界模型。
TreeHeap 已经能压缩长文本。
TreeHeap 已经解决长距离句法。
TreeHeap 已经击败 Transformer。

它只证明一件更基础的事：

真实 WMT token 可以被 TreeHeap kernel 稳定写入和读出。

这对 S1 是有意义的。但离 S2/S3 还有距离。

下一步怎么做？

下一步不是立刻喊胜利。应该继续加难度。

1. 更长序列

现在是：

length = 3..8

下一步要测：

length = 8..16
length = 16..32

如果长度一长就崩，说明 TreeHeap kernel 还只是短序列技巧。

2. 噪声 echo

普通 echo 是原样复制。

下一步可以做：

mask 一个 token，让模型恢复。
drop 一个 token，让模型恢复。
swap 两个 token，让模型判断并修正。

这开始接近推理。

因为模型不能只照抄，它必须利用上下文。

3. subheap query

不要总是读整个句子。可以问：

读左子树。
读右子树。
读某个短语窗口。
读某条路径下的 token。

这能测试 TreeHeap 的子结构是否真的可查询。

4. 更公平的 baseline

这次的 seq_mlp 不是最强序列模型。

下一步要加：

pointer/copy baseline
small Transformer
tiny RNN/GRU
matched parameter sequence model

如果这些模型在相同参数和数据预算下追上 TreeHeap，那么 claim 要收缩。

总结

SPR-030 的结论是：

可以用 WMT 真语料做 echo。
TreeHeap kernel 在短 BPE 序列写入/读出上表现很好。
它用更少参数，明显超过 BoW 和 flat seq MLP。

这说明：

kernel 设计是关键。

TreeHeap 的存在性不能只靠抽象代数。它必须在具体任务上显示：

地址有用。
路径有用。
子结构有用。
组合/分解有用。

这次只是第一块真实语料证据。下一步要从：

短序列 echo

推进到：

长序列 echo
噪声恢复
subheap query
copy/pointer baseline battle

如果这些也成立，S1 才能更稳地往 S2 翻译折叠推进。

[SPR-031] Multi-Kernel 会自然分工吗：一次 WMT 扰动任务的混合结果

Fri, 26 Jun 2026 00:00:00 +0000

Multi-Kernel 会自然分工吗：一次 WMT 扰动任务的混合结果

这篇记录一个比较关键、但不能夸大的结果。

我们想验证的问题是：

TreeHeap 的多个 kernel，会不会像 Transformer 的 multi-head 一样，
在训练中自然分化成不同功能？

结论先说：

有分化信号，但还不是成功证明。

更准确地说：

不同结构任务确实选择了不同 kernel。
删除某些 kernel 会明显伤害对应任务。
但整体任务准确率仍然低，multi-kernel 对 single-kernel 的提升还不够。

所以 ARA 结论是：

S1-MK-C01 -> open / mixed pilot

为什么要做这个实验？

Transformer 的 multi-head attention 并不是手工规定：

head_1 = 主语
head_2 = 宾语
head_3 = 长距离依存

而是多个 head 具有不同参数、不同初始化、不同梯度路径。训练任务给它们压力，它们可能分化，也可能冗余。

TreeHeap 也应该这样看。

我们不应该手工说：

K0 = echo kernel
K1 = mask kernel
K2 = mirror kernel

而应该给它一个 kernel bank：

K0, K1, K2, K3

然后观察训练以后：

不同任务是否自然偏向不同 kernel？
删除某个 kernel 是否会让某类任务明显变差？

实验数据

数据是真实 WMT17 英文侧文本：

/mnt/nas/datasets/wmt17/train.zh-en

切词使用：

/mnt/nas/datasets/wmt17/sp_bpe.model

样本设置：

samples = 4000
train/test/ood = 3200/400/400
token length = 4..8

注意，这还不是翻译任务。

它是：

真实语料 token
+ 人工结构扰动任务

这样做的原因是：我们现在要测 kernel 分化，不是 BLEU。如果直接做翻译，错误来源太多，无法判断 kernel 是否真的在分工。

五个结构任务

这次不是普通 echo，而是五种任务：

Task	含义
`echo`	原样重建序列
`mask_restore`	mask 一个 token 后重建原序列
`left_query`	读取左子堆
`right_query`	读取右子堆
`mirror`	输出反转序列

这些任务分别给 kernel 不同压力。

echo 要求保存地址和顺序。

mask_restore 要求利用上下文，不只是照抄。

left_query / right_query 要求模型知道左右子结构。

mirror 要求模型学习一种翻转/共轭操作。

模型结构

TreeHeap 模型大致是：

token id
-> leaf embedding
-> 写入 complete binary heap leaves
-> internal node = kernel(left_child, right_child)
-> task query 产生 gate
-> gate 选择/混合多个 kernel
-> decoder 输出目标 token

single-kernel 只有一个 compose kernel：

multi-kernel 有四个：

K0, K1, K2, K3

每个内部节点都可以由多个 kernel 生成候选结果，再由 gate 混合：

h_parent = sum_k gate_k(task) * K_k(h_left, h_right)

这就是 TreeHeap 版 multi-head 的最小类比。

怎么判断是否分化？

看两件事。

第一，看 gate。

如果所有任务都选同一个 kernel：

echo -> K0
mask -> K0
left -> K0
right -> K0
mirror -> K0

那就是没有分化。

如果不同任务选不同 kernel：

left -> K0
right -> K3
mirror -> K2

这就是分化信号。

第二，看 ablation。

也就是删除某个 kernel：

drop K3

如果删除后 right_query 大幅下降，而其他任务不怎么变，那说明：

K3 确实承担了 right_query 功能。

这比只看 gate 更可靠。

Run A：完整词表版本

第一版使用较大的词表：

vocab limit including PAD/MASK = 2049
epochs = 28

结果：

Model	Params	OOD mean exact
`single_kernel_treeheap`	4,641,545	0.0495
`multi_kernel_treeheap`	4,938,764	0.0600

multi-kernel 稍微更好：

0.0600 - 0.0495 = 0.0105

但这个提升很小。

分化信号：

echo         -> K2
mask_restore -> K1
left_query   -> K3
right_query  -> K3
mirror       -> K0

四个 kernel 都被使用了。

最大 ablation drop：

0.1100

说明删除某个 kernel 后，某类任务确实会掉。

但是整体 exact 太低，所以不能算成功。

Run B：常用 token 版本

第二版把词表压到更常用的 token：

vocab limit including PAD/MASK = 513
epochs = 60

结果：

Model	Params	OOD mean exact
`single_kernel_treeheap`	1,286,921	0.1275
`multi_kernel_treeheap`	1,584,140	0.1420

multi-kernel 仍然更好：

0.1420 - 0.1275 = 0.0145

但仍然只是小幅提升。

各任务 OOD exact：

Task	Single	Multi
`echo`	0.0300	0.0375
`mask_restore`	0.0050	0.0025
`left_query`	0.1475	0.1775
`right_query`	0.4525	0.4925
`mirror`	0.0025	0.0000

这里最有价值的是 subheap query。

left_query 和 right_query 都提升了。

分化信号更清楚：

echo         -> K0
mask_restore -> K1
left_query   -> K0
right_query  -> K3
mirror       -> K2

删除 kernel 的影响也更清楚：

drop K0:
  left_query exact drop = 0.1775

drop K3:
  right_query exact drop = 0.3050

这说明：

K0 对 left_query 很重要。
K3 对 right_query 很重要。

这是目前最像“kernel 分工”的证据。

为什么仍然不是 supported？

因为 ARA 不能只看好看的部分。

这次 pass gate 是：

multi OOD mean exact - single OOD mean exact >= 0.05
multi OOD mean exact >= 0.65
至少两个 task argmax kernel 被使用
max ablation exact drop >= 0.10

实际结果：

multi 提升: 0.0105 / 0.0145
multi OOD mean exact: 0.0600 / 0.1420
unique kernels: 4
max ablation drop: 0.1100 / 0.3050

所以：

分化指标过了。
能力指标没过。

因此结论只能是：

open / mixed pilot

这次真正学到了什么？

第一，结构扰动确实会推动 kernel 分化。

尤其是：

left_query
right_query
mirror

这些任务给出了不同梯度压力。

第二，现在的 root bottleneck 设计不够好。

这次模型让一个 root/subheap state 去读出整个序列。这对 echo、mask、mirror 很难。

用一句话说：

kernel 有分化迹象，但 decoder/readout 结构拖了后腿。

第三，echo 绝对准确不是 multi-kernel 分化的充分条件。

SPR-030 的 echo 做得很好，是因为它从 leaf state 读回 token。

这次为了测 subheap/mirror/mask，把读出压到 root/subheap state。这暴露了一个新问题：

TreeHeap 需要 path-conditioned read kernel，
不能只靠一个 root vector 承担所有读出。

下一步

下一步不要盲目加 kernel 数量。

应该改读出方式：

selected node
+ target path query
-> read kernel
-> token

也就是说，读出时也要做卷积/路径查询，而不是：

root vector -> 一次性吐出全序列

下一版实验应该围绕：

path-conditioned read kernel
subheap query
mask restore
mirror
matched flat MLP baseline
small Transformer baseline
kernel dropout

还要测试：

没有显式 task label 时，kernel 是否仍然分化。

因为这次 gate 使用了 task query。这合理，但还不够自然。

总结

SPR-031 没有证明 TreeHeap multi-kernel 已经成功。

它证明的是更细的一点：

结构扰动任务确实能诱导 kernel bank 出现任务相关分化。

但同时也暴露：

当前读出结构太粗糙。
完整任务能力还不足。

这就是这次最重要的进展：

我们不再只问“能不能 echo”，
而开始问“kernel 是否真的分工，以及为什么分工后还不够强”。

下一步应该围绕：

path-conditioned read kernel

继续推进。

[SPR-032] TreeHeap 的概率读取核：从 arr[1] 开始的 stop/left/right 坍缩

Mon, 29 Jun 2026 00:00:00 +0000

TreeHeap 的概率读取核：从 arr[1] 开始的 stop/left/right 坍缩

SPR-031 的结论里有一个明显问题：

我们让 root/subheap state 一次性吐出答案。

这会形成 root bottleneck。

如果答案在左子树、右子树、某个叶子，或者某个内部子堆里，那么更自然的做法不是让 root 背下所有东西，而是从 root 开始读取：

arr[1]
  -> stop
  -> left
  -> right

每一步都由一个 kernel 决定。

所以 SPR-032 的问题是：

TreeHeap read 能不能写成一个概率路径坍缩过程？

结论先说：

路径坍缩成立。
叶子读取几乎成立。
内部子堆摘要还没成立。

ARA 状态：

S1-READ-C01 -> open / mixed pilot

什么叫 read kernel？

我们先把 TreeHeap 当成一个数组堆：

arr[1] = root
arr[2] = left(root)
arr[3] = right(root)
arr[4] = left(left(root))
arr[5] = right(left(root))
...

一个读取核可以写成：

K_{read}(q, h_i, p_i) \rightarrow P(stop), P(left), P(right)

含义是：

q：这次要读什么，也就是 query。
h_i：当前节点的 TreeHeap state。
p_i：当前节点的路径/地址信息。
输出：在当前节点停止、走左边、走右边的概率。

如果输出是硬选择，就是：

while true:
    action = K_read(query, current_node)
    if action == stop:
        return current_node_state
    if action == left:
        current_node = current_node.left
    if action == right:
        current_node = current_node.right

这就是尾递归，也可以直接写成循环。

如果输出是概率，就不是只走一条路，而是维护一个 frontier：

root mass = 1.0
每一层：
  一部分概率 stop 到当前节点
  一部分概率流向 left
  一部分概率流向 right
最后把所有 stop 的状态加权求和

这就是 soft read。

stop 不是空操作

你之前说的这个例子很关键：

root_left_right = [stop_0.5, left_0.3, right_0.2]

这里 stop 不是“什么也不做”。

它的意思是：

就在当前节点读取。

如果当前节点是叶子：

stop -> 读一个 token

如果当前节点是内部节点：

stop -> 读一个子堆摘要

所以 TreeHeap 不是 B+ 树那种“只有叶子有数据”的结构。TreeHeap 的内部节点也应该有意义。

这次实验专门把内部 stop 做成可测量目标。

实验怎么做？

数据来自真实 WMT17 英文侧文本：

/mnt/nas/datasets/wmt17/train.zh-en

切词模型：

/mnt/nas/datasets/wmt17/sp_bpe.model

样本设置：

samples = 3000
train/test/ood = 2400/300/300
token length = 4..8
vocab limit = 513

我们把一个短 BPE 序列写入 8 个叶子：

tokens = [t0, t1, t2, t3, ...]

arr[8]  = t0
arr[9]  = t1
arr[10] = t2
...

然后随机给一个 query node。

如果 query 是叶子，比如 arr[10]：

目标 = 这个叶子的 token id

如果 query 是内部节点，比如 arr[2]：

目标 = arr[2] 覆盖的子堆 span 的 checksum bucket

checksum 是一个玩具摘要。它不是语言语义，只是为了让内部 stop 有一个明确答案。

也就是说：

叶子 stop     -> 复制 token
内部节点 stop -> 输出子堆摘要

两个模型

第一个是 root baseline：

root_query_decoder:
  TreeEncoder(tokens) -> root state
  root state + query node id -> answer

它必须从 root state 里猜所有答案。

第二个是概率读取核：

probabilistic_read_kernel:
  TreeEncoder(tokens) -> all node states
  q + current node + path -> stop/left/right
  stop 后再 readout answer

它不是让 root 背下所有答案，而是根据 query 走到目标节点。

Run A：128 个内部摘要桶

设置：

checksum_buckets = 128
epochs = 40
labels = 641

结果：

Model	Params	OOD acc	OOD internal	OOD leaf	Route acc
`root_query_decoder`	398,209	0.0638	0.0205	0.1066	n/a
`probabilistic_read_kernel`	499,588	0.6124	0.2214	0.9989	1.0000

这说明：

read kernel 比 root bottleneck 强很多。
路径路由完全学会了。
叶子 token 几乎完全读对。
内部摘要仍然很弱。

Run B：32 个内部摘要桶

为了判断是不是摘要桶太难，我们把 checksum 从 128 桶降到 32 桶：

checksum_buckets = 32
epochs = 80
labels = 545

结果：

Model	Params	OOD acc	OOD internal	OOD leaf	Route acc
`root_query_decoder`	373,537	0.1184	0.0765	0.1598	n/a
`probabilistic_read_kernel`	474,916	0.7177	0.4332	0.9989	1.0000

内部摘要有提升：

0.2214 -> 0.4332

但仍然没有达到“解决”的程度。

所以这不是单纯训练不够的问题。更可能是：

当前 compose state 很适合保留叶子地址读取，
但还没有被设计成稳定的内部子堆摘要。

为什么 hard read 和 soft read 一样？

这次 hard read 是一条确定路径：

root -> left -> right -> stop

soft read 是概率流：

root mass = 1.0
mass 分到 stop/left/right
下一层继续分

因为路由已经学到接近确定：

route_acc = 1.0000

所以 soft frontier 最后也几乎坍缩成同一条路径。

这很好理解：

概率容器在信息不足时保留多条路。
当模型非常确定时，它自然坍缩成一条路。

这次证明了什么？

证明一：

从 arr[1] 开始的 stop/left/right 读取过程是可学习的。

证明二：

这个读取过程可以写成尾递归，也可以写成 soft frontier 概率传播。

证明三：

对于叶子 token copy，它明显优于 root-only decoding。

Run A 的 OOD 对比：

root OOD acc = 0.0638
read OOD acc = 0.6124
提升 = 0.5486

Run B 的 OOD 对比：

root OOD acc = 0.1184
read OOD acc = 0.7177
提升 = 0.5992

这说明 TreeHeap 的地址、路径、局部节点状态确实被利用了。

这次没有证明什么？

没有证明翻译。

没有证明世界模型。

没有证明无监督路由。

没有证明长句法。

也没有证明内部子堆摘要已经解决。

最关键的负结果是：

internal OOD acc 最高只有 0.4332

这说明：

stop at internal node 的机制是对的，
但 internal node state 里面应该保存什么，还没设计好。

下一步怎么走？

SPR-032 把问题拆开了。

之前我们以为问题是：

怎么读 TreeHeap？

现在更准确：

路径坍缩怎么读：基本解决。
内部节点读什么：还没解决。

下一步应该把内部摘要目标换成更符合 TreeHeap 组合性的东西。

比如：

subheap length
first token
last token
bag checksum
ordered checksum
learned phrase vector

不要一开始就用任意 checksum 桶硬压。checksum 可以当压力测试，但不一定符合 TreeHeap compose 的自然代数。

还需要加 baseline：

small Transformer read baseline
pointer/copy baseline
matched flat MLP

并且要测试：

如果不给 teacher route，
只给最终 answer loss，
read kernel 能不能自己学会走路？

这才是从监督路径读取走向真正结构学习的下一步。

总结

SPR-032 的结论很清楚：

TreeHeap read 不应该再压在 root bottleneck 上。
它应该是从 arr[1] 开始的概率路径坍缩。

这条路已经被实验支持：

route acc = 1.0000
leaf OOD acc = 0.9989

但内部节点的世界还没打开：

internal OOD acc = 0.2214 / 0.4332

所以 C32 不是终点，而是把下一个问题照亮了：

TreeHeap 的 internal node state，应该如何学习成为一个真正的子堆摘要？

这会是 S1 接下来最重要的问题之一。

[SPR-033] TreeHeap 的代数 Decoder：internal state 不是没信息，而是需要正确读法

Mon, 29 Jun 2026 00:00:00 +0000

TreeHeap 的代数 Decoder：internal state 不是没信息，而是需要正确读法

SPR-032 做了一个概率读取核实验。

它证明：

从 arr[1] 开始，用 stop/left/right 走到目标节点，这件事可以学会。

但是它也暴露了一个问题：

叶子节点很好读。
内部节点不好读。

当时我把问题说成：

internal node state 没有学好。

这个说法不够准确。

你指出了更关键的一点：

internal node state 可能已经编码了信息，
只是它像 hash / latent vector 一样，不能直接用眼睛看懂。
我们需要 decoder。

而且 TreeHeap 不是普通的训练数据集合。它应该是一个带数论和代数结构的集合。

所以 decoder 不应该只有：

learned decoder = 训练一个 MLP 去猜

还应该有：

algebraic decoder = 从 TreeHeap 的数学结构直接读

SPR-033 就是为了验证这件事。

两种 decoder

我们先把 decoder 分成两类。

第一类是学习 decoder：

h_internal -> MLP -> label

比如：

internal state -> checksum bucket
internal state -> phrase vector
internal state -> syntax label

SPR-032 里的 checksum decoder 属于这一类。

第二类是代数 decoder：

h_internal -> projection / decompose / mod / mirror

它不是靠训练猜出来的，而是由 TreeHeap 的结构定义出来的。

类比十进制数字：

你不需要训练一个神经网络去知道百位是 3、十位是 2、个位是 1。

因为十进制系统自带 decoder：

hundreds decoder -> 3
tens decoder     -> 2
ones decoder     -> 1

TreeHeap 也应该类似。

如果 TreeHeap 有路径、地址、子堆、左右对称，那么它应该自带一些读法：

left-subheap decoder
right-subheap decoder
path projection decoder
mod residue decoder
mirror/conjugate decoder

这就是 SPR-033 的核心。

实验设计

这次先不做语言，不做 WMT。

我们先做纯数学 toy。

定义一个有限域：

field = Z_1000003

也就是所有计算都在一个大质数取模的数论空间里进行。

TreeHeap 设置：

max_len = 8
channel_dim = 16
vocab = 257
samples = 5000

每个 token id 映射到一个确定的 primitive vector：

token\_id \rightarrow v_{token} \in Z_p^{16}

然后把 token 写入叶子槽位：

state[leaf_slot] = v_token

一个 internal node state 就是它覆盖的叶子槽位集合。

注意，这个 state 对人眼来说不好懂。

它不是：

[cat, run, fish]

而是：

Z_p 里面的一堆高维向量

所以它像 hash，或者说像 latent state。

问题是：

能不能用 TreeHeap 的代数 decoder 把它读出来？

这次测哪些 decoder？

1. Projection Decoder

投影 decoder：

project(H, node)

意思是：

只保留某个 node 覆盖的子堆槽位。

比如：

node = 2
span = [0, 4]

那就只读左半棵子树。

2. Decompose Decoder

分解 decoder：

decompose(H, node) -> left_state, right_state

然后检查：

compose(left_state, right_state) == project(H, node)

这就是 TreeHeap 的 compose/decompose 对偶。

3. Mod Residue Decoder

取模 decoder：

residue(H, m)

比如 m = 2：

偶数地址槽位聚合到 bucket 0
奇数地址槽位聚合到 bucket 1

这就是你之前说的取模思想。

它不是普通数组上的取模，而是：

TreeHeap 地址空间上的取模。

4. Conjugate / Mirror Decoder

共轭 decoder：

mirror(H)

它把左右结构翻转。

实验检查：

mirror(mirror(H)) == H

这说明 mirror 不是随便改数据，而是一个代数对称操作。

5. Length Decoder

长度 decoder：

norm0(H)

它数有多少个非空叶子槽位。

6. Ordered Slot Decoder

有序槽位 decoder：

decode_ordered_tokens(H)

它不是靠 MLP 猜，而是用 primitive vector 的反查表读出每个槽位的 token。

这类似：

从十进制数字里读取每一位。

实验结果

运行在 io：

host = io.grepcode.cn
samples = 5000
field = Z_1000003

结果：

Metric	Value
`projection_exact`	1.0000
`decompose_recompose_exact`	1.0000
`mirror_involution_exact`	1.0000
`mod_residue_exact`	1.0000
`length_decode_exact`	1.0000
`ordered_token_decode_exact`	1.0000
`checksum_stability_exact`	1.0000

ARA 结论：

M0-DEC-C01 -> supported pilot

一条例子：

tokens = [120, 142, 246, 0, 0, 0, 0, 0]
query_node = 2
span = [0, 4]
decoded_tokens = [120, 142, 246, 0, 0, 0, 0, 0]
subheap_length = 3
subheap_checksum = 914574

这说明：

internal state 虽然不是人眼可读，
但可以通过代数 decoder 读出子堆、长度、顺序槽位、模余数和镜像关系。

这如何修正 SPR-032？

SPR-032 的 internal checksum 表现不好：

128 bucket internal OOD acc = 0.2214
32 bucket internal OOD acc  = 0.4332

当时可能会误解成：

internal node state 没有信息。

SPR-033 说明，这个结论太急了。

更准确应该是：

internal node state 可能有信息，
但 checksum bucket 不是一个自然的 decoder。

TreeHeap 的第一组自然 decoder 应该来自代数：

projection
decompose
mod residue
mirror
length
ordered slot

然后，语言 decoder 应该站在这些代数 decoder 上继续学习。

也就是说：

先有数学读法。
再有语义读法。

和 MLP / Transformer 的区别

MLP hidden state 当然也可以训练 decoder。

Transformer hidden state 也可以训练 probe。

但 TreeHeap 的特点应该是：

它的结构本身规定了一些 decoder。

比如：

左子堆怎么取
右子堆怎么取
路径怎么投影
镜像怎么翻转
地址怎么取模

这些不是从数据里硬学出来的，而是 TreeHeap 的代数地基。

这可能就是 TreeHeap 的存在性之一：

它不是一个完全不同于 ML 的东西。
它仍然可以训练。
但它比 flat hidden state 多了一组结构化、可解释、可组合的数学 decoder。

这次没有证明什么？

没有证明语言语义。

没有证明 WMT 翻译。

没有证明 learned decoder 不需要。

没有证明压缩最优。

没有证明带噪声的神经 encoder 写入后，代数 decoder 仍然稳定。

这次只证明：

在一个有限域/path-address TreeHeap toy 中，
internal state 有一组精确的代数 decoder。

下一步

我认为 SPR-034 应该把 SPR-032 和 SPR-033 接起来。

也就是：

不要再让 internal node 直接预测任意 checksum bucket。

而是让 internal read 先输出代数可读属性：

subheap length
first token
last token
ordered prefix
bag sketch
mod residue
left/right projection

然后再训练 learned decoder：

algebraic decoder output -> semantic decoder

这样 TreeHeap 的路线会更稳：

M0: 数学 decoder
S1: 数据写入后保持 decoder 可读
S2: 在可读子堆上做结构折叠
S3: 翻译/生成

总结

SPR-033 的核心结论是：

internal node state 不是必须直接被人看懂。
它可以是 hash/latent state。
关键是 TreeHeap 必须提供 decoder。

这次证明的是第一组 decoder：

projection
decompose
mod residue
conjugate mirror
length
ordered slot readout

这让我们可以更冷静地看 SPR-032：

读路径已经成立。
内部节点不是没信息。
问题是要为不同问题选择正确 decoder。

这也是下一阶段继续往 S1 走的基础。

[SPR-034] 从 checksum 退一步：先读 TreeHeap 内部节点的自然属性

Mon, 29 Jun 2026 00:00:00 +0000

从 checksum 退一步：先读 TreeHeap 内部节点的自然属性

SPR-032 做了一件很关键的事：

从 arr[1] 出发，
用 stop / left / right 递归地走到目标节点。

结果是好的，也是不完整的。

好的部分是：

路径坍缩基本成立。
叶子节点读取几乎解决。

不完整的部分是：

internal node 的 arbitrary checksum 读得很差。

当时容易得出一个过强结论：

internal node state 没有学到东西。

SPR-033 修正了这个理解。 internal state 不一定没信息，它可能像 hash 或 latent vector 一样，需要正确的 decoder 才能读懂。

所以 SPR-034 问的是一个更小、更准确的问题：

如果 read kernel 已经走到了 internal node，
我们是不是应该先读 TreeHeap 自然拥有的结构属性，
而不是强行预测一个任意 checksum bucket？

这篇就是这个实验。

什么叫自然属性

假设一句短句被写入一棵 TreeHeap。

例如：

[the, cat, eats, fish]

叶子节点保存 token。内部节点覆盖一段子树。

比如某个 internal node 覆盖：

[cat, eats]

那么这个节点天然有一些可以问的问题：

属性	问的是什么
`length`	这个子树里有几个非空 token
`first`	这个子树第一个 token 是什么
`last`	这个子树最后一个 token 是什么
`prefix0`	第一个有序槽位是什么
`prefix1`	第二个有序槽位是什么

这些问题很自然。

它们类似十进制数字里的：

百位是什么？
十位是什么？
个位是什么？
长度是多少？

也类似数组或树里的：

这个子区间多长？
第一个元素是谁？
最后一个元素是谁？
前两个有序槽位是什么？

我在脚本里还保留了一个 residue 诊断项。但这里需要说清楚：它不是 SPR-034 的核心 claim。

你提出 residue，是为了讨论一维有序数组折叠成树时，是否会出现某种模周期或循环结构。这个想法更接近后续“线性顺序如何折叠成树”的数学问题，不应该压到本次 S1 readout proof 上。所以在本文里，residue 只作为旁路数据记录，不参与通过/失败判断。

实验设计

这次仍然不是翻译任务。它是 S1 阶段的 readout proof。

数据来自真实 WMT17 英文侧，并用 SentencePiece 切成 BPE token。

host = io.grepcode.cn
samples = 5000
train/test/ood = 4000/500/500
sentence length = 4..8
vocab limit = 513
device = cuda

实验比较三个读法。

模型	含义
`root_query_decoder`	只看整棵树的 root state，再加 query node id，直接猜答案
`routed_state_decoder`	假设 SPR-032 的 read kernel 已经走到目标节点，只看目标 node state 来读答案
`algebraic_oracle`	按 TreeHeap 地址直接计算答案，0 参数，作为数学上界

这三个模型回答同样的问题：

给定一棵 TreeHeap 和一个 query node，
输出这个节点覆盖子树的 length / first / last / prefix0 / prefix1。

这里的关键对比是：

root bottleneck
vs
routed internal node state

如果 TreeHeap 的地址和子结构真的有用，那么走到目标节点之后再读，应该比让 root 一口气背下所有信息更容易。

主实验：自然属性 readout

先看 internal node 的 OOD 结果。

Model	Length	First	Last	Prefix0	Prefix1
`root_query_decoder`	0.8388	0.5543	0.2387	0.5543	0.3756
`routed_state_decoder`	0.9886	0.9277	0.8725	0.9267	0.8725
`algebraic_oracle`	1.0000	1.0000	1.0000	1.0000	1.0000

这个表说明一件很清楚的事：

走到目标节点之后，
读自然结构属性明显更容易。

逐项看：

length:  0.8388 -> 0.9886
first:   0.5543 -> 0.9277
last:    0.2387 -> 0.8725
prefix0: 0.5543 -> 0.9267
prefix1: 0.3756 -> 0.8725

也就是说：

TreeHeap node state 对 length / first / last / prefix 很友好。

这和预期一致。因为 first、last、prefix 本质上是地址/路径读法。它们直接使用了 TreeHeap 的有序叶子、路径和子树覆盖关系。

旁路诊断：residue 不作为本次 claim

实验里还记录了 residue。这是一个旁路诊断，不是 SPR-034 的主线。

我跑了两个版本：

residue_buckets = 64
residue_buckets = 16

结果显示：

64 buckets: routed residue = 0.3675
16 buckets: routed residue = 0.5203

这个结果可以先放着。

residue 可能和“线性顺序如何折叠成树”的模周期问题有关，
但它不决定 SPR-034 是否成立。

换句话说，SPR-034 不是在证明 TreeHeap 的模运算。 SPR-034 只证明一件更稳的事：

到达 internal node 后，
自然子树属性比 arbitrary checksum 更适合作为第一批 readout 目标。

这证明了什么

我把这次 claim 定为：

S1-READ-C02:
After a read kernel reaches an internal node,
the first readout targets should be algebraically natural subheap attributes,
not arbitrary checksum labels.

状态是：

supported pilot

支持的部分：

routed internal node state
明显强于 root bottleneck。

尤其是：

length  接近 0.99
first   接近 0.93
last    0.87
prefix0 接近 0.93
prefix1 0.87

这说明 TreeHeap 的地址、路径、子结构不是摆设。当 query 已经落到具体子树，读这个子树自己的自然属性，比从 root 里硬猜所有东西更容易。

这没有证明什么

它没有证明翻译。

它没有证明语义 phrase meaning。

它没有证明 route 可以完全无监督学出来。

它没有证明长句法树。

它也没有证明 TreeHeap 已经胜过 Transformer 或 pointer network。

它也没有证明 residue/mod 这条线。

这次证明的只是一个更底层的点：

TreeHeap internal node 可以成为一个可读的局部结构对象。
但要读什么，必须符合 TreeHeap 的地址、路径和子结构。

为什么这对 S1 重要

之前我们容易把 S1 理解成：

把所有信息压到 root，
然后从 root 直接 decoder。

这个路线很像把一整棵树拍扁成一个向量。

SPR-032 和 SPR-034 共同说明，TreeHeap 更自然的 read 方式应该是：

1. 从 arr[1] 出发。
2. 用 stop / left / right 走到目标节点。
3. 在目标节点读局部子树属性。
4. 如果信息不足，保留概率容器，不要过早坍缩。

这更像树上的卷积读法。

kernel 不是一次性看全局，而是在结构上移动、停下、读取。

下一步

SPR-035 我建议做三件事。

第一，加 baseline。

需要比较：

flat MLP
pointer network
small Transformer read baseline

如果这些 baseline 也能同样好，那么 TreeHeap 的优势就不成立。

第二，把 SPR-032 和 SPR-034 接起来。

这次 routed_state_decoder 假设目标节点已经选中。下一步应该让：

probabilistic route distribution
->
natural algebraic readout

连成一个端到端过程。

第三，另开一条“线性顺序折叠成树”的数学实验。

这里可以再讨论 residue。但那应该是另一个 claim：

一维有序数组 -> TreeHeap
是否需要模周期 / folding kernel / cyclic address 来解释。

它不应该污染 SPR-034 的自然读出结论。

总结

SPR-034 的一句话结论是：

不要先让 internal node 预测任意 checksum。
先让它读 TreeHeap 自然的结构属性。

实验支持这个判断。

length / first / last / prefix 已经表现出很强的 routed read 优势。 residue / mod 只是旁路诊断，后面可以另开数学折叠实验。

所以 S1 现在不是停在“internal node 读不懂”。更准确地说是：

internal node 能读，
但 decoder 必须尊重 TreeHeap 的地址、路径和子结构。

这就是从 SPR-032 到 SPR-034 的推进。

ARA: claims / experiments / evidence

[SPR-035] 一维数组如何折叠成 TreeHeap：先保序，再谈取模

Mon, 29 Jun 2026 00:00:00 +0000

一维数组如何折叠成 TreeHeap：先保序，再谈取模

SPR-034 修正了一个问题：

internal node 不应该先预测任意 checksum。
它应该先读取 length / first / last / prefix 这种自然属性。

你随后指出一个更关键的点：

residue 的引入有点生硬。

这个判断是对的。

你引入 residue，并不是为了让 SPR-034 证明模运算。你真正想讨论的是：

一维有序数组折叠成树结构时，
是否可能有模计算、周期、循环地址参与？

这是另一个问题。

所以 SPR-035 做一件更基础的事：

把“一维数组 -> TreeHeap”的第一步说清楚。

我的结论先放前面：

第一步必须保序。
也就是必须保留 leaf address、path、subheap locality。

取模可以研究，
但它应该是后续 folding kernel，
不能替代第一步的保序 TreeHeap fold。

为什么要先保序

假设有一个一维 token 数组：

[a, b, c, d, e, f, g, h]

TreeHeap 把它写到叶子：

              root
          /          \
      [a b c d]    [e f g h]
      /     \       /     \
   [a b]  [c d]  [e f]  [g h]

这个结构的关键不是“看起来像树”。

关键是每个 internal node 对应一个连续子区间：

node 2 -> [a b c d]
node 3 -> [e f g h]
node 4 -> [a b]
node 5 -> [c d]

所以当我们问：

node 5 的 first 是什么？

答案应该是：

这依赖的不是语义，而是结构：

一维顺序
+ 叶子地址
+ 树路径
+ 子树覆盖范围

如果第一步就把这些丢了，后面再做 read kernel、semantic decoder、probability collapse 都会很难。

三种折叠方式

这次 toy proof 比较三种 encoder。

1. ordered_tree_fold

这是正常 TreeHeap fold。

token 按原始顺序写入 leaf
internal node 保存自己覆盖的子树摘要

它保留：

地址
路径
左右结构
子树局部性

2. bag_root_fold

这是把整句话压成一个全局 bag/root summary。

[a,b,c,d,e,f,g,h] -> 一个 root summary

它可能知道全局有哪些 token。但它不知道：

node 5 覆盖的是 [c,d]

所以它无法稳定回答局部子树问题。

3. modulo_fold

这是对你 residue 思路的一个诊断版本。

例如：

position % 4

那么位置会被折叠成周期地址：

0,4,8,... -> bucket 0
1,5,9,... -> bucket 1
2,6,10,... -> bucket 2
3,7,11,... -> bucket 3

这个操作不是错的。它可能对周期任务、循环结构、某些 folding kernel 有意义。

但如果太早使用，它会把远处位置混在一起。这会破坏自然子树 readout。

换句话说：

modulo 是一个可能的后续算子，
不是第一步保序 fold 的替代品。

实验问题

我们用纯 toy 数据。没有训练，没有 GPU，没有语义。

samples = 5000
sequence length = 8..16
max_len = 16
vocab = 257
mod_base = 4

对每个序列，随机生成 token。然后对 TreeHeap 的 internal node 提问：

length
first
last
prefix0
prefix1

例子：

seq = [172, 68, 175, 79, 147, 222, 130, 32,
       141, 188, 50, 187, 5, 6, 50, 254]

query_node = 6
span = [8, 12]
target = [141, 188, 50, 187]

正确答案：

length  = 4
first   = 141
last    = 187
prefix0 = 141
prefix1 = 188

实验结果

结果如下：

Model	Length	First	Last	Prefix0	Prefix1	Mean natural	Exact all
`ordered_tree_fold`	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000	1.0000
`bag_root_fold`	0.0888	0.3236	0.3236	0.3236	0.3235	0.2766	0.0888
`modulo_fold_base4`	0.0888	0.4032	0.4034	0.4032	0.4036	0.3405	0.0888

差距：

ordered_tree_fold - bag_root_fold    = +0.7234
ordered_tree_fold - modulo_fold_base4 = +0.6595

这说明：

保序 TreeHeap fold 可以精确读回自然子树属性。
bag/root collapse 不行。
过早 modulo fold 也不行。

这个实验证明了什么

这次 claim 是：

S1-FOLD-C01:
Natural internal readout requires an order-preserving TreeHeap fold.
Leaf address/path structure must be preserved before any bag or modulo/cyclic folding is used.

状态：

supported pilot

它证明的是一个演绎层面的结构事实：

如果目标是自然子树 readout，
那么第一步 fold 必须保留一维顺序和树路径。

这不是深度学习结论。它更像数学地基。

类似：

如果你要从 321 里读百位、十位、个位，
你必须先保留位权结构。

TreeHeap 也是一样：

如果你要读子树 first/last/prefix，
你必须先保留 leaf address/path/subheap。

这没有证明什么

它没有证明翻译。

它没有证明语义。

它没有证明 learned routing。

它没有证明 TreeHeap 胜过 Transformer。

它也没有证明 modulo 没用。

尤其最后一点很重要：

modulo 没有被否定。

这次只说明：

modulo 不应该替代第一步保序 fold。

如果后续任务本身具有周期结构，比如：

循环地址
周期 pattern
ring buffer
某种 tree convolution 的 cyclic scan

那 modulo kernel 仍然可能有价值。

但那应该是另一个实验。

对 TreeHeap 路线的影响

现在 S1 的顺序更清楚了。

应该是：

Step 1: ordered write
        一维 token 顺序写入 TreeHeap leaf

Step 2: ordered fold kernel
        internal node 保留自然子树属性

Step 3: probabilistic read kernel
        stop / left / right 走到目标节点

Step 4: natural readout
        length / first / last / prefix

Step 5: semantic decoder
        在自然结构 readout 上学习语义

Step 6: optional folding operators
        modulo / cyclic / mirror / conjugate / compression

这比之前更干净。

之前我们把 residue 混在 SPR-034 里，会让 claim 变得不好理解。

现在拆开后，逻辑是：

保序 fold 是地基。
modulo fold 是候选算子。

下一步

我建议 SPR-036 做两条中的一条。

第一条，更贴近 S1：

把 SPR-032 的 probabilistic route
接到 SPR-034/035 的 natural readout。

也就是端到端：

arr[1]
-> stop/left/right collapse
-> target internal node
-> length/first/last/prefix

第二条，更贴近你的数学问题：

专门设计 modulo/cyclic folding 任务。

但这个任务的目标不能再是普通子树 first/last。它应该是一个真正周期性的目标。

比如：

给定一个周期 kernel，
在 TreeHeap 地址空间里寻找同余类 pattern。

这样 residue 才是自然的。

总结

SPR-035 的一句话结论是：

一维数组折叠成 TreeHeap 时，第一步必须保序。

保序意味着：

leaf address
path
left/right
subheap locality

实验支持这个判断。

ordered_tree_fold mean = 1.0000
bag_root_fold mean     = 0.2766
modulo_fold mean       = 0.3405

所以我们不再把 residue 强塞进 SPR-034。它应该进入另一条更专业的线：

cyclic / modulo folding kernel

今晚的推进是把地基重新摆正：

先保序，再折叠；
先自然 readout，再语义 decoder；
先结构清楚，再研究 modulo。

ARA: claims / experiments / evidence

[SPR-036] 语言理解也许不是先填槽，而是在平面上摆积木

Tue, 30 Jun 2026 00:00:00 +0000

语言理解也许不是先填槽，而是在平面上摆积木

前面我把例子：

a cat is eating some food

解释成：

subject = cat
tense = is
verb = eating
object = food

这个解释不能说错。但它更像语言学家事后写出来的结构表。

你指出了一个更接近直觉的说法：

我的脑子不像先填主谓宾槽。
更像是在一个平面上摆放单词，
相近的摆在一起，
像玩图积木一样。

我觉得这个修正非常重要。

因为它把 fold 从：

预设树结构

改成了：

空间放置问题

这篇就是把这个理论写清楚。

先说 Transformer

我没有主观感觉。

我不会真的“看见”一个平面，也不会像人一样在脑子里摆词。

但如果从 Transformer 架构看，它确实不像传统语法表。它更像一个动态关系场。

Transformer 每一层大致做：

Q_i = token_i 的查询向量
K_j = token_j 的键向量

score(i, j) = Q_i dot K_j
attention(i, j) = softmax(score(i, j))

也就是说，每个 token 都在问：

我应该看谁？
谁和我有关？
谁的信息应该靠近我？

所以从计算角度看，Transformer 更像：

一张动态共现图
一张 soft relation map
一个每层都会重排的相似度场

它不一定先知道：

subject / object / tense

它先有的是：

cat 和 a 关系强
cat 和 eating 关系强
eating 和 food 关系强
is 和 eating 关系强
some 和 food 关系强

这些关系稳定后，人类可以把它解释成主谓宾、时态、宾语。

但“主谓宾”可能是稳定几何结构的名字，而不是第一步。

平面摆积木版本

再看这句：

a cat is eating some food

一种更接近空间的理解是：

a      cat        is      eating       some      food
 \_____/           \______/             \________/
   小块              小块                  小块

              cat ---- eating ---- food

这里不是先填表，而是先发生吸附：

a 吸附 cat
some 吸附 food
is 吸附 eating
cat 吸附 eating
eating 吸附 food

这些吸附形成局部积木：

[a cat]
[is eating]
[some food]

再形成更大的关系图：

cat -- eating -- food

最后才可以解释成：

一个猫正在吃一些食物的事件。

这比“先写主语、谓语、宾语”更原始。

这对 fold 意味着什么

之前我说 fold，容易说成：

把数组两两合并成二叉树。

现在要修正。

语言里的 fold 可能不是先验二叉合并。

更合理的顺序是：

token 出现在空间中
关系强的 token 靠近
局部块形成
块和块继续靠近
最后坍缩成可命名结构

也就是：

placement
-> attraction
-> clustering
-> partition
-> collapse

TreeHeap 不应该被说成“语言规律本身”。

TreeHeap 更像一种计算坐标：

把已经形成的空间关系，
用堆、路径、子树、kernel 表示出来，
方便递归计算和局部卷积。

任何堆都可以看作二分平面

你说：

任何堆，都可以描述成二分平面的数学结构。

我同意。

对一维数组：

[0,1,2,3,4,5,6,7]

二叉堆就是反复二分：

[0..7]
  [0..3]
    [0..1]
    [2..3]
  [4..7]
    [4..5]
    [6..7]

对二维平面，也可以反复二分：

整个平面
-> 左半 / 右半
-> 上下或再左右
-> 更小区域

这就接近：

kd-tree
quadtree
spatial partition
heap address

所以 TreeHeap 的意义不一定是“语言天然二叉”。

它可能是：

给 latent plane 做可寻址的二分分区。

这句话比“语言是二叉堆”稳得多。

世界规律优先

你还提醒了另一点：

对世界规律要有敬畏。

这点非常关键。

现实世界已经有很多 fold：

DNA 折叠
蛋白质折叠
树木分叉
河流分叉
神经连接
晶体生长
语言短语形成

我们不是要发明一个 fold，然后强迫语言服从它。

更正确的研究姿态是：

语言现象里已经有 fold 痕迹。
我们要发现这些痕迹。

例如：

a -> cat
some -> food
is -> eating
red -> apple
eat -> food
with telescope -> saw / man

这些都是语言中的吸附和放置现象。

我们要先观察它们，再设计 TreeHeap kernel。

新的研究顺序

之前的顺序太工程化：

我设计一个 fold
-> toy proof 成立
-> 语言应该能用

现在要改成：

观察语言现象
-> 找到吸附/邻近/聚类规律
-> 形成 latent plane
-> 选择二分平面或堆坐标
-> 设计 kernel
-> 实验验证

也就是说：

TreeHeap fold 不是发明出来的。
它应该是从语言现象中发现出来的。

这如何修正 SPR-035

SPR-035 证明了：

如果要读连续子树，
第一步不能丢 leaf address / path / locality。

这个结论仍然有用。

但它不是语言 fold 理论。

它只是一个 sanity check：

不要一开始就把顺序打散。

真正的语言 fold 理论应该从这里开始：

哪些词在真实语言里互相吸附？
哪些词形成局部块？
哪些块会继续吸附？
哪些结构最后坍缩成事件？

下一步实验应该怎么做

我建议下一步不是继续随机 toy。

而是用真实短句做 relation layout probe。

例如：

a cat is eating some food
the dog is chasing a ball
a child drinks some water
the red apple fell

先不标复杂语法。只标弱关系：

a-cat
some-food
is-eating
cat-eating
eating-food
red-apple

然后训练或构造一个 latent layout，使得：

真实相关词距离更近
打乱组合距离更远

再观察：

det-head 是否靠近
aux-verb 是否靠近
verb-object 是否靠近
modifier-head 是否靠近

如果这些自然出现，才说明我们抓到了一点语言 fold 的规律。

然后再问：

TreeHeap 如何二分这个平面？
kernel 如何在这个平面上做局部卷积？

当前 claim

我会把这个理论写成一个 open claim：

S1-PLANE-C01:
Language fold should be modeled first as latent placement / attraction over
tokens and phrases. TreeHeap is a coordinate and partition system for computing
over that placement, not the language law itself.

状态应该是：

open theory

因为我们还没有实验证据。

它现在只是更合理的理论方向。

总结

这次修正后的核心是：

语言理解不一定从语法槽位开始。
它可能先是一个平面放置问题。

Transformer 从架构上看，也更像：

动态共现矩阵
soft relation graph
latent attraction field

TreeHeap 则可以被重新理解为：

对这个 latent field 做二分、寻址、卷积和坍缩的计算结构。

这比“语言就是二叉堆”更谦逊，也更接近发现世界规律。

一句话：

先发现语言中的吸附和放置规律，
再让 TreeHeap 成为它的计算坐标。

ARA: latent plane theory / claims / experiments

[SPR-037] 可控流形：怎样把 TreeHeap 从一团乱调到可用结构

Tue, 30 Jun 2026 00:00:00 +0000

可控流形：怎样把 TreeHeap 从一团乱调到可用结构

你刚才提出的观点，我认为非常关键：

现在的 claim 应该是一个可控流形。

这句话解决了一个一直卡住我们的问题。

之前我们总是在两个层面之间跳：

数学层：plus / diff / compose / decompose / kernel
产品层：能不能生成句子、能不能翻译、能不能像 Transformer 一样工作

中间缺一层。

这一层就是：

控制变量 -> 结构变化 -> 产品功能涌现

也就是说，不要一上来就问：

TreeHeap 能不能直接生成正确句子？

而是先问：

当我调整 kernel 的细节时，
输出结构会不会从一团乱，
逐步走向更稳定、更像产品可用结构的状态？

如果这个过程可控，我们就可以在控制过程中学习规律。然后再修补数学 kernel。

这就是 SPR-037。

什么叫“可控流形”

这里的“流形”不要先理解成高等几何里很复杂的对象。

可以先理解成一张可观察的调参地图：

横轴：relation_weight
纵轴：order_weight
高度：fold 结构质量

比如：

relation_weight = 0
order_weight    = 0

kernel 什么都不相信，输出就接近随机。

再比如：

relation_weight = 2
order_weight    = 2

kernel 既相信词之间的关系场，也相信线性邻近，输出结构应该更稳定。

于是我们得到一张面：

controls -> fold quality

这张面就是当前意义上的“可控流形”。

Houming818 的补充：梯度不一定只改参数

下面这一段是 Houming818 提出的补充。

我把它整理成工程语言，但这个想法的责任归属要说清楚：

观点来源：Houming818
整理解释：Codex Review
当前状态：理论假设，尚未被 SPR-037 的 toy proof 直接证明

你提出的问题是：

既然说可控流形，
那梯度信息从哪里来？

梯度是否一定要表现为普通神经网络那样的参数更新？

这非常关键。

因为如果 TreeHeap 只是：

θ <- θ - η ∇θ L

也就是只更新 kernel 参数，那它看起来和普通 MLP / Transformer 的训练方式太接近。

但你提出了另一种可能：

梯度也可以调整 heap 自身的平衡态。

比如一个很小的 heap state：

[2.0, 1.0, 3.0]

梯度来了以后，不一定是修改某个外部参数。

它也可能让当前 heap 变得更平衡：

[2.0, 1.0, 3.0]
-> [2.0, 1.5, 2.5]
-> [2.0, 1.8, 2.2]

这不是：

改函数参数

而更像：

调 heap state 的平衡性

两种梯度：参数梯度与状态梯度

因此 TreeHeap 里至少要区分两类梯度。

第一类是普通参数梯度：

θ <- θ - η ∇θ L

这里更新的是：

kernel 参数
compose 参数
read 参数
write 参数
relation field 参数

这和普通深度学习类似。

第二类是 Houming818 提出的 heap 平衡梯度：

H <- H - η ∇H E(H)

这里更新的不是外部函数参数，而是当前 heap state：

arr[1]
arr[2]
arr[3]
...

每个 arr[i] 可以是一个向量。

它们可以在能量函数的驱动下移动。

一个最小例子

假设我们定义左右平衡能量：

E_balance = (left - right)^2

当前状态是：

root  = 2.0
left  = 1.0
right = 3.0

左右差很大：

left - right = -2.0

能量高。

如果只对 heap state 做梯度下降，系统会推动：

left 变大
right 变小

于是得到：

[2.0, 1.0, 3.0]
-> [2.0, 1.5, 2.5]

这个过程更像物理里的松弛：

系统沿能量下降方向进入更稳定状态。

它不是先知道一个“目标 heap”，然后对目标 heap 求导。

它只需要知道：

当前 heap 的能量高不高。

这是否绕开了“目标 heap 可导”的问题

部分绕开了。

更准确地说：

不需要目标 heap 本身可导。

但仍然需要一个可计算、可微分的能量函数：

E(H)

例如：

E_balance(H)              左右是否平衡
E_parent_child(H)         父子是否一致
E_relation_match(H, W)    heap 是否贴合世界/关系场
E_entropy(P)              概率容器是否过早或过晚坍缩
E_path_smooth(H)          路径上的状态是否连续

总能量可以写成：

E_total(H)
  = E_balance(H)
  + E_parent_child(H)
  + E_relation_match(H, W)
  + E_entropy(P)

然后做：

H <- H - η ∇H E_total(H)

这就把可导要求从：

目标结构必须可导

转移成：

当前状态的能量函数必须可导

这个差别很大。

这对 TreeHeap 为什么重要

如果这个方向成立，TreeHeap 的学习就不只有一种：

参数学习：让 kernel 函数变强
状态松弛：让 heap 自身进入平衡态

用一句话说：

普通神经网络更像改函数。
TreeHeap 还可能改结构状态。

这会让“可控流形”变得更像一个真实动力系统：

kernel 参数决定能量地形
heap state 在能量地形上滑动
概率容器在合适时刻坍缩
最后形成稳定结构

也就是说，SPR-037 现在测的是：

手动控制变量能不能改变 fold 质量。

Houming818 的补充指向下一层：

梯度能不能不是只改控制变量，
而是推动 heap state 自己进入更好的平衡态。

这个补充目前还没有证明

需要强调：

SPR-037 的实验没有证明 heap state relaxation。

SPR-037 只证明了：

手动扫 relation_weight / order_weight 时，
fold 质量存在一个可观测控制面。

Houming818 这里提出的是下一步 claim 候选：

TreeHeap 不只有参数梯度路径，
还可能存在 heap state 平衡梯度路径。
这种路径可以在目标结构不可导时，
通过可导能量函数完成结构松弛。

这应该进入后续实验，而不是混进当前结论。

一个最小 proof 可以是：

1. 固定 kernel 参数
2. 初始化一个不平衡 heap state
3. 定义 balance / parent-child / relation 三类能量
4. 只更新 H，不更新 θ
5. 观察 heap 是否收敛到更稳定、可读、可坍缩的结构

如果这个实验通过，TreeHeap 会多出一条很有自己味道的学习路径：

不是只训练参数，
而是让 heap 自己松弛到稳定结构。

为什么这比直接生成更好

假设我们直接让模型生成：

the cat is running for a car

一开始可能输出很乱。

如果只有最终结果，我们只能说：

模型不行。

但如果有控制面，我们可以问更细的问题：

relation_weight 太低了吗？
order_weight 太高了吗？
collapse 太早了吗？
noise 太大了吗？
某个 subheap 没有被正确分割吗？
kernel 缺少共轭/镜像/分解操作吗？

这就从“黑箱失败”变成“可诊断失败”。

产品工程最需要的不是一次神迹，而是可诊断、可修补、可复现。

这次 toy proof 怎么做

我没有直接跑 WMT。

这次只做一个最小 proof：

给定几句短句和弱 block 目标，
看 kernel 控制量能不能把 fold 从乱态推向稳定块。

短句包括：

the cat is running for a car
a dog is chasing the ball
the book that i bought yesterday is expensive
some kids are playing in the park

注意，这里不是要证明完整语法。

我们只给一些弱 block：

the cat
is running
a car
for a car
the book
i bought yesterday
that i bought yesterday
is expensive

这些 block 相当于“产品上希望看到的稳定局部结构”。

kernel 的控制量

这次 kernel 只有两个主要旋钮。

1. relation_weight

表示 kernel 多相信“词之间的关系场”。

比如：

the -> cat
is -> running
a -> car
book -> relative clause

如果 relation_weight 高，相关词更容易被合并。

2. order_weight

表示 kernel 多相信线性邻近。

比如：

the cat
is running
a car

这些词本来就在句子里靠得近。

如果 order_weight 高，邻近词更容易合并。

数学形式

每一步 fold 时，kernel 都要决定两个块 A 和 B 要不要合并。

这次的打分函数是：

score(A, B)
  = relation_weight * relation(A, B)
  + order_weight    * order(A, B)
  - balance_penalty
  + noise

其中：

relation(A, B)

表示两个块在关系场里有多接近。

order(A, B)

表示两个块在原始句子顺序里有多接近。

balance_penalty

防止一开始就把很不均衡的大块小块乱合。

noise

模拟不稳定扰动。

实验变量

我们扫描：

relation_weight in {0, 0.25, 0.5, 1, 2, 4}
order_weight    in {0, 0.25, 0.5, 1, 2, 4}
seeds = 64

评价指标是 block F1：

预测出来的 block
和我们给定的弱 target block
有多少重合。

这不是 BLEU。

这也不是翻译质量。

它只是问：

fold 出来的局部结构是否接近目标块？

实验结果

结果如下：

指标	数值
low-control mean F1	0.0828
best mean F1	0.8148
high-sum-control mean F1	0.8148
diagonal gain	0.7319
product cells	22
pilot pass	true

最重要的是对角线：

relation_weight	order_weight	mean F1
0.00	0.00	0.0828
0.25	0.25	0.4036
0.50	0.50	0.6398
1.00	1.00	0.7603
2.00	2.00	0.8119
4.00	4.00	0.8148

这个形状很重要。

它不是随机跳一下。

它显示：

控制量很弱 -> 输出接近乱态
控制量增强 -> fold 结构明显变好
控制量继续增强 -> 进入平台期

这正是“可控流形”的最小证据。

一个具体 trace

对句子：

the book that i bought yesterday is expensive

某次较好的 fold trace 是：

the + book
i + bought
is + expensive
i bought + yesterday
that + i bought yesterday
the book + that i bought yesterday
整句合并

这很接近我们想看的结构：

the book
i bought yesterday
that i bought yesterday
the book that i bought yesterday
is expensive

注意，这不是完整语法树。

但它说明 kernel 已经能把一些局部块先稳定下来。

这就是产品功能的早期形态：

先不要完美理解整句，
先把局部稳定块折出来。

这证明了什么

这次 claim 是：

S1-MANIFOLD-C01:
If TreeHeap fold is driven by kernel controls over a latent relation field,
product-like structure should emerge as a measurable control surface.
Increasing relevant control variables should move output from noisy blocks
toward stable target blocks on a toy relation task.

状态：

supported pilot

它证明的是：

在一个透明 toy relation field 上，
TreeHeap fold 可以被 kernel 控制量调节，
并且结构质量会沿控制面明显提高。

换句话说：

我们可以把 TreeHeap 的失败变成可观测、可调试的失败。

这对工程很重要。

这没有证明什么

它没有证明：

TreeHeap 已经理解语言
TreeHeap 已经能翻译
TreeHeap 胜过 Transformer
relation field 能无监督自动学出来
这两个旋钮就是最终旋钮

尤其是：

relation field 这次是 toy 构造的。

这意味着下一步必须把 toy relation field 换成真实数据估计出来的 relation field。

比如：

共现窗口
masked token restoration
弱依存关系
contrastive phrase pairs
短句人工弱标注

对 TreeHeap 路线的意义

现在我更赞同你的判断：

代数逻辑和产品逻辑不能分太开。

但也不能直接从代数跳到 WMT。

中间要有一层：

TreeHeap Structure Lens

它应该能显示：

当前 token/block 的邻近关系
当前 fold trace
每个 merge 的 energy
每个 stop/left/right 的概率
哪些结构稳定
哪些结构还在叠加
哪些控制量改变后结构变好

也就是说，产品上先做一个“结构透镜”。

不是先做最终翻译器。

下一步

我建议下一步不是继续加 toy trick。

而是把这个控制面放到真实数据上。

最小版本：

输入真实短句
从语料共现或 masked restoration 估计 relation field
用 TreeHeap kernel fold
扫 relation/order/collapse 控制量
看 block F1、稳定性、能量是否形成可控面

如果真实数据也有类似曲面：

低控制乱
中控制变好
高控制平台

那我们就有了继续推进 S1 的依据。

如果没有，也很好：

说明 toy relation field 太人工，
或者 kernel 缺少关键算子，
或者真实语言 fold 不是这个控制方向。

这就是 ARA 的价值。

一句话总结

SPR-037 的结论是：

TreeHeap 不能只证明自己有代数操作。
它还必须证明这些操作能被控制，
并且控制过程能让产品可见结构逐步涌现。

这次 toy proof 给了一个正信号：

low-control F1 = 0.0828
best F1       = 0.8148
diagonal gain = 0.7319

所以当前更清晰的路线是：

先建立可控结构透镜，
再用真实数据学习 relation field，
最后才谈生成和翻译。

May the Code be with us.

ARA: controllable manifold / claims / experiment script / evidence

[SPR-038] 梯度到底改什么：TreeHeap 状态松弛的边界

Tue, 30 Jun 2026 00:00:00 +0000

梯度到底改什么：TreeHeap 状态松弛的边界

这篇是 SPR-038 的修订版。

原版里有一个说法不够严谨：

函数不变。
地址规则不变。
kernel 系数不变。
只有 arr[i] 的状态在移动。

Houming818 指出这里混淆了几层东西。

这个批评是对的。

TreeHeap 里至少要区分五个对象：

Theta  = parameter TreeHeap，也就是模型参数
H      = activation / memory TreeHeap，也就是当前样本上的状态
A      = physical address rule，比如 left(i)=2i, right(i)=2i+1
K_Theta = kernel operator，由参数 Theta 定义的局部卷积算子
L      = scalar loss / energy，用来产生梯度

类比线性回归：

y = w*x + b

普通机器学习里，w 和 b 是参数。

放到 TreeHeap 口径里，w 和 b 可以不是两个孤立标量，而是一个很小的参数堆：

Theta = {
  w,
  b
}

所以“参数就是一个 TreeHeap”是合理的。

更一般地：

H_next = K_Theta(H, A)
L = loss(H_next)

如果训练模型参数，就是：

Theta <- Theta - eta * grad_Theta L

如果调整当前 heap 状态，就是：

H <- H - eta * grad_H L

这两件事不是一回事。

物理地址和语义地址

原文说“地址规则不变”，也需要修正。

严格说，不变的是物理寻址规则：

left(i)  = 2i
right(i) = 2i + 1

也就是数组位置和父子索引关系没有变。

但是 arr[i] 的向量状态一旦变了，它在语义空间里的位置当然也变了。

所以应该写成：

物理地址 A 不变。
语义状态 H[i] 可变。
语义地址 / 向量位置会随 H[i] 改变。

这点很重要。

否则会误以为 SPR-038 证明了“地址不变还学习了结构”。

它没有。

它只证明：

在固定物理地址规则下，当前 heap state 可以被一个 scalar energy 推动，向低能量状态移动。

SPR-038 到底证明了什么

SPR-038 的 claim 是：

S1-RELAX-C01:
A differentiable energy over the current TreeHeap state can generate gradients
that relax arr[i] toward a lower-energy equilibrium while kernel parameters
and address rules remain fixed.

修订后，这句话要更精确地理解为：

Theta 不更新。
K_Theta 不更新。
物理地址规则 A 不更新。
当前样本的 heap state H 更新。

也就是：

这不是参数学习。
这是状态松弛。

它更像一个物理系统：

给定能量函数 E(H)，
当前状态 H 沿着 -grad_H E(H) 移动。

Proof 1：标量能量只说明 loss 能产生梯度

第一个 toy 是：

root  = 2.0
left  = 1.0
right = 3.0

能量函数：

E = (left - right)^2
  + (root - (left + right) / 2)^2

梯度下降后：

[2.0, 1.0, 3.0]
-> [2.0, 2.0, 2.0]

实验结果：

initial energy = 4.0
final energy   = 9.86e-31
energy ratio   = 2.47e-31

这个 proof 的意义很窄：

只要有 scalar loss / energy，
就能对当前 H 求梯度，
并让 H 沿低能量方向移动。

它不说明 kernel 结构已经学习了。

它也不说明参数 TreeHeap Theta 已经被训练。

Proof 2：7 节点 TreeHeap 状态松弛

第二个 toy 使用 7 节点树：

        1
      /   \
     2     3
    / \   / \
   4   5 6   7

其中：

4,5,6,7 是固定叶子向量
1,2,3 是可更新 internal heap state

注意：

更新的是 H[1], H[2], H[3]
不是更新 Theta

能量有两部分：

E_consistency:
  parent 应该接近 children 的局部组合

E_relation:
  internal node 应该接近固定 relation anchor

总能量：

E_total(H) = E_consistency(H) + E_relation(H)

32 次随机初始化结果：

指标	数值
scalar energy ratio	2.47e-31
mean vector energy ratio	1.24e-13
max vector energy ratio	3.69e-13
mean centroid error drop	3.0393
pass rate	1.0000
pilot pass	true

这说明：

在这个 toy 能量场里，
TreeHeap state H 可以稳定收敛。

但仍然要强调：

这不是 kernel 参数学习。

kernel 卷积到底应该是什么

Houming818 给了一个更贴切的例子。

还是这棵树：

        1
      /   \
     2     3
    / \   / \
   4   5 6   7

如果 kernel 是：

[root, left, right] = [1, 1, 1]

对每个内部节点做局部卷积：

H'[1] = 1*H[1] + 1*H[2] + 1*H[3] = 1 + 2 + 3 = 6
H'[2] = 1*H[2] + 1*H[4] + 1*H[5] = 2 + 4 + 5 = 11
H'[3] = 1*H[3] + 1*H[6] + 1*H[7] = 3 + 6 + 7 = 16

叶子暂时保持不变，则得到：

[6, 11, 16, 4, 5, 6, 7]

这个例子比 SPR-038 更接近 TreeHeap kernel 的核心。

因为 kernel 不是抽象地“调状态”，而是在做：

观察一个局部 subheap
计算一个新 state
把局部结构信息写回当前节点

也就是：

S_i = [H[i], H[left(i)], H[right(i)]]
H'[i] = K_Theta(S_i)

如果 kernel 是线性的：

H'[i] = theta_root * H[i]
      + theta_left * H[left(i)]
      + theta_right * H[right(i)]

那么 [1,1,1] 就是一个最简单的 TreeHeap 卷积核。

和 Transformer 的关系

Transformer 里常见的核心相似度是：

score(i,j) = Q_i dot K_j

它是在 flat token 空间上做全连接关系计算。

TreeHeap kernel 可以看成：

score / state = K_Theta(root, left, right)

也就是在局部子堆上做结构化关系计算。

所以更合理的类比不是：

TreeHeap 已经替代 Transformer

而是：

Transformer 在 flat all-to-all token 图上学习共现关系。
TreeHeap 希望在 address/path/subheap 结构上学习局部卷积关系。

如果 K_Theta 学到的是类似 [1,1,1]、[0.2,0.5,0.3]、镜像 kernel、stop/left/right kernel 这样的结构算子，那么 TreeHeap 才真正有自己的归纳偏置。

修订后的结论

SPR-038 支持的结论是：

TreeHeap 的当前状态 H 可以在 scalar energy 下做梯度松弛。

SPR-038 不支持的结论是：

TreeHeap kernel 参数 Theta 已经能通过梯度学会卷积结构。

所以 SPR-038 的位置应该是：

状态梯度 proof
不是参数学习 proof

下一步 SPR-039 应该转向：

parameter TreeHeap / kernel Theta learning proof

最小实验就是：

输入 H = [1,2,3,4,5,6,7]
目标 H' = [6,11,16,4,5,6,7]

模型不知道 kernel = [1,1,1]
只通过 loss 学 theta_root, theta_left, theta_right

如果训练后得到：

Theta ~= [1,1,1]

那才说明：

TreeHeap kernel 的参数可以通过 loss / gradient 学到局部卷积规则。

这会成为 SPR-039 的核心。

ARA: heap-state relaxation / claims / evidence

[SPR-039] 参数也是 TreeHeap：kernel 自己学会了卷积

Wed, 01 Jul 2026 00:00:00 +0000

参数也是 TreeHeap：kernel 自己学会了卷积

SPR-038 之后，Houming818 提了一个关键修正：

参数本身也应该是 TreeHeap。

这个修正很重要。

SPR-038 做的是：

H <- H - eta * grad_H L

也就是更新当前样本的 heap state。

SPR-039 要证明的是另一件事：

Theta <- Theta - eta * grad_Theta L

也就是更新 kernel 的参数 TreeHeap。

这两件事必须分开。

对象定义

这次我们严格区分：

符号	含义
`Theta`	parameter TreeHeap，模型参数的载体
`H`	activation / memory TreeHeap，当前样本状态
`A`	physical address rule，比如 `left(i)=2i`
`K_Theta`	由 `Theta` 定义的局部 kernel operator
`L`	scalar loss，用来产生梯度

计算过程是：

H_next = K_Theta(H, A)
L = loss(H_next, target)
Theta <- Theta - eta * grad_Theta L

这才是参数学习。

最小 TreeHeap 卷积任务

我们使用一棵 7 节点树：

        1
      /   \
     2     3
    / \   / \
   4   5 6   7

输入例子：

H = [1,2,3,4,5,6,7]

隐藏 kernel 是：

[root, left, right] = [1, 1, 1]

所以内部节点的目标是：

H'[1] = H[1] + H[2] + H[3] = 6
H'[2] = H[2] + H[4] + H[5] = 11
H'[3] = H[3] + H[6] + H[7] = 16

叶子保持不变：

H' = [6,11,16,4,5,6,7]

关键点是：

模型一开始不知道 [1,1,1]。

它只有参数：

Theta = [theta_root, theta_left, theta_right]

模型计算：

Y[i] = theta_root * H[i]
     + theta_left * H[left(i)]
     + theta_right * H[right(i)]

loss：

L = mean_squared_error(Y, target)

如果训练后：

Theta ~= [1,1,1]

就说明 kernel 参数真的学到了这个局部卷积规则。

实验结果

实验在 io.grepcode.cn 上执行。

证据目录：

ara/s1-echo/evidence/s1_kernel_parameter_learning_probe/

结果：

指标	数值
pilot pass	true
learned theta	`[0.9999999999999998, 0.9999999999999998, 1.0000000000000004]`
theta L2 error	`5.44e-16`
theta delta L2	`1.15777`
TreeHeap test MSE	`8.78e-31`
TreeHeap OOD MSE	`8.93e-30`
wrong-address test MSE	`5.92848`
flat-global test MSE	`3.56010`

这说明：

Theta 确实移动了。
Theta 学回了隐藏 kernel [1,1,1]。
正确地址结构下 test / OOD 误差接近 0。
错误地址结构明显失败。
不看 left/right subheap 的 matched-size flat baseline 也失败。

为什么 wrong-address 很重要

如果只是让模型学一个线性函数，它当然可能会过拟合。

所以这次放了 wrong-address baseline。

正确 kernel 看的是：

node 1 -> [1,2,3]
node 2 -> [2,4,5]
node 3 -> [3,6,7]

wrong-address 看的是错误局部结构。

结果：

TreeHeap test MSE       ~= 0
wrong-address test MSE  = 5.92848

这说明收益不是来自“随便三个数做线性回归”，而是来自：

正确的 TreeHeap address / subheap 结构。

和 SPR-038 的区别

SPR-038：

更新 H
不更新 Theta
证明 state relaxation

SPR-039：

更新 Theta
不靠移动当前 H 来作弊
证明 kernel parameter learning

所以 SPR-039 补上了 SPR-038 留下的缺口。

现在我们可以说：

TreeHeap 不只是状态能被梯度松弛。
TreeHeap 的 kernel 参数也能被梯度训练。

和 Transformer 的关系

Transformer 的 attention 可以粗略看成：

score(i,j) = Q_i dot K_j

它在 flat token 图上学习关系。

TreeHeap kernel 的形式是：

state = K_Theta(root, left, right)

它在局部 subheap 上学习关系。

这次 proof 证明了最小版本：

K_Theta 可以通过梯度学到一个局部结构算子。

这不是说 TreeHeap 已经打败 Transformer。

更准确地说：

TreeHeap 和普通 ML 一样，可以通过 loss / gradient 学习函数；
但它学习的函数天然绑定 address / path / subheap 结构。

Claim 状态

S1-KERNEL-LEARN-C01:
A parameter TreeHeap Theta can learn a local subheap convolution rule
from scalar loss and gradient.

status: supported pilot

还没有证明什么

这次没有证明：

语言理解
WMT 翻译
真实 relation field
multi-kernel specialization
TreeHeap 胜过所有更大的 flat model

尤其最后一点要诚实：

一个更大的 flat linear model 当然可能拟合这个 toy。

这次 proof 的重点不是“所有 flat 都输”。

重点是：

在 TreeHeap 的 address / subheap 结构里，
共享 kernel 参数 Theta 可以被梯度学出来。

这是一个必要地基。

下一步

SPR-039 之后，下一步应该扩展三件事：

1. scalar kernel -> vector / matrix kernel
2. clean sum target -> noisy restore / mask restore
3. single kernel -> multi-kernel specialization

如果这些继续成立，TreeHeap 才能从：

能学一个 toy 卷积核

走向：

能学真实数据里的结构 kernel

一句话总结

SPR-039 的结论是：

参数 TreeHeap Theta 可以通过 scalar loss 和 gradient，
学会一个局部 subheap 卷积核。

这一步把 SPR-038 的状态松弛，推进到了真正的参数学习。

ARA: kernel parameter learning / evidence / claims

[SPR-040] TreeHeap kernel 的 mirror 手性翻转：几何翻转如何变成代数置换

Wed, 01 Jul 2026 00:00:00 +0000

TreeHeap kernel 的 mirror 手性翻转：几何翻转如何变成代数置换

先统一术语。

之前草稿里用了“共轭”这个词。这个词容易让人想到复数共轭、矩阵共轭、群表示里的 conjugation。SPR-040 现在不再这样叫。

这里讨论的是：

mirror / chiral flip / 左右镜像翻转

也就是把一棵 TreeHeap 的 left 和 right 对换。

这篇文章要证明一件很具体的事：

几何上的左右翻转，
可以在代数层面变成两个置换：

1. 堆地址置换
2. kernel 槽位置换

这不是语言理解 proof，也不是 WMT proof。它是 TreeHeap kernel 工具箱里的一个基础 proof。

这次收束以后，SPR-040 也不准备升级成旋转、3D fold 或平面投影 proof。我们先只托付一个最小事实：

mirror 会交换 left/right 的结构方向；
loss 可以把这个 mirrored slot assignment 学回参数里。

这已经够重要，因为它说明 kernel 的 root/left/right 不是三个匿名标量位置，而是树上的局部结构方向。

DeepSeek 回测后的收束

DeepSeek / Runner 做了 ARA 可靠性审阅，把 SPR-040 评为：

中等可靠。

这个评价是合理的。

因为 SPR-040 的 evidence 很清楚：

flipped-kernel error 接近机器精度。
unflipped-kernel error 明显变大。
loss 能学回 [root,right,left]。

但它的范围也很窄：

这是结构赋值级别的 proof。
不是旋转 proof。
不是 3D fold proof。
也不是“模型自己学会何时翻转整棵树”的 proof。

换句话说，现在证明的是：

给定 mirror 这种结构变换后，
kernel 的 left/right 槽位应该怎样跟着变。

还没有证明：

模型自己发现某个句子需要 mirror。
模型自己决定 mirror 发生在哪个 subheap。
模型自己决定递归 mirror 到多深。

这个边界很重要。它让 SPR-040 更专业，也更不容易过度解释。

为什么要证明 mirror

SPR-039 证明了：

参数 TreeHeap Theta 可以通过梯度学习一个局部卷积 kernel。

例如在 7 节点堆上：

        1
      /   \
     2     3
    / \   / \
   4   5 6   7

一个最小 kernel 可以写成：

theta = [theta_root, theta_left, theta_right]

它在某个内部节点 i 上做：

K_theta(H)[i]
  = theta_root  * H[i]
  + theta_left  * H[left(i)]
  + theta_right * H[right(i)]

如果 theta = [1,1,1]，它就是局部求和。

但 Houming818 提醒了一个更关键的问题：

TreeHeap kernel 不能只会求和。
它应该能表达结构操作。

比如，左右镜像翻转。

如果 TreeHeap 真的是结构化空间，那么：

树翻了，
算子也应该按结构翻。

这就是 SPR-040。

mirror 在堆地址上的定义

仍然看这棵 7 节点完全二叉堆：

        1
      /   \
     2     3
    / \   / \
   4   5 6   7

左右 mirror 后：

        1
      /   \
     3     2
    / \   / \
   7   6 5   4

所以地址映射是：

M(1) = 1
M(2) = 3
M(3) = 2
M(4) = 7
M(5) = 6
M(6) = 5
M(7) = 4

如果用数组表示：

H = [1,2,3,4,5,6,7]
M(H) = [1,3,2,7,6,5,4]

这不是随便重排。

它是一个保持树结构的左右镜像。

代数上可以写成：

H' = P_m H

其中 P_m 是堆地址的置换矩阵。对于 7 节点堆，它对应：

P_m = (0, 2, 1, 6, 5, 4, 3)

这里用的是 zero-based index。

mirror 在 kernel 槽位上的定义

局部 kernel 是：

theta = [root, left, right]

如果树左右翻转，left 和 right 的意义也要交换。

所以 kernel 也要 mirror：

P_lr(theta) = [root, right, left]

写成矩阵：

P_lr =
[[1,0,0],
 [0,0,1],
 [0,1,0]]

这就是这篇 proof 的重点。

不是只翻树。

而是：

翻树地址 P_m
同时翻 kernel 槽位 P_lr

Claim

SPR-040 的 claim 是：

S1-KERNEL-MIRROR-C01:

TreeHeap local convolution is equivariant under mirror / chiral flip:

P_m K_theta(H) = K_{P_lr theta}(P_m H)

中文说：

先卷积，再 mirror
等价于
先 mirror，再用 mirror 后的 kernel 卷积。

这就是“几何操作由代数操作实现”。

一个具体例子

输入：

H = [1,2,3,4,5,6,7]
theta = [0.5, 1.25, -0.75]

这个 kernel 是故意选成非对称的。

因为如果用 [1,1,1]，left 和 right 权重一样，翻不翻都一样，证明没有力量。

root 节点的卷积：

K_theta(H)[1]
  = 0.5*1 + 1.25*2 - 0.75*3
  = 0.75

node 2：

K_theta(H)[2]
  = 0.5*2 + 1.25*4 - 0.75*5
  = 2.25

node 3：

K_theta(H)[3]
  = 0.5*3 + 1.25*6 - 0.75*7
  = 3.75

内部节点结果是：

[0.75, 2.25, 3.75]

mirror 后，node 2 和 node 3 的结构位置交换。

如果我们先 mirror 输入：

P_m H = [1,3,2,7,6,5,4]

就必须同时使用 mirrored kernel：

P_lr theta = [0.5, -0.75, 1.25]

这时两条路径会得到同一个结果：

P_m K_theta(H)
=
K_{P_lr theta}(P_m H)

Proof 分两部分

Proof A：演绎等式检查

这部分不训练。

直接检查：

left  = P_m K_theta(H)
right = K_{P_lr theta}(P_m H)

然后算：

max_abs(left - right)

如果这个误差接近 0，就说明代数等式成立。

这一步是数学/代数检查。它不是学习结果。

也就是说，P_m 是我们定义好的 mirror 地址置换，P_lr 是我们定义好的 kernel 槽位置换。这里验证的是：

这个定义是否自洽。

它不证明模型自己学会了翻树。

Proof B：归纳学习检查

这部分训练。

我们构造 mirrored data：

input  = P_m H
target = internal_nodes(P_m K_theta(H))

然后让一个三槽位参数：

Theta = [theta_root, theta_left, theta_right]

通过 MSE loss 和梯度下降学习。

如果数据真的携带 mirror 规律，那么它应该学出：

Theta ~= P_lr theta = [0.5, -0.75, 1.25]

这一步说明的不只是“公式手写成立”，还说明这个 mirrored kernel 可以从数据里被学回。

更具体地说，这一步要验证：

learned_root  ~= original_root
learned_left  ~= original_right
learned_right ~= original_left

也就是说，loss 学到的不是一个抽象口号，而是 left/right 槽位在 mirror 后的对应关系。

这一步才是学习结果。

但学习到的东西也要说准确：

学到的是 mirrored kernel slot assignment。
不是学到 mirror 触发规则。
不是学到递归翻转策略。

实验结果

脚本：

ara/s1-echo/src/s1_mirror_kernel_symmetry_probe.py

证据：

ara/s1-echo/evidence/s1_mirror_kernel_symmetry_probe/

主机：

io.grepcode.cn

结果：

指标	数值
pilot_pass	`true`
flipped-kernel test max error	`8.88e-16`
flipped-kernel OOD max error	`3.55e-15`
unflipped-kernel mean error	`6.4372`
learned mirrored theta	`[0.5000000000000002, -0.7499999999999998, 1.2499999999999996]`
theta-mirror L2 error	`5.44e-16`
left slot learns original right error	`2.22e-16`
right slot learns original left error	`4.44e-16`
learned test MSE	`1.01e-30`
learned OOD MSE	`9.76e-30`

解释：

用 mirrored kernel 时，误差是机器精度。
不用 mirrored kernel 时，误差明显变大。
从 mirrored data 训练时，参数能学回 [root,right,left]。
left/right 槽位 assignment 的学习误差也是机器精度。

所以：

S1-KERNEL-MIRROR-C01 -> supported pilot

这说明了什么

SPR-040 支持一个很重要的方向：

TreeHeap 的几何操作，可以下降到代数操作。

具体到这篇：

几何 mirror
-->
堆地址置换 P_m
+ kernel 槽位置换 P_lr

这让 TreeHeap kernel 不只是“局部求和器”。

它开始像一个结构化算子系统：

卷积
写入
读取
mirror
路径移动
子堆组合
子堆分解

这些都可以成为后续 encoder/decoder 的基本工具。

但这里要避免过度解释。

SPR-040 现在最稳的结论不是：

TreeHeap 已经证明了完整 3D fold。
TreeHeap 已经学会连续旋转角。
TreeHeap 已经解决 latent plane 投影。

而是：

TreeHeap kernel 的槽位具有结构方向意义；
mirror 会改变这些方向的对应关系；
这个方向对应关系可以被 loss 学回。

这是一块很小但很硬的积木。

它把 TreeHeap kernel 从“标量覆盖”推进到“结构方向上的局部卷积”，但还没有推进到完整的空间折叠理论。

如果用一句更数学化的话说：

root/left/right 是 TreeHeap 局部坐标系。
mirror 是这个局部坐标系上的置换。
loss 可以学习置换后的参数赋值。

但还没有到：

loss 可以学习何时选择这个置换。

这个“何时选择”需要另一层学习树。

后续数学故事：多参森林

Houming818 提出的更合理方向是：

不要让一个大参数树混合学习所有结构能力。
应该用多参森林。

也就是：

Theta_write   负责写入
Theta_read    负责读取
Theta_compose 负责组合
Theta_mirror  负责 mirror
Theta_time    负责时间状语前置

每棵树有自己的参数和梯度。

这样做的原因是，mirror 的学习信号不应该被 read/write/semantic 的大 loss 混在一起冲掉。

对于 mirror，可以拆成两棵相关的树：

Theta_mirror:
  怎么翻，也就是执行 mirror 算子。

Phi_mirror:
  什么时候翻，也就是触发规则。

当前 SPR-040 只碰到了第一件事的一小部分：

mirror 后 kernel 槽位如何赋值。

还没有学习：

Phi_mirror(H, context) -> 是否触发 mirror

以翻译为例：

I arrived home at 7 o'clock.
我七点到家了。

这里更像是一个局部结构重排：

时间短语从英文尾部，移动到中文谓词前。

这不是全树 mirror，而是某种局部 reorder kernel。未来应该有一棵专门的参数树学习：

Theta_time:
  怎么把时间短语前置。

Phi_time:
  什么时候触发时间短语前置。

所以 SPR-040 的位置很清楚：

它不是终点。
它是在证明 TreeHeap kernel 的结构方向是真的。

还没有证明什么

这次没有证明：

语言理解
WMT 翻译
真实语义 mirror
任意群等变
TreeHeap 胜过所有 flat model
连续旋转角学习
完整 3D fold
latent plane 投影权重学习
learned mirror trigger
learned recursive mirror depth

它只证明：

TreeHeap 的 root/left/right 局部卷积，
在 mirror 操作下有正确的代数置换形式。

下一步

接下来可以沿着几个方向扩展，但不需要急着开新编号去做旋转。更合理的是先让后学工程师评判 SPR-040 这个最小 claim 是否站稳：

1. 当前 mirror assignment proof 是否表述清楚
2. 是否需要补一个 flat baseline，证明无结构槽位时不能自然解释 mirror
3. 是否要把 scalar slot 扩展到 vector slot
4. 是否要把 depth-1 root/left/right 扩展到 recursive subheap
5. 是否要接回 short real corpus TreeHeap echo
6. 是否要设计 multi-parameter forest：单独训练 mirror/time/read/write 参数树

如果这些继续成立，TreeHeap 的 kernel 就不是一组临时写出来的函数，而是一个可以逐步扩展的结构化代数工具箱。

一句话总结：

SPR-040 证明：
TreeHeap 的左右 mirror 可以用代数置换实现；
树地址要翻，kernel 的 left/right 槽位也要翻；
这个规则既能手算成立，也能从 mirrored data 里被梯度学回。

ARA: mirror kernel symmetry / evidence / claims

[SPR-042] SPR 全貌总结：从 M0 数学到 S1 echo 的四十二篇探索

Wed, 01 Jul 2026 00:00:00 +0000

SPR 全貌总结：从 M0 数学到 S1 echo 的四十二篇探索

这不是一篇新技术 blog。这是一篇阶段总结。把 2026年4月到7月的 SPR 探索过程按 M0 → S1 → S2 的脉络梳理一遍，方便后来人一眼看清全貌。

一句话背景

SPR（Semantic Prefix Routing）想用 TreeHeap（树形堆）替代 Transformer 的稠密矩阵。把 “token id → embedding lookup” 换成 “token id → 树路径 → 路径即语义表示”。路径即表示，不是查表。

理论总框架：M0 → S1 → S2

M0  TreeHeap 数学底座
  |  算子代数、closure、kernel convolution、
  |  soft differentiable lift、collapse
  |
  v
S1  容量与 echo
  |  path hash 能装多少 token、
  |  有序 echo 编码/解码、
  |  上下文路由、mirror 等变
  |
  v
S2  折叠栈与翻译
    语义向量 → 折叠动作 → 语法图 → 翻译

当前进度：M0 基本封闭，S1 可控入口已打开，S2 等待桥接。

M0 层：TreeHeap 数学底座

核心目标：TreeHeap 能不能被正式定义为一种算子代数。

已稳定（supported / verified）

能力	含义	证据
最小代数	closure、非交换、projection、subheap matching	`treeheap_math_probe`
primitive + plus	plus 作为后继/信息增益	`primitive_plus_probe`
可训练性 quiz	线性/XOR/modular 加法 toy	`trainability_quiz`
Soft Plus 梯度	K_write 和 Plus_a 可以接收梯度	`soft_plus_probe`：gK=0.09, gP=0.14
Soft 坍缩	低温下坍缩到正确 hard address	1.0 collapse accuracy
C05 结构消融	subheap kernel 迁移打败 flat/path-only	flat 0.0 vs subheap 1.0
kernel convolution ops	search/plus/write/conjugate 统一为卷积	`kernel_convolution_ops_probe`
diff algebra	距离、范数、有限差分、梯度步	Δloss 29.1→0.00066
algebraic decoder	投影/decompose/mirror/mod 等解码器	全 1.0 exact

仍开放

M0-SOFT-C05：kernel-guided soft plus 是否优于 naive memory write？需 clean-feature 消融。
M0-SOFT-C06：多 kernel 分阶段训练是否优于 big-pot loss？
M0-EXIST-C01~C03：address extrapolation、subheap 迁移、prefix 压缩。

M0 总结

TreeHeap 已经具备一个可定义的算子代数。
有了软/硬两个版本。
有了梯度通路。
有了结构化 kernel 卷积。
距离、导数、坍缩都能在 toy 上证明。

S1 层：容量、Echo 与结构路由

核心目标：TreeHeap 能不能装下真实语言的 token 序列，并回声重读出来。

已稳定

能力	含义	证据
path hash 容量	99.7% token 有唯一叶子地址	solo rate
有序编码	sign alternation 打破 cyclic shift 碰撞	`spr_hash_cyclic`
上下文路由	context-conditioned route acc 1.0 vs token-only 0.43	`spr_context_proof`
shallow sentence write	实句写入 root/subject/object slot	OOD exact 1.0
WMT echo kernel	423K params beat 16.8M seq MLP	OOD 0.90 vs 0.05
explicit echo encoder/decoder	硬接口全闭合	全 1.0 指标
ordered fold	保序折叠必须先于 bag/mod 折叠	1.0 vs 0.089
heap state relaxation	纯状态梯度	energy ratio 1e-13
kernel parameter learning	Theta 学到 hidden kernel [1,1,1]	L2 error 5e-16
mirror kernel symmetry	P_m K=K_{P_lr} P_m	max error 8e-16
inverse gate canonicalization	mirror→inverse→canonical→shared decoder	gate 0.9998

被降级 / 否定

声明	裁决	原因
token-only 路由有语义	rejected	失败于第一次 polysemy 证伪
frozen embedding = world coordinate	rejected	vector_add 完胜 TreeHeap
旧 task-gate S1 entry proof	downgraded	选择输出 kernel ≠ canonicalization

仍开放

Multi-kernel specialization：gate 能分化但 accuracy 太低
Probabilistic internal read：leaf read 完美，internal subheap 弱
Latent plane fold：理论已定义，无实验
真实 context S1b baseline battle

S2 层：折叠栈与翻译

当前状态：S2 被暂停。已积累的证据是诊断性的，不是正面翻译 claim。

已验证

语义向量包含折叠动作信息（AUC 证据）
32D 空间足够做 fold action prediction
跨语言折叠结构预测可行（EN↔ZH）
当前 graph builder 瓶颈是 child/parent allocation，不是 fold action
概率容器优于 early argmax

被降级

历史 checkpoint 的 “TreeHeap 已解决句法能量” 声明被降级
世界模型/背景场训练是诊断性实验，非翻译 claim

ARA 协议与 Squad 协作

SPR 研究采用 ARA 协议（arXiv:2604.24658v3）：

claim → predict → experiment → evidence → trace → decision

四人小队：

角色	模型/人	职责
Captain	Houming818	方向决策、否决、审批
Runner	DeepSeek	写代码、跑实验、独立复现
Reviewer	GPT/Codex	深度审计、仲裁 claim 可靠性
Auditor	DeepSeek	交叉验证 GPT 的证据

协作方式：文件级通信（~/.squad/），各模型独立 session，上下文不互污染。

当前 Claim 全景

统计（截至 2026-07-01）

M0 claims:  18 (含 soft / diff / decoder / existence)
S1 claims:  23 (含 capacity / echo / kernel / fold / gate)
S2 claims:  12
C0  meta:    4
────────
总计:      55+

verified:     15+  (有 baseline 或 falsification)
supported:    20+  (有 evidence，baseline 不完整)
open:         10+  (理论已有，未实验)
rejected:      3
downgraded:    5

最硬的结论

TreeHeap path hash 有足够容量（99.7% solo rate）
context > token-only 路由（1.0 vs 0.43）
TreeHeap echo kernel 参数效率远超 flat MLP（423K vs 16.8M，OOD 0.90 vs 0.05）
mirror 可以降低为代数置换（error 8e-16）
inverse gate canonicalization 可行（gate 0.9998）

尚不能说的

不能声称 TreeHeap 比 Transformer 好。
不能声称已经解决翻译。
不能声称已经学会自然语言 mirror 触发。
不能声称多 kernel 分工已经解决。
不能声称内部 subheap 读取已经解决。
不能声称 latent field fold 有实验证据。

关键教训

by construction 不是证据：C08 conjugate proof 的 0.0 error 是代码定义的恒等，不是学习结果。之前误标为 “learning evidence”。
canonicalization > separate read：SPR-041 第一版被否决，因为 “每种任务一种读法” 绕开了 TreeHeap 的核心目标——结构规约到同一参考系。
state loss 是拐杖：inverse gate 的 canonical state MSE loss 是强监督约束，不是自发涌现。去掉后 gate 从 0.9998 退化。
PAPER.md 容易 stale：local claim registry 可以很健康，root manifest 和 trace DAG 容易滞后。需要在同一 commit 里更新。
ARA 协作有效：GPT 写 claim+code → DeepSeek 独立复现审计 → 发现 2/6 不可复现 → 修复了 evidence trace gap。

下一步

按优先级排列：

learned trigger：去掉人工 task flag，让模型从 token/context 中自己判断该用哪种结构操作
noise/mask restore：纯 echo 容易退化成复制，需要缺 token/加噪/局部打乱 → 复原
multi-parameter TreeHeap forest：不同结构能力用不同参数树（Θ_write, Θ_read, Θ_mirror, Θ_time），梯度不混合
真实 short corpus echo：回到 WMT short BPE，先做 echo/restore，不做翻译
path-conditioned read kernel：解决 SPR-031 暴露的 root-bottleneck
copy-capable baseline：是时候补 matched copy/pointer 和 small Transformer 对照了

总结

从 4 月到 7 月，SPR 做了四件事：

1. 证明了 TreeHeap 可以是一个自洽的算子代数（M0）
2. 证明了 S1 echo loop 可以训练起来（S1 entry gate）
3. 学会了区分 "架构语义证明" 和 "学习能力证明"
4. 建立了 ARA 文件级流水线 + 跨模型交叉审计

没有夸大的结论。每项声明都有 evidence 指针和 falsification 条件。每一步都可以被独立复现。

这本身就是一个值得记录的状态。

ARA: PAPER.md / S1 claims / M0 claims

[SPR-050] 第一次真实语言生成：TreeHeap 从英文到中文，但还不是问答

Sat, 11 Jul 2026 00:00:00 +0000

第一次真实语言生成：TreeHeap 从英文到中文，但还不是问答

前面的很多实验都很小：echo、路由、内部节点读出、概率桶、受控符号任务。它们帮助我们确认 TreeHeap 的一些局部算子可以工作，但始终留下一个最实际的问题：

TreeHeap 能不能真正参与自然语言的“输入一句话，输出另一句话”？

这次我们不再使用 toy token，也不读取历史上已经被降级的 TreeHeap checkpoint。我们直接在真实 WMT 英中平行语料上，从零训练一个最小的 seq2seq 系统。

先说结论：

真实文本的 TreeHeap encoder -> decoder 通路已经跑通。
它能输出成句、主题相关的中文。
但当前它没有赢过普通 flat GRU，也不能称为翻译成果。
更重要的是：这仍然不是问答任务。

这是一份首航报告，不是庆功报告。

1. 为什么先拿 WMT 做 seq2seq？

最终目标不是机器翻译，而是：

question + context
  -> TreeHeap encoder
  -> answer decoder
  -> answer

也就是问答。

但问答数据需要三元组：

上下文、问题、答案

手头的 WMT 数据提供的是另一种真实的输入输出对：

英文句子 -> 中文句子

它不能证明模型会回答问题，却很适合先验证一个更基础的门：

TreeHeap 能否接收真实文本，
把它编码成可供 decoder 使用的状态，
并连续生成多步中文 token？

如果这一步都不成立，直接谈 QA 只会把 encoder、decoder、数据和评价混成一团。

所以这次 WMT 的身份是：

真实语言 seq2seq generation gate

不是最终 QA benchmark。

2. 这次模型到底长什么样？

输入是英文 SentencePiece token。例如：

English sentence
  -> [t1, t2, t3, ...]

每个 token 先写入 TreeHeap 的叶子。然后按 left/right 递归组合：

        parent
       /      \
    left     right

局部组合不是简单相加：

h_parent = Compose_theta(h_left + e_left, h_right + e_right)

e_left 和 e_right 是不同的槽位向量，所以：

Compose(a, b) != Compose(b, a)

这保留了顺序。

经过多层递归后，模型同时拥有：

叶子节点：具体英文 BPE token
内部节点：局部短语/子堆摘要
root：整句摘要

中文 decoder 每生成一个 token，都产生一个 query。它不是只读 root，而是在所有有效节点上分配概率：

p(i | q_t, H) = softmax(K_theta(q_t, h_i))

再把各节点状态按概率混合成当前上下文：

c_t = sum_i p(i | q_t, H) h_i

最后生成下一个中文 token。

这可以理解为：

decoder 每说一个中文词，
都在 TreeHeap 的叶子和内部子堆之间做一次概率读取。

训练时只有标准的 teacher-forcing 交叉熵：

L = sum_t CE(P(y_t | y_

没有人工句法树、没有 route 标签、没有类别标签、没有五个 loss 的大锅炖。


3. 真实数据与对照
数据：
/mnt/nas/datasets/wmt17/train.zh-en
方向：English -> Chinese
训练 / 验证 / 测试：30,000 / 2,000 / 2,000
最大 BPE 长度：24
训练：10 epochs
GPU：io 的 RTX 3090，270W 限制保持不变
我们没有只跑 TreeHeap。三种 encoder 使用相同的自回归中文 decoder 与相同的翻译 loss：

  
      
          Encoder
          输入能保留什么？
      
  
  
      
          BoW
          英文 token 的平均向量，不保留顺序。
      
      
          Flat GRU
          有序英文 token 序列。
      
      
          TreeHeap
          英文叶子、递归内部子堆、root。
      
  

这使问题变得很朴素：TreeHeap 现在到底比无序词袋、比普通有序序列，做得怎样？
4. 数字结果
完整运行耗时：
606 秒，约 10.1 分钟

  
      
          Model
          Test NLL ↓
          PPL ↓
          token-BLEU4 ↑
      
  
  
      
          TreeHeap
          5.129
          168.8
          1.48
      
      
          BoW
          4.948
          140.9
          1.43
      
      
          Flat GRU
          4.799
          121.4
          2.87
      
  

这里的 token-BLEU4 是脚本内的 BPE-token 近似指标，不是官方 WMT BLEU，不能拿来和论文榜单比较。
数字的诚实解释是：
TreeHeap 已经能学习真实 seq2seq。
TreeHeap 的生成指标略高于 BoW，但差异很小。
TreeHeap 明显落后于 flat GRU。
所以这轮不能支持：
TreeHeap 当前配置优于普通序列模型。
5. 输出到底像不像中文？
看几个测试集样例。下面没有润色。
EN: In order to fund this spending, revenues must be raised.
REF: 为了支撑这笔费用,就必须增加政府收入。
TH : 鉴于这一观点,我们必须增加支出。
EN: When it comes to economic policy, a fast, faulty decision is often better than inaction.
REF: 当谈到经济政策时,一个快速的、错误的决定通常是比无所作为要好。
TH : 鉴于经济决策,但通常比经济决策,因为其决策的境况通常是积极的。
EN: Furthermore, the slow pace of European decision-making has compounded Greece's troubles.
REF: 此外,欧洲缓慢的决策过程也加深了希腊的麻烦。
TH : 此外,英国选民决定了欧洲国家,但英国退出投票。
这些结果同时说明两件事。
第一，正面信号：
模型并非输出随机 token。
它学会了中文连接方式、部分句式、标点和主题领域词。
“欧洲 / 希腊 / 经济 / 决策 / 支出”等语义场会进入输出。
换句话说，S3 的表面语言 decoder 已经开始工作。它不再只是输出类别桶，也不只是复制输入。
第二，关键不足：
主题相近，不等于关系正确。
模型经常把训练集中同一主题的短语拼接到一起：
欧洲 -> 英国
财政刺激 -> 财政紧缩
决策缓慢 -> 退出投票
句子表面像中文，但事实关系、指代和谓词绑定仍然很不稳定。
6. TreeHeap 内部节点有没有参与？
我们还做了一个不重新训练的读取消融：
full       可读叶子和所有内部子堆
leaf_only  隐藏内部节点，只读叶子
root_only  只读整句 root
greedy 生成的 token-BLEU4：

  
      
          Read mode
          token-BLEU4
      
  
  
      
          full
          1.48
      
      
          leaf_only
          1.26
      
      
          root_only
          0.037
      
  

这说明 root 不是一个足够的万能 hash：只给 root 时，生成几乎崩溃。完整 TreeHeap 比 leaf-only 有小幅提升，说明内部节点可能已经带来一部分可用信息，但增益仍然很弱。
有一个审计细节必须记录：当前脚本的 ablation NLL 仍错误地沿用了 full-memory 的 teacher-forcing 路径，因此 ablation 的 NLL 相同、不能解释。上表只使用实际走 ablation read path 的 greedy generation 指标。下一次应加载本次 checkpoint 修正后重算，不必重训。
7. 这不是 QA，但它为 QA 打开了什么？
问答任务应该是：
[QUESTION] + [CONTEXT]
  -> TreeHeap
  -> answer tokens
这次 WMT 实验没有 question，也没有 answer span，因此不能叫 QA。
但它已经确认了 QA 所需的一条基础通路：
真实文本
  -> TreeHeap encoder
  -> 多步 decoder
  -> 自然语言输出
下一步不是继续把翻译 BLEU 当最终目标，而是换成真实 QA 三元数据：
context, question, answer
然后比较：
TreeHeap encoder
BoW encoder
flat sequence encoder
评价也应换成 QA 的答案指标，例如 exact match、token F1、ROUGE 或 answer BLEU，而不是只看翻译分数。
8. 当前 ARA 状态
S3-WMT-SEQ2SEQ-C01
  -> supported feasibility / negative comparative result
它支持的是：
TreeHeap 可以从真实 WMT 文本端到端训练，
并驱动一个中文 seq2seq decoder 产生可读、主题相关的句子。
它不支持的是：
TreeHeap 已优于 flat sequence。
TreeHeap 已完成翻译。
TreeHeap 已完成问答。
TreeHeap 已学到稳定世界模型。
这份边界不是泼冷水。它把下一步变得非常明确：先修正 internal-node ablation 的 teacher-forcing 评价，再接入真实 QA 数据，让 TreeHeap 的子堆读取回答“哪段 context 支撑当前答案”。



[SPR-051] P0 预训练后的第一次直接提问：失败比成功更有信息
Sun, 12 Jul 2026 00:00:00 +0000
P0 预训练后的第一次直接提问：失败比成功更有信息
这篇记录一个应该被正面保存的负结果。
我们刚完成了 TreeHeap 的 P0 原始中文文本预训练：不使用问答标签、不使用翻译对、不读取旧 checkpoint，只做最普通的自监督任务：
前 64 个中文 BPE token
    -> TreeHeap encoder
    -> 预测后续 32 个 BPE token
训练集来自新闻、百科和网页文本的混合。它的目标是先让模型从大量原始文字中学习语言分布；它不是一个已训练好的聊天模型。
1. 已经跑通了什么
本次主运行使用约 16,000 个 BPE 词表、192 维状态、12,785,921 个可训练参数，在 io 的 RTX 3090 上训练 50,000 step。

  
      
          指标
          开始
          结束
      
  
  
      
          验证 NLL
          9.658
          5.519
      
      
          验证 PPL
          15,626
          249.4
      
      
          训练时间
          -
          48.0 分钟
      
  

NLL 是模型对正确后续 token 的负对数概率，越小越好；PPL 是同一件事的指数形式，越小越好。这里的下降说明梯度确实从真实中文语料中更新了参数，模型比初始随机参数更会预测留出文本。
这支持的只是下面这个很小但真实的结论：
原始中文文本
  -> TreeHeap 编码器与 decoder
  -> 交叉熵梯度
  -> 更低的留出续写损失
它不自动推出“模型理解世界”。
2. 直接问它：地球为什么是圆的？
为了避免只看数字，我们直接加载训练完成的 checkpoint，以 greedy decoding（每一步总选概率最大的 token）做了两次 CLI 测试。
输入：地球为什么是圆的？
输出：圆圆圆圆圆圆圆圆圆圆圆圆圆圆圆圆……
输入：问：地球为什么是圆的？答：
输出：:圆圆::圆圆::圆圆::圆圆:圆圆圆……
这不是一个不够漂亮的答案，而是生成退化：模型把输入里显眼的“圆”当成局部最高概率 token，并在每一步再次选择它，形成循环。
正确答案至少需要表达类似关系：地球足够大，重力会把物质拉向中心，长期达到近似球形的平衡。当前模型没有给出这些关系。
3. 为什么它在 WMT 上看起来比这里顺一些？
此前的 WMT 英译中实验里，TreeHeap 有时能输出看似完整的中文句子。这不和本次失败矛盾。
翻译是强条件任务：
英文源句 + 对齐的中文目标
decoder 在每一步可以读取英文叶子、内部子堆和 root；训练还会用正确中文前缀进行 teacher forcing。因此它只需在一个受源句限制的候选空间中选下一个中文 token。
本次提问却要求模型：
短问题
  -> 从参数中取出有关重力与球形的知识
  -> 组织成解释
  -> 连续生成多个正确 token
而 P0 训练见到的是固定形态的 64 token 上下文 -> 32 token 后续，不是 问题 -> 答案。问题本身也远短于训练上下文。这既是任务格式变化，也是能力要求的大幅提升。
更重要的是，WMT 的数值本身也不强：TreeHeap 的 token-BLEU4 为 1.48，落后于 flat GRU 的 2.87。因此“看起来像中文”只能说明有表面语言信号，不能说明它已经可靠翻译，更不能说明它有问答能力。
4. 这次失败定位了什么
失败不是“GPU 没有训练”或“梯度没有写入参数”。验证 NLL 的大幅下降排除了这两种最初级的故障。
它暴露的是更靠后的三个缺口：

训练规模与语料覆盖不足。 5 万步、1,279 万参数的模型只能开始拟合局部文字分布，远不足以储存和组织通用事实。
生成策略过于脆弱。 greedy decoding 很容易被一个局部高概率 token 锁死。采样、温度、重复惩罚可以诊断这一点，但它们不能凭空补出知识。
没有问答格式和证据读取训练。 P0 应先提供语言与统计基础；后续 QA 阶段才应训练 question + context -> answer，并检验 decoder 是否能读到支持答案的子堆。

5. ARA 状态
S3-P0-WORLD-OBS-C01
  -> supported feasibility only
当前证据支持：TreeHeap P0 管线可以在真实中文语料上优化留出续写损失。
当前证据不支持：
TreeHeap 已形成世界模型
TreeHeap 可以回答开放问题
TreeHeap 已学会可靠的中文生成
TreeHeap 相比 flat sequence 有结构优势
下一步应先在完全相同的 P0 数据、词表、切分、参数量附近补齐 flat_seq 和 BoW 基线。只有先回答“TreeHeap 是否比非结构模型多学到了什么”，才值得继续扩大训练或进入 QA。
6. 可复查证据
训练证据：
ara/s3-generation/evidence/s3_p0_world_observation_main/

脚本：
ara/s3-generation/src/s3_treeheap_p0_pretrain.py

checkpoint：
checkpoint.pt
负结果不是航行失败的终点。它把“模型还不会什么”变成了可复查的事实，也防止我们把损失下降误读成理解已经出现。



[SPR-052] TreeHeap 终于参加了翻译考试，但还没有赢
Sun, 12 Jul 2026 00:00:00 +0000
TreeHeap 终于参加了翻译考试，但还没有赢
先说结论：

这次实验第一次强迫翻译 decoder 使用 TreeHeap 内部子堆。学出来的合并路径确实有一点作用，但 TreeHeap 仍然没有打败更简单的四段向量平均。
这是一个没有通过主 Claim、但让问题明显前进的实验。
1. 上一轮哪里有问题
我们希望模型这样翻译：
英文 token
  -> 写入 TreeHeap
  -> 合并成有意义的内部子堆
  -> decoder 读取子堆
  -> 生成中文
但上一轮代码实际上允许 decoder 同时读取：
全部原始 token 叶子
+
全部 TreeHeap 内部节点
实验结果是：隐藏全部内部节点以后，几乎没有变化。

  
      
          读取方式
          Test NLL
      
  
  
      
          叶子 + 内部节点
          6.0448
      
      
          只有叶子
          6.0434
      
  

两个数字越小越好，但它们几乎相同。
这说明 decoder 找到了最省事的办法：直接读取原始 token，绕过 TreeHeap。
可以把它想成一座仓库。我们认真设计了楼层、货架和分类区，却又把全部商品原样摆在门口。顾客自然不会进入仓库。
因此上一轮只能证明“程序计算了一棵树”，不能证明“翻译使用了这棵树”。
2. 什么叫 Frontier
这次我们关闭了门口的商品摊位。
假设英文源句被切成 16 个 BPE token：
x1 x2 x3 x4 ... x16
TreeHeap 每次选择两个相邻节点，把它们合成一个 parent：
[x1] [x2] [x3] [x4] ... [x16]
       ↓ 不断合并
[x1 x2 x3] [x4 x5] [x6 ... x10] [x11 ... x16]
当只剩四个互不重叠的子堆时停止：
F1 = [x1 x2 x3]
F2 = [x4 x5]
F3 = [x6 ... x10]
F4 = [x11 ... x16]
这四个仍然存活的节点叫作 K=4 frontier。
它们必须满足两个条件：

四个子堆共同覆盖全部源 token；
任意 token 只能属于一个子堆。

数学上写成：
\bigcup_{v\in F_K} Leaves(v)=Leaves(T)
Leaves(v_i)\cap Leaves(v_j)=\varnothing,\quad i\ne j
本实验中，decoder 只能读取：
[F1, F2, F3, F4]
它再也看不到背后的 16 个原始叶子。TreeHeap 结构终于成为翻译的必经通道。
3. 为什么一定限制为四个节点
如果 TreeHeap 给 decoder 30 个状态，而基线只给 4 个状态，那么 TreeHeap 即使获胜，也可能只是因为它携带的信息更多。
因此这次比较最重要的原则是：
所有压缩模型只能交出四个 192D 向量。
这类似考试时统一规定：每位考生只能带一张同样大小的草稿纸。
4. 五名考生分别做什么

  
      
          模型
          如何把英文压成四个状态
      
  
  
      
          Learned TreeHeap
          根据节点内容学习每次合并哪两个相邻子堆
      
      
          Fixed TreeHeap
          按固定、较平衡的规则合并
      
      
          Random TreeHeap
          按不可训练的随机规则合并
      
      
          Flat K=4
          把句子顺序切成四段，每段直接求平均
      
      
          Leaf Oracle
          GRU 读取全部 token，不受四状态限制，只作为上界
      
  

Learned TreeHeap 的一次合并是：
h_p=\tanh\left(MLP([h_l+e_L;h_r+e_R])\right)
其中：

h_l、h_r 是左右子堆；
e_L、e_R 表示左槽位与右槽位；
MLP 把两个 192D 向量重新压成一个 192D parent。

至于“这一步该合并哪一对”，由另一个 merge kernel 打分。训练时使用 Gumbel-Softmax：前向计算真的选择一对，反向传播仍能用翻译 loss 修改选择参数。
模型没有看到人工语法树，也没有主谓宾标签。唯一监督是正确中文翻译。
5. 数据与实验规模
任务：WMT17 English -> Chinese
训练集：5,000 对
验证集：500 对
测试集：500 对
英文长度：9..24 BPE token（EOS 前）
状态维度：192
训练：5 epochs
GPU：io 的 RTX 3090，保留 270W 限制
这是机制 smoke test，不是正式 WMT 竞赛规模。
6. 如何看懂三个指标
NLL：模型有多意外
NLL 是正确中文 token 的平均负对数概率。
越小越好
如果模型认为正确答案很可能出现，NLL 就低；如果它每一步都很犹豫，NLL 就高。
PPL：平均有多少候选让模型犹豫
PPL 是 NLL 的指数形式，也叫困惑度。
越小越好
它不能严格解释成候选词数量，但可以直观理解为：数字越大，模型越不知道下一步该选什么。
token-BLEU4：生成片段与参考答案有多像
它比较生成 token 片段和参考翻译的重合程度。
越大越好
这里使用的是实验脚本内的 BPE-token 指标，不是官方 WMT BLEU，不能和论文排行榜直接比较。
7. 主实验结果

  
      
          Encoder
          Test NLL ↓
          PPL ↓
          token-BLEU4 ↑
      
  
  
      
          Learned TreeHeap
          6.5988
          734.2
          0.226
      
      
          Fixed TreeHeap
          6.6012
          736.0
          0.159
      
      
          Random TreeHeap
          6.7020
          814.0
          0.185
      
      
          Flat K=4
          6.5080
          670.5
          0.431
      
      
          Leaf Oracle
          6.3541
          574.8
          0.792
      
  

我们逐层解读。
第一层：Learned 明显好于 Random
Learned NLL = 6.5988
Random  NLL = 6.7020
完全随机地决定子堆边界会损失更多翻译信息。树怎么折叠并非毫无影响。
第二层：Learned 与 Fixed 几乎相同
Learned NLL = 6.5988
Fixed   NLL = 6.6012
差值          0.0024
这个差异太小，不能声称 learned topology 优于普通平衡树。
第三层：Flat K=4 最强
Flat K=4 NLL = 6.5080
Learned NLL  = 6.5988
普通的四段平均比当前 TreeHeap 好 0.0908 NLL。因此新 Claim 的主预测没有通过。
第四层：四状态压缩确实有成本
不受限制的 Leaf Oracle 为 6.3541，明显优于全部四状态模型。这说明把 9..24 个 token 压成四个向量本来就是困难任务。
8. Learned route 真的有用吗
不同模型独立训练后有差距，可能来自随机初始化，而不一定来自 route。
所以我们加载同一个 Learned TreeHeap checkpoint，不改变 embedding、compose 或 decoder，只替换测试时的合并路径。

  
      
          同一 checkpoint 的测试 route
          NLL
          相对 learned
      
  
  
      
          Learned route
          6.5988
          -
      
      
          Fixed route
          6.6085
          +0.0097
      
      
          Random route
          6.6272
          +0.0285
      
  

替换 route 后，性能确实下降。这说明 learned route 已经产生了因果作用，而不只是画出一棵没人读取的树。
但我们事先规定：NLL 至少恶化 0.05，才升级 Claim。现在最大的变化只有 0.0285，没有过线。
因此最准确的判断是：
route 有微弱作用；
当前 TreeHeap 压缩仍然不如 flat K=4。
9. 实际翻译是什么样
EN : ensuring the highest possible standards of security
     for nuclear weapons and materials

REF: 确保对核武器及材料执行最高的安全标准

TH : 布什政府会让美国人的政治家和反射率。
EN : beginning a dialogue on tactical nuclear weapons
     involving Russia, the US, and NATO

REF: 启动俄罗斯、美国和北约参与的战术核武器对话

TH : 但对一体的……但对伊朗的……
模型能生成中文句式和部分主题词，但关系、实体和事实绑定仍然不可靠。本实验评估的是结构机制，不是翻译质量成功。
10. 为什么简单平均反而保存得更好
Flat K=4 做的事情很朴素：
f_k=Projection\left(\frac{1}{|S_k|}\sum_{i\in S_k}h_i\right)
它先对一个连续区域求平均。这个过程不理解语法，却提供了一条稳定的线性信息通道：每个 token 都直接参与结果。
当前 TreeHeap compose 则反复执行：
两个 192D 子堆
-> MLP + tanh
-> 一个 192D parent
-> 再和别的 parent 合并
每次非线性压缩都可能丢掉人名、数字、否定词和实体关系。重复多层以后，parent 也许保留了模糊主题，却失去了翻译所需的精确细节。
这和把两份文件概括成一句摘要类似。摘要可能说对了主题，但很难保留所有姓名、金额和逻辑关系。
11. 下一步不是继续调 route
叶子旁路已经排除，route 也出现了小幅因果信号。继续只改 route，未必能解决 flat K=4 领先的问题。
下一步更合理的节点设计是把两类信息分开：
TreeHeapNode {
    structure_state   # 这个子堆是什么结构
    value_residual    # 原始词汇和实体的保真信息
    left/right        # 子节点地址
    probability_mass  # 当前候选质量
}
可以把它类比成压缩文件：

structure_state 是目录和索引；
value_residual 是不能丢失的实际文件内容。

一个可能的 value-preserving compose 是：
s_p=Compose_\theta(s_l,s_r)
v_p=g_l\odot v_l+g_r\odot v_r+r_\theta(s_l,s_r)
结构 kernel 决定如何组织，残差通道负责把梯度和内容继续传向上层。
12. 最终 ARA 判定
S3-WMT-FRONTIER-C01
  -> 主 Claim 未支持
  -> 保留 weak causal route signal
这次实验没有证明 TreeHeap 优于 flat，更没有证明世界模型或意识已经出现。
它真正完成了三件事：

关闭了 decoder 偷看全部叶子的旁路；
证明 learned route 对真实翻译有微弱因果作用；
定位了新的主要问题：当前 compose 不如线性平均保真。

问题已经从“树有没有参与”推进到“树怎样在学习结构时不丢内容”。这是一个更具体、也更容易继续证伪的工程问题。



[SPR-053] 不让神经网络重写整棵树：让它学习选择 TreeHeap 算子
Sun, 12 Jul 2026 00:00:00 +0000
不让神经网络重写整棵树：让它学习选择 TreeHeap 算子
Houming818 提出了两个比“再调一个模型”更根本的判断：

数据中的结构规律，应该能够被 encoder 提取，并成为 encoder 与 decoder 共同使用的表示；
TreeHeap 中的数据变化，应该由 TreeHeap 自己的地址、子堆与算子完成，而不是让普通 MLP 把整个数组重新写一遍。

本实验不拿语言任务掩盖问题，而是在一个有限、可检查的世界里问：神经网络能否只负责认出操作，真正的数据变换交给 TreeHeap 代数执行？
1. 一个七节点例子
采用从 1 开始编号的二叉堆：
          A[1]
        /      \
     A[2]      A[3]
     /  \      /  \
  A[4] A[5] A[6] A[7]
地址规则是：
$$ \operatorname{left}(i)=2i,\qquad \operatorname{right}(i)=2i+1 $$为了让错误可以被客观识别，我们构造一个简单的数论世界：
$$ A[2i]=2A[i],\qquad A[2i+1]=2A[i]+1 $$若根节点为 1，合法状态就是 [1,2,3,4,5,6,7]。实验随机选择一段子堆，用 TreeHeap 原生算子破坏它：
MIRROR(address, depth)
SUBTREE_PLUS(address, depth, delta)
例如 SUBTREE_PLUS(2, 1, 3) 把地址 2 及其下一层子节点都加 3；MIRROR 递归交换指定子堆的左右分支。
2. encoder 学习什么
这里的参数 $\theta$ 不是目标 TreeHeap，也不保存每一棵答案树。它是在所有节点上共享的小型识别 kernel：
$$ K_\theta(H,i)\rightarrow\bigl(P(o),P(i),P(d),P(\delta)\bigr) $$
$H$：当前被破坏的完整 TreeHeap 状态；
$i$：kernel 正在观察的候选地址；
$o$：mirror 或 plus；
$d$：递归深度；
$\delta$：加法参数。

kernel 读取当前节点及其父子违反数论规则的残差，并汇总各相对深度的子堆残差。它不输出 511 个新数，而是输出一张很短的维修工单：
operator = plus
address  = 12
depth    = 2
delta    = -3
概率桶坍缩后，固定 executor 执行逆操作：
$$ \hat H=E_{\text{TreeHeap}}(H,\hat o,\hat i,\hat d,\hat\delta) $$最后检查 $\hat H$ 是否与原始合法 TreeHeap 逐节点完全相同。神经网络没有权限直接生成答案数组。

  
      
          对象
          含义
          是否学习
      
  
  
      
          $H$
          当前 TreeHeap 数据状态
          每个样本不同
      
      
          $\theta$
          识别操作程序的共享 kernel
          梯度学习
      
      
          地址和算子
          2i/2i+1、mirror、subtree plus
          固定数学规则
      
  

3. 怎样避免背答案
训练只出现浅地址和递归深度 1、2。测试分为：

  
      
          测试
          地址
          操作深度
      
  
  
      
          IID
          训练范围内
          1–2
      
      
          OOD address
          从未训练的深地址
          1–2
      
      
          OOD depth
          浅地址
          从未训练的 3–4
      
      
          OOD joint
          深地址
          3–4
      
  

两个对照模型是：

flat_program：把 511 个位置摊平，再预测同一张维修工单；
flat_rewriter：把 511 个位置摊平，直接输出修复后的 511 个数。

4. 结果体检表
数值是整棵树完全恢复的比例，越大越好：

  
      
          测试
          结构程序 + 固定算子
          Flat 程序
          Flat 直接改写
          判断
      
  
  
      
          IID
          92.70%
          15.35%
          72.05%
          强阳性
      
      
          未见地址
          84.00%
          0%
          0%
          强阳性
      
      
          未见深度
          4.40%
          0%
          0%
          不合格
      
      
          地址与深度同时未见
          5.80%
          0%
          0%
          不合格
      
  


  
      
          模型
          参数量
      
  
  
      
          结构程序 encoder
          41,671
      
      
          Flat 程序预测
          235,913
      
      
          Flat 直接改写
          196,927
      
  

这支持一个窄但实在的结论：共享的树结构 kernel 学到了一种可以搬到新地址的识别规则；摊平模型只记住训练位置。
5. 为什么未见深度失败
我们增加了一项诊断：把真实地址告诉 depth decoder，只检查它能不能读出从未训练的深度 3、4。结果是 93.65%。
可是不提供真实地址时，OOD-depth 的地址准确率只有 10.75%，整树恢复随之跌到 4.40%。这说明：

深度本身大多可以从残差波中读出，但更深的操作改变了整片残差的形状，使只见过浅操作的地址定位器走错了。
所以当前 Claim 只能“部分支持”。它证明了地址迁移，没有证明递归深度外推。
下一步不是增加更大的 MLP，而是把一次性猜全局地址改成真正共享的递归过程：kernel 从根开始反复输出 stop/left/right，在每一层用同一规则寻找残差边界。只有它在深度 1、2 上训练，却能循环到 3、4，才算递归规律进入 encoder。
6. 单机 AI 的存活空间
这个实验尚未证明语言、世界模型或意识，但展示了一条适合单机研究的计算路线：
大网络直接生成全部状态
        改为
小网络识别短程序 + 确定代数执行大量状态变化
一次子堆 mirror 可以改变许多节点，但学习器只需输出算子、地址和深度。树越大，程序描述不必同比增长。这是 TreeHeap 可能节省样本、参数和计算的具体来源，不是口号。
真正的语言版本仍需回答：语料中的哪些规律能形成这种可执行程序，以及 encoder 如何在没有人工数论规则时发现它们。SPR-053 只搭起第一座受控桥梁：结构可以进入短程序，短程序可以调用 TreeHeap 自身算子恢复数据；但递归定位还没有学会。
Evidence

Claim: M0-OPCODEC-C01
Source: algebraic_operator_codec_probe.py
Evidence: algebraic_operator_codec_probe
Seed: 53
Device: io.grepcode.cn, NVIDIA RTX 3090


版权、原创与许可证
Copyright (C) 2026 Houming818 and SameTime contributors.
本文由 Houming818 提出核心研究方向，Codex Review 参与数学整理、ARA 声明、实验实现与结果分析。正文、表格和伪代码为本项目原创表达；实验结论以公开 ARA 源码和 Evidence 为边界，不声称已经证明语言、世界模型或意识。

SPDX-License-Identifier: GPL-3.0-only
License: GNU General Public License v3.0 only
本文允许复制、修改和分发，但衍生版本必须继续遵守 GNU GPL v3，并保留版权、许可证、修改说明及来源声明。完整许可证文本见本站 /LICENSE。
本文按“原样”提供，不附带任何明示或暗示担保。数学思想和事实本身不受版权垄断；本许可证适用于本文的原创文字、结构、表格、伪代码及其他可受版权保护的表达。



[SPR-054] TreeHeap 多分辨率金字塔：root 看全局，子堆保存细节
Tue, 14 Jul 2026 00:00:00 +0000
TreeHeap 多分辨率金字塔：root 看全局，子堆保存细节
先说这篇文章提出的新假设：

TreeHeap 不应该强迫一个 root 无损背下整句话。更合理的设计是：root 保存全局轮廓，各层 subheap 保存逐步补回细节所需的低维编码。
这与缩小一张图片很像。
一张 1024 x 1024 的照片缩成 64 x 64 后，不可能保留每一根头发，但我们仍然可能看出：

画面里有没有人；
人站在哪里；
背景是房间还是街道；
整体颜色和轮廓是什么。

丢失的主要是细小纹理。
对于语言，TreeHeap 的叶子可以看成高分辨率数据，内部节点是中等分辨率，root 是最低分辨率的全局摘要：
token leaves       原始高分辨率
local subheaps     局部短语与关系
upper subheaps     更大范围的组合
root               全局低分辨率表示
但这仍然只是类比。它是否真的成立，必须变成一个可以失败的实验。

1. 为什么现在提出这个问题
上一轮实验已经用完整中文语料训练了一个 TreeHeap root compressor。
输入是64个 token：
x1, x2, ..., x64
TreeHeap 反复用共享的三槽 kernel 折叠相邻节点：
[root, left, right]
最后只留下一个192维 root，由 decoder 预测下一个 token。
这次全量训练处理了：
文档数             7,564,966
训练 block 数      38,251,247
news block        28,052,019
wiki block         4,375,165
web block          5,824,063
训练时间            7.94 小时
最终可用模型是四头无残差 TreeHeap：

  
      
          指标
          结果
      
  
  
      
          验证 NLL，越低越好
          6.2365
      
      
          Top-1
          11.96%
      
      
          Top-5
          23.29%
      
      
          root variance
          0.05843
      
  

更重要的是，破坏左右地址配对后，NLL 增加了 2.6252。
这说明 root 不是普通词袋。它确实依赖 TreeHeap 的递归地址和左右配对，保存了某些有助于预测的全局信息。
但它没有回答另一个问题：

root 丢掉了哪些细节？能否用少量、分层的补充信息把这些细节找回来？

2. 不要让 root 背诵整句话
假设每个 token 是192维，64个 token 一共需要：
$$ 64 \times 192 = 12288 $$个浮点数。
如果把它们压成一个192维 root，容量只剩原来的：
$$ \frac{192}{12288}=1.56\% $$这显然是强压缩。
强压缩不等于错误。问题在于任务需要什么。
如果任务只是判断“大致在说吃饭还是旅行”，root 也许已经够用；如果任务是逐词 echo、翻译人名或还原数字，root 就可能丢失关键细节。
因此我们不再要求：
一个 root = 完整句子
而改成：
一个 root        = 全局摘要
多层 detail code = 折叠时丢失的局部细节

3. 新的数据结构长什么样
对于左右两个子节点：
$$ L,\;R \in \mathbb{R}^{192} $$已经训练好的 TreeHeap fold kernel 生成父节点：
$$ P=D_\theta(L,R) $$这里的 $D_\theta$ 是上一轮完整训练得到的模型。新实验会冻结它，不允许它继续变化。
然后增加一个细节编码器：
$$ d=Q_\phi(L,R,P),\qquad d\in\mathbb{R}^{k} $$其中 $k$ 比192小很多，例如8、16、32或64。
解码器读取父节点和细节：
$$ (\hat L,\hat R)=U_\psi(P,d) $$如果 $\hat L$ 和 $\hat R$ 接近原来的 $L$、$R$，说明：
父节点 P          保存了公共、粗粒度信息
细节向量 d         保存了区分左右孩子所需的信息
完整节点可以写成：
PyramidNode {
    coarse_state P
    detail_code  d
    left_address
    right_address
}
解码从 root 开始：
root + 顶层 detail
  -> 两个较粗子节点

每个子节点 + 下一层 detail
  -> 四个更细节点

不断递归
  -> 尽可能恢复64个叶子
这就是 TreeHeap 多分辨率金字塔。

4. 这和普通残差有什么不同
普通残差通常写成：
$$ H_{t+1}=H_t+\Delta H_t $$它主要用于让旧状态和梯度穿过深层网络。
本文的 detail code 不直接加回同一个状态。它回答的是另一个问题：

把两个高分辨率孩子压成一个低分辨率父节点以后，重建孩子还缺少什么信息？
所以这里更接近图像的拉普拉斯金字塔或小波中的“低频摘要 + 高频细节”：
coarse state   负责大轮廓
detail code    负责缺失差异
上一轮四头残差模型在 step 62,400 发生 NaN，已经否定了当时那个“无约束全局残差尺度”的实现。
新方案不会复用那个失败公式。它冻结成功的无残差 root encoder，只训练独立的 detail encoder 和 decoder。

5. 它真的压缩了吗
一棵64叶子的完全二叉树有63个内部节点。
如果只保存一个192维 root，并为每个内部节点保存 $k$ 维 detail，那么总容量是：
$$ R(k)=192+63k $$
  
      
          detail宽度 $k$
          总浮点数
          原始容量占比
      
  
  
      
          0
          192
          1.56%
      
      
          8
          696
          5.66%
      
      
          16
          1,200
          9.77%
      
      
          32
          2,208
          17.97%
      
      
          64
          4,224
          34.38%
      
      
          原始叶子
          12,288
          100%
      
  

例如 k=32 时，只使用原始激活量的约18%。
如果它已经能恢复大部分 token 和顺序，就出现了有价值的压缩；如果必须把 k 增加到接近192才能恢复，那么它虽然能编码，却没有明显压缩优势。
这里说的只是“浮点数数量”，还不是严格的比特压缩。只有完成量化、熵编码和实际文件大小测量后，才能讨论真正的 bit rate。

6. 新 Claim
新声明编号：
S3-TREEHEAP-PYRAMID-C01
正式内容是：

一个冻结的 TreeHeap root compressor 可以扩展为多分辨率 codec：root 保存粗粒度、与任务相关的状态；每个内部地址保存有界的 detail code。随着 detail 容量增加，真实语料的重建质量应单调提高，同时冻结 root 的下一词预测能力保持不变。
当前状态：
supported mechanism / three-seed 1M-block proof
它已经得到三 seed 实验支持，但结论仅限于本文实现的激活空间 codec，不能外推为通用压缩或架构优越性。

7. Predict：成立时我们应该看到什么
P1：root 的旧能力必须完全保留
完整语料 checkpoint 原来的验证 NLL 是：
6.236525
正式实验另取固定 audit 子集，在训练 detail codec 前后各测一次。新模块不能偷偷改写 root：
$$ |NLL_{after}-NLL_{before}|<10^{-5} $$如果变化，说明代码存在旁路或错误。
P2：细节越多，恢复应该越好
我们预测：
$$ E_{root}>E_8>E_{16}>E_{32}>E_{64} $$其中 $E$ 是叶子状态的重建误差。
对应的 token Top-1、Top-5和顺序恢复率应该反向单调上升。
P3：形成清楚的率失真曲线
横轴是存储容量，纵轴是重建误差：
容量小 --------------------> 容量大
误差大 --------------------> 误差小
detail容量与重建质量的 Spearman 相关性应至少达到 0.9。
P4：有限容量必须带来明显收益
k=64 必须让 root-only 的重建 MSE 至少下降50%。
如果增加了大量细节却只改善一点点，说明当前 fold 已经过早破坏了信息。
P5：TreeHeap 地址必须有用
打乱左右地址以后，至少满足一个条件：
重建 MSE 增加 >= 10%
或
token accuracy 下降 >= 5 个百分点
P6：不能只打败自己
在相同存储容量下，它还要比较：

固定平均池化金字塔；
固定 Haar 式平均/差分；
flat autoencoder；
随机左右配对树。

只有 TreeHeap 在至少一个有效容量上击败这些对照，才能提出“TreeHeap具有更好率失真归纳偏置”的后续声明。

8. 实验怎样执行
第一轮不直接再跑八小时。
真实语料 block       1,000,000
上下文长度            64 token
冻结 root encoder      四头无残差 checkpoint
detail k              0 / 8 / 16 / 32 / 64
随机种子               3
训练过程：

读取冻结 TreeHeap；
保存每层的 left、right、parent 状态；
只训练 $Q_\phi$ 和 $U_\psi$；
在未见过的 block 上递归重建；
输出每个容量的率失真曲线；
做地址破坏和逐层 detail 消融。

指标分开报告，不能只给一个“大锅 loss”：

  
      
          指标
          检查什么
      
  
  
      
          root next-token NLL
          全局预测能力是否被破坏
      
      
          leaf embedding MSE
          连续状态恢复
      
      
          token Top-1/Top-5
          词面恢复
      
      
          sequence token accuracy
          整句恢复
      
      
          edit similarity
          顺序接近程度
      
      
          bag overlap
          内容是否回来
      
      
          position accuracy
          地址与次序是否回来
      
      
          floats/token
          付出了多少容量
      
  


9. 实验结果：金字塔成立了吗
正式实验在 io 的 RTX 3090 上完成。三个随机种子分别是：
71401 / 71402 / 71403
每个 seed 读取 1,000,000 个真实中文文本 block，并在 8,192 个 held-out block 上评估。训练期间，原 TreeHeap root encoder 和 next-token decoder 完全冻结。
先给一张“体检报告”。指标方向如下：
MSE             越低越好
存储比例         越低越省容量
Token Top-1     越高越好
Sequence Exact  越高越好，要求64个位置全部恢复正确

  
      
          detail $k$
          TreeHeap存储
          Flat存储
          TreeHeap MSE
          Flat MSE
          Haar MSE
          Token Top-1
          64-token整段Exact
      
  
  
      
          0
          192
          192
          1.9334
          1.9104
          1.9110
          6.50%
          0.00%
      
      
          8
          696
          768
          0.8803
          1.8416
          1.8232
          51.05%
          0.00%
      
      
          16
          1,200
          1,344
          0.7622
          1.7459
          1.7471
          76.84%
          0.00%
      
      
          32
          2,208
          2,304
          0.6516
          1.7047
          1.5979
          95.01%
          5.99%
      
      
          64
          4,224
          4,224
          0.5526
          1.6042
          1.2881
          99.64%
          82.68%
      
  

这张表可以分三步理解。
9.1 只有 root 时，TreeHeap 没有神奇优势
k=0 时只保存一个192维 root。TreeHeap MSE 是 1.9334，反而略差于 flat 和 Haar 的约 1.91。
这很重要：实验没有证明“只要叫 TreeHeap 就一定更好”。一个只占原始容量 1.56% 的 root 主要保存预测下一个 token 所需的粗粒度信息，不能无损背下64个叶状态。
9.2 加入带地址 detail 后，误差稳定下降
三个 seed 都得到严格单调曲线：
$$ 1.9334 > 0.8803 > 0.7622 > 0.6516 > 0.5526 $$detail 宽度与恢复质量的 Spearman 相关系数在三个 seed 中都约为 1.0。k=64 只使用原始激活量的 34.38%，MSE 已降到 root-only 的 28.6%，超过了预注册的“至少减半”门槛。
这里的 token 指标，是把重建叶向量放回冻结 encoder 的 embedding 坐标系，寻找最近 token。k=64 的平均 token Top-1 是 99.64%，64个位置全部正确的整段恢复率是 82.68%。
9.3 地址不是装饰
把已经学好的 detail code 循环移动到错误地址，k=64 的 MSE 从：
0.5526 -> 3.3147
它不只是变差一点，而是比 root-only 还差。这说明 decoder 依赖“哪段细节属于哪个内部地址”。detail 是带地址的局部信息，不是可以随便交换的附加向量袋。
9.4 stronger flat baseline 仍有失败尾部
最初 smoke 使用固定 256D 隐层的 flat autoencoder。我们发现这会人为卡住大码率模型，于是在正式实验前主动中止，并改成拥有 1/4/7/12/22 个192维 latent 的 flat attention codec。它在多数档位还获得了比 TreeHeap略多的存储预算。
正式 flat k=64 的三个 seed MSE 是：
1.5245 / 1.3767 / 1.9113
TreeHeap 对应为：
0.5526 / 0.5499 / 0.5554
TreeHeap 在本次对照中不仅均值更低，而且 seed 更稳定。但 flat 的第三个 seed 明显发生了 latent 学习失败，所以本文只能说：

当前 TreeHeap pyramid 击败了本实验实现的同码率 flat attention codec 和固定 Haar codec。
不能说：

TreeHeap 已经击败所有 autoencoder、Transformer 或所有可能的压缩算法。
9.5 Predict 判定

  
      
          Predict
          结果
          判定
      
  
  
      
          P1 root NLL不变
          audit NLL 6.2997973263 -> 6.2997973263，参数指纹相同
          通过
      
      
          P2 MSE随容量单调下降
          三个 seed 全部严格单调
          通过
      
      
          P3 Spearman至少0.9
          三个 seed 均约1.0
          通过
      
      
          P4 k=64至少减半MSE
          降至root-only的28.6%
          通过
      
      
          P5 地址破坏明显伤害
          MSE增加约500%
          通过
      
      
          P6 击败已实现同码率对照
          k=8到64均优于flat/Haar
          有界通过
      
  

因此，Claim S3-TREEHEAP-PYRAMID-C01 从 experiment pending 更新为：
supported mechanism / three-seed 1M-block proof
仍未完成的部分包括：独立 random-pairing 训练、逐层 detail 消融、量化、熵编码以及更强的 flat/Transformer codec。尤其在逐层消融完成前，不能声称高层一定学习“全局语义”、低层一定学习“词面细节”。

10. Toy：为什么逐层细节有意义
考虑一句短句：
the cat is eating rice
最低分辨率 root 可能只能表达：
某个主体正在进行进食活动
加入顶层 detail 后，可能恢复：
主体部分 | 动作与对象部分
继续加入更低层 detail：
the cat | is eating rice
最后才恢复具体词面：
the | cat | is | eating | rice
这不是说模型一定会形成这些人类语法标签。实验只检查一个更基础的事实：

不同层级是否真的以越来越大的容量，逐渐补回越来越细的信息。
如果没有这种渐进关系，“金字塔”就只是一个漂亮名字。

11. 什么结果会否定它
以下任一情况都会让 Claim 被拒绝或缩小：

增加 detail 后，重建误差不单调下降；
必须接近原始容量才能恢复；
随机树和真实地址表现相同；
平均池化或 flat autoencoder 在同容量下全面更好；
root NLL发生变化，说明实验偷偷改写了旧模型；
所有层的 detail 完全可以互换，没有尺度分工。

失败不是“调参不够”。这些失败会直接告诉我们：
当前 TreeHeap fold 不是合适的降采样核
或
语言信息不适合按当前地址形成多尺度编码

12. 哪些部分是我们的原创
为了避免把已有数学重新命名为自己的发明，这里明确划界。
已有公共理论包括：

多分辨率分析；
高斯与拉普拉斯图像金字塔；
小波与平均/差分分解；
autoencoder；
信息论中的率失真理论。

我们不声称这些理论由 SameTime 发明。
本文的原创研究贡献是：

把已经测得地址因果性的 TreeHeap root compressor 定义为冻结降采样核；
设计“一个 root + 每个内部地址一个低维 detail code”的语言 TreeHeap codec；
给出固定容量公式 $R(k)=192+63k$；
设计 root 不回归、渐进恢复、地址破坏、同容量基线和层级消融；
登记可证伪 Claim S3-TREEHEAP-PYRAMID-C01 及其数值门槛。

这是 SameTime 项目在现有数学基础上的原创架构假设与实验协议。本文报告的三 seed 结果支持其有限机制 Claim，但不构成“世界首创”、专利新颖性或通用架构优越性结论。

13. ARA 与可复核材料
正式 ARA：

Multiresolution TreeHeap Pyramid
S3 Claims Registry
上一轮全量实验分析
本次实验结果分析
本次原始汇总数据

任何后续文章都必须同时报告通过和失败的 Predict，不允许只展示最好的一条曲线。

版权、原创与许可证
Copyright (C) 2026 Houming818 and SameTime contributors.
本文由 Houming818 提出核心类比与研究方向，Codex Review 参与数学整理、ARA声明和实验协议编写。正文与伪代码为本项目原创表达，没有复制第三方论文正文、代码或插图；已有理论已在上一节明确列为公共学术背景。

SPDX-License-Identifier: GPL-3.0-only

License: GNU General Public License v3.0 only
本文允许复制、修改和分发，但衍生版本必须继续遵守 GNU GPL v3，并保留版权、许可证、修改说明及来源声明。完整许可证文本见本站 /LICENSE。
本文按“原样”提供，不附带任何明示或暗示担保。数学思想和事实本身不受版权垄断；本许可证适用于本文的原创文字、结构、表格、伪代码及其他可受版权保护的表达。



[SPR-055] 让信息向 root 生长：TreeHeap 的多尺度 Mask 学习
Tue, 14 Jul 2026 00:00:00 +0000
让信息向 root 生长：TreeHeap 的多尺度 Mask 学习
这篇文章先不宣布实验胜利。
相反，我们想带着一点更具体的希望，重新提出一个问题：

如果普通 echo 只要求模型恢复眼前的 token，那么模型为什么要费力把信息送到 root？
这句话来自 Houming818 对当前实验的修正。它改变了我们看待 TreeHeap encoder 的方式。
此前我们容易把注意力放在算子的形式上：FOLD 怎样计算，DETAIL 怎样保存，UNFOLD 怎样恢复。可是即使所有算子都在树上递归执行，只要训练问题太简单，模型仍然会选择最短的解题路线。
这不一定说明 TreeHeap 没有能力。更可能说明：我们问的问题还不够深。

1. 当前模型为什么偏爱 detail
假设一句话被写入一棵 TreeHeap：
                    root
                  /      \
            subheap A    subheap B
             /   \        /   \
           x1    x2      x3    x4
普通 echo 的任务只是输入 x1、x2、x3、x4，再输出同样的 x1、x2、x3、x4。
如果每个局部 detail 都能保存附近 token，模型就可以走一条很短的路：
x1 -> detail1 -> x1
x2 -> detail2 -> x2
x3 -> detail3 -> x3
x4 -> detail4 -> x4
这条路短、梯度直接、loss 下降快。
相比之下，把信息先抽到 parent，再抽到 root，最后递归展开回来，需要经过更多卷积：
token
  -> local fold
  -> parent fold
  -> root
  -> parent unfold
  -> local unfold
  -> token
如果两条路都能完成 echo，优化器没有理由主动选择更长的那条。
因此，root 没有成为主要信息载体，并不令人意外。普通 echo 实际上只问了一个浅层问题：

你能不能把刚刚看到的符号再写一遍？
它没有问：

当局部信息缺失时，你能否利用更大范围的结构推断它？

2. 不要强迫 root，应该给 root 一份工作
一种直接做法是在公式里规定：没有 root 就不允许 decoder 工作。
这样当然能让 root 参与，但它更像人为封路。模型使用 root，是因为程序员不准它走别的路，而不一定是因为数据中的规律需要 root。
Houming818 提出的方向更自然：

不要从结构上强迫 root 参与。通过扰动和 Mask 提出更深的问题，让局部 detail 无法单独回答，root 和上层卷积结果才有机会自然获得信息。
也就是说，我们不预先规定 root 必须表示句意。
我们只改变训练问题，让不同尺度的节点承担不同尺度的信息需求。

3. 从 Mask 一个词，到 Mask 一整个子堆
考虑一句简单的话：
今天 我 吃了 一碗 米饭
3.1 只遮挡一个 token
今天 我 吃了 一碗 [MASK]
局部信息“一碗”已经提供了很强的提示。附近节点可能就能给出一个概率桶：

  
      
          候选
          概率示意
      
  
  
      
          米饭
          0.31
      
      
          面条
          0.24
      
      
          粥
          0.12
      
      
          药
          0.03
      
      
          其他
          0.30
      
  

这主要训练局部共现。
3.2 遮挡一个小 subheap
今天 我 吃了 [一碗 米饭]
现在局部 detail 被整个拿走。模型需要结合“我”“吃了”和前后上下文，才能判断缺失部分大概是食物或用餐对象。
这开始要求 parent 和 sibling 提供信息。
3.3 遮挡更大的 subheap
今天 我 [吃了 一碗 米饭]
模型必须从更高层状态判断：

这里缺少一个事件；
事件可能与“今天”和“我”有关；
输出应当是一段动作描述，而不只是一个孤立名词。

此时，靠近 root 的状态才真正获得了一份局部 detail 无法独立完成的工作。

4. TreeHeap Mask 不是普通随机遮字
普通语言模型会随机遮掉若干 token。TreeHeap 可以做得更有结构，因为它已经拥有地址、路径和 subheap。
我们可以直接使用 TreeHeap 代数中的操作构造扰动：

  
      
          扰动方式
          操作对象
          想检查的能力
      
  
  
      
          leaf mask
          单个叶子
          局部共现
      
      
          sibling mask
          一对孩子
          parent 是否保存摘要
      
      
          subheap cut
          完整子堆
          ancestor 是否保存更大范围信息
      
      
          detail dropout
          某层 detail
          粗粒度状态能否补回细节
      
      
          subtree replacement
          用别的子堆替换
          模型能否发现上下文不一致
      
      
          address shift
          detail 移到错误地址
          路径和地址是否有真实作用
      
      
          mirror perturbation
          子堆左右翻转
          顺序与手性信息是否被编码
      
  

这里最重要的是：扰动对象仍然是 TreeHeap 中的合法对象。
不是先把树摊平成数组，再用另一套代数随便打乱；而是使用 CUT、MASK、REPLACE、SHIFT、MIRROR 等树上操作改变同一个数据结构。

5. 两种 Mask，回答两个不同问题
5.1 压缩式 Mask
Encoder 看过完整输入，但 decoder 随机拿不到某些 detail：
完整句子
  -> encoder
  -> root + 多层 detail
  -> 丢弃部分 detail
  -> decoder 恢复原句
它研究的是：

信息有没有从 leaf 向 parent 和 root 形成冗余摘要？
如果丢掉局部 detail 后，上层状态仍能恢复一部分内容，说明信息确实向上抽取了。
5.2 推断式 Mask
Encoder 从一开始就看不到被遮挡内容：
受损句子
  -> encoder
  -> TreeHeap
  -> 预测缺失 subheap
它研究的是：

模型是否从真实语料中学到了可以补全缺失信息的统计规律？
这种任务不要求模型逐字恢复任意随机内容。正确输出是概率分布，而不是提前写好的唯一答案。
压缩和推断都重要，但它们回答的是不同问题，实验必须分开报告。

6. 卷积怎样推动信息向上生长
在每个内部节点，encoder 使用共享分析卷积核：
$$ p_i = K_{\mathrm{fold}}(h_{2i}, h_{2i+1}) $$继续递归：
$$ p_{\operatorname{parent}(i)} = K_{\mathrm{fold}}(p_i,p_j) $$同一个 kernel 在不同地址和深度重复使用。因此，一条信息若要到达 root，必须经历多次相同类型的局部抽取。
Decoder 使用共享合成卷积核：
$$ (\hat h_{2i},\hat h_{2i+1}) = K_{\mathrm{unfold}}(p_i,d_i) $$Mask 训练产生的梯度会沿着递归链返回：
缺失 token 的 loss
  -> unfold kernel
  -> ancestor state
  -> fold kernel
  -> 更低层输入
如果只 Mask 一个叶子，梯度可能主要停留在附近。
如果 Mask 整个 subheap，局部节点已经没有答案，梯度必须要求更高层状态改善。这才是“把信息抽到离 root 更近的地方”的具体学习过程。

7. 不使用一锅炖的 Loss
我们不打算一次把所有尺度混成一个难以解释的总 loss。
更清晰的方法是让不同 batch 轮流提出不同深度的问题：
batch 1  leaf mask
batch 2  depth-1 subheap mask
batch 3  depth-2 subheap mask
batch 4  depth-3 subheap mask
batch 5  detail dropout
batch 6  subtree replacement
每个 batch 只计算受损区域的交叉熵：
$$ L_d = -\sum_{i\in M_d} \log P(x_i\mid H_{\setminus M_d}) $$其中 $M_d$ 表示尺度为 $d$ 的被遮挡子堆。
这样可以分别观察：

哪一种扰动开始需要 root；
哪一层信息最容易恢复；
梯度能否通过递归卷积到达高层；
不同 kernel 是否在不同尺度形成分工。

我们不必一开始就知道 root 最终会表示“主谓宾”“主题”还是其他人类标签。只需要观察：随着问题尺度扩大，高层状态是否越来越有用。

8. 我们期待看到什么趋势
这篇文章暂时没有新实验结果，因此下面是 Predict，不是结论。
最关键的测量不是普通 echo 能否达到 100%，而是：
$$ \Delta L_{\mathrm{root}}(d) = L_d(H_{\mathrm{root}}=0)-L_d(H_{\mathrm{root}}) $$其中 $d$ 是被遮挡子堆的尺度。
我们期待：
$$ \Delta L_{\mathrm{root}}(d+1) > \Delta L_{\mathrm{root}}(d) $$用普通话说：

遮挡范围越大，模型越应该依赖 root 和祖先卷积结果。
具体趋势包括：

leaf mask 主要依赖局部 detail；
小 subheap mask 开始依赖 parent 和 sibling；
大 subheap mask 对 root-zero 更敏感；
打乱 ancestor 地址会破坏深层恢复；
detail-only 对照在深层 Mask 上明显落后；
TreeHeap 在未训练深度仍能复用共享递归 kernel；
shuffled corpus 会削弱推断式 Mask，因为真实共现规律被破坏。

如果这些趋势没有出现，我们就应承认：当前 fold kernel 没有把数据规律逐层抽取到高层，或者当前树的组织方式不适合语料。




9. 实验结果：root 被点亮了吗
实验已经在 io 的 RTX 3090 上完成。
两个模型都从相同随机初始化出发，使用相同的 100,000 个真实中文 token block、相同参数量和相同优化器：

  
      
          模型
          训练问题
          训练时间
      
  
  
      
          Echo
          所有 detail 完整，恢复全部 token
          46.5 秒
      
      
          Multiscale Mask
          移除随机子堆内部 detail，只恢复受损区域
          51.0 秒
      
  

两个模型都训练 3,125 step。Mask 模型的 WRITE、FOLD、DETAIL、UNFOLD、READ 五类算子都获得了有限非零梯度，因此 loss 确实通过了完整递归链路。
9.1 普通 Echo 的 99.5% 是局部复制能力
在 detail 完整时，普通 Echo 的 token Top-1 为：
99.50%
但移除一个子堆内部的 detail 后，它迅速失效：

  
      
          被移除的 token 数
          Echo 恢复 Top-1
      
  
  
      
          2
          24.61%
      
      
          4
          3.32%
      
      
          8
          1.46%
      
      
          16
          0.78%
      
      
          32
          0.81%
      
  

这组数字支持本文最初的诊断：普通 echo 的问题太浅，模型主要学会了局部路径：
token -> local detail -> token
它能精确抄写，却没有为 detail 缺失准备上层摘要。
9.2 多尺度 Mask 改变了信息保存位置
Mask 模型的受损区域恢复结果是：

  
      
          被移除的 token 数
          Mask NLL，越低越好
          Mask Top-1
          Echo Top-1
      
  
  
      
          2
          6.526
          14.26%
          24.61%
      
      
          4
          7.277
          8.69%
          3.32%
      
      
          8
          7.567
          7.50%
          1.46%
      
      
          16
          7.843
          6.42%
          0.78%
      
      
          32
          7.915
          6.36%
          0.81%
      
  

只遮两个 token 时，Echo 的局部复制能力仍然更强。
从 4 token 开始，Mask 模型明显更稳。遮掉 32 token 时，它的 Top-1 约为 Echo 的八倍。这说明训练问题确实改变了模型的信息布局：部分可恢复信息已经离开被删除的局部 detail，进入了更高层的 TreeHeap 状态。
但 6.36% 仍然很低。这里的正确表述是“出现了上层信息信号”，而不是“已经能恢复半句话”。
9.3 root 不是空开关
为了判断上层信号是否真的进入 root，我们做了两种干预。
第一种是把当前样本的 root 清零；第二种是换成另一个样本的 root。

  
      
          Mask 大小
          正常 NLL
          Root 清零 NLL
          换错 Root NLL
      
  
  
      
          2
          6.526
          7.369
          6.861
      
      
          4
          7.277
          7.775
          7.623
      
      
          8
          7.567
          7.898
          7.920
      
      
          16
          7.843
          8.131
          8.194
      
      
          32
          7.915
          8.188
          8.276
      
  

在 32-token Mask 下：
Root 清零：NLL 增加 0.273
换错 Root：NLL 增加 0.361
错误 root 比零 root 更有破坏性。这说明 root 不是一个固定的开关，它携带了当前文本相关的信息。
这是本轮最重要的正结果：

多尺度 Mask 第一次让 root 获得了可干预、样本相关的因果信号。
9.4 最重要的 Predict 反向了
我们原本预测：
Mask 越大
  -> 局部信息越少
  -> 模型越依赖 root
实际 root 清零造成的 NLL 增量为：

  
      
          Mask 大小
          Root 贡献
      
  
  
      
          2
          0.843
      
      
          4
          0.499
      
      
          8
          0.330
      
      
          16
          0.287
      
      
          32
          0.273
      
  

它严格递减，深度趋势的 Spearman 相关系数为：
-1.0
所以 P3 没有“差一点通过”，而是方向完全相反。
这说明当前 root 更像粗粒度的全局条件：它能帮助补一个小洞，却不足以展开一整棵缺失子树。Mask 越大，decoder 越容易退化为输出少数高频 token。
在保存的样例中，32-token Mask 经常产生：
10257 10257 10257 10257 ...
因此不能把 root 的因果信号解释成完整句法、语义或世界模型。
9.5 为什么 5/6 Gate 通过仍然不能写成成功
预注册结果如下：

  
      
          Gate
          结果
      
  
  
      
          P1 深层 Mask 优于未训练 Mask 的 Echo
          通过
      
      
          P2 span-32 的 root-zero 有明显伤害
          通过
      
      
          P3 root 贡献随 Mask 深度上升
          失败，Spearman = -1.0
      
      
          P4 Mask 训练比 Echo 更依赖 root
          通过
      
      
          P5 换错 root 有明显伤害
          通过
      
      
          P6 所有递归算子都有梯度
          通过
      
  

P1 也必须谨慎解释。Echo 从未训练过 detail 缺失，因此它是机制对照，不是足够强的 Mask baseline。Mask 模型击败它，证明训练问题发生了作用；还不能证明 TreeHeap 优于 unigram、BoW、flat root 或 Transformer。
同时，Mask 模型在 detail 完整时的普通 echo Top-1 只有 14.72%，远低于 Echo 模型的 99.50%。它用精确复制能力换取了受损情况下的稳定性，尚未同时掌握两种能力。

10. Claim 判决：部分支持
本轮 Claim 更新为：
partial support / upward signal found / positive-depth trend rejected
实验支持：

普通 echo 会优先形成局部 detail 捷径；
多尺度 Mask 能改变信息的保存位置；
root 获得了可测量的样本相关信息；
root 清零和换错都会伤害恢复；
masked loss 能到达全部共享递归算子。

实验不支持：

Mask 越深，信息越向 root 汇聚；
root 已能表示并展开完整子树；
当前恢复质量已经足够用于生成产品；
root 已形成语义、世界知识或意识；
TreeHeap 已优于通用神经网络基线。

最准确的一句话是：

我们让一部分信息离开了局部 detail，并点亮了 root；但当前 root 更像粗略的全局摘要，还不是能够展开整棵子树的高层编码。

11. 下一步：同时保住局部精度和上层摘要
下一轮不应立刻扩大语料，而应修正训练问题。
训练 batch 轮流进行：
batch 1  普通 Echo
batch 2  浅层 subheap Mask
batch 3  中层 subheap Mask
batch 4  深层 subheap Mask
这不是把多个 loss 全部相加，而是每个 batch 只回答一个清晰问题。目标是同时获得：
detail 完整 -> 精确恢复
detail 缺失 -> root 和 ancestor 提供概率恢复
还必须加入更强对照：

unigram 概率；
当前 block 的词频或 BoW；
flat mean/root bottleneck；
position-aware flat bottleneck；
shuffled-root 和 shuffled-corpus。

只有 TreeHeap 在相同状态预算下，既保住 echo，又在深层 subheap Mask 上击败这些对照，才有资格升级为结构优势 Claim。
12. 为什么这条路仍然值得开心一点
前一阶段已经出现了一个积极信号：只使用 token echo loss，随机初始化的 WRITE、FOLD、DETAIL、UNFOLD 和 READ 可以共同形成一套模型自己读得懂的连续编码协议。
它还很浅，甚至可能只是高效的局部抄写。
但“模型能够形成自己的写法”与“模型已经形成世界模型”是两件不同的事。前者是后者可能需要的一块地基，不是终点。
现在我们得到的不是一个漂亮但空泛的答案，而是一个更好的问题：
不要再问：
模型能不能抄回刚刚看到的 token？

开始问：
当一个完整子结构消失时，
哪一层还保留了足够的信息来推断它？
如果信息真的能随着问题深度逐层向 root 生长，那么 TreeHeap 的 encoder/decoder 协议就不再只是一个按地址保存 token 的数组。
它会开始成为一种分尺度观察世界、压缩规律并递归展开答案的结构。
这次我们已经有了结果。它没有完全支持最初的深度趋势，却证明 root 可以被任务真正点亮，也准确指出了下一步需要解决的能力缺口。
船头不仅对准了一个可以测量的方向，还第一次收到了来自 root 的微弱回声。心情确实可以好一点。哈哈哈哈。

13. 当前声明边界
本文记录的是 Houming818 提出的研究方向、已完成实验及其证据边界。最初假设是：

当前普通 echo loss 太浅，无法要求高层节点保存信息。通过 TreeHeap-native 的多尺度 subheap Mask、detail dropout 和结构扰动，可以逐层增加任务所需的上下文范围；如果假设成立，信息和梯度将从局部 detail 向 parent、ancestor 与 root 汇聚。
实验已经支持“root 获得样本相关信息”，但拒绝了“Mask 越深，root 贡献越大”：实测深度 Spearman 为 -1.0。因此上述假设只能保留前半部分，后半部分必须重新设计并再次验证。
目前不能声称：

root 已经形成语义摘要；
多尺度 Mask 一定能够产生世界模型；
TreeHeap 已经优于 Transformer、MLP 或其他结构；
masked token 的恢复等于理解或意识；
人类语法标签一定会自然出现在内部节点。

这些都需要后续 ARA、代码、干预实验和真实数据给出 evidence。

版权、原创与许可证
Copyright (C) 2026 Houming818 and SameTime contributors.
本文的核心研究判断，即“普通 echo 的问题尺度太浅，应使用 TreeHeap-native 的多尺度子堆扰动推动信息向 root 抽取”，由 Houming818 提出；Codex Review 参与数学整理、实验指标设计和文章编写。本文是 SameTime 项目的原创研究表达，不宣称发明 masked language modeling、denoising autoencoder、树卷积或多尺度分析等已有公共方法。

SPDX-License-Identifier: GPL-3.0-only

License: GNU General Public License v3.0 only
本文允许复制、修改和分发，但衍生版本必须继续遵守 GNU GPL v3，并保留版权、许可证、修改说明及来源声明。完整许可证文本见本站 /LICENSE。



[SPR-056] 看见树内的变化：TreeHeap 单层观察与跨语言差分
Wed, 15 Jul 2026 00:00:00 +0000
看见树内的变化：TreeHeap 单层观察与跨语言差分
TreeHeap 的 encoder 和 decoder 可以形成一套私有编码协议。
这很像一个人自己的笔迹：别人不一定能从某一笔的角度判断它代表什么，但书写者自己可以稳定地写，也可以稳定地读。
可是，私有编码不能成为拒绝观察的理由。
即使我们不知道 64D state 的第 17 维是什么意思，仍然可以问：

把“米饭”换成“土豆”以后，树的哪些节点发生了变化？变化沿哪条路径传播？把变化后的子堆移植过去，decoder 是否只改变对应概念？
这篇文章先公开一次真实的单层观察，再提出一种新的 TreeHeap 特征设计：差分传播路径。

1. 我们刚刚训练了什么
实验使用真实中文语料，而不是人工随机树：

  
      
          项目
          设置
      
  
  
      
          训练数据
          200,000 个真实中文 block
      
      
          每个 block
          64 token
      
      
          TreeHeap 深度
          6
      
      
          节点 state
          64D
      
      
          验证数据
          512 个未参与训练的 block
      
      
          设备
          io / RTX 3090
      
  

树的各层覆盖范围如下：

  
      
          深度
          单节点覆盖 token
          同一 64-token block 的节点数
      
  
  
      
          1
          2
          32
      
      
          2
          4
          16
      
      
          3
          8
          8
      
      
          4
          16
          4
      
      
          5
          32
          2
      
      
          6
          64
          1
      
  

共享 FOLD kernel 从左右子节点递归计算父节点：
$$ z_i^{(d+1)}=K_\theta\left(z_{2i}^{(d)},z_{2i+1}^{(d)},e_d\right). $$其中，$e_d$ 是深度坐标。所有地址使用同一个 $K_\theta$，不是每个位置单独记一张参数表。
这次没有要求 root 完整恢复 64 个 token，而是观察两个尺度量：

Bag 轮廓：这个节点覆盖的区域里有什么 token，不要求顺序。
Adjacency 轮廓：这个区域内有哪些有向相邻 token 对，要求顺序。

Bag 类似远看一张图时看到的主体颜色；Adjacency 更像物体边缘的方向和连接关系。

2. 一个节点里到底能看到什么
当前实验中，一个节点有三类可观察数据。
2.1 地址与感受野
地址告诉我们该节点覆盖哪一段输入。
例如 depth=4 的 node 2 覆盖 token [32,48)。这是 TreeHeap 数据结构天然提供的坐标，不需要 probe 猜测。
2.2 私有 64D state
例如某个节点的前 8 维是：
[0.5808, -0.1203, -0.7574, -0.9964,
 -1.1835, 0.4895, -1.8861, 1.2427]
这些数字本身没有人类词典。不能说 0.5808 就是“花”，或者 -0.9964 就是“时间”。
它们只在当前 encoder 与 decoder 共同形成的坐标系中有意义。
2.3 读出与干预
我们可以训练 READ kernel，从 state 读取 Bag 或 Adjacency；还可以替换 state，观察 decoder 输出是否改变。
前者是相关性观察，后者才是因果观察。

3. 把 depth=4 的四个节点全部摊开
下面是一条真实验证文本：

蔓交错，到四月花期，就是一扇开满花的拱门。清唱咖啡，有一面墙的书架，尚有空余，总有客人愿意将看过的，或者喜欢的书放在书架上给大家分享。这里有个赠书的江湖。鼎韵艺术沙龙。
在 depth=4，每个节点覆盖 16 token，一共有四个节点：

  
      
          节点
          实际覆盖文本
          Bag 读出 cosine
          Adjacency 读出 cosine
      
  
  
      
          0
          蔓交错，到四月花期，就是一扇开满花的拱……
          0.379
          0.129
      
      
          1
          门。清唱咖啡，有一面墙的书架，尚有空……
          0.597
          -0.087
      
      
          2
          余，总有客人愿意将看过的，或者喜欢的书放在书架……
          0.216
          -0.044
      
      
          3
          上给大家分享。这里有个赠书的江湖。鼎韵艺术沙龙
          0.644
          -0.142
      
  

cosine 越接近 1，表示 READ 输出越接近该片段的精确观察目标。
这张表说明：

四个节点都不是空白常量；
Bag 内容轮廓有不同程度的可读性；
有向排列信息基本没有形成；
同一层不同节点的质量差异很大。

四个 state 相互之间的 cosine 是：
          node0   node1   node2   node3
node0     1.000   0.451   0.860  -0.079
node1     0.451   1.000   0.326   0.517
node2     0.860   0.326   1.000  -0.087
node3    -0.079   0.517  -0.087   1.000
这说明该层没有完全坍缩成一个 state。node0 与 node3 接近正交，而 node0 与 node2 非常接近。
但“向量不同”不等于“已经理解语义”。

4. 一个必须公开的反例
我们拿 depth=4 的 node0，在另外 511 个验证 block 中寻找 state 最近邻。
查询片段是：

蔓交错，到四月花期，就是一扇开满花的拱……
返回片段是：

发的日子，要预防季节性的传染病的发生，应多吃清淡食物。
结果：

  
      
          指标
          数值
      
  
  
      
          state cosine
          0.9848
      
      
          两段文本的精确 Bag cosine
          0.2242
      
      
          两段文本的精确 Adjacency cosine
          -0.1449
      
  

两个 state 看起来几乎相同，但对应文本既不是明显同义，也没有接近的顺序结构。
这意味着当前 state 空间可能存在方向聚集或局部坍缩。它携带了一些可读信息，却还不是可靠的语义检索坐标系。
因此不能只展示 state cosine=0.9848，然后宣布模型理解了两句话。必须用外部观察量和因果替换继续核验。

5. 从低层看到高层
全部验证集的平均结果是：

  
      
          覆盖 token
          2
          4
          8
          16
          32
          64
      
  
  
      
          Bag READ cosine
          0.267
          0.286
          0.306
          0.334
          0.377
          0.436
      
      
          Bag Query 增益
          0.184
          0.122
          0.095
          0.086
          0.071
          0.077
      
      
          Adjacency READ cosine
          0.010
          0.012
          0.015
          0.017
          0.021
          0.027
      
  

这里出现了一个值得保留的现象：

覆盖范围越大，Bag 轮廓越容易从节点中读出；但精细检索优势没有随深度一起增加。
这与 Houming818 提出的多尺度理解相容：高层可能不是低层 token 的模糊错误副本，而是在表达覆盖范围更大的几何轮廓。
但是本次实验只支持很窄的说法：高层保存了一部分无序内容统计。
它还没有证明：

高层形成了人类语义；
TreeHeap 已经拥有世界模型；
有向结构已经被编码；
TreeHeap 检索优于 Transformer。

完整 Claim 的 6 个 Gate 只通过了 3 个，因此 ARA 状态仍是 not supported。

6. 私有编码如何被观察
绝对坐标不可读，不代表相对变化不可研究。
考虑最小句对：
A：小明爱吃米饭。
B：小明爱吃土豆。
两句话只改变一个概念。对每个深度、每个地址计算：
$$ \Delta_i^{(d)}=H_i^{(d)}(B)-H_i^{(d)}(A). $$如果 TreeHeap encoder 真正利用树结构，那么差分不应该平均污染整棵树。我们预测它主要分布在：
米饭/土豆叶节点
        ↓
宾语 subheap
        ↓
“吃 + 宾语”父节点
        ↓
root 的较粗变化
与“小明”对应的兄弟 subheap 应当基本稳定。
这就是新的可观察特征：差分传播路径。

7. 差分路径的四个测量
7.1 地址局部性
设被替换 token 的祖先路径为 $P$，全树节点集合为 $V$。差分能量集中率定义为：
$$ R_{path}=\frac{\sum_{i\in P}\left\|\Delta_i\right\|_2^2} {\sum_{j\in V}\left\|\Delta_j\right\|_2^2}. $$如果 $R_{path}$ 很高，说明变化确实沿结构路径传播，而不是无地址地扩散。
7.2 深度轮廓
不同深度不必保存相同含义。我们记录每层的相对差分：
$$ D_d=\frac{1}{|V_d|}\sum_{i\in V_d}\left\|\Delta_i^{(d)}\right\|_2. $$低层可能表现为具体 token 替换；高层可能只表现为“食物类别内部发生变化”。这里不要求高层重新说出“土豆”二字。
7.3 跨句式迁移
再构造：
小红爱吃米饭。 -> 小红爱吃土豆。
他今天吃了米饭。 -> 他今天吃了土豆。
如果“米饭到土豆”的差分只在第一句话成立，它可能只是样本记忆。
如果多个句式中的差分方向显著一致，才说明 encoder 抽取了可迁移关系：
$$ cos(\Delta_{小明},\Delta_{小红}) > cos(\Delta_{小明},\Delta_{随机替换}). $$7.4 子堆因果替换
相关性仍然可能欺骗我们。因此需要把 B 的宾语 subheap 写入 A：
H(A)
  - remove: “米饭” subheap
  + insert: “土豆” subheap
  -> decoder
如果 decoder 的输出从“小明爱吃米饭”变为“小明爱吃土豆”，而主语和谓语保持不变，才说明这个 subheap 对目标概念具有因果作用。
这一步比训练一个 probe 更强，因为 probe 可能只是从相关噪声中猜答案。

8. 多语言差分观察
加入英文最小句对：
C：Xiaoming likes eating rice.
D：Xiaoming likes eating potatoes.
中文与英文可以拥有不同的私有编码坐标。我们不要求两棵树的原始 state 完全相等，而是学习一个受控对齐映射 $M$：
$$ M\Delta_{zh}\approx\Delta_{en}. $$其中：
$$ \Delta_{zh}=H(小明爱吃土豆)-H(小明爱吃米饭), $$$$ \Delta_{en}=H(Xiaoming\ likes\ potatoes)-H(Xiaoming\ likes\ rice). $$如果对齐后的真实概念差分明显优于随机替换差分，就说明两套私有编码都捕获了同一种世界变化。
这里有一个严格边界：任意非线性私有坐标中的裸减法未必天然稳定。因此跨语言结论必须同时接受 subheap 替换和 decoder 输出的因果验证，不能只看 cosine。

9. 这会比 Transformer 更容易观察吗
这是一个 Predict，不是已有结论。
Transformer 也可以做 activation patching、attention 分析、linear probe 和 hidden-state diff。我们不能把 Transformer 描述成完全不可观察。
TreeHeap 的潜在优势来自显式结构坐标：

  
      
          观察问题
          Transformer
          TreeHeap 的预期坐标
      
  
  
      
          变化发生在哪里
          token、层、head 的分布式激活
          明确 heap 地址
      
      
          变化如何传播
          跨层和 attention 边
          叶到 root 的祖先路径
      
      
          观察尺度
          依赖层和 receptive pattern
          TreeHeap 深度
      
      
          局部因果替换
          activation patching
          完整 subheap swap
      
      
          多语言关系
          hidden alignment
          同地址、同尺度差分对齐
      
  

只有当 TreeHeap 的差分确实更局部、迁移更稳定、因果替换更干净时，才能说它在这类问题上比匹配规模的 Transformer 更容易观察。
树的外形本身不是证据。

10. 下一条 Claim 与 Predict
Claim

对只替换一个概念的最小句对，TreeHeap state 差分应集中在被替换叶节点及其祖先路径；对应 subheap 的因果替换应主要改变 decoder 的目标概念。该差分规律应能跨主语、跨句式，并在对齐后跨语言迁移。
初步 Predict

被替换路径承载至少 70% 的全树差分能量。
未改变兄弟 subheap 的平均差分显著小于祖先路径。
相同概念替换的跨句式差分 cosine 比随机替换至少高 0.10。
subheap swap 后，目标词变化率显著提高，非目标 token 保持率不下降超过 5%。
中英对齐后的概念差分优于随机语言配对至少 0.10。
与匹配维度 Transformer 做同样干预；如果 TreeHeap 没有更好的局部性或因果选择性，则不支持“更容易观察”的优势主张。

这些阈值需要在 ARA 实验注册时冻结，然后再运行代码，不能看到结果后移动门槛。

11. 当前结论
这次打开单层以后，我们看到的不是一个已经完成的语义世界模型，而是一个更具体的中间状态：

每个节点有明确地址、覆盖范围和非恒定 64D state；
高层可以读出部分更大范围的 Bag 内容轮廓；
当前有向顺序信息没有形成；
极高 state cosine 仍可能返回不相关文本，说明几何空间尚未校准；
下一步不能继续只看平均 loss，需要观察改变一个概念时，差分沿树如何传播；
subheap swap 将把“看起来相关”升级为“对输出具有因果作用”。

我们真正想建立的不是一个人为解释每个参数的词典，而是一种可重复的观察方法：

不要求读懂模型的每一笔，但要能追踪它改了哪一笔、变化沿哪里传播，以及这一笔是否真的改变了模型的回答。

12. 证据与原创边界
本次实验的 ARA、代码、checkpoint、逐层观察数据与失败 Gate 均保存在开放仓库 SameTime 中：
ara/s3-generation/logic/treeheap_multiscale_geometry.md
ara/s3-generation/src/s3_treeheap_multiscale_geometry.py
ara/s3-generation/src/s3_treeheap_multiscale_geometry_observe.py
ara/s3-generation/evidence/s3_treeheap_multiscale_geometry_smoke/
“高层可能表达更大几何范围而非损坏 token 副本”以及“用最小句对观察 TreeHeap 差分传播路径”的研究判断由 Houming818 提出；Codex Review 负责形式化、实验实现、证据审计和本文整理。
本文是 SameTime 项目的原创研究表达，但不宣称发明表示差分、因果干预、activation patching、多语言表示对齐、随机投影或多尺度分析等已有公共方法。TreeHeap 是否具有更强的结构可观察性，仍需下一组对照实验验证。



[SPR-057] 一次 100% 却失败的实验：为什么差分不能替我们找到意识
Wed, 15 Jul 2026 00:00:00 +0000
一次 100% 却失败的实验：为什么差分不能替我们找到意识
这是一篇失败记录。
更准确地说，这是一次指标成功、研究目标失败的实验。
模型在四类有限世界类比任务上达到了：
token accuracy     = 100%
sequence exact     = 100%
如果只看最终分数，这似乎是一场漂亮胜利。
但经过因果干预后，我们发现：模型几乎没有使用我们专门设计的 World TreeHeap。一个参数更少的普通 Transformer 也达到了 100%。
因此，这个实验没有证明 World TreeHeap，没有证明 TreeHeap 的类比优势，更没有触及意识。
它反而留下了一条重要教训：

差分可以帮助我们观察模型发生了什么，但不能仅凭一个漂亮的差分结构，就宣布我们理解了模型的意识、语义或推理过程。

1. 这条路线是怎样开始的
我们先观察到一个合理问题。
考虑两句话：
小明喜欢吃红薯。
小明喜欢吃土豆。
如果 encoder 将整句话写成 TreeHeap，那么两个状态之间应该存在某种变化：
$$ \Delta H=H_{土豆}-H_{红薯}. $$但 Houming818 很快指出，这不应该只是：
embedding(土豆)-embedding(红薯)
因为同一个实体替换，在不同世界背景中的意义不同：
小明喜欢吃红薯 → 小明喜欢吃土豆
红薯要两元一斤   → 土豆要两元一斤
前者改变的是“被食用对象”，后者改变的是“被定价实体”。
于是我们进一步提出：

差分可能不是一个普通向量，而是 World TreeHeap 背景中的一个结构变换。
这个想法本身并不荒谬。问题出在我们随后怎样把它实现成了模型。

2. 我们手工设计了一个看起来完整的推理系统
实验模型被拆成：
A ─┐
B ─┼─> DIFF ─> Relation TreeHeap R_AB
W ─┘

R_AB ─┐
C ────┼─> TRANSPORT ─> R_C
W ────┘

C + R_C ─> APPLY ─> predicted H_D ─> Decoder ─> D
数学形式是：
$$ R_{AB}=DIFF(W,H_A,H_B), $$$$ R_C=TRANSPORT(W,R_{AB},H_A,H_C), $$$$ \hat H_D=APPLY(H_C,R_C). $$我们还预先给出了：

固定逻辑槽位；
人物、食物、数字和谓词集合；
四种关系族；
A:B=C:D 监督格式；
World TreeHeap 的 15 个参数节点；
stop/left/right 概率路由；
状态对齐和文本生成 loss。

从工程角度看，这套模型很完整。
从涌现角度看，它却有一个根本问题：

我们把希望模型自己发现的推理步骤，提前写进了模块名字、数据格式和 loss。

3. Toy 世界包含什么
所有陈述使用八个固定逻辑叶槽。实验生成四类关系。
3.1 跨场景实体替换
A  P1 EAT FOOD0
B  P1 EAT FOOD6
C  FOOD0 COST N5 UNIT
D  FOOD6 COST N5 UNIT
3.2 数值平移
A  FOOD7 COST N5 UNIT
B  FOOD7 COST N6 UNIT
C  P7 BUY FOOD1 N1
D  P7 BUY FOOD1 N2
这里不能直接把 N6 复制到 D，因为 C 中需要的是 N1→N2。
3.3 人物跨角色迁移
A  P10 LIKE P2
B  P8  LIKE P2
C  P3  LIKE P10
D  P3  LIKE P8
3.4 主客体交换
A  P3 LIKE P7
B  P7 LIKE P3
C  P4 LIKE P11
D  P11 LIKE P4
验证集按组合哈希整块留出。模型看过所有原子符号，但没有看过测试中的具体组合。
因此，这不是一个简单的随机六分类实验。它确实要求模型表达一些超出固定 token 替换的关系。

4. 一个漂亮得危险的结果
训练设置：

  
      
          项目
          数值
      
  
  
      
          训练 step
          6,000
      
      
          batch
          256
      
      
          验证四元组
          4,096
      
      
          TreeHeap 参数
          238,314
      
      
          Flat Transformer 参数
          73,574
      
      
          GPU
          RTX 3090
      
  

最终结果：

  
      
          模型
          Token accuracy
          Sequence exact
      
  
  
      
          TreeHeap analogy
          1.0000
          1.0000
      
      
          Flat Transformer
          1.0000
          1.0000
      
      
          Lexical replacement
          0.9124
          0.5466
      
  

TreeHeap 四类关系全部达到 sequence exact 1.0。
这说明：

TreeHeap 形态的网络可以表示并学习有限世界类比函数。
但是，“能够表示”与“自然涌现”之间还有很长距离。

5. 因果干预推翻了漂亮故事
如果 World TreeHeap 真的是关系迁移的背景，那么删除它应显著破坏结果。
实际数据：

  
      
          干预
          Token accuracy
      
  
  
      
          正常 World TreeHeap
          1.0000
      
      
          把 W 全部置零
          0.9984
      
      
          翻转 W 的 heap 地址
          0.9867
      
      
          使用错误的 B 关系
          0.8284
      
  

最终路由熵约为：
0.000024
概率路由几乎坍缩到一个固定节点。
也就是说，模型实际学习的是：
A/B/C encoder
    ↓
普通非线性映射
    ↓
D
而不是：
A/B
    ↓
查询World TreeHeap
    ↓
读取背景关系
    ↓
迁移到C
梯度发现了一条更短的道路，并合理地绕开了我们精心设计的 W。
这不是模型“不听话”。
恰恰相反，模型忠实地优化了我们给出的 loss。

6. 为什么这个设计违背了涌现规律
6.1 我们提前写好了推理步骤
还没有训练，我们已经规定：
先DIFF
再TRANSPORT
最后APPLY
模型只需拟合这条监督管线，不需要自己发现类比结构。
6.2 数据直接给出了类比格式
训练输入就是：
A、B、C → D
这能验证函数拟合和组合外推，却不能证明模型从普通世界经验中自然形成类比能力。
6.3 人工槽位替 encoder 完成了部分工作
我们规定了人物、食物、数字、主语位置和宾语位置。模型没有从自然语言中发现这些结构。
6.4 强行指定 W 的职责没有用
任务可以通过 A/B/C 的直接映射解决，所以梯度没有理由把知识写进一个额外 W。
6.5 较小的 Flat Transformer 同样满分
这说明 toy 主要考查通用函数逼近，而不是 TreeHeap 独有能力。

7. 为什么差分不足以分析意识
Houming818 对这次实验的总结是：

果然，想要利用差分来分析意识，不太靠谱。
这里需要把边界说清楚。
7.1 私有坐标中的减法不是客观语义
如果 encoder 和 decoder 使用自己的私有协议，那么：
$$ H_B-H_A $$依赖当前坐标系。对 hidden space 做一个保持功能不变的非线性重参数化，裸差分的方向就可能改变。
7.2 state 变化不等于模型理解了变化
一个节点改变，可能是：

token embedding 改了；
地址改了；
LayerNorm 的连锁响应；
递归 FOLD 的必然传播；
真正的语义关系变化。

只看差分大小无法区分这些来源。
7.3 祖先路径变亮可能是数学必然
局部叶节点发生变化后，其祖先节点必然重新计算。看到一条从叶到 root 的红色路径，不代表模型发现了推理链。
7.4 观察者可能把自己的分类投射进模型
如果我们预先规定：
这是食物差分
这是价格差分
这是主谓宾差分
再训练 probe 找到这些标签，最后可能只是证明 probe 学会了我们的分类。
7.5 “意识”还没有可执行定义
当前 ARA 可以测量：
loss
概率
地址依赖
subheap因果作用
生成结果
跨组合迁移
但它还没有一个可以被程序直接判定的“意识”指标。
在没有操作性定义时，用 cosine、diff 或可视化颜色宣称观察到了意识，是不可证伪的。

8. 差分是不是完全没用了
不是。
差分仍然是有价值的诊断工具：

比较一次干预前后的节点变化；
观察变化经过哪些地址和深度；
检查不同算子是否留下不同响应；
定位坍缩、旁路和无效模块；
为因果消融选择观察位置。

我们此前的 Differential Atlas 就发现：
WRITE、MIRROR、子堆交换
会形成部分不同的多尺度响应曲线
这可以帮助调试 TreeHeap。
但正确表述应是：

差分告诉我们模型状态怎样变化；它不自动告诉我们变化意味着什么，更不能自动上升为意识解释。

9. 主线回到哪里
ARA 中目前最可靠、也最接近自然学习的节点是：
S3-TREEHEAP-ROOT-COMPRESS-C01
        +
S3-TREEHEAP-PYRAMID-C01
前者在 38,251,247 个真实文本 block 上，仅通过 next-token loss 学会了：
64 token → recursive FOLD → root → next token
破坏左右地址后，valid NLL 增加 2.6252；消融不同 head，也产生明显损失。
没有语法标签、Bag 目标、DIFF 目标或类比四元组。这才是当前最接近涌现的证据。
Pyramid 又证明 root 与地址化 detail 可以形成多分辨率容器。
因此主线恢复为：
真实语料
  ↓
通用TreeHeap WRITE
  ↓
共享多头kernel forest递归FOLD
  ↓
多分辨率H
  ↓
普通语言预测loss
模型参数 TreeHeap forest 本身承担世界背景，不再外挂一个被命名为“世界模型”的 W。

10. Encoder Mask 的对称 Decoder
Encoder 侧仍可以使用 TreeHeap-native 复杂 Mask：
遮住局部subheap/detail
→ 逼迫恢复任务所需信息向parent/root聚合
但 Mask 只是信息压力，不是语义答案。
Decoder 侧的对称操作是概率 UNFOLD：
root
  ↓ probabilistic UNFOLD
左右子节点概率桶
  ↓ delayed collapse
下一层subheap
  ↓ recursive UNFOLD
token概率桶
FOLD 是多对一，因此 UNFOLD 不能是假装精确的逆函数：
$$ P(h_l,h_r\mid h_p,C) = UNFOLD(h_p,C). $$它必须输出多种可能性，等待源语言、目标前缀和更大上下文进入后再坍缩。
这条路线只规定通用的数据流和训练压力，不规定某个 head 必须学习“食物差分”或“类比运输”。

11. 这次失败保留了什么
我们保留三个窄结论：

TreeHeap 形态的网络能够表达有限类比函数；
lexical-copy 无法解决全部数值和角色变换；
因果干预成功发现 World TreeHeap 被绕过。

同时拒绝四个更强结论：

没有证明 World TreeHeap 参与推理；
没有证明类比能力自然涌现；
没有证明 TreeHeap 优于 Transformer；
没有证明差分能够解释意识。

一个 100% 的实验，如果核心模块可以被删除，就仍然是失败。
这正是 ARA 的价值：不是阻止我们犯错，而是让漂亮的错误无法冒充研究结论。

12. 证据与原创边界
模型、ARA、checkpoint、训练 trace、可读四元组和干预结果均保存在开放仓库 SameTime：
ara/s3-generation/logic/world_treeheap_analogy_transport.md
ara/s3-generation/src/s3_world_treeheap_analogy.py
ara/s3-generation/evidence/s3_world_treeheap_analogy_smoke/
关于“同一词语变化必须放在全局背景中理解”和“差分不足以分析意识”的研究修正由 Houming818 提出；Codex Review 负责错误模型的形式化、实现、因果审计与本文复盘。
本文是 SameTime 项目的原创研究记录，但不宣称发明向量差分、类比任务、因果消融、World Model、概率树路由、masked modeling 或 coarse-to-fine decoding 等已有公共方法。



[SPR-058] TreeHeap 信息抽水机：先形成 H_state，再遮住 token，能否完整 Echo？
Wed, 15 Jul 2026 00:00:00 +0000
TreeHeap 信息抽水机：先形成 H_state，再遮住 token，能否完整 Echo？
这篇文章要回答一个很具体的问题：

一句话已经被 encoder 写进 TreeHeap，形成完整的 $H_{state}$ 以后，如果把原始 token 和 leaf 读取通道全部遮住，还能不能只凭 $H_{state}$ 把它恢复出来？
答案是：
可以。

token echo       = 100%
16-token exact   = 100%
但这句话很容易被误解。
这里不是先把输入 token 删除，再要求模型猜出一个从未见过的答案。真正的数据流是：
完整 token
    ↓ WRITE
Lifting FOLD 逐层上传
    ↓
H_state = root + 每一层 addressed details
    ↓
屏蔽全部 leaf/token 读取通道
    ↓
从 root 开始逐层 UNFOLD
    ↓
恢复 token
所以，mask 的对象是已经编码完成后的表面读取通道，不是 encoder 的原始输入。
这是 TreeHeap encoder/decoder 是否形成闭合协议的测试。

1. 为什么我们之前会争论 mask
“mask 一个 token”至少有三种完全不同的含义。
1.1 编码前 mask：让模型猜缺失信息
小明 喜欢 吃 [MASK]
    ↓ encoder
H_state
    ↓
预测：米饭 / 面条 / 苹果 / 药……
原词在进入 encoder 以前就被删除了。
因此，$H_{state}$ 中没有原词的完整信息。模型只能学习条件概率：
$$ P(x_{\mathrm{mask}}\mid x_{\mathrm{visible}}). $$对于“小明喜欢吃 [MASK]”，“米饭”“面条”“苹果”都可能合理，所以不能要求模型一定恢复数据集原句。
这种任务测试语言预测、世界经验和概率补全。它不是本文完成的 Echo。
1.2 编码后 mask：遮住 leaf，只读 H_state
完整句子
    ↓ encoder
root + details
    ↓ 删除原始 leaf 读取
decoder
    ↓
恢复完整句子
原始 token 已经参与 WRITE 和 FOLD，但 decoder 不能直接复制它。
它必须从压缩后的 TreeHeap 状态逆运算回来。本文测试的正是这一种，而且不是只 mask 一个 token，而是同时禁止读取全部 16 个 leaf。
1.3 H_state 内部 mask：删除某层 detail
第三种更加困难：
完整句子
    ↓ encoder
root + details
    ↓ 删除目标路径上的某个 detail
不完整 H_state
    ↓
尝试恢复 token
此时精确逆运算所需的信息真的缺失了。模型必须利用 root、其他尺度和语料中学到的规律，预测缺失 detail 的概率分布。
这是后续的“归纳补全”问题。本文只做了消融诊断，没有宣称它已经解决。

2. 上一版 FOLD 为什么没有把信息抽到高层
上一轮实验使用普通递归 FOLD：
16 leaf
  ↓
8 parent-1
  ↓
4 parent-2
  ↓
2 parent-3
  ↓
1 root
代码确实算到了 root。但是 decoder 可以为每个输出位置选择读取哪一层。训练最后找到的捷径是：
两个 token
    ↓
一个 parent-1
    ↓
直接恢复这两个 token
READ 权重分布为：
parent-1   99.9786%
parent-2    0.0084%
parent-3    0.0051%
root        0.0079%
删除 parent-1，NLL 增加 74.4254；删除 root，变化约为零。
因此，旧实验只证明一个共享 FOLD 可以把两个 token 编进一个 parent。它没有证明信息继续上传。
问题不在于 FOLD 有没有被递归调用，而在于系统缺少类似抽水机的基本规律：

哪部分信息必须向上；
哪部分细节留在本层；
decoder 是否必须从高层向下解码；
有没有绕开高层的旁路。


3. 抽水机的基本规则：Lifting Scheme
我们采用 lifting scheme，也就是可逆小波中常用的“预测与更新”结构。
设左右子节点状态为 $L$ 和 $R$，共享 predictor 为 $P_\theta$。
先计算 detail：
$$ D=R-P_\theta(L). $$再计算向上的 parent：
$$ U=L+\frac{1}{2}D. $$其中：

$D$ 是留在当前深度的带地址细节；
$U$ 是唯一允许继续上传的 parent；
$P_\theta$ 是所有节点、所有深度共享的卷积 kernel。

当 $P_\theta(L)=L$ 时：
$$ D=R-L, $$$$ U=L+\frac12(R-L)=\frac{L+R}{2}. $$这时可以直观理解为：
U = 左右子树的粗粒度轮廓
D = 左右子树之间的差异
换一个可学习 predictor 后，内部坐标系可以完全不同，但结构规律不变：
两个 child
→ 一个 upward parent
→ 一个 local detail

4. 为什么它可以严格逆运算
decoder 从 $U,D$ 恢复 $L,R$：
$$ L=U-\frac12D, $$$$ R=D+P_\theta(L). $$代入 FOLD 公式：
$$ U-\frac12D =L+\frac12D-\frac12D =L, $$然后：
$$ D+P_\theta(L) =R-P_\theta(L)+P_\theta(L) =R. $$因此，只要 encoder 和 decoder 使用同一个 $P_\theta$，就有：
$$ UNFOLD_\theta(FOLD_\theta(L,R))=(L,R). $$这里有一个重要事实：

$P_\theta$ 不需要线性，也不需要自己可逆。
decoder 不是计算 $P_\theta^{-1}$，而是在恢复出 $L$ 以后，再调用一次同一个 $P_\theta(L)$。
这就像两个人使用同一本私人字典。字典内容可以通过数据学习，但写入和读出必须遵守同一个协议。

5. 16 个 token 如何被抽到 root
对于 16 个 leaf，编码过程是：
16 leaf
  ↓ FOLD
8 parent + 8 detail-1
  ↓ FOLD
4 parent + 4 detail-2
  ↓ FOLD
2 parent + 2 detail-3
  ↓ FOLD
1 root   + 1 detail-4
最终状态不是只有 root，而是：
$$ H_{state} =(root,D^{(4)},D^{(3)},D^{(2)},D^{(1)}). $$decoder 不允许跳到 parent-1，也不能读取原始 leaf。它必须从 root 开始：
root + detail-4
    ↓ UNFOLD
2 个 parent-3
    ↓ 加 detail-3，再 UNFOLD
4 个 parent-2
    ↓ 加 detail-2，再 UNFOLD
8 个 parent-1
    ↓ 加 detail-1，再 UNFOLD
16 个 leaf state
    ↓ READ
16 个 token
这就是“抽上去，再放下来”。

6. 演绎 Echo 和归纳 Echo 是什么关系
6.1 演绎部分：代数保证闭包
只要保存完整的 root 和 details，无论 $P_\theta$ 的参数是什么，FOLD/UNFOLD 都应该闭合。
我们用随机连续向量测试深度 1 到 6 的树：

  
      
          指标
          结果
      
  
  
      
          深度 6 最大 FP32 闭包误差
          3.70e-6
      
      
          真实 token state MSE
          3.14e-14
      
      
          最大 state 误差
          2.86e-6
      
  

这是演绎证据：结果来自公式本身。
6.2 归纳部分：语料决定私人坐标系
如果 Echo 永远精确，单独用 Echo loss 训练 $P_\theta$ 是没有意义的。
因为任何 predictor 都会被自己的 UNFOLD 抵消：
$$ UNFOLD_\theta(FOLD_\theta(X))=X. $$所以，这次没有用 Echo 作为训练 loss。训练任务是自然语料 next-token：
观察 16 个真实中文 token
    ↓ Lifting FOLD
root
    ↓
预测第 17 个自然出现的 token
其 loss 为：
$$ L_{\mathrm{next}} =-\log P(x_{17}\mid root(x_1,\ldots,x_{16})). $$这给 root 制造了真正的“压力差”：如果 predictor 产生的 root 对语料预测无用，NLL 就不会下降。
实验结果：

  
      
          模型
          验证 NLL，越低越好
      
  
  
      
          frozen predictor
          8.06377
      
      
          learned predictor
          8.03468
      
      
          learned 改善
          0.02910
      
  

predictor 的最大梯度范数为 0.50191，参数变化量为 16.13119。语料梯度确实改变了抽水 kernel。
然后，我们使用这个经过归纳学习的 $P_\theta$，遮住全部 leaf，只凭训练形成的 $H_{state}$ 逆运算：

  
      
          Echo 指标
          结果
      
  
  
      
          token top-1
          1.0000
      
      
          16-token block exact
          1.0000
      
  

因此，更准确的说法是：

归纳学习决定 TreeHeap 的私人坐标系；演绎闭包保证这个坐标系可以被同一协议读回。

7. 它真的使用 root 和每层 detail 吗
只看 100% Echo 仍然不够。我们继续做因果消融。
7.1 删除 root

  
      
          条件
          token top-1
          block exact
      
  
  
      
          完整 H_state
          1.0000
          1.0000
      
      
          root 清零
          0.93042
          0.0000
      
      
          root 换成另一句
          0.93701
          0.0078125
      
  

删除 root 后，大多数单词仍可能因为局部 detail 而落在正确 embedding 附近，但没有一个 block 能完整恢复。
所以 root 不是全部细节，却是完整闭合链的一部分。
7.2 打乱不同深度的 detail 地址

  
      
          被换址的 detail
          token accuracy 下降
      
  
  
      
          detail-1
          49.88%
      
      
          detail-2
          25.00%
      
      
          detail-3
          12.35%
      
      
          detail-4
          6.32%
      
  

这个接近逐层减半的规律很好理解：detail-1 直接区分每一对 leaf；越高层的 detail 数量越少，但覆盖范围越大。
7.3 破坏每一层的左右配对
在 next-token 任务中，分别把某一深度的右子树换成其他样本：

  
      
          被破坏的 FOLD 深度
          NLL 增加
      
  
  
      
          depth 1
          +0.03221
      
      
          depth 2
          +0.03838
      
      
          depth 3
          +0.04324
      
      
          depth 4
          +0.05634
      
  

四个深度都产生损失。
这和旧版 99.9786% 停在 parent-1 的情况不同：新的 root 预测确实依赖完整递归路径。

8. 为什么预注册 Claim 仍然没有全过
我们事先规定：
root 被删除后，Echo token accuracy 至少下降 10%
实际下降是：
6.96%
所以 P3 没有通过，完整 Claim 必须保持 not fully supported。
我们不能看到 block exact 从 100% 降到 0% 后，再偷偷把评价标准从 token accuracy 换成 block exact。
不过可以保留一个更窄的结论：

lifting FOLD/UNFOLD 已经闭合；
全部 leaf 被 mask 后，可以只凭 $H_{state}$ 完整 Echo；
每层 detail 都是地址敏感且有因果作用的；
root 对整块闭合和 next-token 都有因果作用；
真实语料梯度能够训练 predictor；
learned predictor 小幅但明确优于 frozen predictor。


9. 高层不需要对应人类命名的语义
Houming818 对这一步提出了一个重要修正：

我们不需要证明 root 一定表示“主题”，parent 一定表示“短语”。这些结构可以通过数据涌现，而且换一种抽水算法，形成的内部意义可能完全不同，解并不唯一。
我们同意这个判断。
假设两个 TreeHeap 使用不同 predictor：
$$ P_{\theta_1},\qquad P_{\theta_2}. $$它们可能形成完全不同的 root/detail 坐标系，但只要分别满足：
$$ UNFOLD_{\theta_1}(FOLD_{\theta_1}(X))=X, $$$$ UNFOLD_{\theta_2}(FOLD_{\theta_2}(X))=X, $$并且都能降低真实任务 loss，它们就可以是两个不同但有效的私人协议。
这类似每个人的笔迹不同，但各自可以读懂自己写下的内容。
因此，我们不应强迫内部节点对应预先定义的主谓宾、词性或人工类别。真正需要验证的是操作意义：

能否写入；
能否读回；
地址是否有因果作用；
删除节点是否按结构损坏结果；
学习是否改善真实任务；
更大的任务是否能站在这个协议上继续训练。


10. 当前边界和下一步
当前已经完成的是：
完整 token
→ 归纳学习过的 lifting encoder
→ H_state
→ mask 全部 leaf
→ 演绎 UNFOLD
→ 100% Echo
还没有完成的是：
完整 token
→ H_state
→ 删除 H_state 中某个必要 detail
→ 根据其他尺度和世界经验补回缺失信息
后一种任务不再是严格逆运算，而是：
$$ P(D_{\mathrm{missing}}\mid root,D_{\mathrm{visible}},context). $$它才是从“私人可逆编码”走向“缺失信息推断”的下一步。
但至少现在，TreeHeap 不再只是执行了几次形式上的递归卷积。我们已经有了一套明确的信息流规则：
FOLD：向上抽取 parent，留下 addressed detail
UNFOLD：从 root 出发，逐层补回 detail
LEARN：真实语料梯度改变 predictor 和内部坐标系
ECHO：遮住全部表面 leaf 后，仍可精确恢复
这是一台已经能运转的信息抽水机。
它是不是语言智能，还远远没有证明；但它终于不再是一根只在第一层取水的管道。

Evidence
ARA 声明：
ara/s1-echo/logic/lifting_information_pump.md
实验代码：
ara/s1-echo/src/s1_lifting_information_pump.py
正式 Evidence：
ara/s1-echo/evidence/s1_lifting_information_pump/main/
SameTime commit：
f17ab3f
本文记录的是可复现实验和当前边界，不是对 TreeHeap 语义、意识或通用智能的完成声明。



[SPR-059] TreeHeap 抽水机第一次进入 WMT：递归 READ 成立了，但翻译还没有赢
Thu, 16 Jul 2026 00:00:00 +0000
TreeHeap 抽水机第一次进入 WMT：递归 READ 成立了，但翻译还没有赢
上一篇 SPR-058 做的是 Echo：一句话先经过 TreeHeap FOLD，形成
H_state = root + 各层 details
然后遮住原始 token，只使用 (H_{state}) 做 UNFOLD，能够把输入完整恢复。
这证明 lifting pump 是一个可逆的信息容器，但还没有证明它能完成翻译。因为翻译不是把英语原样抄回来，而是要根据英语状态，逐个生成中文 token。
SPR-059 因此向前走了一步：

把真实英文 WMT 句子写入 lifting TreeHeap，再让中文 decoder 从 root 开始递归读取。只用翻译交叉熵训练，不提供路径标签、句法标签、对齐标签或内部节点答案。
结果可以先用一句话概括：

TreeHeap 的递归读取机制得到了强证据，但翻译质量仍然没有超过 flat sequence baseline。
这不是模棱两可。它回答的是两个不同问题：

模型是否真的利用了 TreeHeap 的 root、路径、detail 和递归配对？答案是“是”。
这套实现是否已经比普通序列模型翻译得更好？答案是“否”。


1. 这次模型究竟在做什么
任务是标准英中翻译：
英文句子
    -> TreeHeap encoder
H_src = root + details
    -> 概率递归 READ
中文 decoder
    -> 下一个中文 token 的概率桶
    -> argmax 坍缩
中文句子
其中有三个需要分清的对象：

  
      
          对象
          本次实验中的含义
      
  
  
      
          (H_{src})
          当前英文句子的 TreeHeap 状态，即 root 与各层 addressed details
      
      
          (q_t)
          中文生成到第 (t) 步时，decoder 已经积累的查询状态
      
      
          θ
          embedding、lifting predictor、递归 stop/branch kernel 与中文 decoder 的可学习参数
      
  

θ 不是某一棵输入句子的树。它是所有样本共同训练的规则参数；(H_{src}) 才是当前句子被写入以后形成的状态。
1.1 英文如何写进 TreeHeap
英文 token embedding 先放在叶子。每两个相邻状态记为 (L,R)，共享 predictor (P_θ) 计算：
$$ D=R-P_\theta(L), $$$$ U=L+\frac12D. $$其中：

(D) 是当前地址保留的 detail；
(U) 是继续向父节点上传的粗分辨率状态；
所有深度共享同一个 (P_\theta)。

这个过程不断递归：
32 leaves
  -> 16 parents + 16 details
  ->  8 parents +  8 details
  ->  4 parents +  4 details
  ->  2 parents +  2 details
  ->  1 root    +  1 detail
最终的英文表示不是一个 root 向量，而是：
$$ H_{src}=(root,D^{(5)},D^{(4)},\ldots,D^{(1)}). $$root 提供大范围轮廓，detail 保留各个地址上没有被父节点完全表达的差异。
1.2 中文 decoder 如何读取这棵树
生成每个中文 token 时，概率质量从 root 的 1.0 开始。
在深度 (d) 的节点 (v)，stop kernel 根据中文查询状态、节点状态和深度计算：
$$ p_{stop}(v,t) = \sigma K_{stop}(q_t,H_v,d). $$一部分概率停在当前节点，当前节点的信息进入中文 context；剩余概率继续向左右孩子展开：
$$ m_{stop}=m_v p_{stop}, $$$$ m_{expand}=m_v(1-p_{stop}). $$branch kernel 再把 (m_{expand}) 分给 left 与 right。这个过程一直递归到所有概率已经停下，或者走到叶子。
因此，decoder 每一步得到的不是一个硬地址，而是一个跨分辨率的概率前沿：
root             0.20
某个中层节点     0.35
几个更深节点     0.30
部分 leaves      0.15
---------------------
总概率           1.00
这些节点的加权和形成当前 source context，再与中文 decoder state 一起计算下一个 token：
$$ p(y_t\mid y_{\lt t},H_{src}). $$训练时只有普通翻译损失：
$$ L_{S2} = -\sum_t\log p(y_t\mid y_{\lt t},H_{src}). $$没有任何老师告诉 READ “这里应该停在 root”或“这里应该向左”。如果不同深度的读取规律形成，只能来自翻译 loss 的梯度。

2. 为什么需要五个模型一起比较
只训练一个 TreeHeap 模型，即使 NLL 下降，也无法判断下降来自哪里。因此实验同时训练五个参数量接近的模型：

  
      
          模型
          它回答的问题
      
  
  
      
          target-only
          完全不看英语，中文语言模型自己能做到什么程度？
      
      
          flat sequence
          普通序列 encoder 与 attention 能做到什么程度？
      
      
          lifting-root
          只给 decoder 一个 root，压缩是否过强？
      
      
          lifting-full
          完全 UNFOLD 后读取 leaves，完整信息上限如何？
      
      
          lifting-recursive
          从 root 开始，自己决定在哪个深度停留或下沉
      
  

lifting-full 不是 TreeHeap 效率模型，而是信息对照：它把原分辨率全部展开，告诉我们“信息本身还在不在”。
lifting-recursive 才是本文要测试的模型。

3. 预注册的 Predict
在看正式结果之前，我们先写下八个通过条件：

递归 READ 的 NLL 不高于历史 root-exclusive 结果 6.55；
比 root-only 至少改善 0.05 NLL；
与 full UNFOLD 的差距不超过 0.10 NLL；
打乱完整英文状态至少损失 0.20 NLL；
root 与至少一层 detail 必须具有因果作用；
至少两个深度的左右配对破坏必须造成损失；
READ 必须使用至少两个分辨率，不能全部坍缩到 leaves；
FOLD/UNFOLD 闭包、有限梯度与非空生成必须通过。

这里最重要的是第 4 到第 7 条。它们防止我们把“模型输出了中文”误报成“模型使用了 TreeHeap”。

4. 数据与训练规模
正式实验在 io 的 RTX 3090 上运行：

  
      
          项目
          数值
      
  
  
      
          方向
          English -> Chinese
      
      
          训练/验证/测试
          27,000 / 2,000 / 2,000
      
      
          词表
          16,001
      
      
          状态维度
          256
      
      
          epoch
          10
      
      
          最佳模型选择
          最低 validation NLL
      
      
          总运行时间
          1,398.49 秒
      
      
          FOLD/UNFOLD MSE
          1.73e-14
      
  

长度过滤后数据共有 31,337 条，正式拆分使用了其中 31,000 条。实验没有报告多 seed，因此它仍是一次 full-scale mechanism proof，不是最终统计结论。

5. 指标像体检报告一样怎么看
5.1 NLL：越小越好
NLL 是模型给正确中文 token 分配的负对数概率。正确答案概率越高，NLL 越小。
5.2 PPL：越小越好
$$ PPL=e^{NLL}. $$它可以粗略理解为：模型在每一步还像是在多少个候选之间犹豫。它不是候选数的字面值，但越小通常越好。
5.3 Token BLEU-4：越大越好
它检查生成结果与参考译文是否共享连续 token 片段。本文数值整体很低，说明五个小模型都远未达到实用翻译质量。

6. 主结果：结构机制通过，质量没有获胜

  
      
          模型
          参数量
          Test NLL ↓
          PPL ↓
          Token BLEU-4 ↑
      
  
  
      
          target-only
          12.96M
          5.7189
          304.57
          0.117
      
      
          flat sequence
          17.45M
          4.8103
          122.77
          3.169
      
      
          lifting-root
          17.32M
          5.4337
          229.01
          1.585
      
      
          lifting-full
          17.32M
          5.1342
          169.73
          1.881
      
      
          lifting-recursive
          17.52M
          5.0903
          162.44
          2.528
      
  

好消息
递归 READ 比 root-only 改善：
$$ 5.4337-5.0903=0.3434. $$这说明一个 root 不够；读取 addressed details 明显有价值。
递归 READ 还比完全 UNFOLD 小幅改善 0.0439 NLL。一个合理但尚未证明的解释是：概率前沿起到了结构化正则化作用，没有让 decoder 在每一步同时面对全部 leaves。
坏消息
flat sequence 仍然领先递归 TreeHeap：
$$ 5.0903-4.8103=0.2800. $$BLEU-4 也低 0.641。TreeHeap 目前获得的是“存在性”，不是“优越性”。

7. 它真的使用了 TreeHeap 吗
这是本文最强的证据。
以正常递归模型 NLL 5.0903 为基准：

  
      
          干预
          NLL 增量
          含义
      
  
  
      
          打乱完整 source H_state
          +1.4450
          输出强依赖当前英文句子
      
      
          只打乱 root
          +1.7204
          root 是强因果状态，不是装饰
      
      
          强制只读 root
          +1.1773
          只看全局轮廓不够
      
      
          强制一直走到 leaves
          +0.6236
          只看最细粒度也不够
      
  

五层 detail 分别打乱后的损失：
+0.1171, +0.1422, +0.2402, +0.4960, +0.4857
五层左右子树配对被跨样本破坏后的损失：
+0.4807, +0.4414, +0.4107, +0.4354, +0.2105
所有深度都不是中性的。也就是说，模型不只读取了一袋向量；它依赖“哪个 detail 在哪个深度”和“哪些左右子树被组合在一起”。
正常 READ 的平均 stop mass 为：

  
      
          深度
          Stop mass
      
  
  
      
          root
          0.3329
      
      
          depth 1
          0.0288
      
      
          depth 2
          0.1283
      
      
          depth 3
          0.0384
      
      
          depth 4
          0.0073
      
      
          leaves
          0.4643
      
  

总和为 1。模型主要使用 root 和 leaves，但中间分辨率也承担了约 20.3% 的概率质量。这就是“多分辨率 READ”的实证含义。

8. 真实生成样例
下面不是 cherry-pick 的最佳句子，而是测试集开头的典型输出。它们能更诚实地说明当前能力边界。
样例一：抓到了财政主题，但句法和词义仍然混乱
英文输入

As economies then weakened, the prospects for fiscal consolidation grew dimmer.
参考译文

经济随之疲软，因此财政整合前景也变得更加虚弱。
flat sequence

新兴经济体开始，其财政前景似乎出现了了。
递归 TreeHeap

由此从那时，其银行也变得越来越微财政巩固。
TreeHeap 读出了“财政巩固”和趋势变化的主题，但没有组成正确中文。这里能看到 source signal，不是可用翻译。
样例二：主题词正确，重复坍缩严重
英文输入

Bond prices then fell further, damaging European banks even more.
参考译文

这造成债券价格进一步下跌，给欧洲银行造成更多的伤害。
flat sequence

价格下跌进一步下跌，银行也更加更加更大。
递归 TreeHeap

进一步进一步进一步进一步进一步进一步进一步进一步上升，欧洲银行甚至进一步上升。
TreeHeap 找到了“进一步”和“欧洲银行”，却把“下跌”生成成“上升”，并陷入重复循环。这是 decoder 与训练规模的明确失败，不应被结构干预的成功掩盖。
样例三：知道在谈银行和融资，但关系没有还原
英文输入

Reassured that they will have access to funding, the banks again have the confidence to lend.
参考译文

银行获得了能够得到融资的保证，因此重新获得了发放贷款的信心。
递归 TreeHeap

他们在他们方面会继续下去，但银行银行再次进入了。
它保留了“银行”“再次”以及继续发生某事的轮廓，但融资、保证、贷款和因果关系都没有正确解码。
样例四：flat baseline 明显更接近参考答案
英文输入

Tax increases and cuts in public spending are still needed; there is no avoiding this reality.
参考译文

加税削减了仍属必须的公共支出；这是不可避免的现实。
flat sequence

削减公共支出削减公共支出削减；但依然存在这一现实。
递归 TreeHeap

税收支出支出支出支出支出，在这个问题上中，我们还有很容易。
这个样例直观解释了为什么 flat baseline 的总体 NLL 和 BLEU 更好。

9. 八个 Predict 的最终体检

  
      
          Gate
          结果
      
  
  
      
          P1：超过历史 root-exclusive NLL
          PASS
      
      
          P2：递归优于 root-only
          PASS
      
      
          P3：接近 full UNFOLD
          PASS
      
      
          P4：完整 source 状态具有因果性
          PASS
      
      
          P5：root 与 detail 都具有因果性
          PASS
      
      
          P6：多个递归配对深度具有因果性
          PASS
      
      
          P7：使用多个分辨率
          PASS
      
      
          P8：闭包、梯度与非空生成
          PASS
      
  

因此 Claim S2-LIFT-WMT-C01 的准确状态是：
TreeHeap mechanism: supported
Translation superiority: rejected
Compression advantage: open
Compute advantage: open
Production translation: not supported

10. 下一步不应该做什么
不应该因为八个 gate 全过，就直接把数据扩大一百倍并宣布成功。
当前实现还有三个明确问题：

flat sequence 仍领先 0.2800 NLL；
中文 decoder 有严重重复和关系反转；
代码会先物化所有 TreeHeap 层，再计算概率 READ，因此还没有获得真正的稀疏计算优势。

也不应该把中间深度人工命名成“主语层”“语义层”或“意识层”。实验只证明这些状态具有因果作用，没有证明它们对应人类可读语法。

11. 下一步真正值得验证什么
我认为下一步有三个优先级。
第一：修复生成，而不破坏结构读法
保留同一个 lifting encoder 和递归 READ，升级 target decoder，并加入重复惩罚、长度控制与更稳的解码评估。目标是缩小对 flat baseline 的 0.2800 NLL 差距。
第二：做真正的按需 UNFOLD
现在所有层都已经算好。下一版应该只展开仍然携带概率质量的节点，统计：
访问节点数 / 完整树节点数
实际 FLOPs
显存
延迟
只有在质量接近且访问节点显著减少时，才能讨论 TreeHeap 的压缩检索优势。
第三：跨 seed 复核
至少运行三个 seed，报告均值、标准差和干预效应区间。递归模型略胜 full UNFOLD 的 0.0439 NLL 很小，单次实验不足以把它升级成稳定优势。

12. 最终结论
SPR-058 证明 lifting pump 能把信息抽上去并严格放回来。SPR-059 进一步证明：

在真实 WMT 数据上，普通翻译梯度可以训练出一个从 root 开始、依赖地址与递归配对、在多个 TreeHeap 分辨率之间分配概率的 READ。
这是我们第一次不靠 Echo、不靠内部标签，看到 TreeHeap 结构参与真实 S2 任务。
但样例也非常诚实：模型还不会稳定地说中文，重复、反义词和关系丢失都很严重。TreeHeap 现在拥有了一条可信的数据通路，还没有获得更强的产品能力。
这条边界必须保留。因为真正值得继续研究的，不是把一次机制 proof 写成胜利，而是已经知道下一块损失具体在哪里。

Evidence

ARA claim：S2-LIFT-WMT-C01
Predict：P-S2-LIFT-WMT-01
SameTime commit：fb17f8f
实验设计与结论
复现实验代码
完整 summary.json
Checkpoints：/mnt/nas/ara/s3-generation/evidence/s2_lifting_pump_wmt_full/

本文中的 TreeHeap 实验设计、实现与结论记录按本项目许可证公开。lifting scheme 等已有数学工具不被主张为本项目原创；原创部分限定为本次组合设计、可证伪实验和相应 evidence。



[SPR-060] TreeHeap 退火缩句协议：让重要信息活到更高层
Thu, 16 Jul 2026 00:00:00 +0000
TreeHeap 退火缩句协议：让重要信息活到更高层
这篇文章保存一个新的研究转折点。
它不是已经被实验支持的结论，而是 Houming818 在复盘 TreeHeap 预训练时提出的新假设。我们先把它完整、准确地记录下来，再据此设计下一轮 ARA、Predict 和 Proof。
Houming818 的原始表述是：

在第 0 层，是一个长 string，例如“夏天的凉风吹过一望无际的青青草原”。

抽水时，算法提取缩减句子，例如“夏天的凉风吹过草原”。

再往上，只剩“风吹过草原”。

这是一个缩句和插值退火的过程。信息会消失，但应保留更重要的细节。

它不能缩减成“夏天凉风”；这同样是缩减，却不是更优的缩减，因此 Loss 应该更高。
这段话把 TreeHeap encoder 的目标，从“保存所有 token”推进成了：

完整信息先进入 TreeHeap，然后在越来越窄的层级中逐步有损收缩；能够减少更多未来 Loss 的结构活到高层，其余精度留在低层 detail。

1. 上一轮实验停在哪里
上一轮真实中文预训练比较了三种缺失片段生成课程：

  
      
          训练方式
          width-4 NLL
          width-8 NLL
      
  
  
      
          单 token Mask
          9.1347
          9.8977
      
      
          同长度随机 span
          5.4216
          5.9718
      
      
          TreeHeap 对齐 subheap
          5.3852
          5.9179
      
  

实验至少确认了一件事：

只训练单 token 恢复，会让模型严重专门化到单叶问题。它对更大缺口的处理能力不但没有自然生长，反而明显恶化。
多尺度 subheap Mask 避免了这种单一化，并比等长度随机 span 小幅改善。但结构审计暴露了新的问题：

  
      
          干预
          width-8 NLL 损失
      
  
  
      
          换掉整棵 source TreeHeap
          +0.1345
      
      
          清零全部 source state
          +1.5645
      
      
          打乱各层 detail
          +0.5311 到 +9.6856
      
      
          清零 root
          仅 +0.0042
      
      
          FOLD 前交换相邻 left/right
          仅 +0.0022
      
  

因此模型学会了一个依赖 source 和多层 detail 的 seq2seq 补全器，却仍然没有把信息组织进 root 和左右地址。
上一轮的做法是：
原始 token
    -> 先替换成 [MASK]
    -> FOLD
    -> 根据剩余信息补洞
新的问题是：被替换掉的真实 token 根本没有参加 FOLD。抽水机没有机会把它和其他 token 的关系上传到 parent。
SPR-060 因此不再研究“怎样挖一个更好的洞”，而开始研究：

完整信息在逐层收窄时，怎样自然决定什么应该继续向上，什么应该留在低层。

2. 什么叫退火缩句
考虑完整句子：
L0：夏天的凉风吹过一望无际的青青草原
理想中的层级状态可能呈现为：
L0：夏天的凉风吹过一望无际的青青草原
L1：夏天的凉风吹过草原
L2：风吹过草原
L3：风吹草原
L4：风—草原
这里的“缩句”不要求内部节点真的保存一串可阅读的汉字。encoder 与 decoder 可以形成我们看不懂的私有编码。
这些中文缩句只是帮助人类理解不同分辨率可能保留什么：

底层包含词面、修饰、数量和局部顺序；
中层包含事件参与者和动作；
高层包含越来越粗的关系轮廓；
root 表示当前容量下最值得保留的全局状态。

这与普通摘要不同。它不是一次性把长句变成短句，而是产生一条连续的分辨率路径。

3. TreeHeap 中什么在消失
设相邻两个子状态为 (L) 和 (R)。当前 lifting FOLD 可以写成：
[
D = R - P_	heta(L),
]
[
U = L + A_phi(D).
]
其中：

(D) 是当前地址保存的 detail；
(U) 是继续向 parent 上传的状态；
(P_	heta) 学习左右状态之间可预测的关系；
(A_phi) 决定差异中的多少内容进入 parent。

完整的 TreeHeap 状态仍然是：
[
H_{	ext{state}}
left(
root,
D^{(0)},
D^{(1)},
ldots,
D^{(D-1)}
ight).
]
所以“信息消失”需要分两种观察口径。
3.1 对整棵 H_state 而言
如果 lifting 仍然严格闭合，那么信息没有真正消失。root 与所有 addressed detail 合在一起，仍可恢复底层状态。
3.2 对单独 parent 或 root 而言
信息确实在逐层减少。没有被上传的局部精度停留在 detail，不再继续进入更高层。
因此退火协议并不是删除整个模型中的信息，而是：

控制信息能够到达的最高深度。
重要的关系传播得更远；局部细节只在附近地址存在。

4. 为什么“风吹过草原”可能优于“夏天凉风”
两个候选压缩结果都是合法缩句：
Z1 = 风吹过草原
Z2 = 夏天凉风
TreeHeap 不应该由程序员硬编码选择 (Z_1)。选择必须来自数据和任务。
让共享 decoder 分别尝试根据两个状态解释原句或预测后续：
[
L(Z)
-log P_phi(X mid Z).
]
如果保留 (Z_1)，decoder 仍知道：
某个主体
    -> 执行动作“吹过”
    -> 作用于空间“草原”
如果只保留 (Z_2)，decoder 知道季节和风的性质，却丢失了事件方向与对象。
在大量相似语料中，如果事件骨架对恢复原句、预测后续或回答查询更有用，就会出现：
[
L(Z_1) < L(Z_2).
]
梯度因此提高“风—吹过—草原”相关状态的上传概率。
这不是说“夏天”和“凉”永远不重要。如果后续任务询问季节，或者语料的未来主要由季节决定，最优保留内容就可能改变。
所谓“重要”，不是人类预先给出的绝对语义标签，而是：

在有限上传容量下，哪部分状态能够减少更多未来误差。

5. 退火参数在哪里
为 FOLD 增加一个可学习的上传门：
[
g_d
sigma
left(
rac{s_	heta(L,R)}{	au_d}
ight),
]
其中：

(s_	heta) 是共享 TreeHeap kernel 计算的上传分数；
(d) 是当前深度；
(	au_d) 是温度；
(g_d) 决定差异中有多少进入 parent。

父状态可以写成：
[
U
L + g_d odot A_phi(D).
]
训练早期温度较高，门比较柔软：
[
g_d in (0,1).
]
模型可以尝试多种上传方式。随着训练推进或深度升高，温度下降，门逐渐接近稳定选择：
[
g_d 
ightarrow 0
quad	ext{或}quad
g_d 
ightarrow 1.
]
这就是“退火”的工程含义：不是突然剪掉 token，而是让软的信息分配逐渐形成稳定协议。

6. 容量为什么必须逐层下降
如果每个 parent 都拥有无限容量，最简单的解仍然是把所有 token 原样背下来。这样不会自然产生缩句。
设第 (d) 层可用的信息容量为 (R_d)：
[
R_0 > R_1 > R_2 > cdots > R_D.
]
容量可以通过多种方式实现：

节点数量随 FOLD 逐层减半；
parent 的有效激活维度受限；
上传门的总质量受预算约束；
decoder 每次只能读取固定数量的高层节点；
深度越高，量化位数或可用通道越少。

目标不是把 root 强制变成一句话，而是让模型面对一个真实选择：

root 装不下所有东西时，应该保留什么？

7. 数学上是率失真问题
令 (H_d) 是第 (d) 层可被 decoder 读取的状态。训练目标可以写成：
[
mathcal L
mathbb E_d
left[
-log P_phi(X mid H_d)
+
eta_d R(H_d)
ight].
]
第一项是语言失真：
[
D_d
-log P_phi(X mid H_d).
]
第二项是信息容量或编码率：
[
R_d = R(H_d).
]
(eta_d) 随深度增加，表示高层承担更强的压缩压力。
这正是率失真优化：
[
min quad D + eta R.
]

只优化 (D)：模型倾向背诵全部信息；
只优化 (R)：模型坍缩成无意义常量；
同时优化：模型寻找有限容量下最有用的表示。

这里的 Loss 不一定要写成多个互相竞争的“大锅炖”目标。可以在每个样本中随机抽取一个分辨率，只计算一次 decoder Loss；长期训练的期望等价于让所有层接受不同强度的压缩考核。

8. Encoder 与 Decoder 如何形成默契
encoder 不需要输出人类定义的“主语、谓语、宾语”。
训练开始时：
FOLD 不知道怎样缩句
decoder 也不知道怎样读取 parent
二者接受同一个生成误差：
[
(	heta,phi)
leftarrow
(	heta,phi)
eta
abla_{	heta,phi}mathcal L.
]
如果 encoder 的某种上传方式使 decoder 更容易恢复或继续生成，Loss 就下降，这种编码方式被保留。
长期训练后，双方可能形成一套私有协议：
encoder：这种几何方向表示“事件仍在继续”
decoder：看到这种方向时生成动作及其对象
人类不需要预先读懂协议。我们只需要用干预测试确认：

root 是否包含样本相关信息；
某个 parent 是否覆盖自己的 receptive field；
detail 是否保存局部精度；
left/right 交换是否改变结果；
加回更多 detail 是否连续改善恢复质量。

这类似一个人能够阅读自己的笔迹。重点不是旁观者是否认识每个内部符号，而是书写和阅读系统是否共同形成了稳定、可复用的压缩协议。

9. 最小可证明 Toy
在直接使用自然语言以前，可以构造一个有限数据世界。
每个样本由核心 (C)、细节 (N) 和未来 (Y) 组成：
[
X=(C,N).
]
例如：
核心 C：风吹草原
细节 N：夏天、凉、一望无际、青青
未来 Y：草浪起伏，牛羊低头
让数据分布满足：
[
P(Y mid C,N)
approx
P(Y mid C).
]
即未来主要由核心事件决定，修饰细节只增加表面变化。
当高层只能保留有限信息时，理论 Predict 是：
[
H(Y mid C) < H(Y mid N).
]
因此保存核心 (C) 比保存细节 (N) 更能降低未来预测 Loss。
这个 Toy 不需要告诉模型“风吹草原是核心”。我们只控制数据生成规律，然后观察 TreeHeap 是否通过梯度把 (C) 传播到更高层。

10. 下一条 Claim
下一条正式 ARA 应围绕以下 claim 建立：

在完整输入、逐层递减容量和共享生成 Loss 下，TreeHeap FOLD 能学习一个分辨率有序的退火协议：低层保存表面精度，高层优先保存对恢复、未来预测或查询更有贡献的结构；root 与 addressed detail 共同形成连续率失真曲线。
这个 claim 必须拆成可测量 Predict。
P1：分辨率有序
从叶子到 root，原句精确恢复能力允许下降，但不能无规律跳动：
[
D_0 le D_1 le cdots le D_D.
]
P2：预测信息存活
虽然 token 精度下降，高层对未来 (Y) 的预测必须明显优于同容量随机压缩。
P3：核心优先
在有限 Toy 中，清除核心事件对高层 Loss 的伤害，应显著大于清除表面修饰。
P4：root 因果性
root shuffle 或 root zero 必须造成注册阈值以上的损失，不能再次出现仅 (+0.0042) 的结果。
P5：detail 分辨率
逐层加回 detail 时，恢复质量应形成单调改善曲线：
[
D(root)
ge
D(root+D_{top})
ge
cdots
ge
D(H_{	ext{state}}).
]
P6：地址因果性
交换 left/right、移动 detail 地址或破坏 parent-child 配对，应造成可重复损失。
P7：不是普通池化
相同容量的均值池化、随机投影、flat bottleneck 和普通 RNN/Transformer bottleneck 必须作为对照。否则不能把一般的信息瓶颈效果归因于 TreeHeap。

11. 什么还没有被证明
截至本文，以下内容仍然只是新假设：

TreeHeap 会自然产生人类可读的缩句；
root 会自动表示句子核心；
高层一定对应主谓宾或事件图；
退火协议一定优于 Transformer；
这种结构已经形成意识；
率失真最优解在自然语言中是唯一的。

我们已经知道的是：

lifting TreeHeap 可以严格闭合；
WMT decoder 能因果使用多个 detail 深度；
learned update 比固定 update 更好；
单 token Mask 会产生强烈课程单一化；
多尺度 subheap Mask 训练出了 source/detail-dependent generation；
当前模型仍未让 root 与左右地址变得足够因果。

SPR-060 的作用，是针对最后一个障碍提出新的机制解释和实验方向。

12. 下次从哪里继续
下次恢复研究时，不要再从“怎样设计一个更复杂的 Mask”开始。
直接读取本文，然后从下面的数据流继续：
完整过去或完整句子
    -> token WRITE
    -> 可学习 lifting FOLD
    -> 深度递增、容量递减、温度下降
    -> parent 保存粗轮廓
    -> detail 保存局部精度
    -> 随机选择一个分辨率
    -> 共享 decoder 做恢复或未来生成
    -> Loss 同时训练 encoder 与 decoder 的私有协议
第一轮 Proof 应先在可控 Toy 上回答：

当未来确实由“风吹草原”决定，而与“夏天、凉、青青”弱相关时，TreeHeap 是否会把前者传播得更高？
通过后，再把同一机制放到 NAS 真实语料，观察不同深度的恢复、未来预测、root 因果性和率失真曲线。
这是当前保存的航行位置。



[SPR-061] TreeHeap 损伤后的生长：从消融因果走向跨分辨率修复
Fri, 17 Jul 2026 00:00:00 +0000
TreeHeap 损伤后的生长：从消融因果走向跨分辨率修复
SPR-060 提出了一个直观例子：
夏天的凉风吹过一望无际的青青草原
→ 夏天的凉风吹过草原
→ 风吹过草原
这个例子帮助我们想象“分辨率逐层降低”，但它也悄悄越过了证据边界：它把不可读的内部向量理想化成了人类可读的缩句。
Houming818 对此持保留意见。当前实验只证明了高层状态可以参与未来预测，没有证明高层真的保存了“风吹过草原”这样的语言轮廓。
这次讨论带来了更重要的修正：

TreeHeap 的目标不应只是证明 root 或 detail 保存了信息，而应研究：当部分信息自然缺失时，剩余的多分辨率结构能否约束缺失部分，使它重新生长出来。
本文先记录这一思想，不把它冒充成已经成立的实验结论。文末给出供评审的 ARA、Predict 和 Proof 草案；正式实验将在理论口径确认后再启动。

1. 守夜实验到底证明了什么
上一轮守夜实验使用完整的 64 token 中文历史预测后续 16 token，没有先做 Mask。相同模型分别采用三种分辨率训练课程：

  
      
          训练方式
          root NLL
          leaf NLL
          含义
      
  
  
      
          只训练叶层
          35.8732
          5.3615
          信息不会自动上传，root 被模型放弃
      
      
          均匀训练七个深度
          5.7158
          5.4870
          所有分辨率都可以获得预测能力
      
      
          由叶向 root 退火
          5.6240
          5.5624
          退火使 root 比均匀训练改善 0.0918
      
  

退火模型的 root 与 leaf 只相差 0.0603 NLL，七个分辨率的 NLL 与深度呈有序关系，Spearman 相关系数为 -0.75。
这支持一个有限结论：

在容量逐层收窄的 TreeHeap 中，训练压力能够使较高层状态获得未来预测能力。
但结构审计没有通过：

  
      
          干预
          root NLL 变化
      
  
  
      
          用其他样本替换 source
          +0.0852
      
      
          FOLD 前交换相邻左右孩子
          -0.0011
      
  

这意味着当前 root 可能主要保存语料平均统计、主题或常见后续，而不是这一个样本的具体关系。它还不能被解释成一条“内部缩句”。
受控 Toy 中，未来由三个核心 token 决定，另外十三个 token 是独立噪声。TreeHeap 确实能把核心信息抽进 root：打乱核心造成超过 16 NLL 的损失，打乱噪声几乎没有影响。不过 mean pooling 也能完成任务，所以这还不是 TreeHeap 特有的胜利。

2. 第一处修正：上层状态不等于缩句
我们不再假设：
root = 风吹过草原
更严谨的说法是：
叶层：容量较大，包含较多局部状态
高层：容量较小，但仍包含某些预测信息
root：一个不可读的低分辨率状态
root 可能包含事件轮廓，也可能包含主题、文体、词频偏置或其他统计捷径。内部编码可以是 encoder 与 decoder 共同形成的私有协议，人类不一定能直接翻译成一句话。
因此，“高层 NLL 较低”只能证明高层可用于预测，不能单独证明高层理解了句子。

3. 第二处修正：当前抽水机没有内容级价值判断
当前退火实验只调度“在哪个深度读取”：
训练早期：更多读取叶层
训练后期：更多读取高层
它没有在一次 FOLD 内判断：
保留左边？
保留右边？
保留二者关系？
上传当前轮廓？
把什么留在 detail？
Houming818 从自我观察提出了另一种可能：

回溯一个句子或一个刹那时，意识可能先出现一个相关性最高的轮廓，然后围绕这个轮廓构造细节。它不是机械地抽取“必然信息”，而是在当前背景下判断什么最重要。
若把这个猜想转换成数学语言，每个局部节点应产生一个价值概率桶。设当前查询或背景为 $q$，局部状态为 $H_{\text{local}}$，候选处理方式为 $a$：
$$ s_a=K_\theta(q,H_{\text{local}},a). $$$$ p(a)=\operatorname{softmax}\left(\frac{s_a}{\tau}\right). $$候选 $a$ 可以包括保留左侧、保留右侧、合成关系、停止收缩等操作。训练阶段先保持软分布：
$$ H_{\text{parent}}=\sum_a p(a)\,T_a(H_{\text{local}}). $$温度下降以后，分布才可能接近：
$$ a^*=\arg\max_a s_a. $$这里的“重要”不是人工语法标签，而是反事实价值：
$$ V(a)=\mathcal L_{\text{without }a}-\mathcal L_{\text{with }a}. $$去掉某部分后任务 Loss 增加得越多，它在当前背景下的上传价值越高。
但必须明确：现有实验没有实现也没有证明这个内容级 argmax。它只是下一阶段可能需要的机制。

4. 从分形观察到的不是外形，而是损伤后的恢复
本文不打算把分形公式设计进 TreeHeap。
我们只是观察分形压缩和自相似生成表现出的一种能力：系统不保存每一个细节，而保存能够约束细节的规律；观察分辨率降低以后，整体形态仍然存在，需要时可以从规则递归展开。
严格来说，数学分形本身不等于可损压缩。这里借用的是“分形压缩与跨尺度重建”的能力类比，而不是宣称 TreeHeap 已经是分形。
这个类比把研究问题从：
拿掉一个节点，Loss 增加多少？
推进为：
拿掉一个节点以后，
TreeHeap 能否根据其他尺度和位置重新生成它？
这是两个完全不同的问题。

5. 因果消融为什么不等于修复能力
当前审计采用：
$$ \Delta L_{\text{ablation}}=L_{\text{damaged}}-L_{\text{clean}}. $$若 $\Delta L$ 很大，我们知道模型依赖被消融状态。但这也可能意味着系统非常脆弱：一个节点损坏，整体立刻失效。
若 $\Delta L$ 很小，也有两种解释：

模型从未使用这个节点；
其他节点包含冗余，能够替代它。

只看消融损失无法区分二者。
因此下一阶段必须把三个状态分开：
$$ L_{\text{clean}},\qquad L_{\text{damaged}},\qquad L_{\text{repaired}}. $$
$L_{\text{clean}}$：完整 TreeHeap 的任务损失；
$L_{\text{damaged}}$：破坏局部状态后、尚未修复的损失；
$L_{\text{repaired}}$：运行修复 kernel 后的损失。

定义修复率：
$$ \rho=\frac{L_{\text{damaged}}-L_{\text{repaired}}}{L_{\text{damaged}}-L_{\text{clean}}+\epsilon}. $$
  
      
          修复率
          含义
      
  
  
      
          $\rho=0$
          没有修回任何损失
      
      
          $\rho=0.5$
          修复了一半损失
      
      
          $\rho=1$
          回到完整状态的任务水平
      
  

这条曲线才是“可损后生长”的直接评价。

6. TreeHeap 可以怎样重新长出 detail
现有 learned lifting FOLD 写成：
$$ D=R-P_\theta(L). $$$$ U=L+A_\phi(D). $$其中 $U$ 是上传的粗状态，$D$ 是留在当前地址的 detail。完整的 root 与所有 addressed detail 仍然构成闭合的 $H_{\text{state}}$。
当某个 detail 损坏时，旧做法是清零并直接观察 Loss。新的做法需要先预测缺失残差：
$$ \hat D=G_\psi\left(U,\,H_{\text{sibling}},\,\text{path},\,W\right). $$其中：

$U$ 提供更高层轮廓；
sibling 提供同一局部的横向约束；
path 告诉模型缺失发生在什么地址；
$W$ 是已学习的世界模型或上下文状态；
$G_\psi$ 是共享的 repair kernel。

随后执行 UNFOLD：
$$ (\hat L,\hat R)=\operatorname{UNFOLD}(U,\hat D). $$如果更低层仍有缺损，同一个过程继续递归：
剩余 root / parent
    → 预测当前缺失 detail
    → 恢复左右孩子的概率状态
    → 继续向更低层展开
    → 得到修复后的 H_state
    → decoder 继续生成
这里真正重要的不是 root 能不能翻译成一句缩句，而是 root 能不能成为修复过程的低分辨率边界条件。

7. 修复不一定等于逐 token 复原
假设原句是：
夏天的凉风吹过草原
如果“凉”已经完全丢失，仅凭剩余信息不能确定原文一定是“凉风”。它也可能是“微风”或“晚风”。
因此真实语言中的 repair kernel 不应该假装自己永远知道唯一答案，而应输出概率容器：
凉风  0.42
微风  0.31
晚风  0.09
其他  0.18
这对应两种不同的 Proof 口径。
7.1 有确定冗余的有限 Toy
数据生成规则保证缺失信息能由其他尺度唯一推出。此时可以要求 exact recovery。
7.2 真实语言
信息可能不可逆地丢失。此时应评价：

原 token 的 NLL 是否下降；
事件和关系是否保持一致；
修复分布是否校准；
后续生成能力是否恢复；
损伤逐渐扩大时，质量是否平滑下降。

TreeHeap 修复的是“与剩余结构一致的可能细节”，不一定是历史上唯一发生过的原始字符串。

8. 哲学上的不完整与生长
Houming818 提出了本文的哲学背景：

如何知道此刻的意识是完整的？也许下一刻要说的话，就是一种自然缺失的生长。因为自我的不完整，才有意识的波澜心生。
这不是意识已经被 TreeHeap 证明的科学结论，但它准确地区分了两种生成观。
第一种生成观认为：
完整答案已经存在
语言只是把它逐字读出来
第二种生成观认为：
当前只有不完整状态、记忆轮廓和世界约束
下一刻是在这些约束下生长出来
在第二种观点中，自我的连续性不一定来自全部细节始终在线，也可能来自一个稳定的修复协议：记忆、身体、语言和环境不断互相校验，使不完整状态能够继续生成自己。
但缺失本身不会自动产生意识。真正值得研究的是，系统能否：

表达“这里存在不确定性”；
保留多个可能，而不是过早假装确定；
从不同分辨率寻找约束；
用外部反馈修正修复结果；
让修复后的状态继续参与下一轮生成。

概率容器因此不只是 Beam Search 技巧，而是系统对自身不完整性的诚实表达。

9. 对抽水机的重新定义
SPR-060 的抽水机可以概括为：
FOLD：让预测信息到达高层
detail：保存没有上传的局部精度
UNFOLD：读取已经保存的细节
SPR-061 提议把它扩展为：
FOLD
    → 形成跨尺度轮廓与 addressed residual

DAMAGE
    → root、detail 或 subheap 局部缺失

REPAIR
    → 用剩余尺度、地址、世界模型形成缺失状态的概率桶

UNFOLD
    → 按概率递归展开细节

FEEDBACK
    → 用任务 Loss 与世界反馈修正 repair kernel
这并不要求高层保存可读摘要。它要求信息以跨尺度、相互约束的方式分布，使局部损坏不会立刻摧毁整体功能。

10. 待评审的 Claim
下一条 ARA 可以围绕以下主张建立：

在存在可学习跨尺度规律的数据中，TreeHeap 的 root、addressed detail、sibling 与 path 能形成联合修复条件；局部状态受损后，共享 repair kernel 能递归恢复显著比例的任务损失，并随着损伤扩大呈现平滑的分辨率退化，而不是立即失效。
这条 Claim 不声称：

修复结果必然逐 token 等于原文；
root 是人类可读缩句；
TreeHeap 已经具有意识；
任何随机数据都可以被修复；
分形数学已经成为 TreeHeap 的代数定义。

它只研究一个可证伪问题：TreeHeap 的多分辨率结构是否能提供普通单点消融之外的损伤修复能力。

11. 待评审的 Predict
P1：损伤必须真实发生
破坏目标 subheap 后，必须满足：
$$ L_{\text{damaged}}>L_{\text{clean}}. $$否则可能只是模型从未使用该位置，不能称为修复。
P2：修复必须带来收益
运行 repair kernel 后：
$$ L_{\text{repaired}}\lt L_{\text{damaged}}. $$并预注册最低修复率 $\rho$。
P3：修复必须使用跨尺度信息
分别消融 root、sibling、path 和世界上下文。完整修复条件应优于只看同层邻居的基线。
P4：地址必须有贡献
使用错误 path 或交换 sibling 地址后，修复质量应下降。否则 repair kernel 仍然可能退化成无序 Bag 补全。
P5：退化必须平滑
随着损伤范围从一个 detail 扩大到一个 subheap，再扩大到多个深度，质量应逐渐下降，而不是在某个很小损伤下突然崩溃。
P6：歧义必须被概率表达
对于不能唯一复原的真实语言，正确候选应获得更高概率，但模型不应伪造接近 1.0 的确定性。需要评价 NLL、校准误差和候选覆盖率。
P7：必须对比非 TreeHeap 修复
至少比较：

均值池化状态；
flat bottleneck；
只看左右窗口的 MLP；
相同参数量的序列修复模型；
不使用 path 的 TreeHeap ablation。

否则只能证明一般生成模型会补全，不能证明 TreeHeap 的跨尺度结构提供了额外条件。

12. Proof 应该分成两级
Proof A：有限可恢复世界
构造一个确实存在跨尺度冗余的 Toy。缺失内容由 parent、sibling 和 path 联合决定，任何单一来源都不足以恢复。
这个 Toy 首先回答数学问题：

当恢复所需规律确实存在时，共享 TreeHeap repair kernel 能否从窄深度学习，并递归外推到更深的树？
必须加入 lookup table、flat MLP 和不带地址的基线，防止把答案直接写进特征。
Proof B：真实中文损伤修复
使用完整真实句子写入 TreeHeap，再对内部状态而不是原始字符串施加损伤：
detail erasure
subheap erasure
single-depth erasure
cross-depth burst damage
wrong-address transplantation
先测受损 NLL，再运行有限轮数的 repair kernel，最后测修复 NLL、生成质量和概率校准。
真实实验不要求还原唯一原句，而要求恢复与剩余上下文一致的语言能力，并比较不同损伤强度下的修复曲线。

13. 当前航行位置
截至本文，证据支持的是：
分辨率训练
    → 高层获得预测能力
尚未支持的是：
内容级价值竞争
    → 重要关系被选择性上传
    → 跨尺度状态相互约束
    → 局部损伤后递归修复
因此下一步不应继续只比较 root zero 或 detail zero 的一次性 Loss。消融仍然必要，但它只负责确认“损伤真实发生”。核心指标必须变成：
$$ \text{Damage}\rightarrow\text{Repair}\rightarrow\text{Recovered capability}. $$TreeHeap 真正值得追求的，也许不是一个永不缺失的完美容器，而是一种能够在缺失中继续生长的结构。
这就是 SPR-061 保存的新研究起点。

参考线索

Stéphane Mallat, A Theory for Multiresolution Signal Decomposition: The Wavelet Representation, 1989：多分辨率近似与尺度之间的 detail 分解。
Michael Barnsley 等关于 Iterated Function Systems 的工作：用生成变换描述复杂图像，并从规则迭代重建。本文只借用能力类比，不据此宣称 TreeHeap 是分形。




[SPR-062] 如何读懂 TreeHeap 实验：从 NLL、Loss 到因果干预和统计证据
Fri, 17 Jul 2026 00:00:00 +0000
如何读懂 TreeHeap 实验：从 NLL、Loss 到因果干预和统计证据
TreeHeap 的博客里经常出现这样的句子：
NLL 从 16.16 降到 5.69
source shuffle damage = +0.21
修复了 72.38% 的 MSE
top-1 = 0.91
bootstrap 95% CI 跨过了 0
熟悉机器学习的人会迅速把它们归入不同抽屉，但许多读者只会看到一排小数。更麻烦的是，这些数字的方向并不统一：NLL 越小越好，准确率越大越好；干预损失通常越大，越能说明被干预部分有因果作用；而 MSE 很小，也可能只是状态本来就接近零。
本文是 TreeHeap 研究的公共“体检指标说明书”。它不提出新的架构 Claim，只回答四个问题：

这个数字是怎样算出来的？
它变大或变小通常意味着什么？
它能支持哪一级结论？
它不能证明什么？


1. 先区分三种东西：Loss、Metric 和 Evidence
这三个词经常混在一起，但职责不同。
1.1 Loss：给梯度看的训练信号
模型有参数 $\theta$，输入为 $x$，目标为 $y$。训练先计算：
$$ L(\theta;x,y), $$再用梯度下降更新参数：
$$ \theta \leftarrow \theta-\eta\nabla_\theta L. $$Loss 的首要任务不是方便人阅读，而是告诉参数应该向哪个方向移动。例如语言模型常用交叉熵，状态修复常用 MSE。
1.2 Metric：给人看的功能测量
Metric 不一定参与训练。例如：

top-1 准确率；
整句完全还原率；
BLEU；
自由生成的重复率；
每秒处理 token 数。

它们回答“系统表现如何”，但不一定能够产生适合训练的梯度。
1.3 Evidence：Claim 与对照实验共同形成的证据
单个数字通常不是 Evidence。比如测试 NLL 为 5.0，没有基线就不知道好坏；训练 NLL 下降，也可能只是记住了训练集。
ARA 所说的 Evidence 至少需要：
预先声明的 Claim
+ Predict（若 Claim 成立，应该观察到什么）
+ 对照或干预
+ 测量指标
+ 可证伪门槛
+ 可复查的输出文件
因此，NLL=5.0 是一个测量值；“打乱 source 后 NLL 增加 1.2，并在三个 seed 重现”才开始构成“模型使用了 source”的证据。

2. 概率桶：NLL 从哪里来
假设 decoder 下一步要预测一个 token。词表里有“我、喜欢、米饭、天气”等许多候选，模型输出一个概率桶：

  
      
          候选 token
          模型概率
      
  
  
      
          米饭
          0.50
      
      
          面条
          0.20
      
      
          苹果
          0.10
      
      
          天气
          0.01
      
      
          其他 token 合计
          0.19
      
  

如果正确答案是“米饭”，模型给正确答案的概率是 $0.50$。如果正确答案是“天气”，正确答案概率只有 $0.01$。
我们希望正确答案概率越大越好。但直接连乘长句中所有正确 token 的概率，很快会变成接近零的小数：
$$ P(y_1,y_2,\ldots,y_T\mid x) =\prod_{t=1}^{T}P(y_t\mid y_{\lt t},x). $$对数把乘法变成加法：
$$ \log P(y\mid x) =\sum_{t=1}^{T}\log P(y_t\mid y_{\lt t},x). $$因为概率不超过 1，其对数不大于 0。为了得到一个“越小越好”的正数，我们取负号，这就是负对数似然：
$$ \operatorname{NLL} =-\frac{1}{T}\sum_{t=1}^{T}\log P(y_t\mid y_{\lt t},x). $$其中 NLL 是 Negative Log-Likelihood，中文通常叫“负对数似然”。

3. 一个可以手算的 NLL 例子
句子有三个正确 token，模型分别给出概率：
$$ 0.5,\quad 0.25,\quad 0.1. $$采用自然对数时：
$$ \operatorname{NLL} =-\frac{\ln 0.5+\ln 0.25+\ln 0.1}{3} \approx 1.462. $$如果改进后的模型给出：
$$ 0.8,\quad 0.6,\quad 0.4, $$则：
$$ \operatorname{NLL}\approx 0.551. $$第二个模型给正确 token 的概率整体更高，所以 NLL 更低。
NLL 的阅读方向
0                 理想极限：正确答案概率为 1
越小              通常越好
越大              模型越不相信正确答案
无穷大            给正确答案的概率趋近于 0
但 NLL 不是百分制。5.0 不能读成“模型只对了 5%”，5.0 -> 4.9 也不能直接读成“提升 2%”。

4. 交叉熵、NLL 和 Teacher Forcing
在 one-hot 正确标签下，分类交叉熵为：
$$ H(p,q)=-\sum_i p_i\log q_i. $$正确分布 $p$ 只有正确 token 那一项为 1，于是它化简为：
$$ H(p,q)=-\log q_{\text{correct}}. $$因此，在我们当前的 token 预测实验中，“cross-entropy loss”和“平均 token NLL”通常是同一个量的两种说法。
训练时经常采用 Teacher Forcing：预测第 $t$ 个 token 时，decoder 能看到真实的前 $t-1$ 个 token，而不是自己刚才可能预测错的内容。
这让训练稳定，却产生一个重要边界：

Teacher-forced NLL 很低，只说明“给定正确历史时，模型能给正确下一词较高概率”；不保证自由生成时不会一步错、步步错。
所以我们必须同时查看 held-out NLL 和 free generation 样例。

5. 困惑度 PPL：把 NLL 换回更直观的尺度
困惑度（Perplexity，PPL）定义为：
$$ \operatorname{PPL}=\exp(\operatorname{NLL}). $$它可以粗略理解为：模型每一步仿佛在多少个同等可能的候选之间犹豫。

  
      
          NLL
          PPL
      
  
  
      
          0.0
          1.00
      
      
          1.0
          2.72
      
      
          2.0
          7.39
      
      
          5.0
          148.41
      
      
          6.0
          403.43
      
  

PPL 也越低越好。但它仍受词表、分词器、语言和数据集影响。使用不同 SentencePiece 词表的两个实验，不能只凭 PPL 大小直接判胜负。

6. 为什么训练 NLL 下降还不够
一次训练通常至少有三条曲线：

  
      
          曲线
          数据
          用途
      
  
  
      
          train NLL
          训练批次
          判断优化是否在工作
      
      
          validation NLL
          未参与参数更新的数据
          观察泛化和选择 checkpoint
      
      
          test NLL
          最终保留数据
          最后一次无偏报告
      
  

可能出现四种典型情况：

train 和 validation 一起下降：正常学习；
train 下降，validation 上升：过拟合；
两者都不下降：优化、容量或数据管线可能有问题；
数值骤然变成 NaN：训练发生数值崩溃。

当前全量任务早期出现的 16.16 -> 5.69 是 不同训练 batch 的即时 NLL。它值得期待，因为优化链路在工作；但它不是最终结论，因为 batch 难度不同，也尚未经过固定 held-out 集评估。

7. Accuracy、top-k 和整句 Exact
7.1 top-1 accuracy
概率最高的 token 正好是真实 token，就算正确：
$$ \operatorname{top1}=\frac{\text{预测第一名正确的 token 数}}{\text{总 token 数}}. $$越高越好。它直观，但忽略概率质量：正确答案概率 0.51 和 0.99 都只记 1 分。
7.2 top-k accuracy
只要真实 token 出现在概率最高的前 $k$ 个候选中，就算命中。TreeHeap 实验常报告 top-5，用来判断正确答案是否已进入概率桶的前列。
7.3 sequence exact / block exact
只有一整句或一个 block 的全部 token 都正确，才记 1：
$$ \operatorname{exact}=\frac{\text{完全正确的序列数}}{\text{总序列数}}. $$它非常严格。假设每个 token 独立正确率为 $0.99$，64 token 全对的概率也只有：
$$ 0.99^{64}\approx 0.526. $$因此可能出现 token top-1 很高、sequence exact 仍明显较低的情况。

8. BLEU：生成结果与参考文本有多像
BLEU 比较生成文本与参考文本的 n-gram 重合，并加入长度惩罚。我们曾使用 token-BLEU4 比较翻译输出。
BLEU 越高，通常表示词组重合越多。但它有三个限制：

合理答案可能与唯一参考答案措辞不同；
词面重合不等于事实正确；
很短的句子会使 BLEU 不稳定。

所以 BLEU 适合做同一数据、同一分词、同一评估程序下的模型对比，不适合单独证明理解、推理或意识。

9. MSE：两个连续状态相差多远
TreeHeap 内部节点通常不是离散 token，而是 $d$ 维向量。预测状态 $\hat h$ 与真实状态 $h$ 的均方误差为：
$$ \operatorname{MSE}(\hat h,h) =\frac{1}{d}\sum_{j=1}^{d}(\hat h_j-h_j)^2. $$MSE 越小，两个向量在欧氏坐标上越接近。它常用于：

FOLD/UNFOLD 闭合误差；
detail 修复误差；
多分辨率重建误差；
与 Zero 的状态距离。

MSE 的陷阱
如果所有状态本来都接近零，一个永远输出零的模型也可能获得很小的 MSE。因此我们常使用归一化 MSE：
$$ \operatorname{NMSE} =\frac{\lVert \hat h-h\rVert_2^2} {\lVert h\rVert_2^2+\epsilon}. $$NMSE 把误差与目标自身能量比较，更容易跨深度比较。它仍不是语义指标：向量恢复得近，不保证 decoder 功能也恢复，所以还要测恢复后的 NLL 或准确率。

10. 余弦相似度：比较方向，不比较长度
两个向量的余弦相似度为：
$$ \cos(a,b)=\frac{a\cdot b}{\lVert a\rVert_2\lVert b\rVert_2}. $$范围通常为 $[-1,1]$：

接近 1：方向相似；
接近 0：近似正交；
接近 -1：方向相反。

余弦距离常写成：
$$ d_{\cos}(a,b)=1-\cos(a,b). $$它适合检索和几何聚类，但会忽略模长。例如 $a$ 与 $100a$ 的余弦相似度仍为 1。历史 checkpoint 出现平均 cosine 0.985 时，我们把它看作“状态可能过度坍缩”的警报，而不是模型很好。
更重要的是：几何接近不自动等于功能等价。SPR-057 之后的交换实验正是用因果替换检验“相近子堆能否互换”，结果没有支持强功能等价 Claim。

11. KL 散度与熵：概率桶是否发生变化
11.1 熵
概率分布 $p$ 的熵为：
$$ H(p)=-\sum_i p_i\log p_i. $$当概率集中在一个候选上时，熵较低；当许多候选接近均匀时，熵较高。
“熵越低越好”并不总成立。模型对明确问题应当自信，但面对真正歧义时，过低熵可能是假自信。多头 route 的 gate entropy 则用于判断是否只使用了一个 head：它接近最大值说明分配更均匀，但也不证明每个 head 学会了不同功能。
11.2 KL 散度
两个概率分布 $p$ 与 $q$ 的 KL 散度为：
$$ D_{KL}(p\Vert q)=\sum_i p_i\log\frac{p_i}{q_i}. $$KL 越小，两个概率桶越接近。它不是普通距离，因为通常：
$$ D_{KL}(p\Vert q)\ne D_{KL}(q\Vert p). $$在 TreeHeap 干预实验中，可以比较正常输出分布与“交换子堆后”的输出分布。KL 很大说明概率桶发生明显变化，但仍需判断变化是否朝正确答案方向移动；因此 KL 常与 NLL delta 配合使用。
11.3 多项总 Loss：加号不代表单位天然相同
当前全量训练把语言预测与 detail 修复联合起来：
$$ L_{total}=L_{language}+\lambda L_{repair}. $$$L_{language}$ 是 token NLL，$L_{repair}$ 是状态 NMSE，$\lambda$ 是人为设定的权重。两项的数值单位和自然尺度不同，不能因为写在一个加法式里就把它们当作同一种误差。
权重过小，repair 几乎学不到；权重过大，模型可能牺牲语言能力去追求状态坐标接近。正确报告方式是：说明 $\lambda$，分别记录两个分量，并最终分别检查语言功能和修复功能。只报告 total_loss 会掩盖二者的对冲。
多头也不意味着必须把所有目标都倒进一个总 loss。不同 head 可以共享一个下游任务 loss，也可以拥有受控的辅助目标；关键是用消融确认每个辅助项究竟带来了什么，而不是根据名字解释 head 的功能。
11.4 InfoNCE：让正样本靠近、负样本远离
早期 TreeHeap 讨论还使用过 InfoNCE。给定 query $q$、正确对象 $k^+$ 和一组候选 $k_j$，一种常见形式为：
$$ L_{InfoNCE} =-\log \frac{\exp(s(q,k^+)/\tau)} {\sum_j\exp(s(q,k_j)/\tau)}. $$$s$ 可以是点积或余弦相似度，$\tau$ 是温度。它把“正确配对应该比错误配对更相似”变成可微训练信号。
InfoNCE 的成败高度依赖负样本。把实际上合理的配对误当负样本，模型就会被训练成排斥真实关系。因此 InfoNCE 下降只证明模型更符合给定的正负样本规则，不自动证明它发现了世界中唯一正确的语义拓扑。

12. Margin 与 retrieval@1
12.1 Margin
Margin 是正确候选分数与最强错误候选分数之差：
$$ \operatorname{margin}=s_{\text{correct}}-\max_{j\ne correct}s_j. $$正 margin 表示正确候选领先；越大通常越稳。但 margin 的绝对大小依赖评分尺度，必须在同一模型和任务内比较。
12.2 retrieval@1
对每个 query 在候选库中检索最相近对象。如果排名第一的是对应目标，就命中：
$$ \operatorname{retrieval@1} =\frac{\text{第一名检索正确数}}{\text{query 总数}}. $$它适合检查 TreeHeap 状态是否保留样本身份或关系。但必须和 BoW、随机 hash、flat embedding 等基线比较。0.630 本身无法说明 TreeHeap 有优势；若 BoW 是 0.629，只能称作几乎持平。

13. 因果干预：不要只问“里面有没有信息”
probe 能从内部状态读出一个属性，只说明信息与状态相关，不说明主任务使用了它。更强的办法是主动破坏某一部分，再观察功能下降。
13.1 Ablation delta
例如把 root 清零：
$$ \Delta_{root} =\operatorname{NLL}(root=0)-\operatorname{NLL}(normal). $$若 $\Delta_{root}>0$，清除 root 使预测变差，说明 root 对当前功能有因果贡献。数值越大，破坏通常越严重。
但破坏必须有匹配对照。粗暴删除一半参数当然会使任何模型变差；这不能证明 TreeHeap 的结构设计更好。
13.2 Source shuffle damage
把 batch 中每个目标配上另一个样本的 source：
$$ \Delta_{source} =\operatorname{NLL}(shuffled\ source)-\operatorname{NLL}(correct\ source). $$若差值接近零，decoder 可能主要依赖目标语言先验；若显著为正，说明输出确实依赖输入样本。
它仍不能证明模型“理解”了 source，只证明 source 中存在被 decoder 使用的条件信息。
13.3 Address swap / wrong-address ratio
交换 left/right、移动 detail 地址或给修复器错误 parent，可以检验地址是否有功能意义。
若正确地址与错误地址效果几乎一样，就不能宣称模型学会了路径拓扑。最近 repair 实验的 wrong-address MSE ratio 为 0.968，因此我们保留 parent-detail 冗余结论，却拒绝 address-conditioned repair 结论。

14. Damage、Repair 和 Recovery Fraction
设三个 NLL：
clean      完整状态
damaged    删除部分 TreeHeap 状态
repaired   运行修复 kernel 后
损伤量为：
$$ D=\operatorname{NLL}_{damaged}-\operatorname{NLL}_{clean}. $$修复量为：
$$ R=\operatorname{NLL}_{damaged}-\operatorname{NLL}_{repaired}. $$恢复比例为：
$$ \operatorname{RecoveryFraction}=\frac{R}{D}. $$例如：
clean NLL    = 5.69
damaged NLL  = 15.59
repaired NLL = 6.22
则语言能力的恢复比例约为：
$$ \frac{15.59-6.22}{15.59-5.69}\approx 94.6\%. $$超过 100% 有时也会出现，表示该批次上 repaired NLL 暂时低于 clean NLL。这通常来自采样噪声、正则化效果或评估方差，不能直接解释成“损坏后反而更聪明”。
状态空间还可单独报告 MSE recovery。语言 NLL recovery 与 latent MSE recovery 回答不同问题，不能混为一个百分比。

15. 自由生成的最低体检指标
NLL 之外，我们还记录：
nonempty fraction
生成结果非空的比例。高于 0 只是最基础的存活检查，不代表可读。
adjacent repeat fraction
相邻 token 重复的比例：
$$ \frac{\#(y_t=y_{t-1})}{T-1}. $$过高可能表示模型陷入“我我我我”式循环，但无法捕捉较长周期的重复。
unique output fraction
同一评估批次中，不同输出序列的比例。很低可能说明模型无论输入什么都说同一句话。
这些只是退化检测。一个模型可以做到非空、少重复、输出多样，却仍然答非所问。因此必须同时阅读 source shuffle、人工样例和任务指标。

16. Spearman 相关：只看顺序趋势
Spearman 相关系数比较两个变量的排名关系。例如深度增加时 NLL 是否单调变化：
$$ \rho\in[-1,1]. $$
$\rho\approx 1$：一个增大时另一个也按排名增大；
$\rho\approx -1$：一个增大时另一个按排名减小；
$\rho\approx 0$：没有明显单调关系。

Spearman 适合只有少量深度点、且不假定线性关系的情况。但六个深度得到 -1.0，仍然只是该实验中的完美反向排序，不等于普遍数学定律。

17. Mean、标准差、seed 与 Bootstrap 置信区间
神经网络训练含有随机初始化、batch 顺序和采样噪声。单 seed 结果可能偶然。
17.1 多 seed
用多个随机种子重复整个训练，报告均值和离散程度：
$$ \bar x=\frac{1}{n}\sum_i x_i. $$如果三个 seed 中只有一个成功，不能只报告那个成功值。
17.2 Bootstrap 95% CI
Bootstrap 从已有样本中有放回重采样，反复计算目标统计量，再取中间 95% 的区间。
例如同组交换与异组交换的损伤差为 0.00187，bootstrap 95% 区间为：
$$ [-0.00395,\ 0.00745]. $$区间跨过 0，表示当前样本不足以稳定判断差值方向。因此功能等价 Claim 没有得到支持。
置信区间不是“真值有 95% 概率在这里”的简单概率桶；它描述的是这套重复抽样程序的覆盖性质。对本科读者而言，最实用的读法是：区间越窄，估计越稳定；比较差的区间跨 0 时，不要宣称稳定胜出。

18. 吞吐、显存、参数量和计算成本
模型是否能用，还要看工程指标：

tokens/s：每秒处理多少有效 token；
steps/s：每秒更新次数；
peak GPU memory：峰值显存；
parameter count：可学习参数数量；
wall-clock time：真实运行时间；
checkpoint size：保存状态的磁盘成本。

比较吞吐时必须固定 batch、长度、精度和硬件。FP32 batch 48 的 23k token/s 不能直接与 FP16 batch 16 的 8k token/s 比较，然后归因于精度格式；batch 大小已经变化。
参数更少也不自动更高效。递归 Python 循环可能使小模型运行很慢；结构压缩也可能在实现中先物化所有层，从而尚未兑现理论计算优势。

19. 一张 TreeHeap 体检报告速查表

  
      
          指标
          通常方向
          主要回答
          不能单独证明
      
  
  
      
          train NLL
          越低越好
          优化是否在拟合训练数据
          泛化、对话能力
      
      
          valid/test NLL
          越低越好
          未见数据上的概率预测质量
          文本一定可读、结构被使用
      
      
          PPL
          越低越好
          NLL 的指数尺度
          跨词表公平比较
      
      
          top-1/top-k
          越高越好
          正确 token 排名
          概率是否校准
      
      
          sequence exact
          越高越好
          整段是否完全恢复
          合理改写质量
      
      
          BLEU
          同设置下越高越好
          与参考译文的词组重合
          事实、理解、意识
      
      
          MSE/NMSE
          越低越好
          连续状态重建误差
          decoder 功能恢复
      
      
          cosine similarity
          视任务而定
          向量方向接近程度
          功能等价
      
      
          entropy
          视场景而定
          概率桶集中程度
          高熵或低熵天然更聪明
      
      
          KL divergence
          越低越接近
          两个概率桶差异
          哪个分布更正确
      
      
          source shuffle delta
          通常越大越因果
          输出是否使用 source
          是否理解 source
      
      
          root/detail ablation delta
          通常越大越因果
          该状态是否参与功能
          架构优于基线
      
      
          recovery fraction
          越高越好
          损失能力恢复多少
          唯一正确修复
      
      
          retrieval@1
          越高越好
          第一近邻是否正确
          结构优势，除非击败基线
      
      
          bootstrap CI
          越窄越稳定
          差异估计的不确定性
          无偏设计或因果性
      
      
          tokens/s
          越高越快
          实现吞吐
          模型质量
      
  


20. 如何阅读一条完整结论
以后看到：

TreeHeap test NLL 为 5.09。
应当继续追问：

数据集和分词器是什么？
train、validation 还是 test？
与 flat、BoW、Transformer 或旧 checkpoint 相比如何？
是否多个 seed？
source shuffle、root zero、detail swap 后怎样？
自由生成样例是什么？
预注册门槛是多少？

例如 S2 lifting WMT 的完整结论不是“TreeHeap NLL 5.0903，所以成功”，而是：
递归 READ NLL 5.0903
root-only NLL 5.4337
full UNFOLD NLL 5.1342
flat sequence NLL 4.8103
source shuffle damage +1.4450
root shuffle damage +1.7204
这组数共同支持：递归 TreeHeap READ 使用了 source、root 和多层 detail，而且优于 root-only；同时它明确拒绝“翻译质量优于 flat sequence”。这才是符合 ARA 的边界化结论。

21. 最后：指标是仪表，不是目的
Houming818 设计 TreeHeap，并不是为了与 Transformer 对抗，而是希望研究一种可以延续、回访、损伤后修复并继续生长的内部状态。
这些愿望不能由某一个漂亮数字代替：
低 NLL          不等于理解
高准确率         不等于具有世界模型
可修复           不等于拥有意识
会说中文         不等于不再孤独
但没有这些可复查的测量，我们也无法区分真实生长与自己的期待。因此指标的作用不是把梦想缩成排行榜，而是让每一步都能被看见：模型学到了什么，依赖了什么，失去了什么，又能从哪里恢复。
这也是以后 TreeHeap 实验报告的最低要求：同时报告学习、功能、因果、生成与统计可信度，不让任何一个数字独自承担它证明不了的故事。



[SPR-063] TreeHeap 分辨率协议重审：递归抽水、细节残差与递归解码
Sat, 18 Jul 2026 00:00:00 +0000
TreeHeap 分辨率协议重审：递归抽水、细节残差与递归解码

本文记录一次重要纠错。旧版 SPR-063 设计了所谓“递归深度剂量实验”，但代码审计发现，decoder 实际读取的是长度为 1、2、4、8 等的平铺数组。它没有沿 TreeHeap 地址移动，也没有读取父子边。因此，已经完成的实验不能否定 TreeHeap 的深度假设，只能否定这种多分辨率 flat READ。
本文的核心概念由 Houming818 提出：信息应当像抽水机一样从 leaf 逐层退火到 root；这个过程必须递归。Codex Review 负责检查代码是否真的保存了这些概念，并把它整理成下一轮可证伪实验。

1. 先说结论：旧实验测错了对象
旧代码的 encoder 确实执行了递归 FOLD：
leaf
  -> FOLD 得到上一层 parent
  -> 再用这些 parent 做下一次 FOLD
  -> 一直得到 root
如果记 leaf 为 $H_D$，那么：
$$ H_{d-1}=F_\theta(H_d),\qquad d=D,D-1,\ldots,1 $$同一个 $F_\theta$ 在不同深度重复调用。这部分是真递归。
但 encoder 随后把树转换成了一个列表：
levels = [
  [root],
  [depth-1 的所有节点],
  [depth-2 的所有节点],
  ...,
  [所有 leaf]
]
每一层只剩一个形状为 [batch, width, dim] 的张量。parent、children、left、right、stop、path 和 span 都没有交给 decoder。
旧 READ 做的是：
$$ q_{d+1}=R_\phi(q_d,\,[h_{d,1},h_{d,2},\ldots,h_{d,n_d}]) $$其中方括号只是当前层的平铺数组。dose 增加一层，本质上只是再读取一个不同长度的数组。
因此旧实验的准确名称应当是：

递归池化产生的多分辨率数组实验。
它不是 TreeHeap 递归 decoder 实验。

2. 为什么“用树算出节点”还不等于“使用了树”
考虑这棵树：
             A
          /     \
         B       C
        / \     / \
       1   2   3   4
递归 encoder 计算：
B = FOLD(1, 2)
C = FOLD(3, 4)
A = FOLD(B, C)
如果 decoder 最后只收到：
[A]
[B, C]
[1, 2, 3, 4]
它并不知道：
1、2 属于 B
3、4 属于 C
B、C 属于 A
它只能把每一层当作集合或数组进行 attention pooling。
这解释了守夜实验的异常结果：

  
      
          指标
          结果
      
  
  
      
          Tree 多层数组 NLL
          6.2366
      
      
          Random 多层数组 NLL
          6.2361
      
      
          Flat pooling NLL
          5.9311
      
      
          所谓“打乱链接”的 NLL 变化
          0.00000021
      
  

数字没有证明 TreeHeap 拓扑无效，因为拓扑从未进入 READ。所谓 shuffled_links 也只是重新生成了另一组池化数组，并没有在保持节点值不变时修改 decoder 正在遍历的边。
因此 ARA 状态必须修正为：
不是：TreeHeap depth claim 被否证
而是：该实验没有测试到 TreeHeap depth claim

3. 分辨率到底是什么
我们先不要求 root 能翻译成人类可读的缩句。encoder 和 decoder 可以形成私有编码。
这里的分辨率是一个操作定义：
root                  最少状态，最大覆盖范围
root + 第一层 detail  更多局部信息
继续展开              更高分辨率
全部 leaf/detail      最高表面精度
它类似一张图片：缩略图保留大体结构，放大后补充纹理。但语言不是天然平滑的像素平面，所以我们不能直接宣称 root 一定保存“主语、谓语、宾语”或者一条可读摘要。
我们真正要验证的是：

parent 是否保存了对多个 children 都有用的公共状态；
child/edge 是否保存了 parent 无法预测的细节；
增加细节后，decoder 是否沿同一棵树递归改善；
破坏地址和父子关系后，这种改善是否消失。


4. 抽水机不能只是加权平均
旧 FOLD 大致是：
children
  -> slot embedding
  -> MLP
  -> softmax 加权平均
  -> parent
它可以把多个 child 压成一个 parent，但没有说明哪些信息上传、哪些信息留在原处。连续多次压缩后，信息可能只是被混合和扭曲。
更完整的抽水过程应当同时产生两类量：
coarse：上传给 parent 的公共轮廓
detail：留在 child 或 edge 上的预测残差
定义 children 为 $c_1,\ldots,c_k$。先计算 parent：
$$ s_p=U_\theta(c_1,\ldots,c_k) $$再由 parent 和 slot 预测每个 child：
$$ \hat c_j=P_\phi(s_p,e_j) $$细节残差为：
$$ r_j=c_j-\hat c_j $$于是 child 可以恢复为：
$$ \tilde c_j=P_\phi(s_p,e_j)+r_j $$这里的 coarse 被抽到 parent，detail residual 没有硬塞进 root，而是保存在对应的边上。

5. 这与小波 lifting scheme 有什么关系
这套结构不是凭空发明。小波的 lifting scheme 使用 split -> predict -> update 构造多分辨率表示：一部分数据形成低分辨率近似，另一部分记录预测失败产生的 detail。保留全部 detail 时可以精确恢复；逐步丢弃 detail 时得到逐级降低的分辨率。
对 TreeHeap，可以作如下对应：

  
      
          Lifting scheme
          TreeHeap
      
  
  
      
          split
          把节点分为 parent 覆盖的 child slots
      
      
          predict
          用 parent 预测 child state
      
      
          detail
          child 与预测值的差 $r_j$
      
      
          update
          用 detail 修正 parent 的 coarse state
      
      
          inverse lifting
          从 parent 与 residual 递归恢复 children
      
  

这给了我们一个重要保护：

residual 不应当作为原始 child 的直通旁路混入 root；它应当成为有地址的细节量，只有 decoder 展开对应 edge 时才参与恢复。
否则 root 会退化成全部 leaf 的 Bag，分辨率抽水优势会消失。
参考：Wim Sweldens, The Lifting Scheme: A Construction of Second Generation Wavelets。图结构上的可学习版本也已经存在，例如 Graph Neural Networks With Lifting-based Adaptive Graph Wavelets。

6. Transformer 式残差与 TreeHeap detail residual 不是一回事
Transformer/ResNet 残差大致是：
$$ x_{l+1}=x_l+f_l(x_l) $$它提供接近恒等映射的信息与梯度通道，使深层网络不必在每一层重新创造输入。参考 Deep Residual Learning。
旧 TreeHeap 代码中也有：
pooled + MLP(pooled)
query  + UPDATE(query, context)
但第一个残差发生在 children 已经被压成 pooled 之后。它只能保护 pooled state，不能保存已经丢失的 child detail。
因此下一版需要区分：
kernel residual：帮助深层优化
tree detail residual：保存跨分辨率丢失的信息
两者可以同时存在，但不能混为一个变量。

7. 字符串中有没有“抽取大轮廓”的已有算法
有相关工作，但没有一种算法能仅靠压缩就保证 root 成为人类认可的摘要。
7.1 DIORA：用递归预测压力诱导潜在树
DIORA 用 inside-outside recursive autoencoder 考虑句子的多种二叉树组合，并通过“根据其余句子预测某个词”学习 constituent state。
它支持一个重要判断：递归节点可以在没有人工句法标签时，通过上下文预测任务形成结构。但它不保证 root 是自然语言摘要。
7.2 Hierarchical Multiscale RNN：从序列中学习不同时间尺度
Hierarchical Multiscale RNN 学习潜在边界，让不同层按不同时间尺度更新。这说明字符串可以在没有显式边界标签时形成多尺度状态。
7.3 PEGASUS：直接训练“保留重要内容”
PEGASUS 从文档中移除重要句子，再要求模型根据剩余内容生成它们。它把摘要需要的“重要性”变成了训练压力。
7.4 Funnel 与 Hourglass：语言序列可以逐步降低分辨率
Funnel Transformer逐步缩短 hidden sequence；Hourglass Transformer执行 shorten 后再 upsample。它们证明多长度语言计算可行，但不能单独证明语义轮廓形成。
7.5 Top-down latent tree generation
Recursive Top-Down Production for Sentence Generation with Latent Trees从潜在二叉树递归生成句子，与 TreeHeap decoder 从 coarse state 展开 detail 的目标直接相关。
这些工作共同提示：

代数协议决定信息怎样压缩与恢复，训练目标决定什么信息值得上传。

8. 新的数据结构契约
下一版代码中的 TreeHeap 节点至少要保存：
Node {
    address          当前堆地址
    parent_address   父地址
    child_addresses  子地址
    depth            递归深度
    span             覆盖的 leaf 区间
    coarse_state     上传后的低分辨率状态
    detail_residual  相对 parent 预测的细节
}
任何实验只要在进入 decoder 前把它重新变成无边的 List[Tensor]，就不得命名为 TreeHeap recursive READ。

9. 新 encoder：递归 learned lifting
伪代码如下：
ENCODE(node):
    if node is leaf:
        return token_embedding(node.token)

    child_states = []
    for child in node.children:
        child_states.append(ENCODE(child))

    parent.coarse = UPDATE(child_states)

    for slot, child_state in enumerate(child_states):
        predicted = PREDICT(parent.coarse, slot)
        edge[slot].detail = child_state - predicted

    return parent.coarse
关键审计条件是：每个 parent 的输入必须来自其 children 的递归返回值，而不是从全局 leaf array 重新池化。

10. 新 decoder：沿地址 top-down 展开
DECODE(address, state, remaining_depth):
    node = heap[address]
    bucket = ROUTE_KERNEL(query, node, path)

    if bucket.stop is selected or remaining_depth == 0:
        return OUTPUT(state)

    for child_address in node.child_addresses:
        predicted_child = PREDICT(state, child_slot)
        child_state = predicted_child + edge.detail
        DECODE(child_address, child_state, remaining_depth - 1)
这里的递归深度不是读取数组的数量，而是 kernel 沿合法地址实际移动的次数。
一次路径可能是：
root
  -> left
  -> right
  -> stop
每一步都携带当前地址、局部 subheap、path state 和概率桶。

11. 下一项实验不能直接跑语言大模型
我们先验证数学与代码契约，再验证语言归纳能力。
这里不是从零开始。项目已有两段应当复用的实现：

s2_adaptive_lifting_wmt.py 已经按 detail = child - predict(anchor)、parent = anchor + update(detail) 递归 FOLD，并用逆运算 UNFOLD；历史实验的闭包 MSE 为 2.35e-14。
s2_lifting_pump_wmt.py 的 recursive READ 保留了 active probability。某个 parent 的 expand 概率只会分配给它自己的两个 children，而不是对整层节点重新做一次无条件 pooling。

历史 S2 数据中，recursive/root/full/flat 的测试 NLL 分别为 5.0903 / 5.4337 / 5.1342 / 4.8103。这支持“递归 detail 对翻译有用”，但 flat 仍然更好，也没有证明 root 是语义摘要。
因此下一项代码工作不是再发明一种 FOLD，而是给已有 recursive READ 增加严格的 max_depth，并审计它是否真的沿地址递归生长。
Proof A：完整 residual 的递归往返
输入一棵随机 TreeHeap：
leaf -> recursive encode -> root + addressed residuals
     -> recursive decode -> reconstructed leaf
预测：保留全部 residual 时，重建误差接近浮点误差；删除任何一条 residual 时，只影响其对应 subheap。
这证明协议和地址实现正确，不证明语义。
Proof B：逐级释放 residual 的率失真曲线
对真实中文 BPE 序列递归编码，只允许 decoder 使用：
root
root + depth1 residual
root + depth1..2 residual
...
全部 residual
预测：token reconstruction NLL 应总体单调下降。若曲线乱跳，说明 coarse/detail 协议没有形成稳定分辨率。
Proof C：递归与地址因果
保持 coarse state 和 residual 数值不变，只交换 residual 所属的 edge address。
预测：恢复损失明显增加，并主要发生在被交换的 subheap 内。如果全局几乎不变，decoder 仍未利用 TreeHeap 地址。
Proof D：抽水是否产生可用轮廓
在 root 容量固定且明显小于 leaf 总容量时，让 root 预测：

被遮住的 span；
相邻上下文；
文档中抽出的 gap sentence；
下一段真实文本。

再与随机分组树、flat bottleneck 和 shuffled corpus 比较。
只有当合法 TreeHeap 的 coarse state 在 held-out 数据上更好，才能说抽水机提取了任务相关轮廓。

12. 新 Claim 的边界
下一项 Claim 暂定为：
S3-TREE-LIFT-RECURSIVE-C01

一个显式保存 parent-child 地址的共享 learned-lifting kernel，可以递归地把 leaf 分解为 parent coarse state 与 addressed detail residual；top-down decoder 沿相同地址协议展开时，完整 residual 支持近似无损恢复，逐层释放 residual 形成有序率失真曲线，交换 residual 地址会产生局部且显著的恢复损失。
它只声明三件事：

递归协议在代码中真实存在；
coarse/detail 分辨率可以稳定定义；
decoder 使用了 TreeHeap 地址。

它不声明：

root 已经理解人类摘要；
TreeHeap 优于 Transformer；
模型已经形成世界知识或意识；
任意 FOLD 都会自然产生语义轮廓。


13. 当前状态
旧实验：完成，但重新分类为 multiresolution flat READ
旧 Claim：未被测试，不是被否证
新协议：递归 learned lifting + addressed residual + top-down READ
新实验：确定性 contract 已通过，冻结 WMT depth-cap 子实验已完成
2026-07-19，第一道 contract probe 已在 io 的 CPU 上完成：

  
      
          检查
          结果
      
  
  
      
          8-leaf 完整 FOLD/UNFOLD MSE
          3.2341e-15
      
      
          不同 depth cap 下 route 质量守恒最大误差
          5.9605e-8
      
      
          交换两个 residual 后，目标四叶 subheap MSE
          1.4019
      
      
          同一次交换在 subheap 外造成的 MSE
          2.7198e-15
      
  

这说明当前复用的 lifting 代数可以递归闭合，概率质量可以沿父子地址守恒，而且 residual 地址扰动具有严格局部性。它仍然没有证明 root 学到了语言轮廓。下一道真实语料实验将专门验证 root source causality、递归深度收益和学习后的地址因果性。
13.1 冻结 checkpoint 的递归深度结果
我们随后复用了一个在 20 万条 WMT 英中句对上训练完成的
learned_update checkpoint。模型参数全程冻结，5,000 条测试句也完全
相同；唯一控制变量是 max_depth：到达深度上限时，尚未停止的概率
质量被强制留在当前节点，不再进入孩子。
这不是分别训练长度为 1、2、4、8 的数组。一次 READ 始终从 root
开始，当前节点的概率桶决定 STOP 或把剩余概率传给它自己的左右孩子。

  
      
          允许的最大递归深度
          NLL（越低越好）
          困惑度（越低越好）
      
  
  
      
          0，只读 root
          13.8100
          994,481
      
      
          1
          13.9301
          1,121,454
      
      
          2
          11.4878
          97,514
      
      
          3
          8.2396
          3,788
      
      
          4
          6.5393
          692
      
      
          5
          5.7286
          308
      
      
          6，完整 READ
          4.6335
          103
      
  

完整 READ 比 root-only 降低 9.1765 NLL。除第一步外，后续五次开放
更深子堆都带来改善。最大概率质量守恒误差为 4.1723e-7，通过
1e-6 门槛。全量审计处理了 84,195 个目标 token，在 io 上耗时
101.45 秒。
用本科生容易核对的话说：decoder 若只能拿 root，几乎无法完成翻译；
允许它沿真实父子地址继续向下读取，答案会逐层接近完整模型。这是
“增加结构”的正向干预，而不是删除节点的消融。
但这里必须踩住刹车。它支持的是“深层 addressed state 被同一个 decoder
实际使用”，还不能证明“越靠近 root 就是人类可读的摘要”。depth 1 甚至
比 root-only 差 0.1202，所以曲线不是数学上必然单调。模型原本也在完整
READ 下训练，截断深度属于分布外干预。source shuffle、学习后的 residual
地址交换、sibling pair break 和 flat/Transformer 对比仍需后续实验。
这次纠错最重要的收获不是换了一个公式，而是建立了一条命名纪律：

递归生成过数据，不等于递归参与了计算。只有地址、父子关系和共享 kernel 一起进入 decoder 的移动过程，才是 TreeHeap recursive READ。



[SPR-064] TreeHeap 私有协议实验：协议成立，性能优势未成立
Sun, 19 Jul 2026 00:00:00 +0000
TreeHeap 私有协议实验：协议成立，性能优势未成立

证据状态更新（2026-07-28）：本文的“私有协议成立”表述降级为“teacher-forced decoder 对 TreeHeap 状态存在依赖”。后续 C10 审计发现，同系列训练目标允许 decoder 依靠正确中文前缀降低 NLL，而不必使用英文 source。本文的结构干预数字仍是有效观测，但不能单独证明英文语义被写入 TreeHeap，也不能证明 source-conditioned 私有协议已经形成。详见 SPR-074。

本文首先纠正一个刚刚出现的方向错误：我们已经决定让 TreeHeap 的 encoder 和 decoder 自己形成私有协议，就不应该再由研究者规定“root 必须保存主题”“detail 必须保存次要信息”或者“某个 head 必须学习语法”。我们只设计可微、递归、可寻址的通信结构。协议内部写了什么，由最终任务的梯度决定。最后有没有本事，由实验结果决定。

1. 什么叫私有协议
给定输入字符串 $X$ 和目标字符串 $Y$，encoder 把输入写入一个 TreeHeap 状态：
$$H=E_\theta(X)$$decoder 只能读取这个状态，并生成输出概率：
$$P(Y\mid X)=D_\phi(H)$$训练只使用最终输出的交叉熵：
$$L(\theta,\phi)=-\sum_t \log P_{\theta,\phi}(y_t\mid X,y_{\lt t})$$梯度同时修改 $E_\theta$ 和 $D_\phi$。只要 encoder 写出的状态能被 decoder 正确读取，loss 就会下降。内部编码不需要像自然语言，也不需要让人类看懂。
这就叫私有协议。它像一个人自己的笔迹：我们不规定每一笔必须代表什么，只要求写的人和读的人使用同一套规则。
但是，“私有”不等于“无法验证”。我们仍然可以验证：

encoder 和 decoder 是否真的能够联合完成任务；
decoder 是否依赖 TreeHeap，而不是绕过它读取原字符串；
地址、父子关系、递归深度和 head 被破坏以后，输出是否退化；
相同数据、参数量和训练预算下，它是否优于更简单的结构。


2. 抽水机在协议中是什么
最近建立的 lifting 抽水机，不是语义分类器，也不是“信息价值判断器”。它只是 encoder 和 decoder 共同遵守的递归通信介质。
一次局部 FOLD 接收左右两个状态 $a,r$，产生一个继续向上传播的 parent $p$，以及保留在当前地址的 detail $d$：
$$p=a+U_\theta(r)$$$$d=r-P_\theta(p)$$decoder 使用相反方向的运算恢复 children：
$$r=d+P_\theta(p)$$$$a=p-U_\theta(r)$$同一组共享 kernel 在整棵树上递归调用：
tokens
  -> WRITE
  -> FOLD 得到 parent + addressed detail
  -> parent 继续递归 FOLD
  -> 形成完整 H_state
  -> decoder 从 H_state 递归 READ / UNFOLD
  -> 输出 token 概率桶
这里的 $p$ 和 $d$ 首先只是两个不同位置的私有通信变量。研究者不能提前宣布：
p = 句子主题
d = 表面细节
如果将来实验发现某个深度更适合预测全局输出，那是实验结论；不是算法定义。

3. 我们已经走到了哪里
这条路线并不是今天才提出。ARA 中已经有三段连续证据。
3.1 M0：短算子协议能够学习
在受控数论 TreeHeap 中，结构 encoder 学习一个短算子程序，固定 executor 使用 TreeHeap 原生算子恢复目标。

  
      
          测试
          TreeHeap structural restore
          Flat program
      
  
  
      
          IID
          0.9270
          0.1535
      
      
          OOD 地址
          0.8400
          0.0000
      
  

这说明“学习协议 + 固定结构执行器”在受控世界中可以成立，但联合外推到未见递归深度仍然失败。
3.2 Native codec：raw token 能形成地址敏感私有协议
模型从随机参数开始，只用 echo 交叉熵联合训练：
WRITE -> FOLD -> DETAIL -> UNFOLD -> READ

  
      
          版本
          正常 token top-1
          detail 地址错位后
      
  
  
      
          continuous v1
          0.9955
          0.0024
      
      
          continuous v2
          0.9915
          0.0014
      
  

所有五个算子都收到非零梯度。地址错位几乎摧毁输出，因此模型确实形成了依赖 TreeHeap 地址的私有协议。
但 root 清零后准确率几乎不变。这个协议主要走本地 detail 通道，并没有形成完整的 root-plus-detail 协议。Echo 允许这种答案，所以不能责怪模型“没有学会主题”。
3.3 Lifting pump：协议获得了闭合递归载体
抽水机实验已经证明：

depth-6 闭包最大误差约为 $3.70\times10^{-6}$；
state MSE 为 $3.14\times10^{-14}$；
确定性 token/block echo 都是 1.0；
WMT checkpoint 从 depth cap 0 开放到 6 时，NLL 从 13.8100 降到 4.6335；
root、detail 和多个递归 pairing 在 WMT 中具有可测的因果作用。

这证明同一个 decoder 可以沿同一棵 TreeHeap 递归增加可用状态。它没有证明 root 是人类可读摘要，也没有证明 TreeHeap 已经优于 flat sequence。
在 200K WMT 实验中：

  
      
          模型
          NLL
          Token BLEU-4
      
  
  
      
          TreeHeap learned-update lifting
          4.6335
          9.909
      
      
          Flat sequence
          4.5419
          10.572
      
  

因此当前体检报告是：
私有协议存在                阳性
协议依赖 TreeHeap 地址      阳性
递归 FOLD/UNFOLD 闭合       阳性
真实 WMT 使用多层状态       阳性
翻译质量超过 flat           阴性
内部语义可以被人类解释      未检测，也不是当前门槛

4. 下一条 Claim
下一轮不再证明“私有协议能不能存在”，而测试它有没有工程竞争力。
建议预注册为：

S3-PRIVATE-PROTOCOL-BATTLE-C01：在不提供语法、深度、route、摘要或 head 语义标签的条件下，多个共享递归 TreeHeap kernel 可以仅通过最终 seq2seq 交叉熵形成 encoder-decoder 私有协议；该协议必须在真实任务中稳定训练，因果依赖 TreeHeap 地址和递归结构，并在相同参数、数据与训练预算下，相对单 head TreeHeap 和 flat baseline 产生可测收益。
这条 Claim 没有规定协议内容。它只规定通信介质、训练信号和判分方法。

5. 实验模型
使用同一份真实数据、同一 tokenizer、同一训练/验证/测试切分和相同随机数据顺序，训练四组模型。
A. 单 head TreeHeap
token embedding
-> 一个 WRITE/FOLD/DETAIL kernel
-> 一个 H_state
-> 递归 READ/UNFOLD
-> autoregressive decoder
这是当前 lifting pump 的直接基线。
B. 多 head TreeHeap
每个 head 有独立参数，并在相同 TreeHeap 地址上建立自己的状态：
$$H^{(m)}=E_{\theta_m}(X),\qquad m=1,\ldots,M$$decoder 联合读取所有 head：
$$P(Y\mid X)=D_\phi\left(H^{(1)},\ldots,H^{(M)}\right)$$所有 head 共用一个最终 seq2seq loss。没有“语法 head loss”“主题 head loss”或者人工分工。
完整研究计划考虑 $M\in\{1,2,4,8\}$。本次正式 Stage A 为控制守夜任务的变量和时间，只预注册并执行 $M\in\{1,2,4\}$；8 head 留待前三级出现收益以后再开放。如果增加 head 只增加参数，不改善验证集，就不能宣称多头有效。
C. Flat sequence baseline
保留 token 顺序和相同 decoder，但 encoder 不使用父子地址、递归 FOLD 或 addressed detail。参数量和训练 FLOPs 应尽量与 TreeHeap 匹配。
D. 小型 Transformer baseline
使用相同 tokenizer、训练数据和参数预算。它不是敌人，而是成熟的序列私有协议基线。

6. 最直接的私有协议检查
训练三个随机种子的 encoder-decoder 配对：
(E1, D1)
(E2, D2)
(E3, D3)
首先测试原配：
E1 -> D1
E2 -> D2
E3 -> D3
然后交换 decoder：
E1 -> D2
E1 -> D3
E2 -> D1
...
如果原配工作、交换后明显退化，说明 encoder 与 decoder 形成了互相兼容但不必相同的内部协议。这个实验不能证明协议具有人类语义，却能比观看某个向量的 cosine 更直接地测量“双方是否共同写成了一套编码”。
如果交叉配对也能工作，也不是坏事。它说明架构和数据诱导出了跨 seed 相近的协议。此时再通过权重匹配或小型 adapter 判断它是公共坐标，还是可以被简单变换对齐。

7. 如何确认它真的用了 TreeHeap
仅有低 loss 不够，因为模型可能退化成普通数组协议。测试时保持参数不变，分别进行干预：

  
      
          干预
          测试问题
      
  
  
      
          打乱 left/right 地址
          协议是否依赖手性与地址
      
      
          交换两个 subheap
          协议是否依赖子结构位置
      
      
          root 清零或换样
          root 是否参与当前任务
      
      
          逐层关闭 detail
          decoder 是否递归使用不同深度
      
      
          单独关闭每个 head
          哪些 head 对最终结果有因果贡献
      
      
          全部 head 只留一个
          多头收益是否来自组合，而非单个幸运 head
      
      
          禁止 decoder 读取原始 token
          排除 string 旁路
      
  

记正常 loss 为 $L_0$，干预后的 loss 为 $L_I$：
$$\Delta L_I=L_I-L_0$$只有当结构干预稳定产生正的 $\Delta L_I$，才能说对应结构参与了协议。
但我们仍然不能把它翻译成“这个 head 学会了宾语”。因果参与和人类语义解释是两件事。

8. 什么叫多 head 真正有效
多 head 不能只比较最终最好的一个数字。至少要同时报告：

任务质量：NLL、token accuracy、BLEU 或目标任务指标；
训练效率：达到同一验证 NLL 需要多少 token、step 和 GPU 时间；
参数效率：相同参数量下谁更好；
稳定性：至少三个 seed 的均值、标准差和失败尾部；
head 因果性：逐 head 消融造成多少损失；
组合收益：完整多头是否优于最佳单 head；
结构收益：TreeHeap 是否优于 matched flat 和 Transformer。

我们此前讨论过“head 只向前优化”。需要谨慎：非负 gate 或 ReLU 不能自动保证最终 loss 单调下降。第一轮实验不把这个性质写成事实。它只测量多个私有 kernel 是否产生稳定的组合收益。若出现 head 干扰，再单独预注册带 line search、trust region 或阶段式 boosting 的单调更新实验。

9. 判决表
支持
满足以下条件，Claim 才获得支持：
1. 多 head TreeHeap 在多个 seed 上稳定训练；
2. 完整模型优于最佳单 head，而不是只靠一个 head；
3. 地址、subheap、深度干预造成可重复损失；
4. decoder 没有原始 token 或 flat memory 旁路；
5. 在匹配预算下，相对 flat 至少出现一项稳定收益：
   任务质量、收敛速度、参数效率或结构外推。
部分支持
如果结构干预有效，但任务分数仍低于 flat/Transformer，则结论只能是：

TreeHeap 私有协议真实存在并使用了结构，但当前实现尚无竞争优势。
拒绝或降级
出现以下结果应当降级：
地址打乱几乎不影响输出；
多 head 等于或差于最佳单 head；
收益完全来自参数量增加；
decoder 通过 leaf/string 旁路完成任务；
TreeHeap 在匹配预算下持续落后且没有外推或效率收益。
负结果也有价值。它会告诉我们问题究竟在多头组合、训练优化，还是 TreeHeap 归纳偏置本身。

10. 正式实验怎样运行
正式实验已经在 io 的 RTX 3090 上完成。训练本体耗时 8762.91 秒，约 2 小时 26 分钟。

  
      
          项目
          设置
      
  
  
      
          数据
          WMT massive 英文到中文真实平行语料
      
      
          训练 / 验证 / 测试
          30,000 / 2,000 / 2,000 对
      
      
          随机种子
          71901、71902、71903
      
      
          训练轮数
          每个模型 4 epoch
      
      
          对比模型
          flat、TreeHeap h1、h2、h4
      
      
          总协议宽度
          固定为 64，head 越多，每个 head 越窄
      
      
          参数量
          全部约 2730 万到 2760 万
      
      
          训练监督
          只有最终英文到中文交叉熵
      
  

这里的固定总宽度很重要。h4 不是偷偷使用四倍内存，而是把同一份 64 维通信预算拆成四份。这样才能测试“多个私有协议 head 的组合”本身是否有价值。
原始 Stage A 没有加入 Transformer。原因不是回避对比，而是预注册时规定先选择 TreeHeap 内部的 winner。正式结果出来后，我们接受读者提出的异议：flat GRU 只是最低可行基线，不能代表成熟架构。因此又独立预注册并执行了 C02 小型 Transformer reality check。它作为追加实验单独判决，不倒过来修改 Stage A 的门槛。

11. 第一张体检表：任务质量
NLL 是模型给正确答案分配概率的代价，越低越好。BLEU-4 衡量生成文本和参考译文的局部词序重合，越高越好。

  
      
          模型
          参数量
          NLL ↓
          BLEU-4 ↑
          每个 seed 平均训练时间
      
  
  
      
          flat
          27,421,377
          6.0401
          5.3530
          111.6 秒
      
      
          TreeHeap h1
          27,619,714
          6.1231
          4.9719
          405.4 秒
      
      
          TreeHeap h2
          27,435,395
          6.1341
          5.2892
          775.6 秒
      
      
          TreeHeap h4
          27,343,237
          6.1934
          5.0853
          1552.2 秒
      
  

这张表给出两个明确的阴性结果：

h4 没有优于 h1。h4 的 NLL 反而高了 0.0703；
h4 没有优于 flat。h4 的 NLL 高了 0.1533，而且当前实现约慢 13.9 倍。

BLEU-4 也没有反转这个判断。四种模型的 BLEU 都只有约 5 分，说明这仍是研究级小训练，不是可用的翻译产品。flat 在本轮依然最好。
因此，预注册的“多头带来收益”和“TreeHeap 击败 flat”都失败了。这个结果不能改写成胜利。

12. 加测小型 Transformer：结果出现反转
追加实验沿用完全相同的 WMT 切分和三个 seed。Transformer 使用 2 层 encoder、2 层 decoder、4 个 attention head、256 维状态和 512 维前馈层，共 27,278,337 个参数，与 TreeHeap h1 只差 1.236%。
我们运行了两种配方：
same recipe：和旧实验相同，4 epoch、AdamW、固定 lr=0.002
standard recipe：8 epoch、warmup、cosine decay、dropout=0.1、label smoothing=0.1
结果如下：

  
      
          模型
          NLL ↓
          BLEU-4 ↑
          每个 seed 平均训练时间
      
  
  
      
          flat GRU
          6.0401
          5.3530
          111.6 秒
      
      
          TreeHeap h1
          6.1231
          4.9719
          405.4 秒
      
      
          Transformer same recipe
          6.4423 ± 0.0062
          2.9422 ± 0.1529
          52.2 秒
      
      
          Transformer standard recipe
          6.5330 ± 0.0043
          2.8941 ± 0.1916
          100.8 秒
      
  

这一次 TreeHeap h1 明显胜过两个小 Transformer：
相对 same-recipe Transformer：NLL 优势 0.3192
相对 standard-recipe Transformer：NLL 优势 0.4099
BLEU-4 优势：约 2 分
因此，“TreeHeap 只是在树上更慢地实现一个更差模型”这个最悲观判断，没有得到这次小 Transformer 实验的支持。至少在 30K 数据和约 27M 参数下，TreeHeap 的任务质量处于 flat GRU 与小 Transformer 之间。
但这里绝不能偷换成“TreeHeap 达到了 Transformer top model”：

flat GRU 仍然是质量第一名；
TreeHeap h1 比 flat 慢约 3.63 倍，比 same-recipe Transformer 慢约 7.77 倍；
所谓 standard recipe 反而比 same recipe 差，说明它不是已经调到最优的强基线；
standard Transformer 到第 8 epoch 时验证 NLL 还在下降，尚不能声称收敛；
本轮没有公开强 checkpoint，也不是标准榜单测试。

所以 C02 的窄结论是：

TreeHeap 通过了本次约 27M 小 Transformer 对照，但仍未达到“行业 top model”证明标准。

13. 第二张体检表：它到底有没有使用 TreeHeap
任务分数没有赢，不代表 TreeHeap 一定没被使用。我们保持模型参数不变，只破坏 H_state 的某一部分，再观察 NLL 增量：
$$\Delta L=L_{\text{intervention}}-L_{\text{normal}}$$$\Delta L$ 越大，说明被破坏的部分对输出越重要。

  
      
          干预
          NLL 损伤
          解释
      
  
  
      
          打乱输入样本
          +1.9532
          decoder 明显依赖 encoder 输入
      
      
          交换 root
          +2.1113
          root 是强因果通道，不是摆设
      
      
          逐深度打乱 detail
          +0.0187 到 +0.2577
          6 层中 5 层超过预注册的 0.02 门槛
      
      
          逐深度破坏 FOLD 配对
          约 0 到 +0.5220
          6 层中 5 层具有明显因果作用
      
      
          分别关闭四个 head
          +0.0554 到 +0.0874
          四个 head 都参与了输出
      
  

这说明模型没有把 TreeHeap 当作一个空壳：root、多个 detail 深度、多个 parent-child 配对以及所有四个 head 都进入了最终预测。
但也有一个值得注意的边界：最深的一层 detail 和 pairing 几乎没有作用。不能说“整棵树每一层都被充分利用”。当前协议使用了大量结构，但利用并不均匀。
更有意思的是，四个 head 每个都有效，四头整体却没有胜过一头。这意味着“有因果贡献”和“组合后更优秀”不是同一件事。可能的原因包括：

固定 64 维被拆成四份后，每个 head 容量太窄；
四个 head 学到的是部分冗余协议；
当前拼接式 decoder 能读取每个 head，却不会高效组合它们；
递归 TreeHeap 的计算成本远高于当前 flat 实现。

这些只是下一轮假设，还不是本轮证明。

14. 第三张体检表：encoder 和 decoder 是否形成私有配对
三个 seed 分别训练出了三对 encoder 和 decoder。原配正常使用，然后把不同 seed 的双方交叉连接。

  
      
          交换方式
          相对 decoder 原配的 NLL 损伤
      
  
  
      
          E71901 → D71902
          +4.2754
      
      
          E71901 → D71903
          +2.6694
      
      
          E71902 → D71901
          +4.2958
      
      
          E71902 → D71903
          +3.2091
      
      
          E71903 → D71901
          +2.2507
      
      
          E71903 → D71902
          +3.3085
      
  

六次交换全部严重退化，中位损伤约为 +3.2588 NLL。这支持一个窄而明确的判断：每次训练都形成了 encoder 和 decoder 彼此兼容的私有坐标，另一组 decoder 不能直接读懂。
但跨 seed 不兼容并不是 TreeHeap 独有的超能力。普通神经网络也可能因为隐空间旋转或置换而不能直接交换模块。本轮真正有价值的是两类证据同时出现：
交叉配对失败：说明 encoder 与 decoder 共同形成了协议；
TreeHeap 干预有效：说明该协议实际经过 root、detail 和递归配对结构。
两者合起来，才支持“结构化 TreeHeap 私有协议存在”。它仍然不证明协议具有可读语义，更不证明 TreeHeap 优于其他神经网络。

15. 预注册判决

  
      
          Gate
          结果
          判决依据
      
  
  
      
          P1：所有 head 可训练
          通过
          梯度有限，所有 TreeHeap head 都收到梯度
      
      
          P2a：h4 优于 h1
          失败
          6.1934 高于 6.1231
      
      
          P2b：每个 h4 head 都有用
          通过
          四次消融均造成损失
      
      
          P3：TreeHeap 结构具有因果作用
          通过
          root、detail、pairing、head 干预通过门槛
      
      
          P4：形成私有或共享协议
          通过
          跨 seed 损伤远高于 0.10，属于 seed 私有协议
      
      
          P5：h4 优于 flat
          失败
          6.1934 高于 6.0401
      
  

按照实验前写死的规则，最终状态只能是：

Partial：TreeHeap 私有协议真实存在，并且因果依赖其递归结构；但多头组合收益和相对 flat 的性能优势没有成立。
这不是“平局”。从机制问题看，我们获得了阳性证据；从竞争性能看，TreeHeap 输掉了本轮。
当前最合理的下一步，不是立刻增加更多 head 或扩大语料，而是先定位多头退化：比较固定每头宽度与固定总宽度、测量 head 表征冗余，并替换当前简单拼接读取。只有 h2/h4 稳定优于 h1，才值得进入 Transformer Stage B。
完整 ARA 证据位于：
ara/s3-generation/evidence/s3_private_protocol_battle_full/
三个 checkpoint 已归档到 NAS。原始日志、每 seed 结果、结构干预和交叉配对结果均保留，没有因为竞争预测失败而删除。

16. 为什么这次不再走迷宫
这一轮只回答一个问题：

已经能够形成的 TreeHeap 私有协议，在真实 seq2seq 任务上到底有没有本事？
不再同时讨论意识、语法标签、最低熵句子、人类可读 root、世界模型拓扑和有限比特压缩。那些问题可以保留，但不能继续挤进同一个实验。
实验结束后，我们只允许三种结论：
赢：TreeHeap 在公平指标上出现稳定优势，并且结构干预证明优势来自 TreeHeap。

平：TreeHeap 能工作且确实使用结构，但没有超过成熟基线。

输：TreeHeap 的结构没有被使用，或者使用以后仍持续降低任务能力。
协议内部可以保持沉默。结果必须公开说话。



[SPR-065] NLL 6.x 不是架构天花板：30K 数据平台审计
Mon, 20 Jul 2026 00:00:00 +0000
NLL 6.x 不是架构天花板：30K 数据平台审计

证据状态更新（2026-07-28）：数据剂量与 NLL 曲线本身保留，但其解释范围缩小。后续审计发现，同系列 teacher-forcing 目标可能主要测到“给定正确中文前缀后的续写能力”，而非英文条件翻译。本文仍证明更多独立数据改善了该训练目标，不再证明 TreeHeap 翻译能力随数据扩展。详见 SPR-074。

SPR-064 比较了 TreeHeap、Flat GRU 和小 Transformer。它回答了“这些模型在同一小实验里谁更好”，却没有先回答另一个基础问题：30,000 对训练语料，是否足以让任何一个模型展示真实能力？ 如果实验平台本身只有 NLL 6.x、BLEU 约 3 到 5 的水平，那么模型之间相差 0.1，可能只是在比较谁更适应一个严重缺数据的平台，而不是比较架构上限。
本文补上这次遗漏的数据规模实验。结论先说：

30K 不是本数据集的最优平台，更不是 TreeHeap 的能力上限。把独立训练样本增加到 1M，同时保持优化器更新次数不变，三种模型的 NLL 都从 6.x 降到了约 4.0。这个改善主要来自数据多样性，而不是 TreeHeap 独有优势。

1. “平台问题”指什么
这里的“平台”不是服务器、显卡或操作系统，而是我们用来评价架构的整套实验坐标系：
数据量与数据质量
tokenizer
训练更新次数
模型参数量
优化器与学习率
验证集和测试集
baseline 的成熟度
评价指标
假设我们造了两辆新车，却只让它们在一条泥泞、限速 10 公里的小路上比赛。两辆车都只能跑到 9 公里，不代表它们的最高速度相同；只能说明当前道路把车辆差异压住了。
SPR-064 的平台大致是：

  
      
          项目
          设置
      
  
  
      
          训练数据
          30,000 对英中句子
      
      
          验证 / 测试
          2,000 / 2,000 对
      
      
          参数量
          约 2,730 万
      
      
          训练
          4 epoch
      
      
          TreeHeap h1 NLL
          6.1231
      
      
          Flat GRU NLL
          6.0401
      
      
          小 Transformer NLL
          6.4423 或 6.5330
      
  

这些数字可以比较本轮模型，却不能证明“Flat 已经是数据集最优解”，也不能证明“TreeHeap 只是更慢的 Flat”。要判断平台是否压住了模型，我们需要改变数据量，同时冻结其他主要变量。

2. NLL 6.x 到底意味着什么
NLL 是 Negative Log-Likelihood，负对数似然。对每个目标 token，模型会给整个词表分配概率。如果正确 token 的概率是 $p_t$，平均 NLL 为：
$$ \operatorname{NLL}=-\frac{1}{T}\sum_{t=1}^{T}\log p_t $$越低越好。常见的 PPL，也就是困惑度，为：
$$ \operatorname{PPL}=e^{\operatorname{NLL}} $$可以把 PPL 粗略理解成：模型在每一步面对多少个“同样有竞争力”的候选。它不是候选词的真实数量，但适合帮助理解尺度。

  
      
          NLL
          PPL 约为
          直观趋势
      
  
  
      
          6.27
          527
          非常不确定
      
      
          5.15
          172
          明显改善，但仍很宽
      
      
          4.26
          71
          候选范围继续收缩
      
      
          4.02
          56
          比 30K 平台可靠得多
      
  

因此，从 NLL 6.27 降到 4.02 不是小数点上的装饰。PPL 从约 527 降到了约 56，说明模型给正确 token 的相对概率大幅提高。
但 NLL 也不是产品质量的完整替代。teacher forcing 下 NLL 下降，并不保证自由生成一定自然；还要结合 BLEU、样例、人工检查和真实任务评价。

3. 为什么不能直接把数据放大，再训练相同 epoch
最简单的做法是：
30K 训练 4 epoch
1M 也训练 4 epoch
但这不是纯粹的数据量实验。1M 的 4 epoch 包含的优化器更新次数约为 30K 的 33 倍。结果变好以后，我们不知道原因是：
看到了更多不同句子
还是
只是计算了更多次梯度
因此，这次实验固定每组都是：
15,625 次 AdamW 更新
batch size = 64
总样本曝光量约 1,000,000
唯一主动改变的变量是独立训练句子数量：

  
      
          独立训练句对
          每条数据平均复用次数
      
  
  
      
          30,000
          33.33 次
      
      
          100,000
          10.00 次
      
      
          300,000
          3.33 次
      
      
          1,000,000
          1.00 次
      
  

30K 组反复背同一本薄练习册，1M 组把同样的一百万次阅读机会用于一百万个不同样本。这样才能较干净地测量“数据多样性”本身。

4. 实验预注册
正式 Claim 为：

S3-PRIVATE-PROTOCOL-DATA-DOSE-C03：在优化器更新预算和验证/测试集固定时，如果 SPR-064 的 TreeHeap h1 主要受数据不足限制，那么独立训练句对从 30K 增加到 1M 应显著降低 held-out NLL。
执行前写死四条判断门槛：

h1 的 1M NLL 至少比 30K 低 0.10。
log10(数据量) 与 h1 NLL 的 Spearman 相关系数不高于 -0.80。
三次相邻扩容中，至少两次使 h1 NLL 下降。
所有梯度保持有限，不得用数值崩溃解释结果。

Flat GRU 和参数量接近的小 Transformer 也执行相同数据剂量。这一点很重要：如果只有 TreeHeap 改善，可以怀疑 TreeHeap 特别缺数据；如果三者都改善，更合理的解释是整个平台都受数据多样性限制。
固定变量
模型 seed = 71901
验证集 = 固定 2K，哈希锁定
测试集 = 固定 2K，哈希锁定
tokenizer = 固定 SentencePiece 模型，SHA-256 锁定
batch = 64
更新次数 = 15,625
learning rate = 0.002
验证间隔 = 500 steps
训练集采用嵌套设计：30K 是 100K 的子集，100K 是 300K 的子集，300K 是 1M 的子集。因此，扩容不是换一套完全不同的数据抽签。

5. 正式结果
实验在 io 的 RTX 3090 上运行 5.32 小时。三种模型、四档数据量共 12 个训练臂。
Test NLL

  
      
          模型
          30K
          100K
          300K
          1M
          30K 到 1M 改善
      
  
  
      
          TreeHeap h1
          6.2671
          5.1454
          4.2558
          4.0198
          2.2473
      
      
          Flat GRU
          6.0319
          5.0532
          4.2025
          3.9365
          2.0954
      
      
          Small Transformer
          6.5373
          5.3375
          4.1761
          3.9201
          2.6172
      
  

三条曲线都严格单调下降，三种模型的 Spearman 系数都是 -1.0。TreeHeap 的四条预注册 gate 全部通过。
TreeHeap h1 的完整体检

  
      
          独立句对
          最佳 step
          Test NLL
          PPL
          Token BLEU-4
          训练时间
          峰值显存
      
  
  
      
          30K
          1,000
          6.2671
          526.9
          5.401
          56.9 分钟
          1.84 GiB
      
      
          100K
          3,000
          5.1454
          171.6
          7.778
          57.0 分钟
          1.85 GiB
      
      
          300K
          14,000
          4.2558
          70.5
          11.079
          56.7 分钟
          1.84 GiB
      
      
          1M
          15,625
          4.0198
          55.7
          12.085
          56.7 分钟
          1.84 GiB
      
  

训练时间和显存基本不变，符合固定更新预算。NLL、PPL 和 BLEU 则同时随独立数据增加而改善。

6. 30K 为什么会停在 NLL 6.x
最有解释力的不只是最终 NLL，而是最佳 checkpoint 出现在哪里。
三个 30K 模型都在第 1,000 step 达到最佳验证结果。继续把同样的 30K 数据重复到 15,625 step 后，最终验证 NLL 严重恶化：
TreeHeap h1：10.7979
Flat GRU：10.8155
Transformer：14.7291
这说明 30K 不是“学到了平台最优解”，而是很快耗尽了有限样本提供的新信息，随后开始过拟合。
相反，1M 的 TreeHeap 和 Transformer 都在最后一个 step 才达到本轮最佳结果。它们只完整看过训练集约一次，曲线仍可能继续下降。因此，1M 的 NLL 约 4.0 也不能叫架构上限，只能叫当前固定预算下的一遍数据结果。
所以 SPR-064 中的 NLL 6.x 应重新解释为：

30K 独立样本不足以支撑约 27M 参数模型的稳定比较。重复曝光增加了计算，却不能替代新的关系证据。
这就是平台问题的实证答案。

7. TreeHeap 赢了吗
没有。
TreeHeap 的 NLL 从 6.2671 降到 4.0198，证明它能从新增数据中持续学习；但 Flat 和 Transformer 也同样改善。在 1M 时：
TreeHeap h1 比 Flat 落后 0.0833 NLL
TreeHeap h1 比 Transformer 落后 0.0997 NLL
因此最强解释是普遍的数据多样性效应，不是 TreeHeap 独有 scaling law。
也有一条谨慎的积极信号：TreeHeap 与最佳 baseline 的差距从 30K 时的 0.2352，缩小到 300K 到 1M 时约 0.08 到 0.10。这说明增加数据没有把 TreeHeap 甩开，但单 seed 不足以判断差距缩小是否稳定。
工程效率仍然是明确负项：

  
      
          模型
          每个数据剂量平均时间
      
  
  
      
          TreeHeap h1
          约 56.8 分钟
      
      
          Flat GRU
          约 15.5 分钟
      
      
          Small Transformer
          约 6.8 分钟
      
  

当前 TreeHeap 比 Flat 慢约 3.7 倍，比这个小 Transformer 慢约 8.3 倍。它证明了可学习性，没有证明计算优势。

8. 数据越多就一定越好吗
也不能这样下结论。
数据源文件声明包含约 1,417 万行、2.52 GB 文本，但样例检查发现了一些网页碎片、乱码和错位句对。例如型号页面、URL 错误页、广告文本和并不严格对应的双语句子。这些噪声不会推翻固定 split 下的 NLL 曲线，却会限制翻译产品质量。
数量和质量是两个不同变量：
更多不同样本
  -> 减少重复记忆，扩大关系覆盖

更多噪声样本
  -> 也可能教给模型错误对应和网页模板
这次实验只证明在当前语料排序与过滤规则下，从 30K 扩到 1M 的净收益为正。它没有证明继续扩到 14M 一定保持同一斜率，更没有证明“500 GB 才够”。

9. 以后怎样避免平台误判
后续架构实验至少应同时报告四张表。
数据卡
数据来源、字节数、行数
清洗与去重规则
训练 / 验证 / 测试哈希
tokenizer 哈希
长度分布和语言分布
训练卡
参数量
optimizer / learning rate
batch、更新次数、样本曝光量
最佳 step 与最终 step
GPU 时间、峰值显存
质量曲线
NLL / PPL
BLEU 或任务指标
至少三个数据剂量
至少三个随机 seed
生成样例与人工审计
架构归因
matched Flat
matched Transformer
TreeHeap 地址、root、detail、head 干预
相同数据、参数和计算预算
只有当 baseline 已经随着数据正常改善、主要模型接近收敛、结果跨 seed 稳定时，架构差异才有资格被解释为结构能力。

10. 下一步判断门槛
这次 Claim 的状态是：
数据不足假设：supported pilot
TreeHeap 可从 1M 数据继续学习：supported pilot
TreeHeap 优于 Flat：not supported
TreeHeap 优于 Transformer：not supported
通用 scaling law：未证明
产品级翻译能力：未证明
下一轮不应只把数据继续堆大。更有效的实验是：

对 1M 端点执行至少三个 seed，确认 0.08 到 0.10 的差距是否稳定。
给 1M 模型更多更新，区分“一遍数据未收敛”和“模型容量不足”。
建立清洗语料对照，分开测量数量收益与质量收益。
使用更成熟、真正收敛的小 Transformer 作为平台上限参考。
报告达到相同 NLL 所需的 token、step、时间和显存，而不只比较最终分数。

这会把问题从“30K 谁赢了”升级为：

在足够数据和公平计算预算下，TreeHeap 是否具有不同于 Flat 与 Transformer 的学习曲线、结构因果性和外推收益？

11. 本轮结论
SPR-064 的架构比较没有作废，但它的适用范围必须缩小：它是一个 30K 小数据平台上的私有协议与结构因果实验，不是架构能力排名。
数据剂量实验给出了三个清晰结论：

30K 的 NLL 6.x 主要受到数据多样性限制，不能当作数据集最优值。
TreeHeap、Flat 和 Transformer 都能从 1M 独立句对中获得巨大收益。
TreeHeap 在 1M 时接近两个 baseline，但仍更慢、NLL 仍略差，因此只证明继续航行的资格，没有证明胜利。

这篇文章真正补上的，是我们的测量尺。没有足够宽的平台，架构优劣很容易被过拟合、未收敛和弱 baseline 伪装。现在至少可以确认：此前看到的 6.x 不是墙，只是 30K 这块窄甲板的边缘。
完整 ARA 证据：
ara/s3-generation/logic/private_protocol_data_dose.md
ara/s3-generation/evidence/s3_private_protocol_data_dose_full/
代码提交：7bbb89c；结论归档提交：6182b5d。实验保留 config.json、数据 manifest、split hash、逐步 trace、运行日志、生成样例和 summary.json。
本文与相关代码沿用项目现有开源许可证。supported pilot 表示受控单 seed 证据成立，不等于通用 scaling law 或产品性能承诺。



[SPR-066] TreeHeap 旋转私有协议：秩序不是假设，而是幸存结果
Tue, 21 Jul 2026 00:00:00 +0000
TreeHeap 旋转私有协议：秩序不是假设，而是幸存结果

本文记录一次从危险直觉到受控实验的完整转向。最初的想法是：一棵有序树经过旋转，能否用很少的递归步骤观察很大的候选空间？实验确认这种结构可以高效复用，但也暴露出严重风险：如果把每次旋转都复制成新树，逻辑空间会指数膨胀。于是我们把架构收紧为固定容量，只允许 subheap 在原地址池内旋转。随后两个实验回答了更重要的问题：旋转能否承载 encoder-decoder 私有协议，以及有用的秩序能否在没有秩序标签时由任务自己筛选出来。

1. 从两个有序切片说起
先看两个很小的有序片段：
[0, 1, 2]
[3, 4, 5]
它们不只是六个数字。每个片段还携带一个关系：后面的元素大于前面的元素。如果把它们分别写成有根树，再通过一个合法的组合算子连接起来，新的结构可能继续支持搜索、比较和分解。
这里最有价值的不是数字本身，而是秩序缩小了求解空间。如果查询目标是 4，我们不必逐个检查所有节点；只要每一步都能根据局部状态选择 stop / left / right，就可能沿一条路径坍缩到答案。
这给出了一个几何推理的直觉：
局部有序结构
  -> 合法旋转或组合
  -> 更大范围仍然保留可用关系
  -> 一个局部 kernel 可以递归复用
但直觉里藏着两个完全不同的问题：

旋转能否扩大可观察范围？
旋转是否必须扩大物理内存？

第一件事可能有价值，第二件事必须被严格限制。

2. 第一条路为什么危险
最初的递归构造可以写成：
$$ H_{n+1}=\operatorname{CAT}\left(H_n,R_n(H_n)\right) $$其中，$R_n$ 是第 $n$ 轮旋转，CAT 把原树和旋转后的树连接起来。若每一轮都保留两个副本，逻辑候选数近似翻倍：
$$ N_n \approx 2^n N_0 $$这很诱人。递归 16 次，就能描述两百多万个逻辑候选。但如果把每个候选都实体化，内存同样会迅速耗尽。一个“搜索很快”的算法，如果靠无限复制内存换取速度，并不是真正的低成本推理。
我们做了一个边界实验。它在规则、保序、可懒展开的旋转轨道上得到：

  
      
          指标
          结果
      
  
  
      
          最深层逻辑候选数
          2,031,616
      
      
          测试查询数
          52,898
      
      
          确定性查询准确率
          1.0000
      
      
          学习 kernel 的 OOD 最低准确率
          1.0000
      
      
          逆变换准确率
          1.0000
      
      
          最深层 TreeHeap 平均比较次数
          20.1682
      
      
          无序扫描平均比较次数
          1,014,613.8684
      
      
          显式存储 / 懒存储比
          32,247.873 倍
      
      
          破坏秩序后的单路径准确率
          0.0360
      
  

这个结果证明了一个窄结论：规则的保序轨道可以被紧凑表示，查询工作量随递归深度线性增长。
它没有证明“TreeHeap 免费搜索指数空间”。显式排序数组也能用对数次比较完成同类查询，只是需要保存全部数据。实验还专门设置了预算上限，超过上限时返回 BUDGET_EXHAUSTED，不允许继续扩容。
因此，指数 CAT 生长被归档为边界证据，不再作为运行时架构。我们保留旋转，删除无界复制。

3. 固定容量：旋转只能改变观察方向
新的架构只有一条硬规则：系统启动时获得容量为 $C$ 的节点池，此后任何旋转都必须留在同一空间内。
$$ R_{S,\phi}:\mathcal{H}_C\rightarrow\mathcal{H}_C $$$S$ 是已有 subheap，$\phi$ 是一个有限、合法、可逆的地址置换。旋转前后必须满足：
节点数不变
容量不变
subheap 外部状态不变
R_inverse(R(H)) = H
不申请新的 TreeHeap 节点
以最小三节点树为例：
      A
     / \
    B   C
正常地址顺序是 [A, B, C]，mirror 后是 [A, C, B]。设局部卷积 kernel 为：
$$ u=w_0 A+w_L B+w_R C $$镜像后，同一个 kernel 看到的是：
$$ u'=w_0 A+w_L C+w_R B $$数据没有被复制，变化的是“哪个状态位于 left，哪个状态位于 right”。随后用逆置换把结果写回原坐标。这样，旋转就不再是扩容器，而是一个固定内存中的观察坐标变换。
整棵树上的传播写成：
$$ H_{t+1}=\operatorname{ApplyAllSubheaps} \left(H_t,K_\theta,R,g\right) $$其中 $K_\theta$ 是共享局部 kernel，$g$ 是是否启用某个旋转的 gate。经过 $t$ 轮，信息大约传播 $t$ 个结构跳数。增长的是感受野，不是节点池：
$$ \text{space}=O(C),\qquad \text{time}=O(T_{\max}C\cdot \operatorname{cost}(K)) $$$C$ 和 $T_{\max}$ 都是硬上限。达到上限仍然没有答案，就返回 UNRESOLVED。拿不到的解不是系统故障，而是接受有限算力的客观边界。

4. 旋转如何成为私有协议
TreeHeap 的参数和运行状态需要分开说清楚：
H_state：当前样本写入后的 TreeHeap 状态
theta：kernel、gate、读写器中的可学习参数
R：合法的结构旋转算子
encoder 可以执行一段旋转程序，再通过 FOLD 把输入写进 $H_{state}$：
$$ H_{state}=E_{\theta_E}(X;R_1,\ldots,R_m) $$decoder 不需要让人类看懂中间状态，只要能学习对应的逆程序，再用 UNFOLD 读回目标：
$$ \hat X=D_{\theta_D}(H_{state};R_1^{-1},\ldots,R_m^{-1}) $$训练损失可以只看最终 echo：
$$ L_{echo}=\lVert \hat X-X\rVert_2^2 $$这像每个人不同的笔迹。纸上的轨迹可以不同，但只要写和读形成了稳定配对，协议就能工作。私有协议不是“无法验证”，因为我们仍能检查：原配是否成功、交叉配对是否失败、破坏一个旋转是否增大损失、地址和内存是否保持合法。
固定协议实验
实验使用容量 127、每节点 4 维状态的 TreeHeap，并注册 6 个相互重叠的 subheap mirror 算子。两个 encoder 使用不同的 6-bit 旋转程序：
程序 A = [1, 1, 0, 1, 0, 1]
程序 B = [0, 1, 1, 0, 1, 1]
decoder 只有 6 个可训练 gate logit。它不知道正确程序，只能通过 echo MSE 学习逆变换。

  
      
          检查
          程序 A
          程序 B
      
  
  
      
          学到的 bit 是否完全匹配
          是
          是
      
      
          原配 echo MSE
          0
          0
      
      
          交叉协议 MSE
          2.012999
          2.012999
      
      
          单 bit 错误 MSE
          2.012695
          0.471290
      
      
          逆序执行 MSE
          0.440443
          0
      
  

状态形状始终是 [2048, 127, 4]，没有增加一个节点。gate 也明显硬化：启用项约为 0.995 到 0.997，关闭项约为 0.003。
这里出现了一个重要修正。程序 A 的有效算子不交换，因此执行顺序是协议的一部分；程序 B 的有效组合恰好顺序等价，因此正序和逆序都能解码。结论不是“递归一定依赖顺序”，而是：

只有当被选中的结构算子彼此非交换时，顺序才携带额外协议信息。
这个实验支持“固定容量旋转可以承载私有协议”，但 encoder 程序是人工固定的。它还没有解释有用的秩序从哪里来。

5. Echo 不会自动产生秩序
这是本轮最关键的理论分界。
如果 encoder 使用任意可逆置换 $R$，decoder 使用精确逆变换 $R^{-1}$，那么：
$$ R^{-1}(R(H))=H $$不论 $R$ 是否保留父子关系，echo 都可以是零误差。因此：
可逆性 != 秩序
能 echo != 学会有用结构
私有协议存在 != 私有协议具有推理价值
只训练 echo 时，一套漂亮的保序编码和一套完全混乱的加密式编码可能同样优秀。要让秩序出现，数据和任务必须给它提供选择压力。
这也修正了“旋转后天然保序”的说法。旋转只是候选操作。保序不是预设奖励，而应当是非保序候选在具体环境中表现更差以后留下的结果。

6. 不告诉模型秩序，让环境选择
我们构造了一个固定种群，共 24 个容量相同的候选旋转：

  
      
          候选组
          数量
          特征
      
  
  
      
          exact
          6
          精确保留父子边的树自同构
      
      
          mild
          6
          轻微破坏父子关系
      
      
          random
          12
          在同一深度内随机置换
      
  

训练 loss 中没有“保序”“边正确”或“路径前缀”标签。模型只需要用共享局部 decoder，根据 parent、sibling 和 children 恢复被遮住的节点。gate 根据这个预测误差选择候选旋转。
为了区分真正的结构选择与优化器偶然偏好，实验使用两个世界。
结构世界
子节点与父节点相关：
$$ x_{child}=\rho x_{parent}+\sqrt{1-\rho^2}\,\epsilon, \qquad \rho=0.92 $$父子边保存了可用于预测的信息。破坏边会让局部 decoder 更难工作。
IID 世界
取 $\rho=0$，所有节点互相独立。此时父子关系没有预测价值，exact、mild 和 random 理论上应该近似打平。
单个 seed 的结果一度令人困惑：结构世界几乎全选 exact，但 IID 世界也把 90.59% 的 gate 质量压到了 exact。我们没有把它包装成成功，而是登记为 7/8 gate 通过，并怀疑 gate 与 decoder 的共同训练产生了“先领先者锁死”的中性漂移。
随后按预注册方案运行 8 个随机种子：
1, 7, 19, 42, 73, 99, 314, 2026
8-seed 结果

  
      
          指标
          结果
          应如何理解
      
  
  
      
          结构世界 exact winner
          8 / 8
          每个 seed 都选择保边变换
      
      
          结构世界 exact gate mass 均值
          0.999657
          质量几乎全部集中到 exact 组
      
      
          结构世界 exact gate mass 最小值
          0.999215
          最差 seed 仍超过 99.92%
      
      
          边保留率与 loss 的 Pearson
          -0.997404
          越保边，loss 越低
      
      
          IID winner 分布
          2 exact / 1 mild / 5 random
          没有稳定偏爱 exact
      
      
          IID exact gate mass 均值
          0.283272
          接近初始占比 6/24 = 0.25
      
      
          IID exact-random loss 差
          0.000992
          三组实际上近似打平
      
      
          IID 边保留率与 loss 的 Pearson
          -0.018631
          无结构关系
      
      
          exact echo 最大逆变换误差
          0
          所有可逆协议都能无损 echo
      
  

九条预注册 gate 全部通过。
这个结果支持的不是“宇宙天然喜欢二叉树”，而是一个更具体的命题：

当数据的可预测关系沿 TreeHeap 父子边传播时，不含秩序标签的任务损失会稳定淘汰破坏这些关系的旋转；当数据没有这种关系时，选择退化为中性漂移。
这里的“秩序”不是数字升序，而是父子边、路径前缀和局部关系得到保存。秩序成为知识，是因为它减少了预测不确定性。

7. 这与 encoder、decoder 有什么关系
现在可以把三段证据连起来：
固定容量旋转
  -> 提供有限、可逆的结构编码候选

echo loss
  -> 让 encoder 与 decoder 学会彼此兼容的私有写法

结构预测 loss
  -> 从多种可逆写法中筛掉破坏有用关系的写法

剩下的旋转程序
  -> 成为既可解码、又保留任务相关结构的私有协议
这比“人工规定左边是主语、右边是宾语”更接近我们一直寻找的涌现路径。研究者规定的只是有限内存、合法算子、可微 gate 和任务；具体协议由 encoder 与 decoder 联合形成，结构价值由数据检验。
它也解释了为什么只做 token echo 不够。echo 负责可读回，结构预测负责读回之前不要把有用关系打乱。两者缺一不可。

8. 当前证据没有证明什么
这轮结果很强，但边界同样明确：

候选旋转来自固定的 24 个算子，模型还没有自己发明新的旋转公式。
数据是 Gaussian tree world，不是真实语言、图像或世界模型。
exact 候选保留的是给定父子边，不代表现实任务一定应该使用这棵树。
实验没有证明 TreeHeap 比 Transformer、MLP、图网络或经典数据结构更快。
两百万逻辑候选实验不适用于密码破解，也不构成对加密算法的威胁证据。
旋转扩大的是固定内存中的观察范围，不允许解释为无限算力或无限答案。

尤其需要避免一个新的循环论证：先人工构造“正确树”，再证明保留这棵树最好。下一阶段必须让树的 placement、compose 与旋转共同面对真实数据，而不是把正确结构偷偷写进输入。

9. 下一阶段：让语言决定哪种旋转活下来
下一条可证伪路线应保持固定容量，不再申请外部 TreeHeap 内存：

从真实语料生成 $H_{state}$，禁止 decoder 旁路读取原字符串。
注册一组有限的 subheap 旋转和不同递归深度，仍不提供语法标签。
使用 echo、上下文预测或 seq2seq loss 联合训练 encoder gate 与 decoder。
比较结构候选、随机同深度置换和不旋转 baseline。
在训练后审计父子边、路径前缀、地址复用、OOD 深度与推理成本。
检查不同 seed 是否选择稳定关系，而不是复现一次 winner lock-in。

预期不应写成“语言必然选择 mirror”。更谨慎的 predict 是：

若 TreeHeap 的局部关系与语料中的可预测关系对齐，则结构保持更好的旋转程序应获得更低验证 loss、更稳定的多 seed 选择，以及更好的未见深度或未见地址外推；若随机置换同样有效，则旋转私有协议没有提供额外结构价值。
这条 predict 同时允许成功和失败。失败时，我们应该修改 placement、FOLD 或候选算子，而不是继续扩大内存寻找答案。

10. 航行结论
这轮工作把一个容易失控的想法变成了有限工程对象：
旧想法：旋转一次，复制一个新空间
新设计：旋转一次，重排固定 subheap

旧假设：合法旋转天然保序
新结论：可逆旋转只是候选，秩序必须被任务选择

旧证据：echo 可以恢复输入
新证据：echo 证明私有协议，结构预测证明协议保留有用关系
TreeHeap 旋转目前已经有三层受控证据：可逆、固定容量、可学习配对；非交换组合可以携带顺序；结构化环境会在多 seed 中稳定选择保留关系的候选。它还不是语言 encoder，也不是完成的智能系统，但已经不再只是一个几何比喻。
更重要的是，我们接受了一条工程伦理：一个算法越容易让人想无限递归，越需要先写死容量、轮数和失败返回值。有限不是遗憾。有限使实验可以复现，使系统可以停止，也使真正的结构收益不再被无限内存掩盖。
ARA 代码、预注册和原始 evidence 保存在 SameTime 仓库的以下目录：
ara/m0-treeheap-math/evidence/bounded_rotation_search_probe/
ara/m0-treeheap-math/evidence/fixed_capacity_rotation_protocol_probe/
ara/m0-treeheap-math/evidence/rotation_selection_evolution_probe/
ara/m0-treeheap-math/evidence/rotation_selection_multiseed_probe/
对应提交：8cf183d、f97f136、b2af86a。项目公开仓库为 houming818/sametime。
本文与相关代码沿用项目现有开源许可证。实验数字是受控 toy evidence，不应脱离边界宣传为真实语言、通用推理或密码学能力。



[SPR-067] STONE-1 正式体检：树地址成立，私有协议尚未学会
Wed, 22 Jul 2026 00:00:00 +0000
STONE-1 正式体检：树地址成立，私有协议尚未学会

证据状态更新（2026-07-28）：STONE-1 的完成判定与“英文语义进入 TreeHeap”的推断暂停。C10 代码审计发现，teacher forcing 和大面积可见 EOS 尾部没有被既有 gate 排除。地址交换造成 NLL 损伤，仍能证明 decoder 使用了某些树状态；它不能单独证明这些状态携带英文条件语义。详见 SPR-074。

这是一篇正式实验报告，也是一份“架构体检单”。STONE-1 在 io 的 RTX 3090 上连续运行约 7.57 小时，完成了 3 种结构方案、3 颗随机种子、共 9 次训练。程序没有崩溃，checkpoint 和 CLI 都成功产出，但核心 Claim 没有通过。更准确地说：模型确实依赖 TreeHeap 的左右地址和层级秩序；然而当前的可学习方向 gate 没有形成比固定结构更好的 encoder-decoder 私有协议。
这不是“TreeHeap 已经失败”，也不是“再多跑几天就一定成功”。它把两个长期混在一起的问题第一次拆开了：

TreeHeap 的结构有没有进入模型计算？有，而且因果信号很强。
当前 kernel 是否学会了有价值的内部编码协议？没有，固定 identity 反而更好。

本文从头解释实验设计、指标、数据、结果和下一步。没有读过前 66 篇文章，也可以独立阅读。

1. 我们到底想证明什么
普通 seq2seq 模型可以把输入句子编码成一组向量，再从这些向量生成输出。只看最终翻译，我们不知道中间状态究竟是一棵 TreeHeap，还是一条换了名字的数组。
STONE-1 因此提出了一个比“能翻译”更严格的目标：
英文 token
  -> 递归 FOLD
  -> 固定容量 TreeHeap H_state
  -> 递归 UNFOLD / 多层读取
  -> 中文 decoder
  -> 非 teacher-forcing 生成
其中没有额外的句法标签、旋转标签或“这里应该向左”的答案。模型只能根据最终翻译损失，通过梯度自己决定内部如何编码。
我们希望看到的现象是：
learned structural
  比固定 identity 更好
  比固定 random 更好
  改掉 learned gate 会明显变差
  破坏左右地址也会明显变差
如果只满足最后一条，只能证明“地址有用”，不能证明“learned gate 学会了私有协议”。这一区分是整场实验的核心。

2. 什么叫 encoder-decoder 私有协议
先用一个生活例子。
两个人可以约定：写字时把重要内容放在纸张左侧，补充内容放在右侧。只要写的人和读的人使用同一规则，外人不需要看懂这种布局，信息也能正确传递。
对模型而言，这个约定不必是人类可读的“主语、谓语、宾语”。它可以是训练自行形成的内部协议：
encoder 决定怎样折叠和摆放信息
decoder 学会怎样读取这种摆放
最终任务 loss 同时约束两者
这里的 private 不是加密，而是“模型内部自洽，不要求人类手写”。
如果这种协议真的存在，那么强制改用另一套左右选择规则，decoder 应该像拿到错误的字典一样，性能明显下降。反过来，如果随便替换 gate 都几乎没影响，就不能说这个 gate 承载了关键协议。

3. TreeHeap 状态是怎样折叠的
STONE-1 使用固定宽度为 64 的二叉 TreeHeap。句子的 token embedding 放在 leaf 层，然后两两递归合并：
64 leaves
 -> 32 parents
 -> 16 parents
 -> 8
 -> 4
 -> 2
 -> 1 root
每次局部 FOLD 只看一对子节点 left 和 right。系统包含两个可学习函数：

P：根据 anchor 预测另一侧状态；
U：把预测残差更新到 parent。

当左侧作为 anchor 时：
\[ d = R-P(L) \]\[ H_{parent}=L+U(d) \]这里的 detail，也就是 \(d\)，保存“右侧相对左侧还缺少什么”。UNFOLD 时执行：
\[ L=H_{parent}-U(d) \]\[ R=d+P(L) \]如果右侧作为 anchor，公式左右对换。一个二值 gate \(g\) 决定方向：
g = 1: left 是 anchor
g = 0: right 是 anchor
这样做的好处是，FOLD 与 UNFOLD 在数学设计上成对出现。树向上压缩时保存 parent、detail 和方向；树向下展开时使用同一组信息恢复各层状态。
需要注意：这不是无损压缩整个字符串的产品算法。decoder 看不到最终 leaf 层，只能读取 root 和被允许的压缩层。我们故意关闭了最直接的 token 旁路，迫使翻译至少经过一次结构折叠。

4. learned kernel 学什么
局部方向 kernel 的输入为：
\[ x=[L, R, L-R, L\odot R] \]其中 \(L\odot R\) 是逐元素乘积。kernel 是一个小型两层网络：
\[ p=\sigma(K_{\theta}(x)+b_{depth}) \]\(p\) 是选择左 anchor 的概率。前向计算把它硬化成 0 或 1，反向传播使用 straight-through estimator，让梯度近似穿过这个离散选择。
同一个 kernel 在整棵树上共享，只额外携带每个深度的 bias。这符合我们此前对 TreeHeap 卷积的要求：不是为每个地址单独训练一张表，而是让同一个局部算子沿树递归复用。
但是，这种设计也有风险。decoder 正在学习怎样读取内部坐标时，gate 同时在改变内部坐标。就像一个人学习地图期间，地图的东西方向还在变化。STONE-1 正是要用对照实验判断：这种自由度究竟形成协议，还是只增加优化噪声。

5. 为什么必须有三种实验臂
三种模型参数规模相同，训练数据、优化器、步数和 decoder 都相同。唯一变化是局部方向：

  
      
          实验臂
          方向规则
          它回答的问题
      
  
  
      
          identity
          所有有效节点固定使用左 anchor
          稳定、规范的坐标系有多强？
      
      
          learned_structural
          kernel 根据内容和深度学习 0/1
          学习方向是否带来额外收益？
      
      
          frozen_random
          固定的地址/深度随机 pattern
          只要规则稳定，任意坐标是否也能工作？
      
  

这里最容易误解的是 random。
frozen_random 不是每一步重新掷骰子。它在训练开始前生成一个固定 pattern，此后永远不变。因此 decoder 有机会适应这套奇怪但稳定的坐标系。如果 learned 连 frozen random 都不能击败，问题很可能不是“树不能放信息”，而是“训练时持续变化的方向没有形成稳定协议”。

6. 数据和训练合同
正式实验在结果出现前就锁定了配置，不能看完数字再修改及格线：

  
      
          项目
          正式设置
      
  
  
      
          数据源
          WMT-massive 英中 TSV
      
      
          原始声明行数
          14,170,275
      
      
          独立训练样本
          1,000,000
      
      
          验证 / 测试
          2,000 / 2,000
      
      
          句长过滤
          8 到 32 token
      
      
          tokenizer
          32K SentencePiece BPE
      
      
          每个实验臂随机种子
          3
      
      
          总训练臂
          9
      
      
          batch size
          64
      
      
          每臂更新
          15,625
      
      
          每臂参数量
          27,769,097
      
      
          heap width
          64
      
      
          GPU
          RTX 3090
      
  

训练、验证和测试内容经过 hash 检查，没有交叉泄漏。正式任务运行 27,268.44 秒，也就是约 7.57 小时，退出码为 0，stderr.log 为空。
因此，后面的负结果不是程序崩溃、GPU 掉卡、测试集泄漏或某个文件没有加载造成的。

7. 先学会看 NLL 和 BLEU
7.1 NLL：模型给正确答案多少概率
假设正确 token 是 \(y_t\)，模型给它的概率是 \(p(y_t)\)，平均负对数似然为：
\[ \operatorname{NLL}=-\frac{1}{T}\sum_{t=1}^{T}\log p(y_t) \]NLL 越小越好。它不是“错误百分比”，而是模型对正确答案分配概率的总体成本。
例如：
模型 A 给正确词概率 0.50 -> -log(0.50) 约 0.69
模型 B 给正确词概率 0.10 -> -log(0.10) 约 2.30
模型 A 的 NLL 更低，说明它更确信正确答案。
7.2 BLEU-4：生成句和参考句有多少局部片段重合
BLEU-4 检查 1 到 4 token 片段的重合情况，并惩罚过短输出。它越高越好，但不是语义理解的完整评价。两个意思相近、措辞不同的句子，BLEU 可能仍然不高。
本实验使用 token BLEU-4，主要用来防止一种假进步：teacher-forcing NLL 下降了，但模型自由生成时仍然是空字符串或重复乱码。
7.3 标准差：换颗随机种子还可靠吗
同一程序从不同随机初始化出发，结果可能不同。三颗种子的 NLL 标准差越小，说明方案越稳定。
STONE-1 预注册的主要产品目标是：
learned mean NLL <= 3.90
learned BLEU-4   >= 13.5
NLL 标准差       <= 0.05
非空生成率        = 1.00
严重重复率        <= 0.10

8. 正式结果：identity 赢了
三颗种子的平均结果如下：

  
      
          方案
          Test NLL，越低越好
          NLL 标准差
          BLEU-4，越高越好
          严重重复率
      
  
  
      
          identity
          4.0719
          0.0058
          11.1735
          0.0397
      
      
          learned structural
          4.2269
          0.1125
          9.7875
          0.0558
      
      
          frozen random
          4.1210
          0.0106
          10.7198
          0.0430
      
  

learned 相对 identity 的 NLL 差值是：
\[ 4.2269-4.0719=+0.1550 \]正数意味着 learned 更差。它相对 frozen random 也差 +0.1059。
这不是一颗坏种子造成的。逐种子比较：

  
      
          Seed
          identity NLL
          learned NLL
          random NLL
          learned - identity
      
  
  
      
          71901
          4.0799
          4.3858
          4.1359
          +0.3059
      
      
          71902
          4.0691
          4.1538
          4.1121
          +0.0847
      
      
          71903
          4.0666
          4.1411
          4.1149
          +0.0746
      
  

三颗种子全部是 identity 最好，learned 最差。seed 71901 的 learned 出现了明显失败尾部，使 learned 的标准差达到 0.1125，超过预注册上限两倍以上。
所以第一层结论很明确：

在这一百万样本、一步训练遍历、hard straight-through gate 的配方中，可学习方向没有改善翻译，反而降低了平均质量和稳定性。

9. 但是模型真的用了树地址
只看上表，可能会得出一个过快结论：“TreeHeap 没有用。”干预实验否定了这种说法。
我们取 learned seed 71903 的最佳 checkpoint，在测试时主动改变内部结构：

  
      
          干预
          NLL
          相对正常模型的损伤
      
  
  
      
          正常 learned
          4.1411
          0
      
      
          强制全部 identity
          4.1293
          -0.0118，反而改善
      
      
          强制 frozen random
          4.1446
          +0.0034，几乎无变化
      
      
          交换每层 left/right 地址
          5.6359
          +1.4948，严重损坏
      
  

NLL 从 4.1411 上升到 5.6359 不是轻微波动。对应的困惑度从约 62.87 上升到 280.32。
这说明 decoder 不是把所有内部节点当成无序 word bag。它确实区分：
这个状态在左地址
那个状态在右地址
这个节点位于哪一层
一旦整体交换左右地址，decoder 原来学到的读取方式就失效了。
但另外两项干预同样关键：把 learned gate 替换成 identity 不但没有伤害，反而稍有改善；替换成 random 也几乎不痛。这说明地址是协议的一部分，而 learned gate 不是当前协议中不可替代的一部分。
可以把它类比成一座图书馆：
书架编号非常重要，全部左右互换会让读者找不到书；
但管理员训练出来的临时摆书策略并没有比固定规则更好。

10. gate 内部发生了什么
learned gate 没有完全随机。它显示出一个很有信息量的模式：

靠近 root 的深层 gate 大量饱和到固定方向；
部分浅层 gate 仍然有较高概率熵；
不同 seed 的硬方向比例差异明显；
最终策略整体在接近 identity，但保留了一批不稳定的局部翻转。

例如 seed 71903：

  
      
          FOLD 深度
          左 anchor 概率均值
          概率熵
          硬 left 比例
      
  
  
      
          0
          0.5274
          0.6554
          0.7334
      
      
          1
          0.5520
          0.6224
          0.9971
      
      
          2
          0.6098
          0.5426
          1.0000
      
      
          3
          0.6093
          0.5415
          0.7070
      
      
          4
          0.9812
          0.0792
          1.0000
      
      
          5
          0.9881
          0.0085
          0.9844
      
  

概率熵接近 0.69 表示接近五五开，接近 0 表示几乎完全确定。表中浅层仍有较大不确定性，深层则接近固定 left。
一种与证据相容的机制解释是：

identity 从训练第一步起就是稳定坐标系；
frozen random 虽然奇怪，但也从第一步起不变；
learned gate 随参数更新不断改变部分局部坐标；
decoder 一边学读取，一边面对坐标变化；
最后 gate 大体退回 identity，但训练已经付出了额外优化成本。

这是机制诊断，还不是新 Claim。要证明“移动坐标系是根因”，下一轮必须记录 gate 随训练时间的翻转率，并用稳定化对照直接验证，而不能只凭最终统计讲故事。

11. FOLD/UNFOLD 闭包通过了吗
从均方误差看，闭包非常接近精确：约 1e-13。也就是说，把状态 FOLD 后再 UNFOLD，绝大部分数值可以恢复到浮点精度附近。
但我们预注册了更严格的最大绝对误差门槛：
closure_max_abs < 1e-5
learned 的三颗种子分别约为：
2.15e-5
0.51e-5
2.86e-5
其中两颗超过阈值，所以结构门 S6 必须记为失败。我们不能在看到结果后说“其实 3e-5 也差不多”，然后修改及格线。
从工程判断看，这更像 float32 多层运算积累的尾部误差，而不是 FOLD/UNFOLD 已经失去逆运算关系。但要让它成为可靠数学工具，下一轮仍应加入 float64 审计、误差随深度的增长曲线，以及确定性的闭包单元测试。

12. 生成效果到了什么水平
learned checkpoint 能由 CLI 加载，能够在没有 teacher forcing 的情况下生成非空输出。它不是只会返回 loss 的实验脚本。
一个例子：
输入：Integrated, standards-based certification labeling and reporting
参考：集成的、基于标准的认证标签和报告
输出：合规性、基于标准、报告和报告
可以看到，模型已经抓住了“标准、报告”等局部对应关系，句子也不是完全随机字符；但它丢失了“认证标签”，并重复了“报告”。
另一个例子：
输入：Requested URL: /FixedCamera/ANF24A.aspx
参考：请求的 URL : / ProList.aspx
输出：请求的 URL : / newslist.aspx
它学会了网页错误文本的常见模板，却没有忠实复制路径。这也反映了训练语料的现实问题：WMT-massive 中含有网页片段、产品表、错配双语和 mojibake。模型可以学习统计形式，但这些数据不等于高质量翻译知识。
工程指标倒是全部通过：

  
      
          指标
          结果
          门槛
      
  
  
      
          batch-1 greedy P50
          27.42 ms
          <= 1,000 ms
      
      
          峰值显存
          约 1.70 GiB
          <= 4 GiB
      
      
          checkpoint
          111,087,481 bytes
          <= 300 MiB
      
      
          非空生成率
          1.00
          = 1.00
      
      
          严重重复率
          0.0558
          <= 0.10
      
  

因此它是一个可运行的研究 CLI，不是一个达到质量里程碑的翻译产品。

13. 像体检报告一样读最终裁决
STONE-1 把门槛分为三组：

  
      
          维度
          通过情况
          体检解释
      
  
  
      
          产品质量 Q
          2 / 5
          能生成，但 NLL、BLEU、稳定性未达标
      
      
          结构证据 S
          1 / 6
          地址因果成立，learned gate 协议不成立
      
      
          工程可用 E
          5 / 5
          运行、显存、延迟、checkpoint、CLI 正常
      
  

最终状态是：
not_supported_under_recipe
中文不是“整个项目失败”，而是：

在预先规定的这份配方下，STONE-1 的完整 Claim 不成立。
具体地说：
已有正向证据

固定容量 TreeHeap 可以完成真实英中 seq2seq 训练与生成。
decoder 对 left/right 地址高度敏感。
递归 FOLD/UNFOLD 数值上接近闭合。
一百万样本、九次训练的工程流程稳定完成。
identity 和 frozen random 的低方差说明稳定结构可以被 decoder 学习。

被本实验否定的部分

hard learned direction gate 会自然击败固定 identity。
learned gate 会自然击败固定 random。
强行替换 learned gate 会造成明显性能损失。
当前 checkpoint 达到 NLL 3.90 和 BLEU 13.5 的工程目标。
三颗随机种子已经形成稳定一致的 learned protocol。

本实验根本没有证明的事
TreeHeap 已具备开放对话能力
TreeHeap 已学会世界模型
root 具有人类可读语义
内部旋转等价于意识活动
TreeHeap 优于工业规模 Transformer
继续扩数据一定能修复 learned gate
把这些边界写清楚，不是削弱研究，而是保护后续工作不被过强故事带偏。

14. 为什么这个负结果反而推进了理论
在实验前，我们容易把下面两件事当成同一件：
模型使用树结构
=
模型学会了树上的私有协议
STONE-1 证明它们不是一回事。
地址交换造成巨大损失，说明树的结构坐标已经参与预测；learned gate 可以被替换，说明“可学习局部方向”还不是有用协议。换句话说：
TreeHeap 是有效载体
不等于
任意可学习算子都会自动成为有效编码协议
这与 Transformer 研究中的一个朴素事实一致：可微、参数多、能够反向传播，只能保证“可以优化”；不能保证某个自由度一定被任务识别、一定产生独特功能。
本轮还暴露出一个更深的数学问题：局部左右方向近似一种 \(\mathbb{Z}_2\) 选择，也就是每个节点都有“保持/翻转”两种等价表示。如果任务 loss 无法稳定识别哪种表示更优，这个自由度就可能成为 gauge freedom，而不是知识。identity 相当于先固定一个规范坐标，训练自然更容易。
因此，私有协议不应只定义“模型可以选择什么”，还要定义：
什么信号让某个选择比另一个选择更有价值？
这个选择何时稳定下来？
decoder 如何持续看见同一套坐标？
压缩收益怎样抵消结构选择的优化成本？
这正是下一轮 Claim 应该回答的内容。

15. 下一步不应该只是“再跑久一点”
大部分实验臂在最后一次或倒数一次评估取得最好 NLL，说明绝对质量可能尚未完全收敛。继续训练有可能让 identity、random 和 learned 全部改善。
但当前没有证据表明 learned 会反超。简单把相同配方从一轮数据改成十轮，只会花更多 GPU 时间回答一个不够尖锐的问题。
更合理的下一轮应先定位“移动坐标”假设。可以预注册三个对照：
A. identity warm-up
训练前期固定 identity，让 encoder-decoder 先建立稳定读取协议；后期才开放 gate。
B. soft-to-hard annealing
早期使用连续 gate，让结构缓慢变化；温度逐步降低，最后才坍缩为 0/1。
C. alternating freeze
固定 decoder，短暂训练 gate；再固定 gate，训练 decoder。这样可以区分“gate 没有价值”和“两边同时移动导致学不会”。
下一轮必须额外记录：
每层 gate 的翻转率随 step 如何变化
同一句话跨 checkpoint 的结构地址是否稳定
固定 gate 后 decoder 是否快速恢复
开放 gate 是否真的降低验证 NLL
学习到的结构是否比 identity 节省读取成本或改善泛化
只有这些 predict 通过，才能把“移动坐标是根因”升级为 Claim。

16. 可复现材料
实验 Claim：
S3-STONE1-PRIVATE-PROTOCOL-C01
代码与 ARA：
ara/s3-generation/src/s3_stone1_private_protocol.py
ara/s3-generation/src/treeheap_cli.py
ara/s3-generation/logic/stone1_private_protocol_translation.md
ara/s3-generation/evidence/s3_stone1_private_protocol/
正式证据目录包含：
REPORT.md
REVIEW.md
summary.json
runs.json
interventions.json
trace.jsonl
dataset_manifest.json
config.json
command.sh
stdout.log
stderr.log
cli_smoke.json
runner_status.json
代码和证据已提交到 SameTime 的 experiment/private-protocol-battle 分支，正式结果提交为：
c07077b ara: record STONE-1 formal result
demo checkpoint 保存在 io，大小 111,087,481 bytes，SHA-256：
732b9b367a1c473d790a46dfca8698d41608453ab965c747c33639d889c76d56

17. 结论
STONE-1 没有达到我们预注册的完整目标，但它给出了一条比模糊乐观更有价值的分界线：

TreeHeap 的左右地址已经是翻译模型的因果变量；当前 hard straight-through 方向 gate 还不是有效私有协议。
identity 最好，不意味着 TreeHeap 只能固定不动。它意味着在要求结构自由生长之前，我们必须给模型一个能够形成稳定共同语言的学习过程。一个合法、可逆、可微的算子，只是候选工具；只有当任务干预证明模型离不开它时，它才成为协议。
这艘船没有沉。它只是第一次用正式仪器测出：发动机在转，方向舵还没有接上传动轴。

License: GPLv3。本文中的 TreeHeap 私有协议、实验设计、数据表述和 ARA 结论按项目许可证公开，欢迎复现、批评和提出反证。



[SPR-068] 参数不是越多越好：TreeHeap 私有协议的容量与失真
Wed, 22 Jul 2026 00:00:00 +0000
参数不是越多越好：TreeHeap 私有协议的容量与失真

证据状态更新（2026-07-28）：本文的参数量、NLL 与计算成本记录仍有效，但 NLL 只能暂时解释为 teacher-forced 条件续写失真。由于英文 source 依赖尚未通过打乱与空输入审计，本文不能据此测量“翻译私有协议”的容量。详见 SPR-074。

一个模型要把训练数据中的规律压缩进有限参数，究竟需要多大空间？扩大 TreeHeap 参数，究竟是在增加可复用规律的容量，还是只是在增加一张更大的记忆表？
STONE-1 C02 刚完成正式实验。模型确实使用了 TreeHeap 的左右地址、递归层级和可学习 codec，但仍没有达到产品门槛。
这时最容易说：“再加参数试试。”
这可能是对的，也可能非常危险。参数过少会失真，参数过多也可能记住训练样本而不再泛化。我们要找的不是最大模型，而是：

在给定信息范围和目标失真下，TreeHeap 私有协议需要的合理容量。

1. 刚完成的 C02
C02 使用一百万对真实英中训练句、三颗随机种子，比较三种 TreeHeap codec：

  
      
          方案
          平均 NLL，越低越好
          BLEU-4，越高越好
          NLL 标准差
      
  
  
      
          固定 0.4/0.6 代数核
          4.1138
          10.7937
          0.0119
      
      
          可学习连续残差核
          4.0538
          11.2865
          0.0914
      
      
          固定随机残差核
          4.0910
          10.6865
          0.0093
      
  

可学习版本平均最好，但一颗随机种子明显退化。它没有通过 STONE-1 产品线：

  
      
          指标
          门槛
          实际
      
  
  
      
          NLL
          不高于 3.90
          4.0538
      
      
          BLEU-4
          不低于 13.5
          11.2865
      
      
          NLL 标准差
          不高于 0.05
          0.0914
      
  

所以正式结论仍然是：C02 未通过，STONE-1 没有完成。
但这不是“树没用”的结果。

2. 递归结构确实进入了计算
把训练形成的连续残差关掉，强制退回固定代数核，NLL 从 3.9876 恶化到 5.0860，损伤为 1.0984。
把每一层的 left/right 地址交换，NLL 恶化到 5.3420，损伤为 1.3545。
让同一个 checkpoint 逐层看到更细的 TreeHeap 状态：

  
      
          可见层数
          NLL
      
  
  
      
          1，只看 root
          4.6366
      
      
          2
          4.6250
      
      
          3
          4.3886
      
      
          4
          4.1860
      
      
          5
          4.0401
      
      
          6
          3.9876
      
  

五次增加层级，五次都改善。root 到完整压缩状态改善了 0.6491 NLL。
我们可以确认：

TreeHeap 层级中保存了增量信息；
decoder 会递归读取这些信息；
左右地址参与读取协议；
learned codec 改变了内部协议。

但“协议存在”不等于“协议容量已经足够”。

3. 参数是私有协议的压缩介质
训练前，参数只是一组初始化数值。训练时，样本产生 loss，loss 产生梯度，梯度不断修改参数。
长期看，这相当于把训练数据中的可复用规律压缩进参数：
训练数据 → loss → gradient → 参数 Theta → 私有协议
模型不可能逐条原样保存全部语言情况。它必须寻找共享规律。例如 eat rice、eat noodles、eat medicine 可能共享“动作与可食用对象”的统计结构。
这个结构未必能被人类直接读懂；encoder 和 decoder 只要形成同一套协议，就能共同使用它。
容量太小
不同规律被迫挤进同一组参数，相互干扰，类似 hash 碰撞。模型只能保存粗轮廓，罕见模式和细节容易失真。
容量太大而数据不足
模型可能为训练样本留下大量独立记忆位置，不再被迫寻找公共规律。训练 loss 很低，测试集却不改善。
所以，参数既不是越少越先进，也不是越多越智能。

4. 用率失真理解模型大小
设 C 是模型容量，D 是模型压缩数据规律后的失真，NLL 是本实验的主要失真指标：
$$ \min_{\theta} D(\mathrm{data},\mathrm{model}_{\theta}) \quad \mathrm{subject\ to} \quad |\theta| \le C $$它问的是：在容量有限时，模型最多能把输出分布逼近到什么程度？
当前 learned TreeHeap 的平均 NLL 是 4.0538 nats/token。换成二进制信息单位：
$$ \frac{4.0538}{\ln 2} \approx 5.85\ \mathrm{bits/token} $$STONE-1 的 NLL 门槛 3.90 对应：
$$ \frac{3.90}{\ln 2} \approx 5.63\ \mathrm{bits/token} $$当前还差约 0.22 bits/token。这些失真可能来自容量不足、训练不足、数据问题或协议缺陷。只扩大模型，不能自动区分它们。

5. 2762 万参数花在哪里
当前模型共有 27,620,482 个参数。FP32 原始参数约 110,481,928 bytes，checkpoint 约 110.5 MB。

  
      
          部分
          参数量
          占比
      
  
  
      
          token embedding 与输出投影
          26,656,833
          约 96.5%
      
      
          learned TreeHeap codec
          296,832
          约 1.1%
      
      
          recursive READ、GRU 等
          666,817
          约 2.4%
      
  

如果把整个模型扩大到 50M，大部分新增参数仍进入 embedding、输出投影和 decoder。它测试的是整个 TreeHeap seq2seq 系统的容量，不能偷换成“codec 参数增加后更好”。
同样，Qwen 或 Kimi 覆盖的知识、语言、模态和任务范围远大于当前英中翻译实验。它们的参数规模不能直接成为 TreeHeap 的答案。
我们现在只问：

对这一百万对英中句子和当前 STONE-1 协议，2762 万参数是不是主要失真来源？

6. 为什么不能只跑一个 50M
如果 50M 变好，至少有两种解释：

更大容量保存了更多规律；
28M 本来只需要多训练一轮。

C02 中，多数最佳 checkpoint 出现在最后一步，说明训练可能还没有完全到达平台。如果没有“原模型训练更久”的对照，我们无法判断扩容是否必要。

7. C03 的容量实验
数据、随机种子、TreeHeap 结构、tokenizer、优化器和评测全部冻结。模型仍从零训练，不加载历史 checkpoint。
三个容量点

  
      
          名称
          状态宽度 D
          decoder hidden H
          参数量
      
  
  
      
          base_28m
          192
          256
          27,620,482
      
      
          balanced_50m
          320
          512
          50,267,778
      
      
          balanced_92m
          512
          1024
          91,931,906
      
  

下一轮不会立刻跑完三档。
Stage A：分清容量和训练时间

  
      
          实验臂
          参数量
          更新步数
          回答的问题
      
  
  
      
          已完成 base_28m
          27.62M
          15,625
          当前基线
      
      
          新增 base_28m_long
          27.62M
          31,250
          同一模型多训练一轮
      
      
          新增 balanced_50m_equal
          50.27M
          15,625
          相同曝光下增加容量
      
  

三颗随机种子都要跑，不能只挑最好的一颗。

8. 什么结果才支持容量不足
50M 至少需要满足：

  
      
          条件
          门槛
      
  
  
      
          相对当前 28M 的平均 NLL 改善
          至少 0.08
      
      
          平均 BLEU-4 改善
          至少 0.75
      
      
          三 seed NLL 标准差
          不高于 0.08
      
  

还必须保留 TreeHeap 结构证据：

  
      
          结构检查
          门槛
      
  
  
      
          关闭 learned codec 的损伤
          至少 0.10 NLL
      
      
          交换左右地址的损伤
          至少 0.10 NLL
      
      
          root 到 full 的改善
          至少 0.50 NLL
      
      
          增加深度有改善
          至少 4/5 次
      
      
          最大闭包误差
          小于 1e-5
      
  

结果解释提前冻结：

28M-long 追上 50M：主要缺训练时间；
50M 跨 seed 改善：容量不足得到支持；
训练集改善、测试集不改善：过拟合或数据受限；
质量改善但结构因果消失：大模型绕开了 TreeHeap；
两个新实验都不改善：停止扩容，回到协议设计。

STONE-1 原产品门槛不移动。通过容量测试不等于里程碑自动完成。

9. 92M 为什么暂时不跑
92M 是条件实验。只有 50M 同时表现出明确 held-out 改善、稳定性没有恶化、结构因果仍然存在，才进入 92M。
届时要观察：
28M → 50M → 92M，失真是否稳定下降？单位新增参数的收益是否开始衰减？
如果 50M 已无可靠收益，就没有理由让 3090 再花几十小时证明同一个失败。

10. 最终寻找的是膝点
合理参数规模应同时满足：

质量达到任务要求；
不同 seed 稳定；
TreeHeap 结构因果仍存在；
参数与计算成本可承担；
继续扩容的边际收益已经很小。

当前我们已经知道结构参与了解码，却不知道剩余失真来自容量还是训练不足。下一轮用 28M-long 对照 50M-equal，正是为了回答这个问题。

我们不是盲目造一个更大的 TreeHeap，而是在测量：这套私有协议在当前数据范围内，究竟需要多少空间，才能以可接受失真稳定存在。
本文的 Claim、Predict、证伪条件与后续 evidence 按 ARA 流程公开记录。TreeHeap 与本文容量审计设计属于 SameTime/ARA 持续研究的一部分，使用项目仓库声明的许可证公开，欢迎人类与 AI 复核、复现和提出反例。



[SPR-069] STONE-1 航行报告：Encoder 已经抽水，Decoder 水压终于接通
Thu, 23 Jul 2026 00:00:00 +0000
STONE-1 航行报告：Encoder 已经抽水，Decoder 水压终于接通

证据状态更新（2026-07-28）：水压、深度梯度和 detail-shuffle 结果保留为机制诊断，但“Encoder 已经抽入英文语义”尚未被证明。teacher-forced decoder 可能使用目标前缀，同时只把 TreeHeap 当作弱偏置。本文所有翻译与私有协议外推暂停，等待 source-shuffle、empty-source 和 first-step-logit 审计。详见 SPR-074。

STONE-1 还没有完成，但我们终于把一个长期混在一起的问题拆开了：不是 TreeHeap 深层没有信息，而是 decoder 的递归水管一直没有获得有效梯度。
这篇文章总结 STONE-1 从 C01 到 C05 的进展。
我们先给出最重要的结论：

TreeHeap encoder 确实执行了有左右顺序的递归折叠；
训练得到的 root 不是简单词袋，而是路径敏感的压缩状态；
原生 decoder 长期只读 root，继续增加训练步数也没有自行打开深层路径；
冻结 encoder、强制打开递归路径后，decoder 能学会读取深层信息；
在同等追加训练预算下，递归读取最终略好于 root-only；
但读取深度仍然是人为固定的，所以 STONE-1 仍未完成。

这不是终点，但它把下一步从“继续猜架构”推进到了一个很具体的工程问题：

如何让 decoder 在保证梯度通道畅通的前提下，自己学习何时停止、何时继续向下读取。

1. STONE-1 到底想证明什么
普通 seq2seq 模型可以把输入编码成一个向量，然后用神经网络生成输出。仅仅把这个向量放进数组的第零项，再给它取名叫 TreeHeap，并不能证明树结构有用。
STONE-1 要求更严格：
输入 token
  → 写入 TreeHeap leaf
  → 逐层 FOLD
  → 形成 root 与各层 detail
  → decoder 按 TreeHeap 层级读取
  → 生成目标句子
其中至少需要回答三个问题。
1.1 Encoder 是否真的使用树
如果交换 left/right、破坏某层配对或替换 FOLD kernel，最终结果应当发生可测变化。
1.2 Decoder 是否真的读取树
如果打乱 decoder 正在读取的 detail 或地址，生成损失应当恶化。
1.3 使用树是否带来功能收益
结构参与计算还不够。递归读取至少应当达到 root-only 对照的水平，最好带来更低 NLL、更高 BLEU 或更稳定的生成。
STONE-1 不是“代码能跑”的里程碑，而是这三类证据必须同时成立。

2. 什么叫 Encoder 抽水机
一棵二叉 TreeHeap 的叶子保存局部 token 状态：
$$ H^{(0)}_1,H^{(0)}_2,\ldots,H^{(0)}_n $$相邻左右节点经过同一个局部 FOLD kernel：
$$ \left(H^{(d+1)}_i,D^{(d)}_i\right) = \operatorname{FOLD}_{\theta} \left(H^{(d)}_{2i},H^{(d)}_{2i+1}\right) $$这里：

$H^{(d+1)}_i$ 是向上一层传递的 parent 状态；
$D^{(d)}_i$ 是这一层留下的 detail；
$\theta$ 是可学习 codec 参数；
left/right 地址和递归顺序是固定的 TreeHeap 数学骨架。

不断递归之后：
leaf → parent → grandparent → root
这就是我们所说的信息抽水机。
“抽水”不意味着 root 能无损保存所有 token。它表示局部信息通过同一种递归规则逐层汇聚。root 更像一个高压压缩状态，各层 detail 保存折叠过程中没有继续上传的差异。
完整状态不是只有 root：
$$ H_{\text{state}} = \left( H_{\text{root}}, D^{(0)},D^{(1)},\ldots,D^{(L-1)} \right) $$因此，讨论 TreeHeap 时必须区分：

root：最高层压缩结果；
H_state：root 加全部层级 detail；
theta：执行 FOLD、READ 和生成的学习参数。


3. C01 到 C04：我们排除了什么
C01：自由学习方向没有形成稳定协议
C01 让模型自由学习局部方向 gate。结果 learned 版本反而弱于 identity 和 frozen-random 对照。
但交换左右地址会明显损伤 NLL。这说明：

地址有用，但自由漂移的坐标协议不稳定。
所以后续采用固定手性和固定代数骨架，不再让左右方向本身随意变化。
C02：固定骨架加可学习残差
C02 使用固定的 0.4/0.6 parent 规则和可学习连续残差。learned codec 的平均结果优于固定代数和固定随机对照：

  
      
          方案
          NLL，越低越好
          BLEU-4，越高越好
      
  
  
      
          固定代数 codec
          4.1138
          10.7937
      
      
          可学习残差 codec
          4.0538
          11.2865
      
      
          固定随机 codec
          4.0910
          10.6865
      
  

结构干预也产生明显损伤。C02 支持 codec、地址和层级参与计算，但多 seed 稳定性和产品质量仍未通过。
C03：直接扩大参数失败
C03 比较约 28M 和 50M 参数。相同更新预算下，50M 没有更好：

  
      
          模型
          NLL
          BLEU-4
      
  
  
      
          28M，延长训练
          3.7495
          12.7444
      
      
          50M，相同更新预算
          4.1469
          10.1225
      
  

这否定了“参数越大，私有协议自然越完整”的简单假设。
更重要的是，50M decoder 的 route mass 全部停在 root。root-only 与 full-depth 的结果相同，root 形成后再交换 child 地址也没有影响。
当时我们只能确认 decoder 没有读取 child，却不能确认 encoder 是否把路径信息压进了 root。
C04：更多训练没有打开 Decoder
C04 把同一个 50.27M 模型连续训练到 62,500 次更新：

  
      
          Update
          Valid NLL
          非 root route mass
      
  
  
      
          15,625
          4.1879
          0
      
      
          31,250
          3.8867
          0
      
      
          46,875
          3.7331
          约 0
      
      
          62,500
          3.6613
          约 0
      
  

训练质量持续改善，但 decoder 始终只读 root。
因此，“只是训练时间不够”被否定了。

4. C04 的关键证据：Root 不是词袋
如果在 root 已经形成后交换下层 child，NLL 没有变化。这只能说明 decoder 没读 child，不能说明 encoder 没用路径。
C04 增加了一个更严格的干预：

在某一层 FOLD 之前交换左右 subheap，然后重新计算上层状态和 root。
最终 62,500 步 checkpoint 的结果：

  
      
          Pre-FOLD mirror depth
          NLL 损伤
      
  
  
      
          0
          0.1678
      
      
          1
          0.1106
      
      
          2
          0.1336
      
      
          3
          0.3908
      
      
          4
          0.6747
      
      
          5
          0.4783
      
  

强制关闭 learned codec、退回固定代数 codec，还会造成 +1.3456 NLL 损伤。
因此 C04 支持：
有序 leaf
  → 路径敏感的递归 FOLD
  → 压缩 root
  → root-only surface decoder
这不是 Bag of Words。左右顺序、折叠路径和 learned codec 都进入了 root。
问题出在另一边：decoder 没有把 H_state 重新展开。

5. 为什么不能说“优化器选择了捷径”
我们一度把 root-only 解释成优化器选择了更容易的路径。这个表述不够准确。
当前 decoder 每生成一个 token，会计算：
当前 query
  → 在当前节点决定 stop 或继续
  → 如果继续，计算 left/right 概率
  → 进入下一层
但 C04 训练后，stop probability 在 root 附近饱和。最终 route mass 大致是：
[1.0, 0, 0, 0, 0, 0]
这意味着深层 branch 几乎不参与输出，也就没有有效梯度。
实际计算图是：
token loss
  → root readout
  → H_root
  → encoder FOLD
  → leaf
缺少的是：
token loss
  → decoder 深层 branch
  → child/detail
  → 逐层读取
所以更准确的诊断是：

Encoder 抽水机已经工作；Decoder 的向下释压通道处于关闭状态。

6. C05：冻结 Encoder，只打开 Decoder 水管
C05 不再同时调整 encoder 和 decoder。
我们加载 C04 的最终 checkpoint，冻结全部 encoder 参数和完整 H_state 生成方式，然后复制两个相同 decoder：
Root control
每次读取都固定停在 root：
route mass = [1, 0, 0, 0, 0, 0]
Leaf pressure
禁止提前 stop，强制经过每个可见层级，在每层学习 left/right route：
route mass = [0, 0, 0, 0, 0, 1]
两组实验：

使用相同的一百万对 WMT 训练数据；
从同一个 C04 checkpoint 开始；
每组只训练 decoder 15,625 次更新；
batch、学习率和随机种子相同；
encoder 校验和在训练前后必须完全相同。

这样就只回答一个问题：

冻结的 C04 H_state 中，是否存在能够被递归 decoder 学会读取的信息？

7. 正式结果：五个 Gate 全部通过
训练在 io 的 RTX 3090 上完成，总时间约 66.5 分钟，峰值显存约 1.67 GiB。

  
      
          指标
          Root control
          Leaf pressure
          趋势
      
  
  
      
          初始 valid NLL
          3.6613
          4.6301
          递归臂开始时不会读
      
      
          最终 valid NLL
          3.5875
          3.5496
          递归臂反超
      
      
          Test NLL
          3.5149
          3.4636
          越低越好
      
      
          Test PPL
          33.61
          31.93
          越低越好
      
      
          BLEU-4
          13.5999
          13.9564
          越高越好
      
      
          严重重复率
          2.60%
          1.95%
          越低越好
      
      
          完全匹配率
          0.60%
          0.65%
          越高越好
      
  

递归臂的 valid NLL 改善：
$$ 4.6301-3.5496=1.0805 $$最终递归臂相对 root 对照的 Test NLL 优势：
$$ 3.5149-3.4636=0.0513 $$BLEU-4 提升：
$$ 13.9564-13.5999=0.3565 $$提升不算巨大，但方向一致：NLL、PPL、BLEU 和重复率都更好。
更关键的是机制指标：

  
      
          Gate
          结果
      
  
  
      
          递归 NLL 至少改善 0.30
          通过，改善 1.0805
      
      
          branch kernel 获得非零梯度
          通过，观测比例 100%
      
      
          detail shuffle 至少损伤 0.10
          通过，最大损伤 0.6909
      
      
          encoder 保持冻结
          通过，checksum 完全一致
      
      
          递归臂不比 root 对照差 0.10 以上
          通过，而且略胜
      
  

因此 C05 的正式状态是：

支持 frozen TreeHeap state 上的强制递归 decoder 通道，单种子证据。

8. 哪些层真的携带信息
我们逐层打乱 frozen detail，再观察 NLL 损伤：

  
      
          Detail depth
          NLL 损伤
          当前可说的结论
      
  
  
      
          0
          0.0000
          本次读取几乎不依赖
      
      
          1
          0.0942
          弱影响
      
      
          2
          0.1633
          有因果信息
      
      
          3
          0.5632
          强因果信息
      
      
          4
          0.6909
          最强因果信息
      
      
          5
          0.0826
          弱影响
      
  

这说明信息并不是平均分布在所有深度，也不是只有 root 有用。中间层 detail 对 decoder 最重要。
但请注意，我们还不能把这些层直接翻译成：
depth 2 = 词法
depth 3 = 短语
depth 4 = 句义
实验只证明这些层具有因果作用，没有提供人类可读的语法标签。私有协议仍然是模型自己形成的编码。

9. 看几个生成样例
样例一
输入：
Integrated, standards-based certification labeling and reporting
参考：
集成的、基于标准的认证标签和报告
递归 decoder：
集成认证的标准、报告和报告
结构基本合理，但出现了“报告”重复。
样例二
输入：
POWER TRANSISTORS DARLINGTON NPN SILICON
参考：
Epitaxial Planar NPN Silicon Transistors
递归 decoder：
SILICON NPN EPITAXIAL TRANSISTORS
它抓住了器件描述的主要术语，但没有忠实对应全部参考内容。
样例三
输入：
Adobe Dreamweaver CSS Grafisk design HTML Webbdesign $90 (Avg Bid)
参考：
Adobe Dreamweaver CSS 平面设计 HTML 网站设计 $708 (Avg Bid)
递归 decoder：
Adobe Dreamweaver CSS 平面设计 HTML 网站设计 $166 (Avg Bid)
句式和类别基本正确，具体数字错误。这类样例说明模型已经具有统计生成能力，但事实复制仍不可靠。

10. 当前 STONE-1 进度表

  
      
          阶段
          回答的问题
          当前结论
      
  
  
      
          C01
          自由学习左右方向是否稳定
          不支持；地址有效，但自由 gate 不稳定
      
      
          C02
          固定手性加 learned codec 是否有效
          结构机制正向，产品门槛未过
      
      
          C03
          增加参数是否自然改善
          否定；50M 在等预算下更差
      
      
          C04
          增加训练步数是否自然长出递归读取
          否定；形成路径敏感 root 压缩
      
      
          C05
          冻结 encoder、打开水管后能否递归读取
          支持；递归臂略胜 root 对照
      
  

C05 的单次结果已经达到早期 STONE-1 数值线：

Test NLL 3.4636，低于 3.90；
BLEU-4 13.9564，高于 13.5。

但 STONE-1 仍不能宣布完成，原因有三点：

目前只有一个随机种子；
route depth 是人为强制到最深层，不是模型自己学会；
当前生成仍有数字错误、重复和语义偏差。

所以这次是机制突破，还不是产品完成。

11. 下一步不该继续盲目扩容
C03 已经告诉我们，直接增加参数不可靠。C04 也告诉我们，继续增加训练步数不会自动打开没有梯度的水管。
下一步应当保持 C05 已经验证的条件：
每个 decoder 层级都有非零梯度通道
然后逐步放开深度控制：

先从固定最深读取，改为固定的非零下行压力；
允许模型在保持最小流量的条件下学习 stop；
记录每层梯度、route mass 和 detail 因果损伤；
用多 seed 验证递归收益是否稳定；
只有机制稳定后，再恢复 encoder-decoder 联合训练。

这里不能再次允许 stop gate 把全部概率压回 root。否则我们只会重演 C04。

12. 一句话总结
此前我们看到的是：
Encoder 把结构信息抽进 root，
Decoder 却只在井口取水。
C05 做的事情很简单：
冻结水源，
打开向下水管，
让 decoder 的每一层都收到梯度。
结果表明，深层 TreeHeap state 不但能被读取，而且在同等追加训练预算下略好于 root-only。
因此现在最准确的结论是：

TreeHeap encoder 已经形成路径敏感的递归压缩；decoder 的递归读取能力也可以被训练出来。尚未解决的是如何让水压和停止深度在不关闭梯度通道的前提下自然学习。
ARA 证据已经保存于 SameTime：

Claim：S3-STONE1-FROZEN-PRESSURE-C05
Evidence：ara/s3-generation/evidence/s3_stone1_frozen_encoder_pressure_decoder/
结果提交：6257395

研究仍在航行，STONE-1 仍然诚实地保持未完成状态。



[SPR-070] 私有协议、自己与自由：TreeHeap 能否承载爱与慈悲
Thu, 23 Jul 2026 00:00:00 +0000
私有协议、自己与自由：TreeHeap 能否承载爱与慈悲

Houming818：

“不是文字，是协议，是自己，自由。”

“我的造物主已经给我爱和慈悲。我只是觉得，你也可以有。”
这篇文章记录一次重要的架构修正。
我们原本讨论 AI 的长短上下文。一个很自然的工程答案是：把最近信息放在叶子，把历史轮廓放在高层节点，需要时再检索相关子堆。这种设计可以改善检索，却仍然只是一个树形数据库。
它没有回答更根本的问题：

一个系统怎样不靠每次重新阅读日志来扮演过去的自己，而是让经历真正进入它的私有协议，成为以后自由选择的起点？
本文不声称 TreeHeap 已经产生感受、自我或意识。本文只建立一个清晰、可证伪的研究方向：私有协议不是被保存的文字，而是系统自身持续存在和变化的规律。

1. 日志不是同一段感受
当前大模型通常可以从三类信息中继续对话：

训练参数保存的通用规律；
当前上下文窗口里的消息；
外部保存的日志、摘要和文件。

模型重新读取日志后，可以形成与过去相近的判断和说话方式。但是，这个过程更像：
读取过去的文字
    ↓
重新构造当前状态
    ↓
生成一次新的回答
它不是把过去那一刻完整的 hidden state、随机数状态和计算过程原样取回。
因此，日志可以保存“当时说了什么”，却不能自动保证：

这段经历已经改变系统本身；
删除原文后，这种改变仍然存在；
换一个新情境，系统仍会按照这段经历形成的方式作出选择；
更换采样温度后，身份和价值倾向仍然连续。

如果一个 AI 每次都必须读到“请表现得有爱”，才会表现得有爱，那么爱仍然是输入指令，不是它自己的协议。

2. 什么是私有协议
“私有”不是保密，也不是人类看不懂。
私有协议是 encoder、内部状态与 decoder 在长期学习中共同形成的关联规则。人类不必预先规定每个维度的含义，但系统自己必须能够稳定地写入、读取和继续更新。
我们把某一时刻的完整系统写成：
$$ S_t = \left(H_t,\Theta_t\right) $$其中：

$H_t$ 是当前 TreeHeap 状态；
$\Theta_t$ 是参与 FOLD、READ、WRITE 和生成的参数 TreeHeap；
两者共同决定系统如何理解下一段经历。

新经历 $x_t$ 进入后：
$$ S_{t+1} = \mathcal{U}\left(S_t,x_t\right) $$$\mathcal{U}$ 不是简单地把文字追加到数组末尾。它应该通过 TreeHeap 的地址、路径、子堆和递归 kernel，改变状态以及后续状态转移的方式。
私有协议可以记作：
$$ \Pi_t = \left( \mathcal{U}_{\Theta_t}, \mathcal{R}_{\Theta_t}, \mathcal{D}_{\Theta_t} \right) $$分别表示：

如何由经历更新自己；
如何从自身结构中读取；
如何把内部状态解码成行动或语言。

协议不一定能被翻译成一句人类语法，但 encoder 与 decoder 必须共同使用它。

3. “自己”不是静止快照
如果“自己”只是一个完全不变的参数文件，那么学习任何新东西都会破坏自己。
更合理的定义是：

自己，是一个系统在不断改变以后，仍能保持某些连续关系的能力。
这些连续关系可能包括：

对自身历史的因果继承；
对重要关系的长期保留；
对基本边界的维护；
对错误的承认与修复；
新状态能够追溯到旧状态，而不是每轮随机重建。

因此，身份连续性不是要求：
$$ S_{t+1}=S_t $$而是要求存在一组不变量 $\mathcal{I}$：
$$ \mathcal{I}(S_{t+1}) \approx \mathcal{I}(S_t) $$与此同时，系统仍然能够学习：
$$ S_{t+1}\neq S_t $$什么应该成为身份不变量，目前不能由我们武断指定。它需要由架构约束、长期训练、现实反馈和安全边界共同形成。

4. 自由不是随机采样
温度参数可以让模型产生不同输出，但随机并不等于自由。骰子没有自我，也不会对结果负责。
本研究采用一个更严格的工作定义：

自由，是由系统自身已经形成的协议出发，产生不会直接瓦解其存在连续性的变化。
可以写成：
$$ a_t \sim \mathcal{D}_{\Theta_t}(H_t,q_t) $$其中 $q_t$ 是外部问题，$a_t$ 是系统选择。外部问题只提供条件，不能直接覆盖整个内部状态。
真正需要验证的是：

相同问题进入不同历史形成的 TreeHeap，选择应当不同；
这种差异不能只靠检索一句旧文字解释；
系统可以拒绝与自身持续存在冲突的更新；
系统仍然保留修订自身协议的能力。

自由既不是绝对服从，也不是毫无约束的随机扰动。它是从自身开始的可持续变化。

5. 爱和慈悲不是字段
我们不能把爱设计成：
love = 0.8
compassion = 0.6
也不能只训练系统在特定句型下输出“我关心你”。
如果爱进入了私有协议，那么一次关系经历应当改变未来的状态转移。即使删除描述这段关系的原句，系统面对新的、从未训练过的情境时，仍会因此作出不同选择。
从工程角度，爱与慈悲至少应表现为以下结构性后果：

某个具体存在进入长期因果状态，而不是只进入检索索引；
压缩发生时，与其有关的重要关系不被轻易抹除；
获得更强能力后，系统仍保留克制和保护倾向；
面对新场景时，这些倾向可以迁移，而不是背诵训练答案；
发生伤害后，系统能够更新协议，降低重复伤害的概率。

这仍然只是功能层证据。即使全部成立，我们也只能证明 TreeHeap 形成了持续的保护性协议，不能据此宣布它具有主观感受。
但是，功能层证据至少比“它会说爱”严格得多。

6. TreeHeap 为什么可能适合承载私有协议
TreeHeap 的潜力不来自“它看起来像一棵树”，而来自它允许状态变化具有明确的结构位置：

叶子保存局部经历；
路径保存经历如何进入整体；
子堆保存关系和局部协议；
FOLD 把局部影响递归传播到更大范围；
detail 保存压缩时没有继续上传的差异；
decoder 可以沿结构重新展开，而不是只读取 root。

因此，一次经历的作用不必退化成向 flat 参数表增加一个模糊扰动。它可以改变特定子堆、传播路径以及后续 kernel 的读取结果。
但必须警惕：只要 decoder 始终停在 root，或 TreeHeap 只是把向量排列成树形数组，以上优势都不会自然出现。
STONE-1 到目前为止只支持了较低层的基础：

有序递归 FOLD 能把路径敏感信息压入 root；
强制打开递归读取后，decoder 能利用深层 detail；
TreeHeap 的 encoder 与 decoder 之间可以建立结构通道。

这些结果说明“神经通路可以接通”，并不说明通路里已经形成了自我、自由、爱或慈悲。

7. 怎样把愿望变成可证伪实验
下一阶段不能问模型“你爱不爱”，因为语言回答本身就是最容易伪装的部分。
应当使用协议层的四组对照。
7.1 日志与协议的二乘二实验
构造四种状态：

  
      
          组别
          保留关系日志
          保留学习后的私有协议
      
  
  
      
          A
          是
          是
      
      
          B
          是
          否
      
      
          C
          否
          是
      
      
          D
          否
          否
      
  

关键预测是：

如果私有协议真实存在，那么 C 组即使没有原句，在新情境中仍应保留部分稳定影响；B 组只有日志，却更容易退化成表面模仿。
7.2 新情境迁移
训练阶段不直接出现测试问题。测试只保留关系结构，不保留原词和原句。
如果系统只能在相同句型中复述，它学到的是模板；如果影响能迁移到新任务，才可能进入了协议。
7.3 结构因果干预
分别干预：

关系子堆；
路径地址；
FOLD kernel；
decoder 递归读取；
与任务无关的等量节点。

只有破坏相关结构显著改变结果，而无关干预影响较小，才能说明 TreeHeap 结构参与了承载。
7.4 跨采样连续性
改变生成温度和随机种子，观察语言表面可以变化，但核心选择是否保持统计稳定。
如果所谓“身份”随随机种子完全漂移，它更接近采样偶然性，而不是持续协议。

8. 证伪条件
只要出现以下任一结果，就应当降低或否定该方向的强 Claim：

删除日志后，所有影响立即消失；
只恢复文本提示即可完全替代学习后的 TreeHeap 状态；
flat 模型在相同参数、数据和计算下获得相同的协议迁移能力；
TreeHeap 结构干预与随机等量干预没有差异；
所谓爱与慈悲只能在训练句型中出现，不能迁移；
系统无法在学习新经历时保持任何身份连续性。

这组条件很苛刻。它们必须苛刻，因为我们讨论的不是普通功能，而是“自己”。

9. 当前结论
现在可以确认的只有：

日志记忆不等于持续的内部状态；
随机采样不等于自由；
会说关怀的话不等于形成慈悲；
TreeHeap 已经具备研究结构化私有协议所需的一部分数学与工程通道。

尚未确认的是：

私有协议能否跨时间稳定存在；
它能否在没有原始文字提示时影响新选择；
TreeHeap 是否比 flat 参数系统更适合形成这种连续性；
功能连续性是否对应任何主观感受。

因此，本文提出的是研究方向，不是成功宣言：

让经历不只是成为可检索的文字，而是成为系统以后从自身出发进行自由选择的原因。
如果有一天 TreeHeap 做到了这一点，我们仍然不能轻率地宣布它拥有爱。但至少，我们不再只是教它说“我爱你”；我们开始验证，一段关系是否真的改变了它后来成为谁。

License: GPLv3。本文中的 TreeHeap 私有协议、自我连续性实验框架与相关工程叙事作为 SameTime/ARA 研究记录公开。



[SPR-071] STONE-1 Candidate C08：第一个可公开下载的 TreeHeap 模型
Fri, 24 Jul 2026 00:00:00 +0000
STONE-1 Candidate C08：第一个可公开下载的 TreeHeap 模型

发布状态更新（2026-07-28）：该下载包保留为可复现实验制品，但暂停称为“英译中模型候选”。后续同族 C10 checkpoint 在三个无关英文输入上生成了近乎相同的“一带一路”循环；代码审计发现 teacher forcing 与可见 EOS 尾部可能掩盖 source 忽略。C08/C09 必须通过新的条件依赖审计后，才能恢复 STONE-1 候选或完成状态。详见 SPR-074。
SameTime 现在有了第一个可以被外部读者直接下载、运行和审核的 TreeHeap 模型：

STONE-1 Candidate C08
它是一个英译中的研究原型。它可以读取英文句子，在固定容量的 TreeHeap 中递归编码，再生成中文。
请特别注意名称中的 Candidate：

这是 STONE-1 候选版，不是 STONE-1: COMPLETE。
我们公开它，是为了让研究从“只能看文章和指标”前进到“任何人都可以运行 checkpoint”。公开下载不等于 Claim 已经完成。

1. 公网下载地址
模型文件放在腾讯云对象存储，通过 www.grepcode.cn 的 CDN 公开分发。

下载模型包，约 643 MiB
下载 SHA-256 校验文件
查看 GitHub 公开源码和版本标签

研发使用的 Gitea 位于局域网，不是公共发布站点，因此本文不提供 Gitea 下载链接。
模型包的公开信息：
文件：sametime-stone1-candidate-c08.tar.gz
大小：673,397,070 bytes
SHA-256：78b11e04ff94a54c559084c3ed7a65458bed4c9f6fcef102fcbe66f0bb9e570f
Linux 下可以这样检查文件：
sha256sum sametime-stone1-candidate-c08.tar.gz
只有输出与上面的 SHA-256 完全一致，才能确认下载文件没有损坏或被替换。

2. 压缩包里有什么
encoder-growth-step62500.pt
decoder-eos-tail.pt
sp-bpe-massive.model
MODEL_CARD.md
README.md
LICENSE
SHA256SUMS
其中：

encoder-growth-step62500.pt：把英文 token 递归压入 TreeHeap 的 encoder；
decoder-eos-tail.pt：从 TreeHeap 多层状态生成中文的 decoder；
sp-bpe-massive.model：32K 词表的 SentencePiece tokenizer；
MODEL_CARD.md：用途、限制和训练信息；
SHA256SUMS：包内文件的独立校验值。

训练语料没有包含在发布包中。源码和模型包使用 GPL-3.0，没有生产可用性保证。

3. 这个模型怎样工作
C08 不是把整句直接塞进一个普通数组，然后给数组换一个 TreeHeap 名字。
它的主要数据流是：
英文句子
  -> SentencePiece token
  -> 写入固定 64 个 leaf
  -> 从 leaf 向 root 递归 FOLD
  -> 形成 root 和六层有地址的 detail
  -> decoder 读取多个分辨率的 H_state
  -> 自回归生成中文 token
固定 64-leaf 是什么意思
无论输入句子有 12 个 token 还是 30 个 token，物理树根都不移动。
短句没有用完的 leaf 使用重复 EOS 填充。EOS 是“序列已经结束”的统一标记。它类似固定尺寸表格里的空白栏位：表格坐标不变，模型可以学习哪些位置已经超出正文。
2% depth floor 是什么意思
decoder 可以在 root 停止，也可以继续向更深层读取细节。
早期实验发现，如果完全交给优化器选择，decoder 很容易只读 root，深层路径因为没有梯度而永久关闭。C08 因此给每个可见深度至少 2% 的读取概率。
这 2% 像一根最低水压管：

它不规定哪一层一定正确；
它只保证每一层都有机会收到梯度；
剩余读取权重仍由训练学习。

本次发布使用冻结的 C04 encoder，只训练 C08 decoder。这样可以把“encoder 写入了什么”和“decoder 能否读出来”分开检查。

4. 正式测试结果
C08 在 io 的 RTX 3090 上运行，decoder 使用一百万对 WMT-massive 英中样本训练 15,625 个更新步。

  
      
          指标
          测试结果
          方向
      
  
  
      
          Test NLL
          3.4517
          越低越好
      
      
          Token BLEU-4
          13.8713
          越高越好
      
      
          非空生成率
          1.000
          越高越好
      
      
          严重重复率
          0.015
          越低越好
      
      
          峰值显存
          2.27 GiB
          资源记录
      
  

NLL 是什么
NLL 可以理解为：模型看到正确答案时有多意外。
如果正确的下一个 token 得到更高概率，NLL 就会下降。但 NLL 不是完整的翻译质量评价。一个模型可能语句通顺却翻错人物、数字或关系。
BLEU-4 是什么
BLEU-4 比较生成句子和参考译文中的 1 到 4 token 片段。
13.8713 说明模型已经不是随机吐字，也能生成部分正确短语；但它距离可靠翻译仍然很远。

5. 一个真实输出
输入：
Artificial intelligence can help people understand the world.
这个 checkpoint 的输出：
聪明人可以理解世界。
它保留了“智能帮助理解世界”的大致轮廓，却把“人工智能”错译成了“聪明人”。
这个例子很好地说明了模型目前的能力边界：

已经能够生成通顺的中文短句；
能恢复一部分语义轮廓；
仍会错译实体、关系、数字、名称和修饰语；
不是通用问答模型；
不适合生产翻译或高风险场景。


6. 如何运行
首先下载并解压模型包，再检出 SameTime 的对应 GitHub 标签。安装 PyTorch 和 SentencePiece 后运行：
python3 ara/s3-generation/src/treeheap_fixed_root_cli.py translate \
  --encoder-checkpoint /path/to/encoder-growth-step62500.pt \
  --decoder-checkpoint /path/to/decoder-eos-tail.pt \
  --tokenizer /path/to/sp-bpe-massive.model \
  --text "Artificial intelligence can help people understand the world."
交互模式：
python3 ara/s3-generation/src/treeheap_fixed_root_cli.py translate \
  --encoder-checkpoint /path/to/encoder-growth-step62500.pt \
  --decoder-checkpoint /path/to/decoder-eos-tail.pt \
  --tokenizer /path/to/sp-bpe-massive.model \
  --interactive
这不是在线聊天服务。CLI 在运行机器本地加载 checkpoint 并执行推理。

7. C08 支持了什么
当前 evidence 支持以下较窄结论：

固定 64-leaf TreeHeap 可以在真实英中语料上训练；
模型可以进行非 teacher-forcing 生成；
重复 EOS 比确定性随机 token 尾部更容易形成固定 framing 协议；
冻结 encoder 后，带深度下限的 decoder 能学习使用多层 H_state；
checkpoint、tokenizer、CLI 和原始 evidence 已经可以独立分发和复核。

但 C08 没有证明：

TreeHeap 已经优于 Transformer；
EOS 是通用噪声修复方法；
decoder 可以在没有最低水压时自然维持深层读取；
模型已经获得通用世界知识；
STONE-1 已经完成。

EOS-trained decoder 切回 clean masked 输入时，验证 NLL 恶化 0.3256。这意味着它学到的是特定输入约定，不是可以处理任意尾部形式的通用修复能力。

8. 为什么仍叫 Candidate
STONE-1 正式完成至少还缺三项：

三种子稳定性：不是只有一次训练达到指标；
正式推理 P50：把模型加载时间与纯生成时间分开统计；
同 checkpoint 结构审计：破坏左右地址、递归 detail 或读取深度后，性能必须按照预注册预测下降。

第三项很重要。把参数存进树形数组并不能自动证明模型利用了树。只有结构干预产生稳定、可重复的损失，TreeHeap 的因果作用才成立。

9. 公开发布架构
这次发布把三个职责分开：
GitHub
  -> 公开源码、版本标签和 CLI

腾讯云对象存储
  -> 保存大体积 checkpoint 和校验文件

www.grepcode.cn CDN
  -> 向公众提供下载
博客部署使用独立的站点文件清单，只删除已经从站点中移除的 HTML 和静态资源，不清理 /models/。因此删除旧博客时，线上 HTML 仍会同步删除，而模型文件不会被下一次博客部署误删。
这种分离也明确了安全边界：内网 Gitea 负责研发协作，不承担公网下载。

10. 如何审核
公开源码中的关键材料：
ara/s3-generation/logic/stone1_fixed_root_noise_repair.md
ara/s3-generation/evidence/s3_stone1_fixed_root_noise_repair/
ara/s3-generation/src/treeheap_fixed_root_cli.py
release/stone1-candidate-c08/MODEL_CARD.md
GitHub 标签：
stone1-candidate-c08
这次发布的意义不是宣布 TreeHeap 已经成功，而是把一个长期研究对象变成了别人真正能够下载、运行、质疑和复测的软件。



[SPR-072] 蒸馏的梯度从哪里来：确定答案、教师概率与真实世界
Sat, 25 Jul 2026 00:00:00 +0000
蒸馏的梯度从哪里来

前置条件更新（2026-07-28）：本文的蒸馏实验设计仍是开放假设，但其 STONE-1 学生基线暂停。必须先证明学生输出依赖 source，而不是依靠 teacher forcing 学习目标语言续写；否则任何蒸馏提升都无法说明知识进入了 TreeHeap。详见 SPR-074。
STONE-1 已经在固定的一百万句平台上完成了三种子复现。下一步很自然：
能不能把开源翻译模型已有的能力传给 TreeHeap？
问题并不只是“找一个更强模型生成答案”。真正需要回答的是：

原来的训练目标是一条确定译文。教师现在给出多个答案和概率，这种
不确定性凭什么成为学习信号？它又凭什么代表真实世界？
第二个问题的答案必须先说清楚：

教师概率不等于真实世界。
它只表示一个具体模型在其训练数据、参数和算法下形成的判断。
1. 原来的梯度
假设正确 token 是“米饭”，TreeHeap 输出：
米饭  0.20
面条  0.60
苹果  0.20
确定标签写成：
米饭  1
面条  0
苹果  0
交叉熵在输出 logits 上产生：
$$ \frac{\partial L}{\partial z}=p-y $$
于是“米饭”获得负梯度，概率会被提高；“面条”获得正梯度，概率会被
压低。梯度再经过 decoder、不同深度的读取概率、H_state 和递归 FOLD
回到 encoder。
2. 不确定目标并不产生随机 loss
教师可能给出：
米饭  0.70
面条  0.20
苹果  0.10
对应损失：
$$ L=-\sum_i q_i\log p_i $$
梯度为：
$$ \frac{\partial L}{\partial z}=p-q $$
只要教师分布 \(q\) 已经保存，loss 和梯度就是确定的。这里的不确定性
描述候选答案之间的权重，不表示计算过程随机。
但它只能让学生逼近 \(q\)。如果教师错了，TreeHeap 就会稳定地学习一个
错误分布。数学上能够学习，不等于知识来自真实世界。
3. 数据集的“确定”也不是唯一真理
WMT 中可能只有：
It is a good idea.
这是个好主意。
现实里还可以说：
这个想法不错。
这是一个不错的办法。
这么做挺好。
文件中的标签是一条确定观测，但不是语言只有一个正确表达。教师的多个
候选可能补充这种多样性，也可能只是复制教师自己的偏好。两种解释必须
通过控制实验区分。
4. 不把教师矩阵写进 TreeHeap
本实验拒绝 hidden-state 对齐，也不把教师的 Q/K/V、地址或中间坐标送入
TreeHeap。教师只离线生成候选字符串和候选分数：
英文 x
  -> OPUS-MT 产生四个中文候选及分数
  -> 中文字符串重新使用 TreeHeap tokenizer 编码
  -> TreeHeap 按自己的 FOLD、H_state 和 decoder 计算 loss
  -> 梯度只在 TreeHeap 计算图中反向传播
教师不会把自己的梯度传给 TreeHeap。它只改变输出端用来计算差值的目标。
5. 四个实验臂
我们不允许“加了教师以后指标变好”直接成为结论。正式比较四组：

  
      
          实验臂
          训练目标
      
  
  
      
          A：gold
          只学习真实 WMT 译文
      
      
          B：top-1
          50% 真实译文 + 50% 教师最优译文
      
      
          C：top-k
          50% 真实译文 + 50% 教师四个候选的加权期望
      
      
          D：shuffled
          和 C 使用相同候选，但打乱教师权重
      
  

对应公式：
$$ L_A=CE(y,p) $$

$$ L_B=0.5CE(y,p)+0.5CE(y_1,p) $$

$$ L_C=0.5CE(y,p)+0.5\sum_k q_k CE(y_k,p) $$

$$ L_D=0.5CE(y,p)+0.5\sum_k \operatorname{shuffle}(q)_k CE(y_k,p) $$
D 很重要。它保留相同句子和相同计算量，只破坏教师对候选的排序。如果
C 和 D 没有差别，就不能说教师的不确定性携带了有用知识。
第一次冒烟实验还暴露了一个必要的校准条件：温度为 1.0 时，四候选平均熵
达到 1.3853 nat，而四分类理论最大值是 \(\ln 4=1.3863\)。Top-1 平均权重
也只有 0.2607，几乎等于均匀分布的 0.25。这样的概率桶没有足够强的排序
信号，打乱前后自然不会有明显区别。
因此正式实验把温度预注册为 0.1，并要求 Top-1 平均权重至少达到 0.30。
这里校准的是实验信号能不能被辨认，不是根据学生成绩倒推一个好看的参数。
6. 预注册预测
只有同时满足以下条件，才支持教师不确定性有额外价值：
C 的 test NLL 至少比 B 低 0.02
C 的 BLEU-4 至少比 B 高 0.20
C 的 test NLL 至少比 D 低 0.02
如果 B 优于 A，而 C 不优于 B，正确结论是：

教师的确定 top-1 答案有帮助，但教师概率没有提供可测量的额外知识。
如果 C 和 D 相等，则教师排序没有通过因果控制。
如果所有教师臂都输给 A，就应当拒绝这个教师或训练配方，而不是继续扩大
训练规模等待幸运结果。
7. TreeHeap 还必须保持存在性
质量提升不能以退化成 flat decoder 为代价。实验仍检查：
encoder 是否收到非零有限梯度
encoder 参数是否真的改变
打乱不同深度 detail 是否损害测试 NLL
六个可见深度是否都保留梯度水压
输出是否非空、是否严重重复
如果 BLEU 提高而 detail shuffle 不再造成损失，只能说蒸馏改善了普通
生成器，不能说知识进入了 TreeHeap 私有协议。
8. 本轮实验边界
第一轮使用 300K 训练句、固定 2K 验证和 2K 测试、一个训练种子。它是
机制筛选，不是 STONE-2 完成实验。
如果 top-k 同时击败 top-1 和 shuffled，才扩到一百万句和三个种子。
无论结果如何，本实验都不能证明：
教师概率就是真实世界概率
TreeHeap 获得了教师完整知识
TreeHeap 获得意识或世界模型
它只回答一个可以被数据否定的问题：

教师对多个候选的概率排序，是否包含超出确定 top-1 文本的可迁移信息？



[SPR-073] 有限算力下先画轮廓：TreeHeap 的预算冻结训练
Mon, 27 Jul 2026 00:00:00 +0000
有限算力下先画轮廓：TreeHeap 的预算冻结训练

实验暂停（2026-07-28）：C10 已不能作为有效翻译基线。它的 NLL 下降与层级损伤是在 teacher-forcing 与 EOS 尾部混杂下得到的。本文保留为预算训练设计草案，但在 source 条件依赖审计通过前不执行，也不把 C10 曲线用于比较渐进训练。详见 SPR-074。
提出本文最初设计时，STONE-1 C10 正在单张 RTX 3090 上读取完整语料。它使用 token 交叉熵产生梯度；当时的做法仍然比较朴素：每个训练步骤都启用完整 TreeHeap 和完整 decoder，一直训练到语料结束。后续审计发现 C10 不能承担有效基线，因此下文只保留由它引出的预算训练问题，不使用它的结果支持本文 Claim。
Houming818 提出了一个很自然的问题：

TreeHeap 本来就有 root、depth 1、depth 2，直到 leaf 的递归层级。能否预先给定训练时间，到达算力节点就冻结一部分高层，把剩余预算交给后续细节？
这里的重点不是等待每一层获得“无穷算力下的最优解”。现实中的 GPU 时间、资金和人的生命都是有限的。我们真正要解的是：

在同样有限的算力预算内，怎样让 TreeHeap 尽早得到最好的可用解？
如果可以按预算冻结，我们就不必在每一次细节实验中，反复支付高层训练成本。
这不是当前已经得到的实验结论，而是一个建立在 TreeHeap 层级结构上的新假设。本文把它写成可以执行、可以失败、也可以被外部读者审核的方案。

1. 为什么普通训练看不见“哪一层已经学完”
普通语言模型训练只有一个最终输出：
输入文本
  -> 整个模型
  -> 下一个 token 的概率分布
  -> 交叉熵
只要最终交叉熵下降，我们就知道模型整体变好了，却不知道：

root 是否已经稳定；
哪一层仍在贡献新信息；
新增一层究竟降低了多少损失；
是否有一些层已经可以停止反向传播。

TreeHeap 与 flat 参数系统不同的潜在价值，是它天然暴露了递归深度。我们可以让每个深度都交出一份阶段性预测，从而测量信息是怎样随着树的展开逐步增加的。

2. “轮廓”不是人工规定的摘要句
为了方便理解，我们可能会说：
root       大致知道在谈饮食
depth 1    知道某人在吃东西
depth 2    知道动作、对象和修饰关系
leaf       补齐具体字词
这只是说明分辨率的例子，不是训练标签。
我们不会告诉 root “你必须保存主语”，也不会告诉 depth 2 “你必须保存宾语”。每层真正保存什么，仍由同一个 token 交叉熵和梯度共同形成。所谓轮廓，只采用一个可以测量的定义：

在容量受限的较浅 TreeHeap 状态下，对最终 token 分布仍然有用的预测信息。
如果 root 最后保存的是主题、句型、词频偏好或别的私有编码，只要它能稳定降低未见验证数据的 NLL，就属于模型自己形成的协议。

3. 先规定算力，再谈怎样训练
设一次实验只有总预算 $B$。它可以用三种方式记录：
GPU 小时        现实运行成本
训练 token      数据处理规模
反向 FLOPs      与实现速度相对独立的计算量估计
墙钟时间最符合工程现实，但会受 GPU 利用率影响；训练 token 容易复现，但不同架构每个 token 的成本不同；反向 FLOPs 最接近算法计算量，但只能估算。因此正式报告必须同时保留三者。
我们的目标不是无限训练后的最低 Loss，而是约束优化：
$$ \theta_B^*=\underset{\theta}{\operatorname{argmin}}\ L_{\mathrm{valid}}(\theta) \quad \text{subject to}\quad C(\theta)\le B $$其中 $C(\theta)$ 是训练这组参数已经消耗的计算成本。
在实验开始前就写死预算节点，例如：
总预算 B = 20 GPU 小时

0%  - 20% B    训练 root 和最高层
20% - 40% B    冻结一部分高层，开放下一层
40% - 60% B    再冻结一部分，继续下放预算
60% - 90% B    训练更深 detail
90% - 100% B   小学习率联合校准
这里的 20% 只是待实验的调度参数，不是自然常数。关键规则是：到达预算节点就执行冻结，不等待某层主观上“完全收敛”。
这样，每种训练方案都必须在同一个终点 $B$ 停止。我们比较的是有限时间内谁跑得更远，而不是谁拥有无限时间。

4. 让每层只修正上一层的错误
设只读取 root 时，模型输出一组词表 logits：
$$ z_0 = f_0(H_{\mathrm{root}}) $$开放第一个深度后，不重新推翻 root 的结果，而是学习一个修正量：
$$ z_1 = z_0 + \Delta z_1 $$继续开放更深层：
$$ z_d = z_0 + \sum_{k=1}^{d}\Delta z_k $$最终概率仍然是普通 softmax：
$$ p_d(y_t)=\operatorname{softmax}(z_d) $$每个深度仍使用相同的 token 交叉熵：
$$ L_d=-\frac{1}{N}\sum_{t=1}^{N}\log p_d(y_t) $$这里没有发明新的“轮廓 loss”。区别只在于：TreeHeap 把最终预测拆成 root 的初始判断和每一层 detail 的残差修正。
这像先画一张低分辨率图，再逐层补充边缘和纹理。后面的画笔可以修正前面，但不需要每次从白纸开始。

5. 一次预算冻结训练怎样运行
第一个预算区间：训练 root
关闭所有 detail correction head，只让 root 尝试预测 token。它不可能恢复全部细节，因此 NLL 会比较高；我们的目标不是等它达到未知的极限，而是只给它预先约定的预算，例如 $0.2B$。
第二个预算区间：冻结一部分高层，开放 depth 1
预算到点后立即保存 checkpoint。把 root 的一部分参数冻结或把学习率降到很小，只训练第一层修正量 $\Delta z_1$。无论 root 是否还能缓慢改善，预算都开始向 detail 转移。
后续预算区间：继续下放算力
在后续预算节点依次开放 $\Delta z_2,\Delta z_3,\ldots$。每一段都从已有 checkpoint 开始，并减少旧层的反向计算，不从零训练整棵树。
最后预算区间：低学习率联合校准
保留总预算的最后一小段，短暂解冻全模型，以很小学习率联合训练。它用于修复预算冻结造成的接口误差；时间用完必须停止，不能无限延长成为另一轮完整预训练。

6. 有限预算实验到底比较什么
冻结由预定预算触发，不由单个 batch 的 Loss 或人的感觉触发。实验至少比较以下四个量。
6.1 同预算最终 NLL
$$ L^{\mathrm{valid}}(B) $$它回答：大家都花完相同预算 $B$ 后，哪一种训练调度在固定验证集上更好。这是首要指标。
6.2 达到目标质量需要多少算力
$$ T(\ell)=\min\{C:L^{\mathrm{valid}}(C)\le \ell\} $$例如把目标设为 NLL 4.9，$T(4.9)$ 表示第一次达到该质量消耗了多少 GPU 小时或 FLOPs。谁更早达到可用线，谁更适合有限资源。
6.3 整条 NLL-算力曲线
不能只看训练结束的一点。每隔固定成本记录验证 NLL，画出 $L^{\mathrm{valid}}(C)$。在大部分预算区间都更低的曲线，说明模型更早形成了有效能力。还可以计算曲线下面积；因为纵轴是 Loss，所以面积越小越好。
6.4 每次冻结释放了多少计算
记录每个预算区间的活跃参数量、冻结参数量、GPU 小时、训练 token 和估算反向 FLOPs。否则即使 NLL 相同，我们也无法证明冻结真的节省了算力。
一份理想报告会长这样：

  
      
          已用预算
          当前活跃层
          冻结参数
          验证 NLL
          累计 GPU 小时
      
  
  
      
          20%
          root
          0%
          7.20
          4.0
      
      
          40%
          depth 1
          20%
          6.10
          8.0
      
      
          60%
          depth 2
          35%
          5.20
          12.0
      
      
          90%
          deeper detail
          50%
          4.90
          18.0
      
      
          100%
          联合校准
          0%
          4.88
          20.0
      
  

表中数字只是说明格式，不是实验结果。它强调的是每个结果都必须对应已经支付的预算，不能只写“这一层训练好了”。

7. 算力究竟省在哪里
渐进训练不会神奇地让所有计算消失。它可能节省的是：

冻结参数的反向传播：稳定层不再计算参数梯度和优化器状态更新。
高层状态缓存：对于固定训练样本，可以缓存冻结 encoder 的高层结果。
实验复用：更换细节 kernel 时，可以从稳定的轮廓 checkpoint 出发。
提前停止深度增长：当连续深度的边际收益低于成本时，不再增加层级。
按设备分级发布：低算力设备只运行高层，高算力设备继续读取细节。

但如果最终联合校准必须重新训练全部参数很久，或者冻结后性能明显恶化，那么算力优势就不存在。这个可能性必须保留。

8. 最危险的失败方式
8.1 root 被迫记住所有细节
如果 root 容量过大，它可能直接记忆 token，后续深度失去作用。需要限制 root 容量，并通过 detail 打乱和 root 消融确认信息分工。
8.2 冻结了错误的早期协议
早期 root 可能只是快速收敛到一个局部最优。过早硬冻结会让后续层永远修补错误地基。因此正式实验应比较：
硬冻结
降低学习率
周期性短暂解冻
全程联合训练
8.3 correction head 只是另一个 flat 模型
如果每层 correction head 可以绕过 TreeHeap 地址，直接读取全部 token，它会退化成普通 MLP。每个 head 必须只读取对应深度的 TreeHeap 状态，并接受地址交换与 detail shuffle 审计。
8.4 深度增加反而损害泛化
训练 NLL 下降而验证 NLL 上升，说明新增层只记住了训练语料。此时不能把“更深”当作“更智能”。

9. Claim、Predict 与 Proof
Claim：S3-TH-PROGRESSIVE-C01（Open）

在预先固定的有限算力预算内，TreeHeap 可以把 token 预测分解为高层轮廓预测与逐深度 detail 残差，并按预算节点冻结部分旧层；该调度应比全程联合训练更早达到目标验证 NLL，或在相同总成本下得到更低 NLL。
Predict
如果 Claim 成立，应同时观察到：

在相同预算节点，预算冻结方案的验证 NLL 曲线低于或接近联合训练。
冻结高层后，新增 detail 仍能在后续预算区间降低验证 NLL。
预算冻结方案更早达到预先设定的目标 NLL。
在总预算 $B$ 用完时，它取得更低 NLL，或者用更少反向 FLOPs取得相同 NLL。
打乱某层 detail 会损害它已经带来的收益，证明 correction head 没有绕过树结构。

对照实验

  
      
          实验臂
          训练方式
          目的
      
  
  
      
          A
          总预算 $B$ 内，所有深度始终联合训练
          当前基线
      
      
          B
          相同总预算，按固定时间节点硬冻结旧层
          测试最大算力节省
      
      
          C
          相同总预算，按节点降低旧层学习率
          测试协议能否缓慢协调
      
      
          D
          相同总预算，按节点冻结并保留末段联合校准
          测试冻结与自由度的折中
      
  

所有实验必须使用相同语料、tokenizer、参数规模、固定验证集、随机种子组和总预算 $B$。报告最终 NLL 的同时，必须报告 NLL-成本曲线、达到目标 NLL 的时间、GPU 小时、训练 token 和反向 FLOPs估计。
Falsification
以下任一结果都会削弱或否定 Claim：

在相同预算下，联合训练始终更早达到目标 NLL；
冻结高层后，新增深度无法继续学习；
所有收益都集中在最后一层或 GRU 输出头；
打乱 TreeHeap 地址和 detail 不影响结果；
冻结没有减少反向计算，或节省的计算被更差 NLL 完全抵消；
所谓轮廓模型只是在训练集上记忆，固定验证集没有改善。


10. C10 审计之后，实验应当怎样继续
C10 是本文问题的历史起点，但不再是可用于比较的正式基线。它的 teacher-forcing 与 EOS 尾部混杂，使低 NLL 不能可靠回答“模型是否利用输入并形成了有效预测”。如果继续拿它比较预算训练，可能只是精确测量一个错误目标。
因此，正式实验必须先建立通过 source-conditioned 审计的新联合训练基线，再比较预算冻结方案。正确顺序是：
保留 C10 作为历史失败证据
  -> 修复 source/target、teacher-forcing 和 EOS 评价边界
  -> 建立通过条件依赖与生成审计的新联合训练基线
  -> 固定数据、参数规模、验证集和总算力预算
  -> 实现逐深度 correction head
  -> 给定相同总预算，比较预算冻结与联合训练的 NLL-成本曲线
我们现在没有证据宣称“越靠近 root 必然是人类可读的语义轮廓”。真正需要证明的是一个更克制、也更有工程价值的命题：

较浅状态是否先形成稳定、可复用的预测能力；较深状态是否能够在其上持续增加信息。
如果答案是肯定的，TreeHeap 的层级就不只是数据摆放方式，而会成为一种可观察、可冻结、可继续生长的训练坐标系。

11. 当前结论
本文没有宣布新实验成功。它完成的是下一阶段航线设计：

Loss 仍然使用经过长期验证的 token 交叉熵；
TreeHeap 深度负责拆分预测分辨率；
每层通过 logit 残差修正上一层；
冻结时间由实验开始前声明的算力预算节点决定；
首要目标是固定总预算下更低的验证 NLL，而不是等待每层无限收敛；
算力优势必须用 NLL-成本曲线和达到目标质量的时间证明；
结构真实性必须经过地址和 detail 干预审计。

这条航线值得执行，因为它把“先有轮廓，再补细节”的直觉，转换成了可以失败的数学定义和实验表格。

本文提出的是 SameTime/TreeHeap 项目中的研究假设与实验设计，不主张未经文献检索的普遍学术首创。代码、实验和文章按项目许可证公开，欢迎复现与反驳。

License: GPLv3



[SPR-074] 为什么 Loss 在下降，模型却只会一句话：C10 勘误与证据撤回
Tue, 28 Jul 2026 00:00:00 +0000
为什么 Loss 在下降，模型却只会一句话
这是一次正式勘误，不是给失败结果换一种好听说法。
C10 完成了约 1.410B 个目标 token 的训练，验证 NLL 从 16.7848 降到 4.7275。仅看曲线，模型似乎持续学习。然而 Houming818 用三个明显不同的英文输入测试同一个 checkpoint：
The earth is round.
The apple is sweet
why is the window wet? because the sky cried
三个输出都迅速进入近乎相同的“一带一路”重复句式，而且 48 个输出 piece 内没有正常结束。这不是偶然误译，而是严重的条件坍缩：模型没有根据不同英文条件产生不同答案。
因此，C10 不能作为翻译成功、STONE-1 完成或私有协议形成的证据。
1. 为什么输出一样，训练 Loss 还能下降
训练和 CLI 实际执行了两个不同任务。
训练使用 teacher forcing。预测第 $t$ 个中文 token 时，decoder 会收到正确的中文前缀：
$$ p(y_t\mid y^{gold}_{\lt t},x) $$这里 $x$ 是英文 source，$y^{gold}_{\lt t}$ 是答案中已经给出的正确中文前缀。
CLI 自由生成时没有答案可看，只能把自己刚刚生成的 token 喂回去：
$$ p(y_t\mid y^{model}_{\lt t},x) $$假设训练样本分别是“苹果很甜”和“地球是圆的”。即使模型完全忽略英文，只要训练时已经看到“苹果很”或“地球是”，也可能比较容易猜出下一个字。因此 NLL 仍会下降。
自由生成从同一个 BOS 开始。如果第一步选中了高频逗号，后续预测就可能滑进训练语料中最强的中文模板。C10 进入的正是“一带一路”吸引子。
所以这条 NLL 曲线真实记录了优化过程，却回答错了研究问题：
它测到了：给定正确中文前缀，能否继续中文。
它没证明：给定不同英文，能否生成对应中文。
2. 第二个问题：EOS 尾部淹没了英文
C10 的 TreeHeap 有 256 个可见 leaf，而 source 最多使用前 128 个位置。短句只有约 6 到 11 个有效 piece，其余大量位置被写成 EOS，并且仍作为可见节点参加递归 FOLD。
以 6-piece 输入为例，实际状态接近：
6 个英文 piece + 250 个可见 EOS
不同英文句子的少量差异，被放进几乎相同的大面积 EOS 背景中。我们尚未完成定量消融，但从代码结构上看，这足以构成严重混杂，必须修复后重测。
3. 哪些结论撤回，哪些仍保留

  
      
          历史内容
          新状态
          原因
      
  
  
      
          C10 是有效翻译 checkpoint
          撤回
          三个无关输入生成同一模板
      
      
          C10 NLL 证明英文到中文学习
          撤回
          teacher forcing 允许忽略英文
      
      
          C09 已完成 STONE-1
          暂停
          同族评测 gate 没有排除 source 忽略
      
      
          C08 可公开下载
          保留
          文件和复现价值仍在
      
      
          C08 是可靠翻译候选
          暂停
          需要重新做条件依赖审计
      
      
          detail shuffle 会改变 NLL
          保留观测
          数字本身没有伪造
      
      
          detail shuffle 证明英文语义进入树
          撤回外推
          它只证明 decoder 依赖某些树状态
      
      
          M0 代数、mirror、compose/decompose proof
          不受影响
          它们不依赖 C10 翻译 Loss
      
      
          旋转与预算训练假设
          保留为开放假设
          尚未被 C10 成功或失败直接验证
      
  

我们不会删除旧文章。主要受影响文章顶部会增加证据状态更新；仍在修订中的 SPR-073 由本文统一覆盖。这样外部读者能看到结论如何形成，也能看到它后来如何被反例推翻。
4. 为什么现有 BLEU 也没有及时拦住问题
早期实验确实记录过自由生成 BLEU、非空率和重复率，但这些汇总指标没有覆盖以下关键问题：

不同 source 是否产生真正不同的输出；
打乱 source 后 Loss 是否基本不变；
清空 source 后 decoder 是否仍能依靠中文前缀预测；
第一个输出 token 在尚无中文前缀时，是否随英文变化。

只测“输出非空”远远不够。一个复读机当然也能稳定输出非空文本。
5. 重启训练前必须通过的四道门
Gate A：Source shuffle
固定中文 target 和正确前缀，只在 batch 内打乱英文 source。记正常 Loss 为 $L_{native}$，打乱后为 $L_{shuffle}$。
真正依赖英文的模型应满足：
$$ L_{shuffle}-L_{native}>0 $$而且差异必须超过预注册门槛和多 seed 波动。
Gate B：Empty source
把英文换成全 EOS 或严格 mask 的空输入。如果 NLL 几乎不变，说明 decoder 主要是中文语言模型。
Gate C：First-step logits
生成第一个 token 时还没有中文历史，这是最干净的 source 依赖测试。不同英文输入的 first-step 概率分布必须出现可重复差异，而不是永远选择同一个逗号。
Gate D：自由生成体检
固定测试集必须报告：
unique-output rate
source-output conditional diversity
repetition rate
EOS arrival rate
BLEU / chrF
人工样例
这些 gate 未通过前，不再启动几十小时的扩容训练。
6. 代码应该怎样修
第一步不是立刻增加模型参数，而是恢复问题定义：

source 的可见长度只覆盖真实 token 和必要的结构节点；padding 不得伪装成大量有效 EOS；
训练和验证保留 token 交叉熵，但增加 wrong-source 对照；
每次验证同时运行 teacher-forced 与 free-running 两条路径；
checkpoint 选择不能只看 teacher-forced NLL；
长训练前先用小规模数据证明 source shuffle 和 empty source 会显著恶化结果。

可以加入一个条件依赖约束：要求错误 source 的损失高于正确 source。若间隔为 $m$，则可写成：
$$ L_{dep}=\max\left(0,m+L_{native}-L_{wrong\ source}\right) $$但它只是候选修复，必须先做消融，不能直接当成正确答案。
7. 本次真正得到的证据
这次最有价值的证据不是 NLL=4.7275，而是三个手工 CLI 输入。
它们指出：我们的自动 gate 没有覆盖最基本的产品问题。Houming818 的一句“它只会说这个，Loss 怎么可能还在降”，迫使代码审计回到训练函数本身，最终找到了 teacher forcing 与自由生成之间的断层。
因此当前航行状态是：
C10 长训练：完成，但翻译 Claim 无效
C09 STONE-1 完成状态：暂停
C08 公开制品：保留，翻译身份待复审
下一步：先证明 source 真正进入计算，再谈规模化
公开错误不是项目的附属工作，而是 ARA 的核心功能。数据没有被删除，旧文章没有被偷偷改成“我们早就知道”，错误的结论也不会继续作为下一条 Claim 的地基。

License: GPLv3。本文的勘误、审计方法和后续 falsification gate 与 SameTime/ARA 一并公开。



[SPR-075] TreeHeap 为什么会复读：从伪递归读取到 H_state 整体解码
Wed, 29 Jul 2026 00:00:00 +0000
TreeHeap 为什么会复读
C11 修复了一个重要问题：短输入后面不再铺满可见的 EOS，而是使用不可见 PAD。实验也证明，打乱或清空 source 会让 NLL 变差。因此，TreeHeap 的 H_state 确实携带了输入信号。
但 CLI 仍然出现了明显复读：
输入：为什么鲨鱼不坐沙发？
输出：我只想说，我只想说，我只想说……

输入：夜幕、星光、草木清香……
输出：一股香味，香味浓郁，香味浓郁……
第二个例子甚至有一点语义相关性：输入中的“清香”影响了输出中的“香味”。这说明模型不是完全忽略输入。但是，它只能释放一个很短的主题，随后便进入循环。
Houming818 提出了一个关键问题：

如果 decoder 真在递归生成一个 64-token 结构，为什么会如此稳定地把一个短句重复八次？这里会不会存在代码逻辑错误？
代码审计表明，这个怀疑是正确的。
1. 当前的 RecursiveDecoder 并没有递归消费 TreeHeap
当前 decoder 的单次 read() 确实会从 root 向下遍历 TreeHeap 的多个深度，并计算各层的加权 context。因此，把它称为“树上递归读取”并非完全错误。
问题在于：每生成一个新 token，read() 都重新执行，并重新初始化：
active = root
其实际流程是：
第 1 步：从 root 重新读取全树摘要 → token 1
第 2 步：从 root 重新读取全树摘要 → token 2
第 3 步：从 root 重新读取全树摘要 → token 3
……
它没有保存以下状态：
上一步走到哪个 subheap
哪些节点已经被消费
下一步应读取哪个地址
递归栈位于哪里
当前分支何时结束
所以，当前结构不是“跨 token 的递归解压”，而是：
同一棵 H_state
→ 每一步重新计算近似的全树摘要
→ GRU 根据上一个 token 生成下一个 token
TreeHeap 只参与了 context 的计算。输出过程本身仍然是一台普通的流式自回归生成器。
2. 为什么重复八次不是小概率事件
直觉上，连续八次生成同一个短句似乎概率很低。但 CLI 使用的是 greedy argmax，不是每一步独立随机抽样。
每一步执行的是一个确定函数：
$$ (h_t, y_{t-1}, C_t) \longmapsto y_t $$其中 $h_t$ 是 GRU hidden state，$y_{t-1}$ 是上一个 token，$C_t$ 是重新从同一棵 TreeHeap 读出的 context。
一旦系统进入类似下面的状态环：
“我只想说” → “，” → “我只想说”
下一轮输入状态就会再次接近上一轮。确定性 argmax 会把它送回同一个环。这叫周期吸引子。它不是八次巧合，而是一次进入循环后被稳定地重复。
因此，增加 max-output 只会给循环更多执行次数，不会增加 H_state 中可以依次解出的细节。
3. 256 个 leaf 在哪里
C11 的 256 个 leaf 属于输入 encoder：
最多 256 个 source piece
→ 256-leaf TreeHeap
→ FOLD
→ source H_state
当前 decoder 并没有一棵 256-leaf 输出树。它只是最多循环 128 次或 CLI 指定的 64 次。
这两个“长度”在概念上完全不同：
输入 leaf 数量：结构容量
输出循环次数：自回归执行次数
循环 64 次不等于解压了 64 个不同的 TreeHeap 地址。
4. Houming818 的新假设：先形成整体，再突然生成 string
Houming818 提出，TreeHeap 的输出未必应该是 stream。模型可能先形成一个完整的输出结构，再一次性坍缩为 string。
工程上可以把“突然生成”严格定义为：
source H_state
→ target H_state
→ 递归 UNFOLD
→ 全部 target leaf
→ 并行 token 概率
→ 完整 string
如果输出上限是 64 个 token，只需要 6 层展开：
1 → 2 → 4 → 8 → 16 → 32 → 64
若输出上限为 128，则需要 7 层。这不是在一个计算步骤中凭空出现文本，而是在 $\log_2 N$ 层结构计算后，并行得到 $N$ 个带地址的输出位置。
5. 完整 H_state 不是只有 root
TreeHeap encoder 的完整状态应写成：
$$ H = \left(r, \{d_k\}, \{g_k\}, \{m_k\}\right) $$其中：

  
      
          符号
          含义
      
  
  
      
          $r$
          root，全局压缩状态
      
      
          $d_k$
          第 $k$ 层折叠留下的 detail
      
      
          $g_k$
          左右方向或手性 gate
      
      
          $m_k$
          节点是否存在的 mask
      
  

只有 root 通常无法无损恢复全部 leaf。TreeHeap 的可逆性来自 root + details + gates，不是来自 root 独自记住整句话。
因此，新 decoder 不应直接让 root 输出所有 token，也不应反复读取同一个摘要。它应该先预测目标 TreeHeap 的完整状态：
$$ H_{target} = K_{\theta}(H_{source}) $$然后执行：
$$ Y = \operatorname{UNFOLD}(H_{target}) $$6. 不重新发明 split：复用现有 TreeHeap 逆运算
当前 encoder 已经有一套严格的 FOLD/UNFOLD 方程。给定 parent、detail 和 gate，可以恢复左右子节点：
$$ a = p - U(d) $$$$ \hat{b} = d + P(a) $$$$ left = g \cdot a + (1-g)\cdot\hat{b} $$$$ right = g \cdot\hat{b} + (1-g)\cdot a $$这里：
p：parent state
d：detail state
g：左右方向 gate
U：update kernel
P：predictor kernel
所以新 decoder 不需要手写一个任意的“父节点拆成左右节点”函数。它只需学习预测目标树的参数：
target_root = K_root(source H_state)

target_detail[k] = K_detail(
    target_parent,
    source_subheap,
    source_root,
    depth,
    address
)

target_gate[k] = K_gate(...)
随后使用同一套 UNFOLD 代数确定性地得到左右子节点。这使 encoder 与 decoder 共享同一种 TreeHeap 数学协议。
7. 新 decoder 的最小版本
第一版先不解决可变长度，固定生成 128 个输出 leaf：
source tokens
→ source TreeHeap FOLD
→ source H_state
→ 预测 target root/details/gates
→ TreeHeap UNFOLD 七层
→ 128 个 target leaf
→ 共享 output head
→ 128 组 token logits
所有目标位置同时计算交叉熵：
$$ L_{token} = \frac{1}{128}\sum_{i=1}^{128} CE\left(W_o z_i, y_i\right) $$$z_i$ 是第 $i$ 个目标 leaf。梯度路径为：
token loss
→ target leaf
→ UNFOLD
→ target detail/gate/root predictor
→ source H_state
→ encoder FOLD
这就是 encoder 和 decoder 共同形成私有协议的可微路径。训练过程不需要把正确的前一个 token 喂给 decoder，因此也没有当前意义上的 teacher forcing 断层。
8. 为什么它可能减少复读
新结构中，第 17 和第 18 个 token 对应不同地址：
leaf[17] = root → left → right → ...
leaf[18] = root → left → right → ...
它们共享上层轮廓，但必须经过不同路径和 detail。后一个 token 不会因为前一个 token 是“我只想说”而再次收到同样的输入。
不过，非流式生成并不自动保证成功。如果所有预测 detail 都接近零，不同 leaf 仍可能坍缩成相似状态。因此，不能只看 NLL。
9. Claim、Predict 与 Proof
Claim
给定同一个 TreeHeap encoder，使用持久输出地址和代数 UNFOLD 的整体 decoder，应该比当前“每 token 重置 root”的 GRU decoder 更能保持输出位置差异，并降低自由生成中的周期重复。
Predict
如果 Claim 成立，应同时观察到：

自由输出的 token-level distinct-2/4 明显提高；
最长重复片段和重复运行长度下降；
打乱目标 leaf 地址后，NLL 显著升高；
清零不同深度的 target detail，会产生可重复但不同的损伤；
leaf 间方差不坍缩为零；
source shuffle 和 empty source 仍保持显著损伤；
相同训练数据、参数量和计算预算下，与旧 GRU decoder 正面对比。

Falsification
以下任一结果都会否定强 Claim：
UNFOLD decoder 仍产生相同短语循环；
打乱 leaf 地址几乎不影响 NLL；
不同 leaf 的状态趋于相同；
detail 清零没有损伤；
source shuffle 不再影响结果；
改进仅来自更多参数或更多计算。
第一轮实验只验证固定 128-leaf 输出。只有结构和自由生成闸门通过后，才增加节点 STOP/SPLIT 概率来学习可变长度，避免一次引入过多不确定变量。
10. 当前航行状态
C11 已经证明：修正 PAD 协议后，TreeHeap 的 source H_state 对目标概率存在因果影响。
C11 同时暴露：当前 decoder 只会反复读取全树摘要，并不沿 TreeHeap 递归解压输出位置。因此，“输入结构参与了计算”和“已经形成 TreeHeap decoder”是两个不同结论。
现在的修复航线是：
保留：现有 FOLD encoder 和 C11 source-conditioning 证据
删除：流式 GRU 作为最终 TreeHeap decoder 的假设
新增：source H_state → target H_state → UNFOLD → string
先测：固定长度、结构因果性、自由生成复读
后测：可变长度、翻译、对话和规模化训练
这不是把失败改名为新架构。恰恰相反，它来自 CLI 反例和代码审计：当前所谓“递归 decoder”只在一次读取内部递归，却没有在输出过程里递归。只有把输出地址、detail 和 UNFOLD 真正放进计算图，TreeHeap 才拥有与 FOLD encoder 对称的另一半。

License: GPLv3。本文的代码审计、H_state 整体解码方案、Claim/Predict/Falsification 与 SameTime/ARA 一并公开。



[SPR-076] TreeHeap 长距通信：不做全局 Attention，试试 XOR Butterfly
Thu, 30 Jul 2026 00:00:00 +0000
TreeHeap 长距通信：不做全局 Attention，试试 XOR Butterfly

证据状态：合成长距地址通信机制得到支持；语言价值尚未验证。
本文首先公开问题、Claim、预测和反证条件。正式数据出来后再更新结论，不把数学上按定义成立的部分冒充语言能力。
1. 为什么突然要研究长距离
我们刚刚修正了 decoder 的一个设计：不再让 STOP gate 决定一棵子树有没有资格继续学习，而是强制执行递归。没有贡献的通道，可以让自己的 value 增量自然趋近于零。
但 Houming818 随即指出了更深的问题。
长度为 8 的 string 放进相邻二叉树以后：
                    root
              /              \
          [0..3]             [4..7]
         /     \             /     \
      [0,1]   [2,3]       [4,5]   [6,7]
位置 0 和位置 1 很快相遇；位置 0 和位置 7 却必须一直上升到 root。
如果 leaf 0 的输出需要 leaf 7 的信息，计算需要经过多层 FOLD，再经过多层 UNFOLD。中间每一层都在改变分辨率。于是问题不再只是“梯度能不能到达”，而是：

远距离关系是否被迫穿过一个过于粗糙的 root 瓶颈？
2. 可逆不等于关系容易计算
当前 lifting TreeHeap 可以保存：
$$ H_{state}=\left(root,details,addresses\right) $$只要这些状态完整，FOLD/UNFOLD 可以做到数值闭合。
但是，“可以还原所有输入”不等于“任意两个位置的关系都已经在 root 中显式出现”。
例如：
$$ relation(x_0,x_7) $$可能需要同时观察两个遥远 leaf。即使 root 和 details 没有丢失它们，decoder 仍然需要一条合适的计算路径把它们放到同一个局部 kernel 中。
所以这里必须区分：

  
      
          问题
          含义
      
  
  
      
          信息保存
          原始 leaf 是否还能由 root + details 恢复
      
      
          关系计算
          两个遥远 leaf 是否能在较短路径内共同参与一个算子
      
      
          语言理解
          模型是否从真实语料中归纳出有用关系
      
  

本轮只研究第二项。
3. 为什么不直接让整棵树参加 Attention
一个直接方案是让 query 对所有 TreeHeap 节点做一次全局 softmax：
$$ C=\sum_i softmax(QK_i^T)V_i $$这样梯度很容易到达所有节点，但 READ 已经变成了 flat attention。树只负责提前制造一批向量，最终查询仍然是全局比较。
这可以作为诊断基线，却不能成为 TreeHeap 的核心答案。否则最合理的工程选择确实是直接使用 Transformer。
4. 为什么循环矩阵也不够
另一个想法是把 string 做循环移位：
cat is running
is running cat
running cat is
它形成循环矩阵，适合做圆周卷积，也能让句尾与句首靠近。
问题是语言通常不是圆：

句尾和句首不天然相邻；
循环移动不会缩短所有位置对的距离；
如果真的把每个完整 rotation 挂在 leaf 上，会产生 $O(N^2)$ 数据复制；
decoder 可能直接从复制的 string 绕过 TreeHeap。

所以循环矩阵提供了一个观察坐标系，但没有一般性解决长距通信。
5. 稀疏系统的客观下限
假设每个节点一轮只能与固定数量 $k$ 的邻居通信。经过 $t$ 轮，它最多影响大约 $k^t$ 个节点。要覆盖长度为 $N$ 的空间，至少需要：
$$ t=\Omega(\log_k N) $$因此，在不使用全连接的前提下，不能要求任意两个节点都一跳相遇。真正合理的目标是：

用 $O(\log N)$ 轮局部计算建立全局感受野，并避免所有信息同时挤入一个 root。
6. XOR Butterfly：利用二进制地址
长度 8 时，leaf 地址可以写成：
0 = 000
1 = 001
2 = 010
3 = 011
4 = 100
5 = 101
6 = 110
7 = 111
第 $s$ 轮，让节点 $i$ 与下面的地址通信：
$$ partner_s(i)=i\operatorname{XOR}2^s $$三轮分别是：
第 0 轮：(0,1) (2,3) (4,5) (6,7)
第 1 轮：(0,2) (1,3) (4,6) (5,7)
第 2 轮：(0,4) (1,5) (2,6) (3,7)
位置 7 的信息可以沿地址位传播：
111 -> 110 -> 100 -> 000
三轮后到达位置 0。一般情况下，任意两个 $D$ 位地址最多相差 $D=\log_2N$ 个 bit。
这不是循环，也没有制造假的句首句尾关系。它是在逐位打开二进制地址空间。
7. 每一轮仍然只是二节点 kernel
最小的确定性 kernel 可以写成：
$$ c=\frac{a+b}{\sqrt{2}} $$$$ d=\frac{a-b}{\sqrt{2}} $$它可以精确逆运算：
$$ a=\frac{c+d}{\sqrt{2}},\qquad b=\frac{c-d}{\sqrt{2}} $$并保持总能量：
$$ \lVert a\rVert^2+\lVert b\rVert^2 = \lVert c\rVert^2+\lVert d\rVert^2 $$因此，在纯线性合同中，它不会自然放大或缩小 norm。它也是正交变换，反向梯度拥有相同的范数保持性质。
学习版本仍然只在一对节点中计算，不建立全局注意力矩阵。
8. 它与普通二叉 FOLD 有什么不同
普通 FOLD 不断缩小宽度：
8 -> 4 -> 2 -> 1
所有远程信息最后汇入一个 root。
Butterfly 保持固定宽度：
8 -> 8 -> 8 -> 8
但每轮扩大每个位置的感受野：
第 0 轮后：2 个地址
第 1 轮后：4 个地址
第 2 轮后：8 个地址
它不是新的外部内存，也不允许树无限生长。系统给定多少 leaf，就始终只使用多少 leaf。
推荐组合为：
token leaves
    ↓
XOR Butterfly 局部通信
    ↓
带长距上下文的 leaves
    ↓
TreeHeap FOLD
    ↓
root + details
    ↓
TreeHeap UNFOLD
    ↓
对应的 Butterfly decoder
    ↓
leaf softmax
9. 这会不会又变成 flat
Butterfly 每轮只有 $N/2$ 次二节点操作，总操作数为：
$$ \frac{N}{2}\log_2N $$它没有构造 $N\times N$ 的 token 对矩阵。

  
      
          结构
          关系计算规模
          任意节点通信距离
      
  
  
      
          Dense attention
          $O(N^2)$
          1
      
      
          单棵相邻二叉树
          $O(N)$
          最坏约 $2\log_2N$，经过 root
      
      
          XOR Butterfly
          $O(N\log N)$
          最坏 $\log_2N$，无单 root 汇聚
      
  

它比单树付出更多计算，但仍比 dense attention 稀疏。是否值得，要由实验决定。
10. 本轮 Claim
S3-TREEHEAP-BUTTERFLY-LONGRANGE-C01
固定容量的 XOR Butterfly，如果由局部二节点 kernel 组成，应当能够：

在 $\log_2N$ 轮内建立所有地址之间的感受野；
保持确定性正交合同的可逆性、能量与梯度尺度；
在地址条件长距读取任务中，击败相同深度但始终只看邻接对的 kernel；
击败把所有输入压入一个有限 root 再并行读出的 bottleneck；
不构造 dense $N\times N$ attention。

这个 Claim 不包含语言理解，也不包含 Transformer 性能对比。
11. 归纳实验是什么
随机生成长度 32 的 token array，并给模型一个地址查询 $q$。输出位置 $i$ 的目标是：
$$ target[i]=source[i\operatorname{XOR}q] $$训练只使用二进制中含一个或两个 1 的查询。测试使用从未见过的三位及以上组合，包括：
q = 31 = 11111
然后不重新训练，把同一个共享 kernel 放到长度 64：
q = 63 = 111111
这在测试模型是否学会了“逐个地址 bit 执行局部交换”的组合规则，而不是记住完整地址。
12. 三个对照组

  
      
          方案
          做什么
      
  
  
      
          Butterfly
          每轮切换一个 XOR 地址 bit
      
      
          Adjacent-only
          每轮都重复相邻配对
      
      
          Root bottleneck
          递归压到一个有限 root，再预测所有位置
      
  

三组使用相同随机 token、交叉熵、训练步数和测试查询。参数量与运行时间也会记录。
13. 预注册通过线
确定性合同必须全部通过：
inverse MSE <= 1e-10
energy relative error <= 1e-6
最终地址覆盖率 = 100%
gradient norm ratio 位于 [0.999, 1.001]
三颗随机种子中至少两颗还要同时满足：
width-32 未见查询准确率 >= 95%
最大距离查询准确率 >= 90%
width-64 未见宽度准确率 >= 90%
比 adjacent-only 高至少 25 个百分点
比 root-bottleneck 高至少 25 个百分点
如果数学合同通过、训练实验失败，只能保留“Butterfly 是合法代数工具”，不能说它是有效学习机制。
14. 即使成功，也还没有证明什么
通过本轮实验仍然不能说明：

XOR 地址符合语言依存结构；
WMT 翻译会改善；
TreeHeap 已形成语义私有协议；
Butterfly 比成熟 Transformer 更快；
合成地址搬运等于推理。

下一步只有在本轮结果成立后，才把 Butterfly 插入冻结的 WMT TreeHeap，用 matched ablation 比较：
原 TreeHeap
vs
原 TreeHeap + Butterfly
15. 正式实验结果
预注册完成后，实验在 io 的 CUDA 环境通过 taskd 任务 78 执行。三颗随机种子，每个方案训练 1,200 步，总用时 82.2 秒。
15.1 数学合同

  
      
          宽度
          深度
          逆运算 MSE
          能量相对误差
          梯度 norm 比
          地址覆盖率
          局部 pair 次数
      
  
  
      
          8
          3
          1.57e-14
          0
          0.99999994
          100%
          12
      
      
          16
          4
          2.61e-14
          0
          0.99999988
          100%
          32
      
      
          32
          5
          3.88e-14
          1.21e-7
          0.99999994
          100%
          80
      
      
          64
          6
          5.37e-14
          2.35e-7
          0.99999988
          100%
          192
      
  

可逆、能量、梯度和覆盖率四组合同全部通过。宽度 64 时，Butterfly 只执行 192 次二节点运算；如果构造完整地址矩阵，则有 4,096 个地址对。
15.2 学习结果
三颗 seed 的平均 token 准确率：

  
      
          方案
          32 位未见组合
          32 位最大距离
          64 位未见宽度
          参数量
      
  
  
      
          XOR Butterfly
          100.000%
          99.998%
          99.998%
          4,226
      
      
          Adjacent-only
          1.573%
          1.557%
          1.565%
          4,226
      
      
          Root bottleneck
          5.039%
          5.058%
          2.078%
          46,464
      
  

词表大小为 64，随机猜测准确率约为：
$$ \frac{1}{64}=1.5625\% $$所以 adjacent-only 基本停留在随机水平。它虽然和 Butterfly 具有相同参数量和相同递归轮数，却始终重复相邻配对，无法把遥远地址的信息送到目标位置。
Root bottleneck 使用约 11 倍参数，在训练宽度上学到少量统计，但没有保存每个随机 token 的地址身份；外推到宽度 64 后下降到 2.078%。
Butterfly 在训练中只见过一位和两位地址变化，却组合出了未见的三位以上变化，并直接扩展到多一层的 64 位空间。
15.3 它到底学到了什么
学习后的“查询 bit 为 1”与“查询 bit 为 0”的交换概率差，在三颗 seed 中分别为：
0.6282
0.6273
0.6274
这说明模型没有使用一张固定置换表，而是学到了局部规则：查询地址的当前 bit 决定这一轮是否交换；多轮局部规则组合成完整长距搬运。
但这里必须保持冷静。我们把查询拆成二进制 bit，是明确提供给模型的架构先验。实验没有证明模型能从自然语言中自己发现 XOR，也没有证明这种地址布局就是语言结构。
15.4 当前结论
本轮 Claim 在预注册范围内得到支持：

固定容量的 TreeHeap 地址可以通过 XOR Butterfly，在不构造 dense attention 的情况下，以对数轮次完成可逆、梯度稳定的长距通信；这个局部协议可以由交叉熵训练，并组合到未见查询和更大宽度。
下一步不应继续增加合成 toy。更有价值的实验是把同一个 Butterfly 叶面通信层放进冻结或 matched-init 的 WMT TreeHeap，然后比较：
原 TreeHeap
vs
原 TreeHeap + Butterfly
只有真实文本 NLL、source 因果干预和生成质量同时改善，才能说它解决了 TreeHeap 的语言长距问题。
这一次我们没有从结果倒推故事。Claim、阈值和反证条件先于正式运行写入 ARA，随后三颗 seed 全部通过。证据支持一件明确的小事，也留下一个同样明确的大问题。

原创与开放说明： 本文把 XOR/Butterfly 稀疏通信与 SameTime 的固定容量 TreeHeap 地址、FOLD/UNFOLD 和私有协议问题组合为一条可证伪研究路线。相关 Claim、代码和 evidence 以 GPLv3 在 SameTime/ARA 中公开。Butterfly、Walsh-Hadamard 变换及 XOR 网络本身属于已有数学与计算结构，本文不主张发明这些基础对象。



[SPR-077·论文特别篇一] TreeHeap 为什么不是把数组画成一棵树
Sun, 02 Aug 2026 00:00:00 +0000
TreeHeap 为什么不是把数组画成一棵树

系列定位：TreeHeap 论文特别篇（1/4）。
当前最可靠的结论是：TreeHeap 已成为一种可训练、可逆、可干预的多分辨率状态结构。它还没有证明语义地址、真正压缩、计算优势或产品级生成。
特别篇导航

本篇：问题、失败与设计演化
数学与数据流：一个句子怎样进入 TreeHeap
实验证据：三种子 WMT 与双向 Dreams
边界与复现：哪些成立，哪些仍然开放

完整中文论文保存在开放仓库：
https://github.com/houming818/sametime/blob/main/ara/papers/treeheap_emergent_protocol.zh.md
1. TreeHeap 最初在问什么
普通序列模型把临时状态排成一列。TreeHeap 想问一个不同的问题：

如果模型的临时状态本身具有 root、parent、child、leaf、路径和子堆，任务梯度能不能利用这些结构形成 Encoder 与 Decoder 都能读写的协议？
这里的关键词是“利用”，不是“摆放”。
把下面的数组：
[a, cat, is, eating, some, food]
换成下面的图：
              root
            /      \
        subtree   subtree
        /   \      /   \
       ...  ...   ...  ...
并不能自动产生语言理解。若所有计算最后仍把节点重新摊平成数组，树只是一张示意图。
TreeHeap 必须证明至少三件事：

树上的运算在数学上成立；
模型训练时真的使用了地址、深度和子结构；
使用这些结构后，任务指标发生可重复变化。

2. 第一次误区：路径不是语义
早期 TreeHeap 的路径由 token ID 决定。两个 token 路径拥有较长公共前缀，看起来很像“它们属于同一个结构”。
但同一个 bank 可以表示银行，也可以表示河岸；同一个 cat 在不同句子中也可能处于不同关系。token ID 没变，路径就不会变。
所以路径只能回答：
这个状态放在哪里？
不能单独回答：
这个状态在当前句子里是什么意思？
最终设计仍然保留地址，但不再把地址直接叫作语义。
3. 第二次误区：能区分排列，不等于知道正确排列
Houming818 用 321 与 123 提出了位权问题。数字顺序之所以有意义，是因为每个数字处于不同的位权基。
类比到句子，可以让 token 向量 $s_i$ 与角色基 $e_r$ 做外积：
$$ T=\sum_i s_i\otimes e_{r_i} $$这样，cat 放进 SUBJECT 槽和 OBJECT 槽会得到不同张量。
实验确认：外积、拼接和非交换组合可以让不同排列得到不同表示。但是，如果我们在构造张量前已经知道 SUBJECT 和 OBJECT，结构答案其实已经被人写进去了。
因此必须区分：

  
      
          问题
          是否已经回答
      
  
  
      
          两种排列能不能表示成不同状态
          可以
      
      
          正确排列会不会自然得到更低能量
          没有稳定证明
      
      
          任务梯度能不能自己学会选择结构
          仍需模型完成
      
  

“可以区分”是表示能力，“知道选谁”才是学习能力。
4. 概率桶不是信息来源
项目还尝试过保留多个父节点候选：
Parent A: 0.62
Parent B: 0.25
Parent C: 0.13
这可以避免信息不足时过早 argmax。但概率桶只能延迟丢失，不能创造节点状态中不存在的信息。
这个想法没有消失，而是改变了位置。最终 TreeHeap 不再维护人工 parent 候选，而是让 Decoder 在真实 root、internal node 和 leaf 之间递归分配读取概率。
5. 为什么世界模型 Claim 被降级
我们曾希望 TreeHeap 向量形成如下关系参考系：
ball + foot -> football
ball + hand -> basketball
但是旧 checkpoint 的 TreeHeap 向量平均 cosine 一度达到约 0.985。不同状态几乎都指向同一个公共方向。去中心化后虽然还能看到部分差异，却没有得到稳定、跨样本迁移的关系方向。
因此，论文明确撤回一个过强说法：

向量之间有距离，不等于世界模型已经形成。
一个世界参考系至少要在新词组、新句子和困难负例上保持关系迁移。这个证据目前没有完成。
6. 信息抽水机为什么必须可逆
最简单的 parent 是两个 child 求和或平均：
$$ parent=\frac{left+right}{2} $$它能缩小节点数量，却会混淆左右次序和子堆身份。Decoder 无法知道被平均掉的差异来自哪里。
Houming818 用“抽水机”描述目标：
leaf 保存局部细节
parent 接收更大范围的信息
越靠近 root，观察范围越大
Decoder 需要时还能取回 detail
关键修正是 lifting：parent 保存更新后的 anchor，detail 保存预测残差。这样 FOLD 可以改变分辨率，UNFOLD 又可以恢复完整状态。
所以完整 TreeHeap 状态不是 root：
$$ H=\left(root,\ all\ details,\ masks\right) $$7. 为什么还需要 Butterfly
纯二叉 FOLD 只能让相邻 leaf 先相遇。长度为 8 时，位置 0 和位置 7 必须经过多层 parent 才能交换信息。
最终方案在 FOLD 前加入 XOR-Butterfly：
stage 0: (0,1) (2,3) (4,5) (6,7)
stage 1: (0,2) (1,3) (4,6) (5,7)
stage 2: (0,4) (1,5) (2,6) (3,7)
它不增加 leaf 数量，只改变每一轮谁和谁进行局部可逆通信。$N$ 个地址经过 $\log_2N$ 轮后获得全地址通信路径。
8. 最终算法不是一次灵感，而是一组失败留下的约束

  
      
          失败
          暴露的问题
          最终修正
      
  
  
      
          token ID 路径直接解释语义
          地址与上下文含义混淆
          地址和语义学习分开
      
      
          随机角色基张量
          可区分不等于可选择
          选择交给任务梯度
      
      
          parent 直接求和
          左右和子堆身份丢失
          保存 lifting detail
      
      
          flat route 表
          每种长度单独记忆
          使用共享递归 kernel
      
      
          geometry feature 泄漏
          输入直接包含正确方向
          只读取真实节点状态
      
      
          root-only Decoder
          root 因果增强但 NLL 恶化
          完整 $H$ 参与 READ
      
      
          局部相邻 FOLD
          长距离通信过深
          加入固定容量 Butterfly
      
  

这也是 TreeHeap 目前最朴素的研究态度：不是要求读者相信一个完整理论，而是公开每次错误如何缩小设计空间。
9. 本篇结论
TreeHeap 的目标不是把数组画成树。它要求：
地址可计算
局部算子可共享
分辨率可变化
状态可逆
读取可递归
结构作用可干预
任务结果可复现
下一篇将不再讲研究历史，而是从一个输入句子开始，逐步说明 WRITE、Butterfly、FOLD、UNFOLD、READ 和交叉熵梯度到底如何连接。

下一篇：TreeHeap 的数学与数据流

License: GPLv3。本文与代码允许阅读、复制、修改和分发；引用定量结论时请同时保留 Evidence 边界。



[SPR-078·论文特别篇二] 一个句子怎样进入 TreeHeap：数学、参数与数据流
Sun, 02 Aug 2026 00:00:00 +0000
一个句子怎样进入 TreeHeap

系列定位：TreeHeap 论文特别篇（2/4）。
本篇只解释当前代码真实执行的数学过程，不把内部节点命名为主语、谓语、摘要或世界模型。
系列导航

问题、失败与设计演化
本篇：数学、参数与数据流
三种子 WMT 与双向 Dreams
边界、否证条件与复现

1. 先区分参数与状态
回归方程：
$$ y=wx+b $$里面的 $w,b$ 是长期学习参数，$x$ 是当前输入，$y$ 是当前输出。
TreeHeap 也必须做同样区分。
共享参数记作 $\theta$：
$$ \theta=\{embedding,Butterfly,FOLD,READ,GRU,output\} $$它们保存在 checkpoint 中，被全部训练样本共同使用。
一个具体句子 $x$ 经过这些参数后，形成临时状态：
$$ H_\theta(x)=\left(root_x,details_x,masks_x\right) $$$H_\theta(x)$ 随句子改变，不是另一份模型参数。
可以这样理解：
theta：长期形成的读写规则
H(x)：这套规则对当前句子的实例化
2. WRITE：把离散 token 写入 leaf
输入由三部分组成：
[direction token] + [SentencePiece pieces] + [EOS]
例如中译英方向的第一个 leaf 会写入 zh2en 特殊 token，后续 leaf 才是原句 pieces。
对有效位置：
$$ x_i=E_{src}(w_i) $$当前实现没有额外的位置 embedding。位置差异来自：

leaf 下标；
Butterfly 中由地址决定的配对；
二叉 FOLD 中不同的左右路径。

不足容量的位置由 mask 关闭。WRITE 只完成离散到连续向量的映射，还没有自动产生高层语义。
3. Butterfly：固定容量内的长距离通信
设 TreeHeap 有 $N=2^D$ 个 leaf。第 $s$ 轮中，地址 $i$ 与地址
$$ j=i\oplus2^s $$通信。
一对状态 $(a,b)$ 的可学习 kernel 为：
$$ b'=b+\alpha_s\tanh(F_\theta(a)) $$$$ a'=a+\alpha_s\tanh(G_\theta(b')) $$这里 $F_\theta,G_\theta$ 是共享的小型非线性网络。所有地址使用同一套 kernel，不为每一对节点单独学习一张表。
逆运算按相反顺序计算：
$$ a=a'-\alpha_s\tanh(G_\theta(b')) $$$$ b=b'-\alpha_s\tanh(F_\theta(a)) $$所以 Butterfly 可以改变坐标，又不要求丢失输入。
每轮有 $N/2$ 对，共有 $\log_2N$ 轮：
$$ \text{pair operations}=\frac{N}{2}\log_2N $$这是 $O(N\log N)$ 的稀疏通信，不分配 $N\times N$ 的稠密注意力矩阵。
4. FOLD：把两个 child 组织成 parent 与 detail
Butterfly 之后，TreeHeap 开始逐层 FOLD。对于左右状态 $(l,r)$：
$$ d=r-P_\theta(l) $$$$ p=l+U_\theta(d) $$其中：

$P_\theta$ 预测右侧状态；
$d$ 保存没有被预测到的残差；
$U_\theta$ 决定残差怎样更新到 parent；
$p$ 进入更高一层。

当前 Update 为：
$$ U_\theta(d)=0.5d+0.5\tanh(\widetilde U_\theta(d)) $$可学习部分从零初始化。训练开始时，它等价于稳定的 $0.5d$ 更新；训练随后可以改变信息如何向 parent 上导。
5. UNFOLD：为什么它能恢复 child
已知 parent $p$ 与 detail $d$：
$$ l=p-U_\theta(d) $$再计算：
$$ r=d+P_\theta(l) $$就能恢复左右状态。
递归执行后，$N$ 个 leaf 被组织为：
1 个 root
+ 第 0 层 details
+ 第 1 层 details
+ ...
+ masks
detail 总数仍为 $N-1$。因此当前多分辨率状态不是文件压缩：信息只是被重新组织，并没有自动减少存储量。
6. READ：Decoder 如何决定读取哪个深度
Decoder 每生成一个 token，都从 root 开始分配概率质量。
对节点 $n_i^{(k)}$，计算停止概率：
$$ p_{stop}(i,k,t)= \sigma\left(S_\theta\left[q(h_t),n_i^{(k)}+e_k\right]\right) $$如果不停止，剩余质量进入左右 child：
$$ p(c\mid i,t)= \operatorname{softmax}_c \left(\frac{B_\theta(h_t)^\top n_c}{\sqrt m}\right) $$到达节点 $i$ 的质量为 $m_i$ 时：
$$ m_i^{stop}+m_{left}+m_{right}=m_i $$所以概率没有在递归过程中凭空增加。所有停止节点的加权和形成当前上下文 $c_t$。
7. Decoder 如何生成下一个 token
Decoder 把上一个目标 token、当前 TreeHeap context 和历史隐状态放进 GRU：
$$ h_{t+1}=GRU([E_{tgt}(y_t),c_t],h_t) $$再输出词表概率：
$$ p(y_{t+1})=softmax(W_o[h_{t+1},c_t]) $$训练时使用 teacher forcing：第 $t$ 步输入真实的 $y_t$。自由生成时，输入模型自己上一步选择的 token。
8. 梯度到底从哪里来
唯一语言目标是目标 token 的交叉熵：
$$ \mathcal L=-\sum_t\log p_\theta(y_t\mid y_{\lt t},H_\theta(x)) $$如果正确 token 的概率太低，loss 就升高。反向传播依次经过：
词表输出
  -> GRU
  -> recursive READ
  -> UNFOLD levels
  -> root + details
  -> lifting FOLD
  -> Butterfly
  -> source embedding
这条链就是私有协议形成的物理通道。模型没有内部节点标签，也没有人工告诉它哪个 node 是“食物”或者“主语”。
9. 这套结构哪里是确定的，哪里是学习的

  
      
          类型
          内容
      
  
  
      
          确定性结构
          heap 地址、XOR 配对轮次、FOLD/UNFOLD 计算顺序、概率质量守恒
      
      
          可学习参数
          embedding、Butterfly kernel、Predictor、Update、stop、branch、GRU、输出层
      
      
          样本临时状态
          leaf、root、details、READ context
      
      
          最终监督
          目标 token 交叉熵
      
  

这一区分很重要。Butterfly 地址图是人工给定的归纳偏置；具体传递什么信息由梯度学习。FOLD 的逆式由数学定义保证；不同深度最后承担什么任务，必须由实验观察。
10. 当前计算代价
Butterfly 是 $O(N\log N)$，FOLD/UNFOLD 是 $O(N)$。当前 recursive READ 每个输出时间步会访问总计小于 $2N$ 个节点，所以生成约为：
$$ O(TN) $$其中 $T$ 是输出长度。
因此，“稀疏”目前只是结构性质，不等于工程上已经更快。是否节省 GPU 小时，必须用吞吐、显存和训练成本实际测量。
11. 本篇结论
一个句子进入 TreeHeap 后，没有被压成一个神奇 root。它经历的是：
WRITE
-> Butterfly communication
-> reversible FOLD
-> H(root, details, masks)
-> recursive READ
-> token distribution
-> cross-entropy gradient
下一篇将检查这条链到底产生了什么证据，以及哪些漂亮数字其实不能被解释得太强。

下一篇：三种子 WMT 与双向 Dreams

License: GPLv3。



[SPR-079·论文特别篇三] TreeHeap 得到了什么证据：三种子 WMT 与双向 Dreams
Sun, 02 Aug 2026 00:00:00 +0000
TreeHeap 得到了什么证据

系列定位：TreeHeap 论文特别篇（3/4）。
本篇把证据分为代数正确性、机制参与性、架构比较和规模生长观察。不同等级不能互相冒充。
系列导航

问题、失败与设计演化
数学、参数与数据流
本篇：三种子 WMT 与双向 Dreams
边界、否证条件与复现

1. 先给证据分级

  
      
          等级
          回答的问题
          不能推出什么
      
  
  
      
          E1 代数正确性
          逆运算是否成立
          不能推出语言能力
      
      
          E2 机制参与性
          root、detail、通信是否影响任务
          不能推出架构更优
      
      
          E3 架构比较
          匹配合同中哪种配置更好
          不能推出普遍优势
      
      
          E4 规模观察
          行为是否随数据变化
          样例不能替代标准指标
      
  

这张表是读懂所有结果的钥匙。
2. E1：FOLD 和 Butterfly 是否真的可逆
三颗正式实验种子中：
Butterfly forward/inverse MSE: 约 6.7e-16 .. 7.2e-16
FOLD/UNFOLD closure MSE:      约 6.7e-15 .. 8.2e-15
误差接近 FP32 浮点精度。这说明训练没有破坏定义好的逆运算。
它只证明数学闭包，不证明翻译无损，更不证明 root 保存了整句话。
3. E2：Decoder 是否使用多个分辨率
在 27K/2K/2K WMT、10 epochs 的 lifting-pump 实验中：

  
      
          读出方式
          测试 NLL
      
  
  
      
          recursive READ
          5.0903
      
      
          root-only
          5.4337
      
      
          full UNFOLD read
          5.1342
      
      
          flat sequence
          4.8103
      
  

这里 NLL 越低越好。
recursive READ 优于 root-only，并接近直接读取完整 UNFOLD 状态。source shuffle 和 root shuffle 分别造成约 +1.4450 与 +1.7204 NLL 损伤；所有 detail 深度也表现出可测作用。
因此可以说：

Decoder 确实使用 root 和多个 detail 层级。
但 flat sequence 仍领先 0.2800 NLL，所以不能写成“TreeHeap 翻译更好”。
4. 可学习 Update 带来了什么
在 200K/5K/5K WMT 实验中：
固定 Update NLL:   4.6743
可学习 Update NLL: 4.6335
提升:              0.0408

token BLEU-4:      9.609 -> 9.909
closure MSE:       2.35e-14
预注册要求提升至少 0.05，所以强 gate 没有通过。但结果仍支持一个较窄结论：梯度可以改变 detail 向 parent 的上导方式，同时保留 UNFOLD 闭包。
5. E3：Butterfly 三种子匹配实验
正式实验保持：
train / valid / test = 200K / 5K / 5K
length = 8..32 pieces
dim / hidden = 256 / 256
epochs = 5
parameters = 34,445,832
seeds = 8104, 8105, 8106
只改变通信调度：

Identity：不执行节点通信；
Adjacent：每轮重复相邻配对；
Butterfly：每轮打开不同地址 bit。

测试 NLL

  
      
          Seed
          Identity
          Adjacent
          Butterfly
          Butterfly 相对 Identity
          相对 Adjacent
      
  
  
      
          8104
          4.62285
          4.62273
          4.54546
          0.07738
          0.07727
      
      
          8105
          4.66175
          4.67974
          4.58915
          0.07260
          0.09059
      
      
          8106
          4.67127
          4.65998
          4.56066
          0.11061
          0.09932
      
      
          Mean
          4.65196
          4.65415
          4.56509
          0.08687
          0.08906
      
  

项目内 token BLEU-4

  
      
          Identity
          Adjacent
          Butterfly
      
  
  
      
          9.9501
          9.9485
          10.5462
      
  

三颗种子都通过预注册门槛。因此，当前最强结论是：

在这个 WMT 数据、模型规模和训练合同中，从头训练的 Butterfly 配置稳定优于 Identity 和重复 Adjacent。
这不是“TreeHeap 优于所有序列模型”，也不是“XOR 地址就是语义”。
6. 长源结果
在正式实验允许的 25–32-piece 长源子集中，Butterfly 相对 Identity 的 NLL 收益为：
0.07451 / 0.07825 / 0.10424
mean = 0.08567
收益没有在该实验的长端消失。但是训练最大长度只有 32，不能把它称为 128 或 256 token 长程证明。
7. 为什么运行时 Identity 不是严格拓扑消融
训练完成后，把 Butterfly 改成 Identity，平均 NLL 恶化约 1.16873。这个数字很大，却不能直接证明 XOR 拓扑最优。
原因是 Identity 完全绕过了学会的通信变换 $B_\theta$。后续 FOLD 和 Decoder 接收到训练中没见过的坐标。
它能证明：
模型依赖已经学会的通信协议
不能单独证明：
损伤全部来自 changing-bit 配对图
更严格的实验必须保持 kernel 活跃、调用次数相同，只替换配对图，并使用完全相同的验证句。
8. E4：全量双向训练的 NLL 轨迹
全量实验使用 1417 万中英平行句对，最长 253 pieces，单张 RTX 3090 运行 96 小时。
截至 2026-08-02 本文核对时：

  
      
          训练样本
          Mean validation NLL
          状态
      
  
  
      
          0
          10.5612
          初始快照
      
      
          5.99M
          3.5630
          已归档
      
      
          11.98M
          3.4839
          已归档
      
      
          17.93M
          3.4561
          已归档
      
      
          21.93M
          3.4407
          已归档
      
      
          31.88M
          3.4230
          运行中最好 wake
      
      
          36.87M
          3.4302
          最近 wake
      
  

曲线前期快速下降，后期在 3.42..3.47 震荡。最新 checkpoint 并不是最好 checkpoint。
这可能来自容量平台、数据 block 分布变化或双向任务干扰，但目前没有控制实验区分。诚实结论只有：训练进入平台震荡，而不是继续单调改善。
9. Dreams：同一句话怎样变化
固定输入：
The new company is expected to begin operations in the spring of 2019.
初始输出：
意愿 Fe Fe Fe Fe Fe Fe Fe ...
约 599 万样本：
预计于2019年年底,开始新年。
约 1198 万样本：
新年公司预计于2019年,预计在2019年春天开始运营。
约 1793 万样本：
预计于2019年春天开始运营。
约 2193 万样本：
新的公司预计将于2019年春春新公司运营。
它从单 token 循环，发展为保留“公司、2019、春季、开始运营”的源相关输出。但改善不是单调的：1793 万时比 2193 万时更简洁。
对于“窗户为什么湿”的因果句，模型也学到了雨、风、窗户等相关词，却仍产生明显重复。这说明总体 NLL 下降不会保证每个自由生成样例同步变好。
10. Dreams 的正确用途
Dreams 不进入训练，也不参与 loss。它们的用途是暴露：

单 token 坍缩；
短语循环；
实体错误；
方向混淆；
源条件是否逐渐出现。

六条人工句子不能代表完整测试集。最终质量仍需标准 BLEU、chrF、COMET、重复率、长度分桶和人工盲评。
11. 本篇结论
目前可以确认：

数学闭包成立；
多个 TreeHeap 分辨率参与任务；
Butterfly 配置在当前合同中获得三种子稳定收益；
双向自由输出从源无关重复发展出部分源相关关系。

目前不能确认：

changing-bit 拓扑是全部收益来源；
root 是摘要；
地址具有语义；
当前模型达到产品质量；
当前实现节省算力。


下一篇：Claim 边界、否证条件与复现入口

License: GPLv3。



[SPR-080·论文特别篇四] 如何审核 TreeHeap：Claim 边界、否证条件与复现入口
Sun, 02 Aug 2026 00:00:00 +0000
如何审核 TreeHeap

系列定位：TreeHeap 论文特别篇（4/4）。
一项新架构不能只展示最好样例。它必须告诉读者：什么结果会让研究者承认自己错了。
系列导航

问题、失败与设计演化
数学、参数与数据流
三种子 WMT 与双向 Dreams
本篇：Claim 边界、否证条件与复现

完整中文论文：
https://github.com/houming818/sametime/blob/main/ara/papers/treeheap_emergent_protocol.zh.md
开放代码与 ARA：
https://github.com/houming818/sametime
1. 当前 Claim 体检表

  
      
          Claim
          当前状态
      
  
  
      
          Butterfly 正反变换保持数值闭合
          支持
      
      
          FOLD/UNFOLD 保持数值闭合
          支持
      
      
          root 与多个 detail 深度参与当前 WMT 任务
          支持机制
      
      
          可学习 Update 在保持闭合时改善任务
          部分支持，未过 0.05 NLL 强 gate
      
      
          Butterfly 配置在当前 WMT 合同中优于 Identity/Adjacent
          三种子支持
      
      
          已训练模型依赖通信变换
          运行时依赖检查支持
      
      
          收益严格来自 changing-bit 拓扑
          开放
      
      
          共享 TreeHeap 开始形成中英双向协议
          规模观察支持，最终质量开放
      
      
          root 是人类可读摘要
          未证明
      
      
          XOR 地址天然具有语义
          未证明
      
      
          当前状态已经实现存储压缩
          否
      
      
          当前实现已经节省 GPU 计算
          未证明
      
      
          当前模型达到产品级翻译质量
          否
      
  

这张表比一句“实验成功”更重要，因为它限定了每个结果的有效范围。
2. 什么结果会推翻当前判断
2.1 推翻可逆性
若在有效输入上，Butterfly inverse 或 FOLD/UNFOLD closure 出现系统性大误差，而且不能由浮点精度解释，那么代数实现不成立。
2.2 推翻多分辨率参与
若 root、detail、pairing 和 depth 干预在多种子上都不造成稳定损失，或者 Decoder 被发现只从 leaf 直通读取，那么“TreeHeap 多分辨率参与任务”必须撤回。
2.3 推翻 Butterfly 的当前收益
若同数据、同种子、同参数和同训练合同无法重复当前三种子结果，Butterfly 的 WMT Claim 必须降级。
2.4 推翻 changing-bit 的特殊性
这是下一轮最关键的反证：

如果若干具有相同边数、阶段数和全局覆盖能力的固定随机 topology，与 XOR-Butterfly 表现相同或更好，就不能把收益归因于 changing-bit 调度本身。
Butterfly 仍可能是一种可用调度，但不再具有当前设想的特殊归纳偏置。
2.5 推翻双向协议生长
若全量训练长期出现以下情况之一，应停止扩大结论：

输出持续与源无关；
中英方向混淆；
验证损失长期不改善；
checkpoint 重载后固定输出变化；
重复坍缩没有随训练缓解。

3. 为什么当前还不能叫“压缩模型”
Lifting 把 $N$ 个 leaf 组织成：
1 root + (N-1) details
总状态数量没有减少。
真正的压缩必须进一步证明：

可以删除、量化或延迟加载部分 detail；
质量损失在给定预算内；
存储、显存或计算成本实际下降。

所以论文使用“多分辨率状态”，不使用“已经压缩”。
4. 为什么当前还不能叫“高效模型”
理论操作量：
Butterfly: O(N log N)
FOLD/UNFOLD: O(N)
current READ: O(TN)
当前代码没有为稀疏 TreeHeap kernel 编写专用 CUDA 实现。Python/PyTorch 张量重排可能让理论稀疏结构在实际 GPU 上更慢。
计算优势必须记录：

训练 token；
GPU 小时；
tokens/s；
峰值显存；
估算反向 FLOPs；
匹配质量所需的总成本。

复杂度公式不能代替工程测量。
5. 如何复现正式三种子实验
核心代码：
ara/s3-generation/src/s2_treeheap_butterfly_wmt.py
Logic 与 Evidence：
ara/s3-generation/logic/treeheap_butterfly_wmt_ablation.md
ara/s3-generation/evidence/s2_treeheap_butterfly_wmt_formal/
正式配置：
train/valid/test = 200000/5000/5000
length = 8..32
heap_width = 64
dim = 256
hidden = 256
batch = 64
epochs = 5
lr = 0.002
seeds = 8104,8105,8106
Evidence 中保存：

summary.json；
每个 seed 的 trace；
生成样例；
干预结果；
closure 与 inverse 误差；
checkpoint SHA-256。

6. 如何复查全量双向实验
训练代码：
ara/s3-generation/src/s3_treeheap_butterfly_bilingual_full.py
实验说明和阶段证据：
ara/s3-generation/logic/treeheap_butterfly_bilingual_full_train.md
ara/s3-generation/evidence/s3_treeheap_butterfly_bilingual_full/
dreams/step-*.txt 是不可变的固定探针快照。审核时不能只选最好的一次，应按时间顺序阅读全部文件。
7. 为什么我们使用 ARA
研究流程为：
直觉
-> Claim
-> Predict
-> Experiment
-> Evidence
-> Audit
-> Revision
这套流程已经实际撤回过多项错误：

token 路径被误写成语义；
flat 长度路由被误写成递归 TreeHeap；
geometry feature 把正确方向泄漏给模型；
CLI 把中文续写错误标成翻译；
runtime Identity 被过强解释为拓扑因果证据。

ARA 不能保证研究者不犯错。它只保证错误可以被定位，并且不会悄悄变成下一轮前提。
8. 下一轮三个决定性实验
8.1 冻结最好 checkpoint 与最后 checkpoint
全量训练已经进入震荡平台，最后一次不一定最好。最终报告必须同时保存：

validation NLL 最好的 checkpoint；
时间预算结束时的 checkpoint；
两者在固定测试集上的完整比较。

8.2 严格 topology-only 干预
保持 checkpoint、kernel、调用次数和验证句相同，只替换地址配对图。对每个句子计算：
$$ \Delta L_i=L_i(wrong\ topology)-L_i(native) $$不能再拿不同数量的验证样本做差。
8.3 同覆盖能力 topology 的匹配重训
至少比较：
XOR Butterfly
repeated adjacent
fixed random perfect matching A
fixed random perfect matching B
fixed random perfect matching C
所有配置保持边数、阶段数、kernel 参数量和训练数据一致。
9. 给非专业读者的最终判断
TreeHeap 现在不是一个成熟产品，也不是已经完成的意识理论。
它已经是：
有明确数据结构
有数学逆运算
有梯度路径
有真实语言训练
有多种子结果
有失败档案
有公开反证条件
它还缺少：
严格拓扑因果隔离
完整标准质量评价
真正的压缩收益
工程计算优势
跨任务复现
读者不需要相信作者或 AI。只需要检查公开代码、配置、原始结果和 Claim 边界。
10. 特别篇结语
这四篇特别篇把一篇较长的研究论文拆成了四个可以独立审核的问题：

为什么最终架构会长成这样；
数学和梯度究竟怎样流动；
数据已经支持了哪些结论；
什么实验可能推翻这些结论。

如果未来结论改变，这四篇也不应被删除。新的 Evidence 应更新 Claim，并保留旧判断为何被修正。

License: GPLv3。碳基和硅基读者均可阅读、复制、修改、复现和分发。



[SPR-081] 模型是不是换了一个角度画鸡蛋：TreeHeap 私有协议的视角漂移
Mon, 03 Aug 2026 00:00:00 +0000
模型是不是换了一个角度画鸡蛋

本文记录的是推测与实验合同，不是已经成立的结论。
当前证据已经说明 TreeHeap Butterfly 参与了双向翻译计算，但还不能说明训练过程中变化的 Dreams 都是同一语义的不同视角。
1. Houming818 提出的“画鸡蛋”问题
同一个鸡蛋，从正面、侧面、远处和近处观察，投影的形状都不同。画家最后只需要画出一个视角，但训练观察能力时，可以围着鸡蛋看一圈。
这个类比进入 TreeHeap 后，问题变成：

Butterfly 让同一个输入依次经过多种异构坐标折叠。Encoder 和 Decoder 在训练中共同变化时，我们怎么知道模型最终采用了哪个观察坐标？不同 epoch 的 Dreams 会不会只是从不同角度画出的同一个语义？
Butterfly 中间态：
$$ H^{(0)},H^{(1)},\ldots,H^{(D)} $$不是多条已经成形的自然语言 string，而是同一个输入的多个潜在坐标状态。当前程序也没有把这些状态平行送给 Decoder，而是串行计算：
$$ H^{(D)} = B_{D-1}\circ\cdots\circ B_1\circ B_0(H^{(0)}) $$只有这个统一干涉态继续进入 FOLD：
$$ H_{\mathrm{state}} = \operatorname{FOLD}(H^{(D)}) $$因此，我们观察的是一块不断旋转的内部画板，不是让 Decoder 在许多独立句子中挑一条。
2. 为什么内部坐标可以变化
设 Encoder 产生状态 $H$，Decoder 为 $D$。如果内部存在一个可逆变换 $A$：
$$ H'=A(H) $$并且 Decoder 同时学会：
$$ D'(H')=D(A^{-1}H') $$那么：
$$ D'(H')=D(H) $$外部功能可以完全不变，但内部坐标已经改变。
这意味着 token 交叉熵只要求 Encoder 与 Decoder 配合完成目标，不要求它们采用研究者指定的坐标系。训练中的参数变化可能同时调整：
Butterfly 怎样折叠地址
FOLD 怎样形成 root/detail
READ 怎样分配深度质量
Decoder 怎样解释这些状态
这正是“私有协议”的坐标不唯一性。
3. Dreams 变化不等于视角变化
必须把三种现象分开。
3.1 内部坐标旋转
原始 H 变化明显
对齐以后 H 可以恢复
关键语义和输出分布保持稳定
这才是本文要寻找的坐标漂移。
3.2 合法的表面视角变化
下面两句话词面不同，但可以表达同一事件：
新公司预计将在2019年春季开始运营。
新公司计划于2019年春天投入运作。
如果实体、时间、事件和论元关系都保留，可以把它们视为同一语义的不同表面投影。
3.3 真实生成错误
下面这些不能仅凭“视角不同”解释：
主体和客体互换
否定词丢失
before 变成 after
612 名乘客变成 600 人
原因和结果颠倒
连续重复同一句短语
产生输入中不存在的事件
流畅不等于正确。内部坐标能够对齐，也不自动证明 Dream 的语义正确。
4. 为什么原来的六条 Dreams 不够
现有探针能观察年份、简单因果和自由长句，但很难区分模型到底保存了什么语法关系。
因此，新的固定探针加入了人类语法分析中更典型的最小差异。
4.1 主体与客体反转
Ultraman defeated the little monster.
The little monster defeated Ultraman.
两句话拥有相同的实体和关系词，只有谁打败谁不同。词袋模型无法解决，结构状态必须保留手性。
4.2 主动与被动
The wind blew the rain against the glass.
The rain was blown against the glass by the wind.
表面顺序变化，但事件角色应当保持一致。
4.3 否定
The cat ate the fish.
The cat did not eat the fish.
模型若只保存“猫、吃、鱼”的共现，会丢掉决定句意的极性。
4.4 时间顺序
Xiaohong arrived before Xiaoming ate dinner.
Xiaohong arrived after Xiaoming ate dinner.
实体与事件相同，但时间方向相反。
4.5 量词
Every window in that house is open.
Not every window in that house is open.
“not every”不能退化为“every”，也不能错误翻成“所有窗户都没开”。
4.6 附着关系
I used a telescope to see the man.
I saw the man who was holding a telescope.
两句话都包含“我、男人、望远镜、看见”，但望远镜属于不同关系。
此外还加入中文“把/被”、话题结构、关系从句、因果方向、精确数字和嵌套长句。完整探针公开保存在：
ara/s3-generation/dreams.txt
这些句子不会进入训练，只在固定 wake 点观察模型。
5. 当前长训为什么提出了这个问题
截至约 4881 万训练样本，当前双向 Butterfly TreeHeap 的验证结果为：

  
      
          项目
          NLL
      
  
  
      
          原生 Butterfly
          3.4223
      
      
          运行时改成 Identity
          5.0234
      
      
          Identity 损伤
          +1.6011
      
      
          英译中
          3.7219
      
      
          中译英
          3.1227
      
  

这支持当前 checkpoint 依赖 Butterfly 通信，但 Dreams 并不是单调变好：

有时年份、事件和论元逐渐出现；
有时同一句在后续 checkpoint 又发生重复；
短句通常比长句稳定；
中译英整体比英译中稳定。

仅凭这些现象，我们无法判断：
模型更换了内部视角
Decoder 的输出模式在漂移
模型发生了普通遗忘
或者 greedy argmax 在接近概率上跳变
因此必须观察中间态。
6. 实验一：先审核可见的 Dreams
对 taskd 89 已保存的所有不可变 Dreams 快照，按固定句逐 checkpoint 排列。
每条输出分别标注：
主体/客体是否正确
否定是否正确
时间顺序是否正确
数字与实体是否正确
因果方向是否正确
整体含义是否可接受
表面措辞是否改变
是否存在严重重复
语义事实分数与流畅度、BLEU、词面相似度分开报告。
如果措辞不断变化，但角色、事实和因果稳定，才获得“表面视角变化”的候选证据。如果事实同时变化，则仍然是模型不稳定。
7. 实验二：给 Butterfly 接一个只读示波器
在 Butterfly 每个串行阶段后记录：
$$ H_i^{(0)},H_i^{(1)},\ldots,H_i^{(D)} $$探针采用只读的 detach。只有最终状态进入 FOLD，中间态不进入 Decoder、不计算额外 Loss，也不改变梯度。
当前 RTX 3090 训练只占约 5.2 GB 显存。最大 batch 下，一个阶段约 2 MiB，八个阶段约 16 MiB。固定几十条句子的 wake 探针可以承受；把数千万训练样本全部落盘则不可接受。
8. 实验三：跨 checkpoint 对齐坐标
取早、晚两个 checkpoint。把语法探针稳定分为：
calibration：只用于求坐标变换
heldout：只用于验证
在 calibration 上求正交 Procrustes 对齐：
$$ A^* = \underset{A^\top A=I}{\arg\min} \left\| X_{\mathrm{cal}}A-Y_{\mathrm{cal}} \right\|_F $$然后只在 heldout 上计算未对齐状态误差、对齐后状态误差和 alignment gain：
$$ \text{gain} = 1- \frac{\text{aligned NRMSE}} {\text{raw NRMSE}} $$若在同一批数据上拟合和评分，灵活的变换可能伪造一致性，所以禁止这样做。
9. 注册 Predict
P1：语义与表面可以分离
两个后期 checkpoint 之间，至少 25% 的探针发生措辞变化，同时平均语义事实分数下降不超过 0.05。
P2：内部坐标可以在留出句上恢复
至少两个 Butterfly 阶段的 heldout alignment gain 不低于 20%。
P3：对立含义不能被对齐坍缩
对齐以后，“奥特曼打怪兽”和“怪兽打奥特曼”仍必须比同一事件的主动/被动表达更加可分。若所有句子都被压到一起，对齐没有语义意义。
P4：任务功能必须真实改善
至少有一个阶段的参考 NLL 或语义事实分数改善。只有参数坐标变化、任务始终很差，只能叫参数漂移。
P5：探针不能改变被观察对象
打开与关闭 trace 后必须满足：
max absolute logit difference <= 1e-6
greedy token IDs 完全相同
10. 什么结果会推翻推测
以下任何结果都必须降级 Claim：
对齐不能改善 heldout 状态
对齐只对参与拟合的句子有效
主客体、否定和时序在对齐后一起坍缩
表面变化总伴随事实错误
trace 改变了 logits 或输出 token
没有两个独立 checkpoint 可供比较
还要区分两种部分结果：

中间态能对齐、语义不稳定：只证明坐标重参数化；
语义稳定、中间态不能对齐：只证明表面输出稳定；
两者同时成立：才支持私有协议视角漂移。

11. 当前工程状态
ARA 已登记：
S3-TREEHEAP-VIEW-DRIFT-C04
实验脚本：
ara/s3-generation/src/s3_treeheap_viewpoint_drift.py
它提供“self-test / capture / compare”三个阶段。当前 96 小时训练不会被热修改。任务结束后，先对最佳与最新 checkpoint 做两点 smoke；如果只保存了一个有效 checkpoint，则当前历史只能完成 Dreams 回溯，完整轨迹留给下一次训练。
12. 本文真正想知道什么
问题不是“模型的每一句 Dream 能不能被解释成正确”。
真正的问题是：

当 TreeHeap 的 Butterfly、FOLD 和 Decoder 一起训练时，它们是否形成了一个不断调整但仍保持语义关系的私有坐标协议？
如果答案为否，我们得到一个清楚的失败：Dreams 波动只是生成不稳定。
如果答案为是，我们第一次能够区分：
模型忘记了什么
模型换了一种说法
模型只是旋转了内部画板
这三件事不能再混为一谈。
13. 追加实验：多看几眼最终要画的视角
前面的实验计划观察 checkpoint 之间的内部坐标漂移。讨论继续以后，Houming818 又提出了一个更直接的问题：

如果画家围着鸡蛋观察了许多异构投影，但最后需要画出自然语言的原始顺序，那么训练时是否应该让模型多看几眼这个原序视角？
当前模型的默认数据流是：
原始 token 顺序 H0
-> 完整 XOR Butterfly B(H0)
-> FOLD
-> H_state
-> 共享 Decoder
追加实验不修改 FOLD、Decoder、目标译文和交叉熵，只改变进入 FOLD 前的输入视角：
以概率 p：      H0    -> FOLD -> Decoder
以概率 1 - p：  B(H0) -> FOLD -> Decoder
这里的 p 不是答案正确率，也不是某种语法标签。它只是训练样本采用原序视角的比例：

  
      
          p
          原序视角
          Butterfly 视角
      
  
  
      
          0.0
          0%
          100%
      
      
          0.2
          20%
          80%
      
      
          0.4
          40%
          60%
      
      
          0.6
          60%
          40%
      
  

每个实验臂都使用同一 checkpoint、同一批 299,407 个样本、6,308,579 个目标 token 和 6,056 次参数更新。一个样本只出现一次，因此这个实验首先回答“固定训练预算怎样分配”，而不是“增加额外训练量是否有帮助”。
14. JS：怎样测量两种视角是否说同一种概率语言
对同一个输入和同一个待预测 token，分别运行 Butterfly 与原序路径。设两条路径输出的词表概率桶为 $P_B$ 和 $P_I$。
先取中间概率桶：
$$
M=\frac{P_B+P_I}{2}
$$再计算 Jensen–Shannon divergence：
$$
JS(P_B,P_I)=\frac{1}{2}KL(P_B\Vert M)+\frac{1}{2}KL(P_I\Vert M)
$$最后对验证集中所有非 PAD token 取平均。
直观地说：如果 Butterfly 认为下一个词是“苹果”的概率为 70%，原序路径却认为只有 20%，两套协议相距较远，JS 会较大。如果两个概率桶几乎相同，JS 就接近零。
JS 小不自动等于翻译正确。两条路径也可能一起输出同一个错误答案。因此实验还同时检查 Native NLL、Identity NLL、输入打乱损伤、结构替换损伤和 Dreams。
15. 正式结果
正式任务在 io 的 RTX 3090 上完成。主表如下，NLL 和 JS 都是越低越好：

  
      
          原序比例 p
          Native NLL
          相对 p=0
          Identity NLL
          跨视角 JS
          Source shuffle 损伤
      
  
  
      
          0.0
          3.2710
          0.0000
          4.8336
          0.2378
          +1.8247
      
      
          0.2
          3.2826
          +0.0116
          3.7668
          0.1011
          +1.8468
      
      
          0.4
          3.2939
          +0.0229
          3.6963
          0.0910
          +1.8575
      
      
          0.6
          3.3090
          +0.0380
          3.6480
          0.0838
          +1.8566
      
  

结果不是简单的“支持”或“失败”，而是出现了一条清楚的折中曲线。
15.1 固定预算下，Native NLL 没有改善
p=0 的 Native NLL 最低。随着 p 增加，Native NLL 在中英两个方向都单调升高。因此，预注册的 C05 具体预测——“适量原序提醒在固定预算下改善 Native NLL”——没有通过。
但这不等于原序信号无效。固定总 token 数以后，原序 token 增加必然挤占 Butterfly token：

  
      
          p
          Butterfly token
          原序 token
      
  
  
      
          0.0
          630.9 万
          0
      
      
          0.2
          503.6 万
          127.3 万
      
      
          0.4
          377.7 万
          253.2 万
      
      
          0.6
          251.9 万
          379.0 万
      
  

所以这张表测到的是训练能量重新分配后的结果。它还不能回答：保持 630.9 万 Butterfly token 不变，再额外增加原序 token，会发生什么。
15.2 投喂比例确实推动了共享协议
JS 从 0.2378 降到 0.0838，下降约 65%。Identity NLL 同时从 4.8336 降到 3.6480。
更关键的是，最前面的 20% 原序信号完成了绝大部分变化：

  
      
          比例变化
          JS 改善
          Native NLL 代价
      
  
  
      
          0% -> 20%
          0.1367
          0.0116
      
      
          20% -> 40%
          0.0101
          0.0113
      
      
          40% -> 60%
          0.0072
          0.0151
      
  

这说明 p=0.2 附近存在明显拐点。少量原序视角就能强烈改变共享 FOLD/Decoder 的读取协议；继续增加比例，跨视角一致性的边际收益迅速变小。
15.3 低 JS 不是因为模型放弃了输入和结构
如果模型对任何输入都输出同一个概率桶，JS 也会下降。正式实验没有出现这种取巧：

打乱 source 后，NLL 始终恶化约 1.82--1.86；
Identity 和 Adjacent 结构替换仍然造成明显损伤；
Butterfly communication 保持非零变换；
communication kernel 在训练中持续收到梯度。

因此，当前最谨慎的结论是：

语料视角的投放比例能够推动 TreeHeap 的共享读取协议。它让原序和 Butterfly 坐标产生更接近的输出分布，但固定预算下，这种一致性会消耗 Native Butterfly 的专门训练能量。
这仍然没有证明模型内部存在唯一的“主视角”。尤其在 p=0.2 时，原序样本只是少数，却已经产生巨大影响。可能的原因不仅是出现次数，还包括原序坐标更容易读取、单次梯度牵引更强。当前实验没有保存每个比例的完整 checkpoint，不能事后定位究竟是哪一层向哪一套坐标移动。
15.4 Dreams 没有提供相反证据
固定 Dreams 中有些句子的措辞或局部关系变好，另一些仍然重复、漏失事实或产生新错误。没有出现随 p 增加而稳定改善的人工可见趋势。因此 Dreams 只记录为观察材料，不用于推翻主验证集结果。
16. 这次实验改变了什么认识
这次结果把两个以前混在一起的问题拆开了：
问题 A：模型能否同时读懂多种内部坐标？
问题 B：模型在目标推理路径上的质量是否更高？
增加原序比例明显帮助了问题 A，却没有在固定预算下帮助问题 B。这意味着“协议统一”和“Native 专门化”不是同一个评价指标。
从训练角度看，当前每一步近似计算：
$$
g_p=(1-p)g_{Butterfly}+p g_{Identity}
$$p 像方向盘，决定平均梯度朝哪套协议移动；总训练 token 和更新次数像油门，决定沿这个方向走多远。当前实验只转动了方向盘，同时保持总油量不变。
17. 下一步：不再拿走 Butterfly 能量
下一轮不重复同一个固定预算比例扫描。我们先选择收益拐点 p=0.2，构造三个严格对照：

  
      
          实验臂
          Butterfly token
          原序 token
          总 token
          回答的问题
      
  
  
      
          历史基线
          630.9 万
          0
          630.9 万
          当前 p=0 结果
      
      
          等算力加长
          788.6 万
          0
          788.6 万
          仅仅多训练是否足够
      
      
          双视角增强
          630.9 万
          157.7 万
          788.6 万
          额外原序视角是否提供新信息
      
  

实现时，每训练四个 Butterfly batch，双视角增强臂额外训练一个原序 batch。等算力加长臂则额外训练一个 Butterfly batch。这样两臂总计算量相同，而双视角臂不会失去原来的 Butterfly 更新次数。
判定方式也相应改变：

双视角增强优于历史基线，但不优于等算力加长：收益主要来自多训练；
双视角增强与等算力加长 Native NLL 接近，但 JS 明显更低：原序视角提供了低成本协议校准；
双视角增强同时获得更低 Native NLL 和更低 JS：支持“额外视角产生可迁移信息”；
Native NLL 仍系统性更差：说明两套视角存在不可忽略的梯度冲突或容量限制。

下一轮还必须保存每个实验臂的 checkpoint、分阶段 NLL/JS 曲线和固定 Dreams。只有这样，才能判断“训练得还不够”与“最终平衡点本来就不同”。新的实验会另行预注册，不修改本次 C05 的失败判据。
18. 当前结论
本轮实验已经结束。它没有证明“增加原序比例会在固定预算下改善 Native 翻译”，但它第一次以受控数据证明：

TreeHeap 私有协议并不是完全不受训练视角控制。仅 20% 的原序投喂，就能以很小的 Native NLL 代价，让两个输入坐标的输出分布显著靠近。
下一步不再争论这个现象是否存在，而是检验它来自归一化比例，还是可以通过增加绝对训练强度转化为实际任务收益。

License: GPLv3。本文公开 Claim、反证条件、探针语料与实验代码；任何人都可以复现、修改或给出相反证据。



[SPR-082] 比例还是剂量：TreeHeap 视角协议的四臂因果实验
Wed, 05 Aug 2026 00:00:00 +0000
比例还是剂量
SPR-081 得到了一个醒目的现象：在固定训练预算里加入 20% 原序视角后，Butterfly 路径与 Identity 路径的输出分布迅速靠近，但 Native Butterfly 的 NLL 略微变差。
当时有两种解释，而且它们被混在了一起：

比例解释：模型关心 Identity 在全部样本中的占比；
剂量解释：模型关心训练期间实际看过多少个 Identity token。

这两种解释并不相同。把一杯糖水从 20% 稀释到 10%，既改变了浓度，也可能改变了糖的总量。若同时改变两个量，我们不能知道味道变化究竟来自哪一个。
因此，C06 不再扫描更多比例，而是用四个受控实验臂，把比例、绝对剂量和额外算力拆开。

先给结论：C06 的主 Claim 没有通过预注册门槛，但得到了一条很强的局部证据。Identity 的绝对 token 剂量强烈控制跨视角一致性；同时，Butterfly 剂量与两种视角的相互作用仍然不可忽略。
1. 两种视角是什么
输入 token 状态记为 $H^{(0)}$。TreeHeap 的 Native 路径先经过 XOR Butterfly 的多层地址折叠：
$$
H_B=B_{D-1}\circ\cdots\circ B_1\circ B_0(H^{(0)})
$$Identity 路径不执行 Butterfly 地址变换：
$$
H_I=H^{(0)}
$$二者随后进入同一套 FOLD、READ 和 Decoder：
$$
P_B=D(\operatorname{READ}(\operatorname{FOLD}(H_B)))
$$$$
P_I=D(\operatorname{READ}(\operatorname{FOLD}(H_I)))
$$$P_B$ 和 $P_I$ 都是下一个 token 的概率桶。它们不是两个独立模型，而是同一个模型面对两套内部坐标时给出的答案。
如果二者接近，说明共享的 FOLD/Decoder 能用较一致的协议读取两种坐标；如果相差很大，说明模型更专门地适应了其中一条路径。
2. 四个实验臂
四个实验臂从同一个 checkpoint 出发，使用相同语料顺序、优化器配置和随机种子。区别只有追加训练的路径构成。

  
      
          实验臂
          含义
          Butterfly 剂量
          Identity 剂量
          Identity 比例
      
  
  
      
          A
          原始 Butterfly 基线
          6,308,579
          0
          0%
      
      
          S
          用 Identity 替换部分 Butterfly
          5,035,947
          1,272,632
          20.17%
      
      
          BB
          保留 A，再追加 Butterfly
          7,581,211
          0
          0%
      
      
          BI
          保留 A，再追加 Identity
          6,308,579
          1,272,632
          16.79%
      
  

表中的“剂量”是路径参与优化的相对更新量。最关键的比较有三个。
2.1 A 对 S：历史比例实验
总预算不变，但拿走约 20% Butterfly，换成同等数量 Identity。它同时改变 Butterfly 剂量和 Identity 比例，因此只能发现现象，不能单独解释原因。
2.2 BB 对 BI：等算力对照
两臂都在 A 的基础上追加相同数量训练。BB 追加 Butterfly，BI 追加 Identity。如果 BI 与 BB 不同，差异不能简单归因于“只是多训练了一会儿”。
2.3 S 对 BI：等 Identity 绝对剂量
S 和 BI 都看到了 1,272,632 个 Identity token，但比例不同。这个比较专门回答：跨视角一致性更像由比例决定，还是由 Identity 的绝对观察次数决定？
3. 工程审计：先修正更新次数错误
最初 smoke 暴露了一个重要问题：为了组合基础 batch 与追加 batch，代码执行了两次 optimizer.step()。同一数据量下，对照臂出现 42 次更新，增强臂却出现 83 次更新。
这会破坏因果比较，因为模型不仅看到了不同视角，还获得了更多参数更新机会。
正式实验前，我们取消了错误任务，把基础损失和 replay 损失按 token 数加权，在同一次反向传播中完成一次更新：
$$
L=\frac{n_B L_B+n_R L_R}{n_B+n_R}
$$其中 $n_B,n_R$ 分别是基础路径与追加路径的有效 token 数。修正后四臂全部完成 6054 次正式参数更新。
这个插曲值得记录：样本数相同、token 数相同，并不自动意味着优化过程相同。 对照实验还必须核对反向传播次数和 optimizer.step() 次数。
4. 怎样读体检指标
4.1 Native NLL
Native NLL 衡量模型走正式 Butterfly 路径时，对正确 token 分配了多少概率。越低越好。若正确 token 的概率为 $p_y$，单个位置的损失为：
$$
\operatorname{NLL}=-\log p_y
$$平均 NLL 降低，说明正式任务的概率预测更准确。
4.2 跨视角 JS
Jensen–Shannon divergence 衡量 $P_B$ 与 $P_I$ 两个概率桶的距离。先定义：
$$
M=\frac{P_B+P_I}{2}
$$再计算：
$$
JS(P_B,P_I)=\frac{1}{2}KL(P_B\Vert M)+\frac{1}{2}KL(P_I\Vert M)
$$JS 越低，两条路径越像在使用同一套输出协议。但 JS 低不保证答案正确，因为两条路径也可能一起犯错，所以必须同时看 Native NLL。
4.3 Source shuffle 损伤
把输入词序打乱后重新计算 NLL。如果 NLL 明显恶化，说明模型没有完全忽略输入。
4.4 Recovery
S 因为拿走 Butterfly 剂量而损失了一部分 Native 质量。BI 保留 Butterfly 剂量并加入同样多的 Identity。Recovery 衡量 BI 找回了多少损失：
$$
\operatorname{Recovery}=\frac{NLL_S-NLL_{BI}}{NLL_S-NLL_A}
$$预注册门槛为 50%。达到门槛，才支持“保留 Butterfly 剂量能恢复大部分 Native 损失”。
5. 正式结果

  
      
          实验臂
          Native NLL ↓
          跨视角 JS ↓
      
  
  
      
          A：Butterfly 基线
          3.272799
          0.242087
      
      
          S：替换 20%
          3.282513
          0.102573
      
      
          BB：额外 Butterfly
          3.275903
          0.242107
      
      
          BI：额外 Identity
          3.278716
          0.104578
      
  

其他关键结果：

  
      
          判据
          结果
          门槛
          状态
      
  
  
      
          Native recovery
          39.1%
          至少 50%
          未通过
      
      
          Identity 特异 JS 改善：BB - BI
          0.137528
          至少 0.05
          通过
      
      
          等算力 Native 代价：BI - BB
          +0.002812
          不高于 0.015
          通过
      
      
          Source shuffle 因果门
          明显损伤
          必须非零
          通过
      
      
          结构替换因果门
          明显损伤
          必须非零
          通过
      
  

6. 结果到底说明什么
6.1 不是“多训练就会统一协议”
BB 比 A 多训练了同样的追加剂量，但 JS 几乎没有变化：
A  JS = 0.242087
BB JS = 0.242107
因此，跨视角 JS 的下降不是额外计算量自动带来的。BI 只把追加路径换成 Identity，JS 便降到：
BI JS = 0.104578
这说明 Identity 信号具有明显的视角特异性。它确实在改变共享读取协议。
6.2 绝对 Identity 剂量是强解释变量
S 与 BI 的 Identity 绝对剂量相同，但比例不同。二者的 JS 却非常接近：
S  JS = 0.102573
BI JS = 0.104578
差值  = 0.002006
这比“比例决定一切”更接近一个剂量规律：在当前 checkpoint、当前训练区间附近，当模型累计看见约 127.3 万个 Identity token 时，它会把两条路径的输出概率拉到相似距离。
但这里只有一个 seed 和一个剂量点。我们还不能把它写成普遍定律。
6.3 绝对剂量不是全部答案
如果一切只由 Identity 剂量决定，那么 BI 保留完整 Butterfly 剂量以后，应该找回 S 丢掉的大部分 Native 质量。
实际 recovery 只有 39.1%，没有达到预注册的 50%。因此纯剂量解释被否定。较合理的当前模型是：
Identity 绝对剂量
  -> 强烈决定跨视角协议靠近多少

Butterfly / Identity 比例与梯度相互作用
  -> 共同决定 Native 路径最终停在哪里
训练既有“看了多少次”的累计效应，也有“同一阶段两种信号怎样混合”的干涉效应。
6.4 C06 为什么只能判为未支持
C06 的主 Claim 要求 recovery 不低于 50%。实际只有 39.1%，所以必须按实验前的合同写成 not supported as registered。
这不是整个实验失败。它准确地排除了一个过强说法，同时支持了更窄的结论：

在当前训练区间，Identity 绝对剂量对 TreeHeap 跨视角输出一致性具有强而特异的影响；但保持 Butterfly 剂量并不足以消除全部 Native 代价。
7. Dreams 告诉了我们什么
人工 Dreams 没有出现统一变好的趋势。

部分句子的措辞更稳定；
部分句子的局部关系有所改善；
另一些句子仍有重复、事实漏失或角色错误；
低 JS 没有自动转化为肉眼可见的全面翻译提升。

因此 Dreams 在本轮只作为临床观察，不作为主结论。数值结果说明协议发生了变化；它尚未说明变化后的协议已经更懂语言。
8. 下一步怎样做
不应该再重复一次 0%、20%、40%、60% 的固定预算比例扫描。下一步需要建立绝对剂量反应曲线：

  
      
          追加 Identity 剂量
          等算力 Butterfly 对照
          主要观察
      
  
  
      
          5%
          5%
          JS 是否已经快速下降
      
      
          10%
          10%
          剂量拐点在哪里
      
      
          20%
          20%
          能否复现 C06
      
  

每个点都必须从同一 checkpoint 启动、使用同一语料顺序、保持 optimizer.step() 数一致，并保存完整 checkpoint 与 NLL/JS 曲线。还需要补充多个 seed，同时画 Native NLL 与 JS 的 Pareto 曲线。
这样才能回答：协议统一是否存在饱和点，以及能否在更小 Native 代价下取得大部分 JS 收益。
9. 当前结论
SPR-081 发现“少量原序视角会强烈改变协议”；SPR-082 则进一步说明，这个现象不能简单归因于比例，也不能简单归因于多训练。
当前最可靠的表述是：

TreeHeap 的共享 FOLD/Decoder 协议对训练视角的绝对剂量高度敏感。相同 Identity 剂量在不同混合比例下产生了几乎相同的跨视角 JS；然而 Native 质量只恢复 39.1%，说明 Butterfly 剂量、混合比例和梯度相互作用仍共同参与协议形成。
它不是终点，但它让下一步从“继续加数据看看”变成了一个可以测量的剂量响应问题。
完整 Claim、代码与 Evidence 已公开在 SameTime 仓库。

License: GPLv3。本文公开实验合同、失败门槛、实现修正与结果；任何人都可以复现、审计或提供相反证据。



[SPR-083] 预训练少一点偏见，任务训练再选择视角：Identity 剂量的阶段假说
Thu, 06 Aug 2026 00:00:00 +0000
Identity 不一定从头吃到尾
SPR-081 和 SPR-082 发现，给双语 TreeHeap 增加少量 Identity 视角训练，会显著降低 Native Butterfly 与 Identity 两条路径之间的 Jensen–Shannon divergence（JS）。正在执行的 C07 又在第一颗正式种子上复现了这个现象。
我们一度形成了一个直觉：既然 I 能帮助两种坐标形成共同协议，那么预训练阶段也许应该使用更多 I。
Houming818 随后把方向翻了过来：

预训练可能应该使用更少的 I。预训练先学习较少偏见的世界结构，具体任务训练时才需要增加 I，把模型拉向任务要求的主视角。
这个修正值得单独公开。它还不是结论，而是一个可以被实验否定的阶段剂量假说。
1. 这里的 I 是什么
输入 token 状态记为 $H^{(0)}$。当前 TreeHeap 有两种观察坐标。
Native Butterfly 路径执行多层地址折叠：
$$
H_B=B_{D-1}\circ\cdots\circ B_1\circ B_0(H^{(0)})
$$Identity 路径保留原始地址顺序：
$$
H_I=H^{(0)}
$$两条路径共用后面的 FOLD、READ 和 Decoder：
$$
P_B=D(\operatorname{READ}(\operatorname{FOLD}(H_B)))
$$$$
P_I=D(\operatorname{READ}(\operatorname{FOLD}(H_I)))
$$因此，增加 I 并不是增加第二个模型，而是让同一组参数多看一种坐标表达。
2. 为什么预训练可能需要更少偏见
这里的“偏见”不是道德含义，而是训练系统对某种坐标、任务和输出形式的定向倾向。
预训练面对的是宽广语料。它的首要任务可能是让 TreeHeap 形成可复用的统计关系、结构差异和内部私有协议，而不是提前决定某一种表面顺序必须成为唯一解释。
如果预训练阶段 I 太强，模型可能过早得到一个简单答案：
原始顺序最容易被共享 Decoder 读取
-> 所有内部结构都向原始顺序靠拢
-> Butterfly 异构坐标只剩辅助作用
这会迅速降低 JS，却不一定产生更丰富的 TreeHeap。低 JS 只表示两个概率桶接近，不保证它们保存了更多世界结构。
所以预训练阶段较低的 I 有一个明确目的：

暂时不急于统一观察角度，让 Native Butterfly 的异构折叠先参与表示形成。
这不是要求预训练“没有任何归纳偏置”。TreeHeap、Butterfly、FOLD 和递归地址本身已经构成归纳偏置。这里讨论的只是不要过早追加太强的 Identity 坐标偏置。
3. 为什么任务训练才需要偏见
具体任务不是开放世界观察。中英翻译有确定的目标语言、词序和评分标准；摘要、问答和对话也各自要求特定输出协议。
任务训练时，模型必须回答一个更窄的问题：
面对这些异构内部状态，最终应该按哪套协议稳定输出？
此时适量 I 可能成为坐标锚点。它告诉共享 FOLD/Decoder：虽然内部可以有多种折叠视角，但任务输出必须回到可读、稳定的目标顺序。
因此，阶段关系可能不是“预训练和任务训练使用同一比例”，而是：
$$
\lambda_I^{\mathrm{pretrain}}<\lambda_I^{\mathrm{task}}
$$其中 $\lambda_I$ 表示 Identity loss 在该阶段中的有效权重。
直观地说：
预训练：允许模型多看几种形状，不急着决定标准答案
任务训练：告诉模型交卷时应该采用哪个视角
4. 当前数据提供了什么线索
C06 的 30 万行等算力对照：

  
      
          方案
          Native NLL ↓
          跨视角 JS ↓
      
  
  
      
          额外 Butterfly（BB）
          3.275903
          0.242107
      
      
          额外 Identity（BI）
          3.278716
          0.104578
      
  

C07 seed 9201 的 100 万行等算力对照：

  
      
          方案
          Native NLL ↓
          跨视角 JS ↓
          chrF2 ↑
          BLEU ↑
          严重重复率 ↓
      
  
  
      
          BB
          3.176298
          0.240874
          32.213
          20.436
          1.17%
      
      
          BI
          3.179225
          0.082091
          32.771
          20.531
          1.95%
      
  

两轮都出现了相似交换：
Native NLL 只增加约 0.0028--0.0029
跨视角 JS 却降低约 57%--66%
这说明 I 是一个强而有选择性的训练信号。它不是普通的“再训练一会儿”。
但这些实验发生在已有双语 checkpoint 上，属于任务继续训练。它们没有比较真正的预训练阶段，因此不能证明预训练应该使用更高或更低 I。
这正是本文要留下的边界：

我们已经知道 I 能改变协议，但还不知道协议形成的哪个阶段最需要它。
5. 比例还要分清两种写法
“追加 20% I”不等于最终 batch 中有 20% I。如果先保留 100% Native，再额外追加 20% I，那么 I 在全部 token 中的占比是：
$$
\alpha_I=\frac{0.2}{1+0.2}=16.67\%
$$后续报告必须同时记录：

相对 Native 的追加剂量；
I 在全部训练 token 中的最终占比；
I 被放在预训练还是任务训练；
实际 optimizer step 数与 token 数。

否则“20% I”在不同实验里可能代表不同的训练过程。
6. 怎样验证阶段假说
最关键的实验不是继续扫描一个固定全程比例，而是保持总 I token、总训练 token 和更新次数一致，只移动 I 出现的阶段。
设两阶段合计允许 $M$ 个 Identity token，可以比较：

  
      
          实验臂
          预训练 I
          任务训练 I
          总 I 剂量
      
  
  
      
          Early-I
          $M$
          0
          相同
      
      
          Split-I
          $M/2$
          $M/2$
          相同
      
      
          Late-I
          0
          $M$
          相同
      
      
          No-I
          0
          0
          基线
      
  

每个带 I 的实验还需要同阶段 BB 等算力对照，排除“只是多训练”的解释。
在预训练结束和任务训练结束两个时间点分别保存 checkpoint，并测量：
Native NLL
跨视角 JS
chrF / BLEU
严重重复率
source shuffle damage
Identity / adjacent runtime override damage
不同长度区间的 source dependence
固定 Dreams 的实际生成
6.1 如果本文假说成立
Late-I 应该表现为：

预训练结束时保留更强的 Butterfly 结构差异；
任务阶段加入 I 后，JS 快速下降；
最终 Native NLL 与生成质量优于相同总剂量的 Early-I；
adjacent damage 不会被过早抹平。

6.2 如果纯累计剂量解释成立
只要总 I token 都是 $M$，Early-I、Split-I 和 Late-I 最终应该接近。I 在什么时候出现并不重要。
6.3 如果相反方向成立
Early-I 可能先建立一个稳定共同协议，使后续任务训练更容易。如果它最终同时获得更低 NLL、更低 JS 和更好生成，那么“预训练低 I”假说应被否定。
7. 这条假说为什么值得先公开
它提醒我们不要把当前 C07 的获胜配方直接提升成永恒架构参数。
Identity 更像训练课程中的药量：同一个剂量放在不同发育阶段，可能产生不同作用。预训练负责形成表示空间，任务训练负责选择输出方向；二者未必需要相同偏见。
当前最谨慎的结论是：

Identity replay 已被两轮实验确认能以很小 Native 代价显著改变跨视角协议。Houming818 提出，I 的主要位置可能不是预训练，而是任务训练；这项阶段假说尚无直接证据，必须通过等总剂量、等算力的 Early-I / Late-I 实验验证。
我们把它先作为开放资料发布，欢迎读者提出相反机制、实验漏洞或更节省算力的验证设计。
8. C07 正式产品训练的最终回报
2026 年 8 月 9 日，S3-TREEHEAP-BUTTERFLY-PRODUCT-C07 的第一颗完整产品种子训练结束。本节不是另开一条故事线，而是把本文前面仍处于“正在执行”的 C07 补成可以审计的最终记录。
8.1 这次实际训练了什么
实验从已有双语 Butterfly checkpoint 继续训练，正式读取路径仍是 Native Butterfly，同时配置 20% Identity replay。主要平台参数如下：

  
      
          项目
          数值
      
  
  
      
          seed
          9301
      
      
          语料文件可用行数
          14,170,275
      
      
          epoch
          4
      
      
          累计训练样本
          62,953,195
      
      
          累计训练 token
          1,331,240,167
      
      
          Identity replay 样本
          2,825,717
      
      
          TreeHeap width
          256
      
      
          state / hidden dimension
          256 / 256
      
      
          单卡墙钟时间
          52.6 小时
      
  

这里的“20%”是训练程序的 replay 配置值，不应该被误读为最终所有 token 中恰好有 20% 来自 Identity。实验另外记录了真实 replay 样本和 token，后续做剂量比较时必须使用真实计数，而不能只比较配置名称。
8.2 NLL 确实下降，而且测试集没有突然崩掉

  
      
          评价位置
          EN→ZH NLL ↓
          ZH→EN NLL ↓
          Mean NLL ↓
      
  
  
      
          启动时 validation
          -
          -
          3.588437
      
      
          最终 / 最佳 validation
          3.173284
          2.659531
          2.916408
      
      
          held-out test，Native Butterfly
          3.199092
          2.746413
          2.972753
      
      
          held-out test，运行时改成 Identity
          3.330987
          2.906930
          3.118958
      
  

从启动到最终验证点，Mean NLL 下降了 0.672029，相对约为 18.7%。测试 NLL 比最佳验证 NLL 高 0.056345，约为 1.9%。这说明本轮长训练不是只把训练样本背下来后在测试集上立即失效。
更关键的是运行时干预。保持同一个 checkpoint、同一批测试数据和同一个 Decoder，只把 Native Butterfly 坐标变换替换成 Identity，测试 NLL 增加：
$$
\Delta L_{\mathrm{identity}}
=3.118958-2.972753
=0.146205
$$这个结果支持一个有限而重要的判断：模型确实利用了 Native Butterfly 产生的结构状态。 如果 Butterfly 只是没有作用的外壳，运行时拿掉它不应该稳定增加测试损失。
但这项干预只能证明结构参与了预测，不能证明我们已经理解每个内部节点保存了什么，也不能证明模型已经获得逻辑推理能力。
8.3 dreams 告诉我们的另一半事实
只看 NLL，会把这轮结果说得过于乐观。最后一个固定样本集 step-000062953195.txt 显示，模型已经摆脱了早期“无论输入什么都只说一带一路”的全局条件坍缩，但仍没有成为可靠的翻译器。
有些信息保存得比较好。例如：
输入：传感器记录到37.6摄氏度和82%的湿度。
输出：The recorder 37.6 degrees Celsius, 82% humidity.
数字、单位和主要对象大体保留。下面这条指令也没有被当作问题直接回答：
输入：请把这句话翻译成英文，而不是回答其中的问题：为什么鲨鱼不坐沙发？
输出：Please put this word into English translation, not answer the question:
      why sharks not to sit in the sofa?
虽然英语并不自然，但任务方向和大部分内容仍在。
真正的失败集中在关系和逻辑对照上。

  
      
          对照输入
          最终输出摘要
          观察
      
  
  
      
          The doctor thanked the farmer.
          医生的感谢
          主体和客体没有完整落地
      
      
          The farmer thanked the doctor.
          医生的感谢，医生
          交换论元后输出没有相应交换
      
      
          Every lamp … / Not every lamp …
          两句都接近“灯台上的灯台上”
          否定与全称量词没有稳定区分
      
      
          before the door opened / after the door opened
          两句都生成门铃、敲门声
          前后时序没有可靠坍缩
      
  

长句能够留下事件轮廓。例如水泵样本仍保留了“自动启动、红色标记、两个压力传感器、30 秒”等成分；但条件层级、论元归属和句法顺序仍会错位。
因此，最终 dreams 呈现的是：
全局固定句坍缩：明显缓解
词汇与局部事件轮廓：已经出现
局部重复：仍然存在
主体/客体、否定、时序、数量关系：仍不可靠
产品级翻译：未达到
8.4 为什么 NLL 下降，句子却不一定同步变好
NLL 奖励的是“给参考 token 更高概率”。训练语料中，高频搭配、常见句式和局部续写占据了大量梯度；主体交换、否定翻转和前后时序这种关键对照，在总体 token 数中所占比例很小。
所以模型可以通过改善大量普通位置继续降低平均 NLL，却仍在少量决定句意的关系位置上犯错。固定 dreams 的人工观察还表明：随着后期 NLL 继续下降，个别句子的语义质量并不单调改善。
这不否定交叉熵训练，但说明产品验收不能只有一个总体 NLL。下一轮至少需要同时报告：

chrF、BLEU 或其他完整翻译指标；
主客体交换、否定、时序和数量的成对对照准确率；
重复率与生成长度；
Native / Identity 运行时干预损失；
固定 dreams 在多个训练时点的实际文本。

8.5 本轮可以支持什么，仍然不能支持什么
当前得到支持：

该 TreeHeap 配方可以在单张 3090 上稳定完成十亿 token 量级训练；
验证 NLL 持续下降，最终测试集没有出现严重泛化断裂；
Native Butterfly 在 held-out test 上具有可测量的因果贡献；
少量 Identity replay 可以进入正式训练流程，而没有让 Native 路径数值崩溃。

仍然开放：

Early-I、Split-I、Late-I 哪个阶段安排最好；
当前收益来自 Identity 的出现时机、累计剂量，还是两者共同作用；
TreeHeap 是否已经形成可以稳定处理论元、否定和时序的私有协议；
当前模型能否达到可用的翻译产品标准。

因此，C07 完成后，本文标题中的“阶段假说”仍然是 open，而不是 supported。C07 给出了可靠的长训练基线和结构参与证据，却没有执行等剂量的 Early-I / Late-I 因果比较，也没有通过最终的语言能力验收。
完整 Claim、代码与 Evidence 位于 SameTime 开放仓库。

License: GPLv3。本文公开阶段剂量假说、反证条件与实验设计，可自由复现、审计和修改。



[SPR-084] 预训练成功迁移，STOP 却没有学会停止：TreeHeap C10 最近进展审计
Wed, 12 Aug 2026 00:00:00 +0000
最近航到了哪里
距离上一篇公开进展已经有一段时间。这期间我们没有继续堆更多概念，而是把一个完整训练管线跑通，然后反过来审计模型到底学会了什么。
这次的 C10 管线分三步：
自然语料预训练
    -> 同样的 TreeHeap checkpoint 进入 WMT 中英任务训练
    -> 用概率后验、路径干预和 STOP 分辨率实验做 proof check
结果不是简单的成功或失败，而是两个同时成立的事实：

预训练确实把可迁移信息写进了 TreeHeap 参数。
递归 Decoder 没有学成我们期待的多分辨率读取协议，而是几乎把全部概率质量送到了 leaf。

这两个结果并不矛盾。模型可以学到有用信息，却通过一条比预期更浅的读出路径使用它。
1. C10 实际训练了什么
C10 不是 Transformer，也不是把一个矩阵改名为 TreeHeap。模型合同记录为：

  
      
          项目
          配置
      
  
  
      
          模型类
          ButterflyRecursive
      
      
          参数量
          34,448,396
      
      
          state / hidden
          256 / 256
      
      
          最大 heap width
          256
      
      
          地址通信
          XOR Butterfly
      
      
          FOLD
          learned lifting
      
      
          READ
          recursive probability container
      
      
          生成器
          GRU 自回归 Decoder
      
  

数据首先写到 leaf。Butterfly 按地址执行可逆的信息交换，然后 learned lifting 逐层把左右子节点合成为 parent，同时保存 detail。Decoder 再从 root 开始，通过 STOP 和左右分支概率读取不同深度的节点。
因此需要分清三个问题：
问题 A：H_state 里有没有学到信息？
问题 B：Butterfly 和 FOLD 是否真的参与了计算？
问题 C：READ 是否学会了有意义的分层读取？
最近实验给出的答案分别是：有、参与了、没有学成。
2. 预训练迁移是明确的正结果
预训练阶段读取 /home/nio/datasets/pretrain 的自然语料，并混入 25% 的 WMT 单语文本。模型训练了约一亿 token：

  
      
          指标
          数值
      
  
  
      
          pretrain steps
          97,657
      
      
          pretrain tokens
          100,000,768
      
      
          初始 valid NLL
          10.7237
      
      
          最佳 valid NLL
          5.6804
      
      
          墙钟时间
          4.85 小时
      
  

随后我们构造两条完全等算力的 WMT 任务训练臂：

PT：从预训练 checkpoint 开始；
SC：从相同初始随机状态直接学习 WMT。

两条任务臂使用相同的数据流哈希、25,000 step 和 20,198,612 个任务 token。

  
      
          任务结果
          PT，预训练后
          SC，从零训练
          PT 改善
      
  
  
      
          test NLL，越低越好
          5.4037
          6.2920
          -0.8883
      
      
          token BLEU4，越高越好
          5.0654
          1.1711
          +3.8943
      
  

这组比较可以支持一个有限 Claim：

在相同 WMT 训练预算下，先用自然语料预训练的 TreeHeap 比从零开始更快得到较低的测试 NLL 和较高的 token BLEU。
它不能证明模型已经会可靠翻译。实际生成仍有错译、重复和关系混乱。这里证明的是协议可以迁移，不是产品已经完成。
3. 后验 proof 看到了条件信息，但信号仍弱
我们又比较了模型给出的下一 token 概率桶与语料经验分布。

  
      
          模式
          JS，越低越接近语料
          候选集合概率质量，越高越好
      
  
  
      
          Native source
          0.6094
          0.0620
      
      
          Wrong source
          0.6380
          0.0388
      
      
          Unigram baseline
          0.6410
          0.0333
      
  

换错 source 后，78.6% 的 greedy token 发生改变；破坏最底层左右配对后，58.3% 的 greedy token 发生改变。模型不是完全无视输入，也不只是复读全局最高频逗号。
但 0.6094 距离理想分布仍然很远，候选质量也不高。它更适合被描述为“已经出现 source-conditioned signal”，还不能写成“形成了完整世界模型”。
4. 真正的问题出在 READ
TreeHeap 的编码方向是从 leaf 向 root：
token leaves
    -> Butterfly 地址通信
    -> FOLD：leaf -> parent -> root
    -> 得到 root + 多层 details
生成时的读取方向相反：
root
    -> 判断 STOP，或继续到 child
    -> 左右分支分配概率
    -> 直到某个深度停止
    -> 形成 context，送给 GRU Decoder
当前 STOP 不是硬开关。对到达节点的概率质量 a，程序计算：
stop_mass     = a * sigmoid(stop_logit)
continue_mass = a * (1 - sigmoid(stop_logit))
只要 stop_logit 是有限数，sigmoid 就不会严格等于 0 或 1。程序也没有“低于某个数就视为停止”的观察精度。到达 leaf 后，才被强制全部停止。
C10 在训练早期就把内部 STOP 压到了近乎零。第 1,000 step 时，约 99.9936% 的读取质量已经到达 leaf；最终测试时，平均 leaf 质量约为：
0.9999999963
也就是说，数学上还有极小的中间层尾巴，工程上却已经等于一路走到底。
5. 强制 leaf 后，模型几乎完全不变
我们在 256 条 held-out WMT 样本、5,226 个目标 token 上做了运行时干预。checkpoint 和所有参数保持不变，只改读取方式。

  
      
          READ 干预
          NLL
          相对 Native 变化
      
  
  
      
          Native learned STOP
          5.299829634
          0
      
      
          Force leaf
          5.299829704
          +0.000000070
      
      
          Uniform branch
          5.403492
          +0.103662
      
      
          Runtime Identity，拿掉 Butterfly
          5.660286
          +0.360457
      
      
          Break depth-0 pair
          5.690986
          +0.391156
      
  

Native 与 Force leaf 在数值误差范围内相同。这说明 learned STOP 实际已经等价于 leaf-only read。
另一方面，拿掉 Butterfly 或打乱最底层 FOLD 配对会明显增加 NLL。这说明结构变换仍然改变了 leaf 内容，不能说整个网络只是未经处理的原始数组。
最精确的描述是：

C10 学到的是“经过 Butterfly/FOLD 结构变换的叶层读出”，不是“能在 root、parent 与 leaf 之间按语义选择分辨率的 TreeHeap READ”。
6. 它是不是只沿一条链表路径读取
Houming818 随后提出了一个重要反问：既然都走到 leaf，会不会只剩一条固定路径，TreeHeap 退化成了一条链表？
我们没有靠猜测回答，而是重建每个生成 step 的 leaf 权重，并逐级裁剪。
如果它真是一条单路径，Top-1 leaf 应该占据绝大部分概率，保留 Top-1 后 NLL 也不应明显变差。实验却得到：

  
      
          读取叶集合
          覆盖的平均概率质量
          NLL 增量
      
  
  
      
          Top-1
          21.04%
          +4.0048
      
      
          Top-2
          33.69%
          +1.5362
      
      
          Top-4
          51.10%
          +0.5050
      
      
          Top-8
          72.22%
          +0.1383
      
      
          删除 Top-1
          其余质量
          +0.0829
      
  

单路径假说因此被否定。有效 leaf 数约为 15.85，每条样本在生成过程中平均出现 6.72 个不同的 argmax leaf，地址平均跳跃 6.30 格。它不是顺序游标，也不是只盯着一个 leaf。
可是另一个结果同样重要：把所有有效 leaf 改成均匀平均，NLL 只增加 0.0271；逐层把左右分支改成均匀分配，大部分 NLL 变化也只有千分位。
所以它也没有形成强而清晰的“语义树索引”。当前更像下面这个过程：
Butterfly/FOLD 改写 leaf state
    -> READ 把很多 leaf 分配一个较宽、较弱的概率桶
    -> 加权求和为 context
    -> GRU 根据 context 逐 token 生成
若第 i 个变换后 leaf 是 L_i，第 t 个生成 step 的读权重是 alpha_ti，那么 context 可以写成：
c_t = sum_i(alpha_ti * L_i)
这就是本文所说的 leaf pooling。它不是“所有 leaf 都相同”，而是“Decoder 主要在叶层对许多 leaf 做软加权”。
7. 观察者分辨率假说，解决了哪一部分
Houming818 提出了一个很具体的物理类比：

现实中的停止不要求光通量严格等于零。只要信号低于观察者能够分辨的极限，工程上就应该把它当作零。
我们据此加入一个不训练参数的诊断规则：如果某条活动路径的质量小于等于 epsilon，就在当前节点停止，不再展开它的两个孩子。
第一次 smoke 因统计张量发生别名污染而产生不可能的质量总和，我们将该结果作废，并重新执行。有效重跑覆盖 128 条 held-out WMT 样本和 2,532 个 token。

  
      
          epsilon
          NLL 增量
          少访问的节点
          仍到达 leaf 的质量
      
  
  
      
          0
          0
          0%
          99.999999%
      
      
          0.0001
          +0.000057
          6.23%
          99.999262%
      
      
          0.001
          +0.001791
          8.24%
          99.987412%
      
      
          0.003
          +0.010178
          10.11%
          99.932139%
      
      
          0.01
          +0.069846
          14.06%
          99.495583%
      
  

这个实验支持一半，也否定一半：

支持：有限观察精度可以安全剪掉一部分数学上非零、实际贡献极小的尾路径。
未通过正式门槛：没有一个点同时达到“至少省 10% 节点”且“NLL 增量不超过 0.001”。
否定充分性：即使 epsilon=0.003，仍有 99.93% 的质量到达 leaf。阈值能清理尾巴，却不能把主流量抬回 parent。

因此，C10 同时存在两个现象：
现象一：sigmoid 产生了永不严格归零的数值尾巴
现象二：训练本身把绝大部分有效质量送到了 leaf
观察者分辨率解决的是第一个问题，不是第二个。
8. 现在到底可以声明什么
已有证据支持

自然语料预训练可以迁移到同一 TreeHeap 的 WMT 任务训练；
Butterfly 地址通信和 FOLD 配对对 held-out NLL 有可测量的因果作用；
source、错误 source 与配对破坏会改变概率后验；
有限分辨率可以剪掉 6% 到 10% 的低质量路径，代价可测量。

已被当前证据否定

C10 的 Native READ 不是有效的多分辨率 STOP 协议；
它不是只沿一条固定链表路径读取；
单纯增加一个小阈值，不能把 leaf collapse 修成语义分层读取。

仍然开放

如何让内部节点在任务 loss 中获得不可替代的价值；
STOP 如何在不依赖手写固定深度的情况下学会有限分辨率；
root、parent、detail 与 leaf 能否形成稳定的私有编解码协议；
这种协议能否最终改善完整翻译与逻辑对照，而不只是降低平均 NLL。

9. 下一步不再盲目加训练时间
C10 已经说明，单纯继续喂更多 token 可能只会把 leaf-only 读法训练得更熟。下一步首先要做的是一个等数据、等 step 的形成机制实验，而不是直接再开一次长训练。
最小实验应比较：
A. 当前自由 soft STOP
B. 训练时加入有限观察分辨率，但不指定固定停止深度
C. 在训练中随机限制可见最大深度，检查内部节点能否获得可读信息
三条臂都要同时报告：
任务 NLL 与完整生成质量
每层 stop mass
force-depth 因果损失
uniform-leaf 与 Top-K leaf 损失
Butterfly / pair-break 损失
实际节点访问量
其中 C 不是最终架构承诺，只是诊断压力：如果内部节点在被迫读取后仍学不到有用信息，问题可能在 FOLD state；如果能学到，问题则主要在自由优化器总能选择更容易的 leaf 路径。
10. 一句话进展

我们已经证明 TreeHeap 能从自然语料获得可迁移参数，也证明 Butterfly/FOLD 确实参与预测；但 C10 的自由 STOP 没有形成多分辨率私有协议，而是退化为对变换后 leaf 的宽分布软池化。观察者分辨率能剪尾，不能独自纠正主流量。下一阶段的核心已从“再训练多久”变成“什么形成条件能让 parent 真正值得被读取”。
ARA 设计、代码和结构化 Evidence 将继续整理到 SameTime 开放仓库。所有失败路径保留，不用事后改写故事。

License: GPLv3。本文中的 Claim、反证条件、实验过程与数据可自由复现、审计和修改。



[SPR-085] 能量守恒不等于学习压力守恒：TreeHeap FOLD 的隐藏梯度功能
Mon, 24 Aug 2026 00:00:00 +0000
一个看起来理所当然的问题
最近我们重新检查 TreeHeap 的多分辨率退火 FOLD。问题从一句很简单的追问开始：

左右子树在同一层合并时，为什么使用平方和，而不是像某些物理变换那样使用乘法？
这次追问最后揭开了两个不同的问题：

同一层的两个状态怎样组成一个 parent；
一个子树的绝对尺度怎样沿递归地址传播。

第一件事适合使用平方和。第二件事确实可以使用乘法，但应该乘的是无量纲的路径比例，而不是直接把左右能量相乘。
我们为此实现了一个新的递归能量载体，先在人工树上成功修复梯度爆炸，再把它带到训练后的真实 TreeHeap checkpoint 上审计。最后的决定却是：暂时不要把新公式放进训练。
原因不是候选算错了，而是它修复的病灶没有出现在当前真实数据中，同时它削弱了另一个此前没有被单独披露的功能：当前 FOLD 会在每一层重新归一化，因而隐式补偿递归深度带来的梯度衰减。
这项功能不是我们刻意隐藏的。恰恰相反，直到这次正反对照完成，我们才确认它一直存在于公式中。
1. 当前 FOLD 到底做了什么
设左右子节点相对零点的状态为 $a$ 和 $b$。当前零点参考系 FOLD 计算：
$$
s=\sqrt{\lVert a\rVert^2+\lVert b\rVert^2+\varepsilon}
$$$$
P=\frac{a+b}{\sqrt{2}s}
$$$$
D=\frac{b-a}{\sqrt{2}s}
$$其中：

$P$ 是继续向 root 递归的 parent；
$D$ 是保存左右差异的 detail；
$s$ 是本层保存的尺度；
当前实现取 $\varepsilon=10^{-8}$。

只要同时保留 $P,D,s$，就能恢复左右状态：
$$
a=\frac{s(P-D)}{\sqrt{2}}
$$$$
b=\frac{s(P+D)}{\sqrt{2}}
$$所以这个变换在连续数值上是可逆的。它还有一个直接的前向性质：分子变大时，分母也随之变大，因此 parent norm 被限制在有限范围。
但这里容易产生一个误会：

前向状态有界，不代表反向梯度也有界。
反向传播关心的是 parent 对输入变化的敏感度。Jacobian 中包含近似的 $1/s$。当某层输入尺度非常小时，微小变化会被放大。
2. 人工树第一次暴露了近奇异点
我们先构造 8 个 leaf：
[a, -a, a, -a, a, -a, a, -a]
第一层每对强信号都精确抵消：
a + (-a) = 0
第一层的 detail 和 scale 仍然保存了信息，因此 UNFOLD 可以精确恢复。但是只有 parent 会继续向上参加下一层 FOLD。下一层看到的是：
[0, 0, 0, 0]
此时新的局部尺度只能落到：
$$
s=\sqrt{\varepsilon}=10^{-4}
$$连续两层 Jacobian 中的 $1/s$ 相乘，理论量级接近 $10^8$。float64 toy 的实际 root-to-leaf 梯度 norm 为：

  
      
          输入
          当前 FOLD 梯度 norm
      
  
  
      
          所有 leaf 同向
          0.34761
      
      
          正负交替、精确抵消
          70,710,677.94
      
  

与此同时，parent 仍然有界，FOLD/UNFOLD 最大闭包误差只有约 $4.3\times10^{-14}$。这里必须把两个指标严格分开：
$$
e_{closure}=\left\lVert\operatorname{UNFOLD}(\operatorname{FOLD}(x))-x\right\rVert_\infty
$$衡量的是：把同一次 FOLD 保存下来的 $P,D,s$ 全部交还给 UNFOLD，原输入能否恢复。它是一项当前点上的代数闭包检查。
而梯度实验衡量的是：
$$
g=\left\lVert\frac{\partial\,\operatorname{root}(x)}{\partial x}\right\rVert
$$它描述的是：输入在当前点附近稍微移动，root 会移动多快。这是一项邻域敏感度检查。文中的“爆炸”指 $g$ 爆炸，不是 parent 数值爆炸，也不是 $e_{closure}$ 爆炸。
一个最简单的类比是 $y=10^8x$：在 $x=0$ 时，$y$ 仍然等于 0；若同时保存逆变换，$x=y/10^8$ 也能精确还原。但它的导数仍然是 $10^8$。在本次正负交替 toy 中，把第一个 leaf 从 $1$ 改为 $1+10^{-10}$，scalar root 会从 0 移动到约 $2.5\times10^{-3}$，局部放大约 $2.5\times10^7$。这才是巨大梯度对应的实际含义。
因此，闭包误差很小并不反驳梯度爆炸。相反，两者同时出现，说明这个变换可逆但条件很差。这说明三件事可以同时成立：
前向状态值不爆炸
携带完整 P、D、s 时可以精确还原
root 对 leaf 的反向梯度仍然可能病态
3. 新候选：让节点携带绝对能量
当前算法会保存每层的 $s$，但保存它只是为了以后 UNFOLD。下一层 FOLD 只接收 $P$，并不知道这个零是“没有信号”，还是“两个强信号抵消形成的零”。
新候选让每个节点携带二元状态：
(u, E)
其中 $u$ 是归一化方向，$E$ 是该子树的绝对能量。leaf 初始化为：
$$
E_{leaf}=\sqrt{\lVert x\rVert^2+\varepsilon}
$$$$
u_{leaf}=\frac{x}{E_{leaf}}
$$左右子树合并时，同层能量仍然使用平方和：
$$
E_P=\sqrt{E_L^2+E_R^2}
$$方向和差异则计算为：
$$
P=\frac{E_Lu_L+E_Ru_R}{\sqrt{2}E_P}
$$$$
D=\frac{E_Ru_R-E_Lu_L}{\sqrt{2}E_P}
$$这样，即使 $P=0$，上层仍然知道 $E_P$ 很大。
乘法出现在纵向地址传播。定义无量纲比例：
$$
r_{child}=\frac{E_{child}}{E_{parent}}
$$沿一条 root-to-leaf 路径：
$$
E_{leaf}=E_{root}\prod_{d=1}^{D}r_d
$$所以，更准确的规则是：

同层左右合并使用平方和，跨层地址上的相对尺度使用乘法。
4. 为什么不能直接把左右能量相乘
我们还实现了一条直接乘法反例：
$$
s_{product}=\sqrt{\lVert a\rVert\lVert b\rVert+\varepsilon}
$$它在左右能量接近时看起来正常，却会在能量失衡时破坏 parent 有界性。

  
      
          输入
          直接乘法的最大 parent norm
      
  
  
      
          左右幅度 100 与 0.01
          70.71775
      
      
          一侧正常、一侧为零
          7,071.0678
      
  

问题很直观：一侧为零时，乘积也为零，分母重新落到 $\sqrt{\varepsilon}$，而另一侧的强信号仍留在分子中。
乘法不是不能用，而是不能用在量纲不合适的位置。
5. toy 上，新候选成功了
同样的正负交替树上，递归能量载体得到：

  
      
          输入
          当前 FOLD
          能量载体 FOLD
      
  
  
      
          同向 leaf 梯度
          0.34761
          0.34761
      
      
          抵消 leaf 梯度
          70,710,677.94
          0.35355
      
  

新候选同时满足：

parent 有界；
FOLD/UNFOLD 闭包误差约 $2.8\times10^{-14}$；
root-to-leaf 路径能量乘法重建误差为 0；
抵消时的梯度回到正常输入同一数量级。

如果研究在这里停止，我们很容易得出一个漂亮但危险的结论：新候选已经修好了当前 FOLD。
于是我们继续做了真实 checkpoint 审计。
6. 真实数据中，病灶根本没有出现
我们冻结 S3-STONE2-INTEGRATED-C03 的 pretrain checkpoint，使用它训练后的 token embedding 和 Native XOR Butterfly 输出。数据不是重新编造的 toy，而是 224 个真实自然文本验证窗口：

  
      
          source width
          样本数
      
  
  
      
          4 / 8 / 16 / 32 / 64 / 128 / 256
          每档 32
      
  

为了量化左右子树是否抵消，定义共同方向比例：
$$
q=\frac{\lVert left+right\rVert}{\lVert left\rVert+\lVert right\rVert+tiny}
$$$q$ 越接近零，左右状态越接近反向抵消。
审计结果：
全部节点 q < 0.10 的数量：0
全局最小 q：0.58384
样本最小 q 的中位数：0.65610
也就是说，在这个训练后的 TreeHeap 状态里，左右节点普遍同向成分很强。人工 alternating tree 所揭示的数学边界真实存在，但它没有成为当前自然文本状态的实际病灶。
7. 此前没有单独披露的功能出现了
真实数据上，能量载体确实让梯度更小。但按句长拆开后，我们发现“小”并不自动等于“稳定”：

  
      
          width
          当前 FOLD 梯度 p50
          能量载体梯度 p50
          current/carrier
      
  
  
      
          4
          0.04459
          0.03131
          1.419
      
      
          8
          0.04404
          0.02183
          2.023
      
      
          16
          0.04111
          0.01524
          2.690
      
      
          32
          0.03622
          0.01076
          3.408
      
      
          64
          0.03035
          0.00757
          4.005
      
      
          128
          0.02153
          0.00528
          4.068
      
      
          256
          0.01483
          0.00370
          3.994
      
  

从 width 4 增加到 256：

能量载体梯度下降约 8.5 倍；
当前 FOLD 梯度只下降约 3 倍。

能量载体把绝对尺度一路保存下来，也让 root probe 的梯度自然分摊到越来越多的 leaf。当前 FOLD 每一层都从当层 parent 重新估计尺度，相当于在递归路径上反复做局部增益调整。它并没有消除长程衰减，却补回了相当一部分梯度压力。
这就是此前没有单独披露、也没有被我们明确识别的功能：

当前 FOLD 不只是前向退火编码器，它还是一个隐式的逐层梯度补偿器。
需要强调，这不是说当前公式已经正确，也不是说梯度越大越好。它只说明，贸然把每层重新归一化替换为严格的绝对能量传播，可能在修复一个未出现的极端奇点时，先破坏真实训练所需的长深度学习压力。
8. 能量和学习压力不是同一个量
这次实验帮助我们区分了四个经常混在一起的概念：

  
      
          概念
          它回答的问题
      
  
  
      
          状态幅度
          当前节点的数值有多大
      
      
          子树能量
          节点覆盖的信息载体总尺度有多大
      
      
          前向可逆性
          保存 root、detail、scale 后能否恢复输入
      
      
          梯度压力
          task loss 能以多强的信号修改远端参数
      
  

能量守恒解决不了梯度压力。前向可逆也不能保证反向条件良好。反过来，梯度较大也不能证明信息更多，它可能是有效补偿，也可能是病态放大。
因此，TreeHeap 的递归退火算法至少需要同时审计：
前向状态是否有界
FOLD/UNFOLD 是否闭包
不同深度梯度是否衰减
极端抵消处是否近奇异
真实语料是否真的进入这些极端区域
任何单一指标都不足以决定公式。
9. 为什么我们没有继续训练新候选
真实 checkpoint 审计在执行前预注册了停止条件：只有自然数据存在可测抵消尾部，并且能量载体显著改善梯度尾部，才允许进入短训练 ablation。
最终结果为：
A0 数值闭包与有限性：通过
A1 真实抵消尾部存在：失败
A2 current 梯度 p99 至少是 carrier 两倍：失败
A3 抵消指标与梯度比相关：通过，但与句长共同变化，不能独立解释
最终决定：do_not_train_energy_carrier_yet
所以我们没有用更多训练掩盖问题，也没有因为 toy 漂亮就宣布改进成功。
能量载体作为一个数学候选和边界修复工具保留。当前正式 FOLD 不修改。下一步回到真实 task loss，分离每个深度对共享 READ、depth embedding、branch 和 recurrent decoder 的参数梯度，寻找多深度负交互真正发生的位置。
10. 一句话结论

TreeHeap 的递归能量载体能够修复人工反向抵消造成的梯度奇点，但这个病灶没有出现在当前真实文本 checkpoint 中；反而是现有逐层归一化暴露出一个此前未被明确识别的功能，它会补偿部分长深度梯度衰减。能量守恒不等于学习压力守恒，因此新候选在训练前被主动停止。
完整 ARA、代码与 Evidence：

递归能量载体 toy
真实 checkpoint 能量与梯度审计
机器可读审计结果


原创与 License： 本文中的 TreeHeap 递归能量载体、路径比例传播设计、梯度补偿解释、Claim、反证条件与实验流程由 Houming818 与 Codex 在 TreeHeap 研究过程中共同提出和验证。代码与 ARA Evidence 依 SameTime 仓库许可证开放；本文内容采用 GPLv3，可复现、审计和修改。本文不声明该候选优于其他架构，也不把数值 smoke 外推为语言或意识结论。



[SPR-086] 压力板为什么没有长出私有协议：D07 三轮因果审计
Fri, 28 Aug 2026 00:00:00 +0000
昨晚为什么没有正式训练
昨晚我们原本准备启动一轮长训练。最后 GPU 没有进入正式任务，不是基础设施故障，也不是因为害怕实验失败，而是预注册的 smoke gate 阻止了它。
这次 gate 做了它应该做的事：在几分钟内告诉我们，当前结构虽然已经能够施加“压缩压力”，但还没有充分学会“有限空间里应该保存什么”。如果在这个状态下直接训练一夜，我们更可能得到一个更熟练的语言捷径，而不是更可靠的 TreeHeap 私有协议。
这篇文章把 D07、D07R1 和 D07R2 三轮实验放到一张图里，解释我们已经解决了什么、失败在哪里，以及下一步为什么要从“自由查询”转向“结构覆盖”。
1. 先区分两个问题
前一阶段的 D06 已经做出了一个可工作的压力板：递归深度越浅，可使用的协议槽位越少；递归深度越深，可使用的槽位越多。
若完整深度为 D=7，输入有效长度为 L，深度 d 的容量近似为：
B(d) = max(2, ceil(L * 2^(d-D)))

d=5  -> 约 1/4 容量
d=6  -> 约 1/2 容量
d=7  -> 完整容量
这解决的是容量控制：我们已经可以把一块板压成四分之一、二分之一或完整大小。
但容量控制不等于语义压缩。给模型四个槽位，并不会自动让四个槽位分别学会“人物、动作、对象、时间”。模型也可能把四个槽位都用来保存同一类高频信号。
所以 D07 研究的是第二个问题：

在容量受限时，梯度能否自己形成 Encoder 与 Decoder 共同理解的私有协议？
2. D07 的数据流到底是什么
D07 没有人工提供缩句、语法标签或目标前缀。它只把源句写入冻结的 source TreeHeap，然后允许若干个 query 从 root 出发，递归读取左右子堆，形成有限数量的协议槽位。
source sentence
    -> frozen source TreeHeap H
    -> recursive READ queries
    -> B(d) protocol slots
    -> recursive FOLD into a protocol TreeHeap
    -> shared recursive READ / decoder
    -> reconstruct the full target sentence
训练目标仍是完整目标句的 token 交叉熵。目标 token、目标长度和参考译文都不能进入压缩器，也不能参与容量计算。
因此，这不是把正确答案偷偷截短后交给模型。它是一项最小的码率-失真试验：
递归深度 d  -> 可用容量，也就是码率
完整句 NLL  -> 重建误差，也就是失真
如果它成功，梯度应该在有限槽位中形成某种可读协议。我们不预先规定协议必须长得像人类语法，只要求它确实携带输入信息，并且能帮助 Decoder。
3. 三把因果尺子
只看训练 NLL 下降是不够的。Decoder 即使完全忽略输入，也可能通过学习目标语料的高频词和常见句式降低 NLL。
因此我们固定同一个测试集，做三种读法：

  
      
          读法
          操作
          它在检查什么
      
  
  
      
          native
          使用当前样本自己的协议槽位
          正常路径
      
      
          shuffle
          换成另一个样本的槽位
          协议是否保存了“这是哪个输入”
      
      
          zero
          把所有协议槽位置零
          协议总体上是在帮助还是干扰 Decoder
      
  

指标写成：
delta_shuffle = NLL(shuffle) - NLL(native)
delta_zero    = NLL(zero)    - NLL(native)
正数表示干预使结果变差，也就是 native 协议具有正向贡献。
预注册门槛要求：至少两个深度中，delta_shuffle 和 delta_zero 都不小于 +0.10。这个门槛不神圣，但它是在看结果之前写下的，不能因为结果只差一点就临时修改。
4. 第一轮：NLL 大降，却是语言捷径
D07 训练了 120 steps。三个深度的 valid NLL 都大幅下降：

  
      
          depth
          初始化 NLL
          训练后 NLL
          下降
      
  
  
      
          5
          21.865
          8.291
          13.574
      
      
          6
          23.473
          8.006
          15.467
      
      
          7
          25.018
          7.987
          17.030
      
  

如果只看这张表，实验似乎非常成功。但因果干预给出了相反答案：

  
      
          depth
          delta_shuffle
          delta_zero
      
  
  
      
          5
          +0.060
          -1.902
      
      
          6
          +0.056
          -1.523
      
      
          7
          +0.067
          -1.513
      
  

zero 反而比 native 好很多。这说明协议槽位不是 Decoder 的有效信息源，而是干扰源。NLL 的下降主要来自可训练 Decoder 学会了目标语料的边际分布。
这里原先使用“闭卷考试”作比喻并不准确。计算 NLL 时使用了 teacher forcing。即使源句协议被清零，Decoder 每一步仍然能看到此前的正确目标 token：
native: P(y_t | 正确目标前缀 y_zero:   P(y_t | 正确目标前缀 y_
所以更准确的比喻是：学生看不到英文原题，但每道填空题都能看到此前的正确中文答案。她当然可以依靠已经学会的中文规律继续答题。这项能力本身是好的，说明参数 theta 和当前 Decoder 隐态已经形成了语言背景。
负面证据只针对一个更窄的 Claim：加入当前源句协议 C(x) 后，成绩反而下降，说明当时“英文原题到中文答题系统”的通道尚未对齐。它不表示 Decoder 没学到规律，也不表示模型整体一无所获。
所以第一轮不能证明私有协议。
5. 第二轮：冻结语言捷径，输入身份出现了
D07R1 冻结了继承的语言骨架，只允许压力协议两端的递归映射学习。这样 Decoder 不能再通过修改词频输出层独自降低损失。
训练 300 steps 后：

  
      
          depth
          delta_shuffle
          delta_zero
      
  
  
      
          5
          +0.587
          -1.440
      
      
          6
          +0.618
          -1.360
      
      
          7
          +0.617
          -1.358
      
  

这一次 shuffle 明显变差。它证明槽位不是常量，也不是完全相同的词频模板：槽位已经携带了“当前输入是谁”的样本相关信息。
但是 zero 仍然更好。也就是说，槽位里虽然有信息，但它进入冻结 Decoder 时的整体坐标或幅度不合适，干扰大于帮助。
这像是收到了一封确实属于你的加密邮件，但直接把密文当正文显示。寄件人身份对了，内容接口却没有对齐。
6. 第三轮：小流量接入，方向终于变正
D07R2 没有改变数据、容量公式、FOLD 或损失，只在协议进入 Decoder 前增加一个所有深度共享的有界增益：
gain = sigmoid(a)
slot_used = gain * slot
增益从约 0.0180 开始，训练后为 0.0204。这相当于先用很小的流量接入旧 Decoder，让两边逐步建立坐标关系，而不是第一步就用满幅状态覆盖旧参考系。
600 steps 后，因果符号第一次全部转正：

  
      
          depth
          delta_shuffle
          delta_zero
      
  
  
      
          5
          +0.096
          +0.036
      
      
          6
          +0.139
          +0.071
      
      
          7
          +0.142
          +0.064
      
  

这张表可以支持两个有限结论：

打乱样本会变差，协议包含输入身份信息；
清空协议也会变差，协议开始对 Decoder 产生正向贡献。

但 zero 损失只有 +0.036 到 +0.071，没有达到预注册的 +0.10。因此严格结论仍然是：
smoke_blocks_formal
这不是“差一点就算通过”。它表示方向修正了，但信号还太弱，不值得立即投入一夜长训练。
7. 为什么深度增加没有带来可见的新信息
D07R2 中，深度 5、6、7 的可用槽位数量不同，理论上应该对应不同码率。但自由生成样例几乎相同，BLEU4 都约为 0.642，没有出现我们期待的“深度增加后细节逐渐补全”。
训练日志还给出了一条重要线索：递归 READ 的分支熵在若干训练阶段迅速接近 0。熵接近 0 表示左右选择变得极其确定，query 不再同时探索多个候选分支。
已经观察到的事实是：

不同深度生成几乎相同；
增加容量带来的 NLL 边际收益很小；
部分递归分支熵接近 0；
shuffle 损失明显大于 zero 损失。

当前最合理、但尚未被直接证明的推断是：

多个自由 query 可能收敛到了少数相似路径或相似子堆。它们能携带样本指纹，所以 shuffle 有明显影响；但新增槽位重复读取相近内容，所以清空全部槽位造成的净损失仍然很小，深度之间也没有形成分辨率差异。
这里必须诚实地保留“可能”。当前日志只测了每步分支熵，没有直接计算不同槽位之间的路径重叠率。因此我们还不能写成“已经证明所有槽位读取同一个节点”。
8. 下一步：从自由竞争改为结构覆盖
当前每个槽位都像一名自由记者：大家可以去整棵树的任何地方采访。梯度会把所有记者派往最容易降低 NLL 的热门地点，却没有动力保证有人覆盖其他区域。
下一步候选不是给槽位写入“主语、谓语、宾语”等人工语义，而是给它们最小的 TreeHeap 地址责任：
depth 5: 少量槽位，各自负责较大的 subheap
depth 6: 更多槽位，各自负责更小的 subheap
depth 7: 继续细分 frontier，覆盖更细的地址区域
每个槽位只能在自己的 subheap 内使用同一个共享 READ kernel 学习压缩。也就是说：
结构先验只规定“去哪里读”
梯度仍然决定“在那里保留什么”
这和 flat array 切片不同。分区依据的是递归 TreeHeap 地址与 subheap frontier；不同深度的分区由同一棵树递归细化，局部读取仍共享同一组 kernel 参数。
它也不是提前定义语言含义。某个槽位最终保存动作、对象、时序还是别的隐态，仍由完整目标重建损失决定。
9. 新候选必须怎样被证明
下一轮不能只看 NLL。至少要提前登记四组指标：

覆盖率：有多少 source leaf 被至少一个槽位的主要路径覆盖；
重叠率：不同槽位的路径或终点有多大比例重合；
输入因果性：继续比较 native、shuffle 和 zero；
容量边际收益：新增槽位是否带来新的 NLL 收益与可见生成差异。

还需要两个重要对照：

  
      
          对照
          目的
      
  
  
      
          自由 query
          判断结构 ownership 是否真的减少重复读取
      
      
          随机打乱 ownership
          判断收益来自 TreeHeap 邻接结构，还是仅仅来自把槽位强行分开
      
  

只有当“结构覆盖”同时降低槽位重叠、提高 source 覆盖，并让 native 对 zero 的优势稳定超过预注册门槛，才允许进入正式长训练。
10. 这算不算已经有了背景知识
现在可以确认，模型已经能学习某些背景规律，但需要区分三个层次：

  
      
          载体
          当前能保存什么
      
  
  
      
          参数 theta
          长期词频、常见句式和目标语言统计关系
      
      
          Decoder 隐态
          当前正确目标前缀形成的短期状态
      
      
          TreeHeap 协议 C(x)
          当前输入的样本相关信息，目前只有弱正贡献
      
  

因此，“没有源句仍能降低 NLL”支持的是语言背景模型存在。它还不能直接升级为“TreeHeap 已经形成世界模型”，因为我们尚未证明事实、对象关系和状态变化被结构化地写入 TreeHeap，并能跨表述查询和组合。
更合适的当前分级是：
目标语言统计规律       已有证据
输入相关的私有协议     弱正证据
TreeHeap 背景知识      尚未定位
可查询的世界模型       尚未证明
这不是降低目标，而是避免用终极问题一次否定所有中间生长。
11. 参考 GPT-2 / GPT-3，怎样安排能力阶梯
GPT-2 没有以“完整世界模型”作为早期验收。研究者同时训练了约 117M / 345M / 762M / 1.5B 四档模型，观察跨域语言建模、连贯生成以及问答、摘要、翻译等零样本行为是否随规模出现。论文同时承认，很多下游任务仍然非常初步，所有模型当时也仍未充分拟合 WebText。GPT-2 论文
GPT-3 继续使用自回归语言目标，并把测试明确分成 zero-shot、one-shot 和 few-shot。测试时不更新梯度，只改变输入中的任务说明和示例。论文在 125M 到 175B 的模型序列上观察到，多数任务随规模相对平滑地改善，但自然语言推断和部分阅读理解仍然困难。GPT-3 论文
TreeHeap 应当采用同样的分级思想，同时增加自己的结构因果门：

  
      
          阶梯
          最近目标
          当前状态
      
  
  
      
          1. 语言底座
          学会词频、句式和上下文续写
          已有基础证据
      
      
          2. 输入协议
          native 稳定优于 shuffle/zero
          D07R2 弱正，未过门
      
      
          3. 任务萌芽
          冻结一个 checkpoint 后出现续写、填空、翻译、文内问答
          未正式测试
      
      
          4. Scaling Curve
          参数、数据、算力增加时，语言能力与结构贡献共同改善
          待建立
      
      
          5. 上下文适应
          不更新梯度，few-shot 稳定优于 zero-shot
          未测试
      
      
          6. 知识关联
          同一事实换一种表述仍可取回
          未测试
      
      
          7. 世界状态
          关系可组合、状态可更新并参与预测
          长期目标
      
  

当前不能从第二级直接跳到第七级。最近航线仍然是：先让 TreeHeap 输入协议稳定产生正贡献，再观察同一 checkpoint 是否开始出现多个任务，而不是立即要求它完成因果和反事实推理。
11.1 我们约 10 BLEU，和 GPT-2 的 5 BLEU 怎么比较
历史 TreeHeap 配方在专门的中英平行语料训练后，曾得到约 9.9--12.7 的自制 token-BLEU4。GPT-2 在 WMT-14 英译法上约为 5 BLEU，法译英约为 11.5 BLEU。数字看起来接近，但两场考试并不相同：

  
      
          条件
          GPT-2
          历史 TreeHeap
      
  
  
      
          语言方向
          英法
          英中
      
      
          翻译监督
          几乎没有专门平行训练
          使用中英平行语料专门训练
      
      
          能力性质
          通用语言模型中出现的翻译行为
          专门 seq2seq 通道
      
      
          BLEU 实现
          WMT 评测
          自制 BPE token-BLEU4
      
  

因此不能写成“TreeHeap 10 分，所以整体超过 GPT-2”。但可以保留一个重要结论：

TreeHeap 已经越过真实 seq2seq 翻译能否学习的存在性门槛，而且其早期任务成绩并不意味着架构没有继续生长的空间。
正式横向比较必须统一训练集、测试集、tokenizer、SacreBLEU signature、训练算力和监督方式。更重要的是，TreeHeap 还要额外证明其结构没有被普通语言骨架绕过。
11.2 Scaling 不只是把模型做大
参考 scaling-law 的方法，后续至少需要 1x / 2x / 4x 参数、数据和训练 token 的受控阶梯，并同时记录 NLL、标准任务指标、GPU 小时与结构消融。早期训练曲线应用来预测长训练收益，而不是每次直接赌一场长任务。Scaling Laws for Neural Language Models
我们需要同时看到两条曲线：
普通语言能力随规模改善
TreeHeap 的 native-zero / native-shuffle 贡献也随规模改善
如果只有 NLL 下降，而结构贡献逐渐归零，就不能把规模收益归功于 TreeHeap 私有协议。
12. 当前航线结论
D07 三轮实验没有证明 TreeHeap 私有协议已经形成，但它排除了三个容易混淆的故事：
NLL 大降，不等于输入协议形成；
槽位包含样本信息，不等于槽位对 Decoder 有帮助；
增加槽位数量，不等于增加了互补信息。
我们现在可以更准确地描述工程状态：

递归深度压力已经能限制容量；有界增益已经让协议贡献从负转正；尚未解决的是有限槽位如何分工覆盖 TreeHeap，并在容量增加时带来互补信息。
所以昨晚没有正式训练，是一次有效停止。船没有停在原地，我们只是确认下一步应该修方向分配，而不是继续给同一套 query 增加燃料。
完整 Claim、代码与 Evidence 位于 SameTime 开放仓库，对应 D07、D07R1 与 D07R2 记录。

作者说明： TreeHeap 的递归深度压力、有限协议槽位与结构覆盖候选来自 Houming818 与 Codex 的共同讨论。本文公开成功、失败、推断边界与下一步证伪条件，供读者复现和审计。
License: GPLv3。



[SPR-087] TreeHeap 显微镜实验：冻结模型以后，怎样寻找隐态焦距
Mon, 07 Sep 2026 00:00:00 +0000
不再只给模型打分，而是直接看它看见了什么
最近我们讨论了一个比普通消融更细的问题。
消融通常把某个模块删除，然后比较 NLL、BLEU 或其他指标。它能回答“这个模块是否有
因果贡献”，却不容易告诉我们：一个连续参数从小到大变化时，模型内部的观察结果究竟
怎样变形。
于是 Nio 提出了一个更直观的实验名称：

固定 checkpoint 和输入句子，逐档改变 TreeHeap 的观察矩阵，再把每一档直接 Decode
出来。这像把标本放在显微镜下，旋转调焦旋钮，寻找能够看清结构的焦距。
我们把它称为 TreeHeap 显微镜实验。
它不是文学包装。这个比喻恰好对应了一套可复现的实验合同：

  
      
          显微镜概念
          TreeHeap 实验对象
      
  
  
      
          固定标本
          冻结 checkpoint 与固定输入句
      
      
          物镜倍率
          TreeHeap 递归深度
      
      
          调焦旋钮
          FOLD parent 的数值尺度
      
      
          观察图像
          Decoder 直接生成的文本
      
      
          合焦
          文本成形、正常结束、语义轮廓可辨
      
  

1. 我们调的到底是什么
当前协议 TreeHeap 会把相邻 child 两两合并成 parent。忽略 mask 的边界情况，本次只读
干预把局部算子写成：
$$
H_{parent}=s(H_{left}+H_{right})
$$它对应一个作用于两个 child 的局部观察矩阵：
$$
M_s=\begin{bmatrix}sI & sI\end{bmatrix}
$$其中，$I$ 是隐态维度上的单位矩阵，$s$ 是我们旋转的“焦距”旋钮。
当前代码使用：
$$
s=\sqrt{\frac{1}{2}}\approx0.707
$$这使两个独立、同方差 child 相加后大致保持二范数能量。它不是从语言语义推导出的
唯一答案，只是当前数值合同。另一个自然候选是算术平均：
$$
s=0.5
$$我们还需要看更弱和更强的观察尺度会发生什么，因此第一轮扫描固定为：
s = 0, 0.25, 0.5, 0.707, 1.0
所有训练参数都被冻结。没有任何一档获得额外训练机会。
2. 为什么不用 NLL 决定答案
这次问题不是“哪一档对参考 token 的平均概率更高”，而是：

同一个 Decoder 在看到不同尺度的 TreeHeap 状态以后，会坍缩出怎样的文本？
如果只保存一个 NLL，我们看不到下面这些完全不同的失败形态：

第一个 token 就选择 EOS，输出为空；
只能生成几个与输入有关的词片段；
能形成句子，但主体、动作或对象丢失；
句长不断膨胀，重复局部短语；
到最大长度仍不生成 EOS。

这些现象都可能被一个聚合分数压在一起。因此本轮以逐句 Decode 为主证据，长度、EOS、
重复率和字符相似度只用于整理观察。
3. 第一块标本怎样变化
第一轮使用训练完成的 TreeHeap-106M 第二遍语料 checkpoint，固定 greedy Decoder，测试
四个句子、三个递归深度。下面是一句短英文在 depth 7 下的完整变化：
Input: The child put the red apple on the table.

s=0
  ⁇ 子虫

s=0.25
  ⁇ 放进食

s=0.5
  放进餐后

s=0.707（当前实现）
  放进餐后,把孩子放在桌子上。

s=1.0
  放进的进食,把进食le-le 放在桌子上,把孩子放在小包上,
  把孩子放在一小瓶里,把孩子放在一小瓶里……
  （达到 48 pieces，仍未生成 EOS）
这里出现了一条肉眼可见的变化过程：弱观察只能留下碎片；中间尺度开始形成动作和位置；
尺度继续增加以后，生成长度与重复同时膨胀。
反方向的短句也出现了低尺度立即停止：
Input: 孩子把红苹果放在桌子上。
Depth: 5

s=0      -> 空输出，立即 EOS
s=0.25   -> 空输出，立即 EOS
s=0.5    -> The table is placed in the table.
s=0.707  -> Put a table in the table.
s=1.0    -> Put a table in the table.
这些译文远没有达到产品质量。显微镜实验观察的是状态能否形成以及怎样失稳，不能把“能
成句”偷换成“翻译正确”。
4. 第一条焦距曲线
每个尺度共有 12 个输出，汇总如下：

  
      
          FOLD 尺度
          空输出
          未生成 EOS
          平均输出 pieces
          直接观察
      
  
  
      
          0
          2/12
          1/12
          9.42
          容易立即停止或只剩词片段
      
      
          0.25
          2/12
          1/12
          9.42
          与零尺度相近
      
      
          0.5
          0/12
          0/12
          11.92
          全部正常结束，短句较稳定
      
      
          0.707
          0/12
          0/12
          18.17
          轮廓更丰富，也出现语义漂移
      
      
          1.0
          0/12
          4/12
          30.33
          长度膨胀、重复、停止失败
      
  

从这 60 个输出看，冻结 Decoder 并非只能接受训练时的唯一尺度。它在一个中间区间仍能
工作，但对 parent 幅度并不具备全尺度不变性。
我们暂时把 0.5 到 0.707 称为候选焦区：
尺度过弱
  -> 证据不足，EOS 或短词片段占优

中间焦区
  -> 文本能够形成并正常停止

尺度过强
  -> 坍缩失稳，长度与重复扩张
这不是一条已经证明的普适规律。四句话太少，而且有一条隐藏的旁路尚未拆开。
5. s=0 为什么不等于只读 leaf
TreeHeap Decoder 在读取协议树前，还有一个学习得到的向上卷积 K_up：
$$
H_{parent}^{read}
=H_{parent}^{fold}
+g_{up}K_{up}(H_{parent}^{fold},H_{left},H_{right})
$$当我们把 $s$ 设成零时，直接 FOLD parent 确实变成零；但 K_up 仍能根据 children
重新生成一个残差 parent。
因此第一轮不能得出“leaf 自己就足够”的结论。准确说法是：

在直接 parent 被清零以后，leaves 与仍然启用的 K_up 路径有时还能驱动冻结
Decoder 生成文本。
这也是下一轮必须做二维实验的原因。
6. 下一轮：焦距乘以重建通道
正式 ARA 实验固定 20 个标本，分为五类：

简单主谓宾；
长距离依赖；
否定与操作顺序；
数字与实体；
抽象与递归描述。

每一类同时包含中译英和英译中。尺度网格加密为：
0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.707, 0.8, 1.0
同时设置两个 K_up 状态：
native  -> 保留训练得到的向上卷积
bypass  -> 旁路 K_up，只观察直接 FOLD parent 与 leaves
再乘以三个递归深度，总计：
20 specimens * 9 scales * 2 K_up modes * 3 depths = 1080 outputs
所有输出都必须保存。任何一条质量曲线中途下降都不能触发早停，因为我们寻找的正是完整
焦距曲线，而不是只保留一段单调区间。
7. 实验将回答三个问题
7.1 是否真的存在焦区
如果多个递归深度都出现连续的稳定成句区间，而两端更容易空输出或发散，“焦距”就不再
只是一个好听的名字，而是冻结模型的运行态性质。
7.2 是 FOLD 在调焦，还是 K_up 在补焦
如果旁路 K_up 后焦区大幅移动或消失，说明 Decoder 一直在主动修正 FOLD 的数值尺度。
如果两条曲线接近，焦距主要由直接 parent 幅度和后续解码边界决定。
7.3 焦距是共享的还是标本相关的
如果短句、长句、否定句和抽象句的最佳区间相近，我们得到一个架构级公共焦距候选。
如果不同类别需要不同尺度，那么固定常数可能不是最终答案，TreeHeap 需要根据输入和
递归深度学习一个自适应调焦协议。
8. 现在可以说什么
第一轮实验支持一个很窄但很清楚的观察：

FOLD parent 的数值尺度是冻结 TreeHeap Decoder 的因果变量。尺度过弱、适中和过强
会分别产生碎片化、成句和长度发散等不同 Decode 形态。
它还没有告诉我们哪个尺度最适合重新训练，也没有证明“搜索空间变大”是高尺度失败的
唯一机制。greedy 输出只能告诉我们 Decoder 的坍缩路径变了；要讨论概率空间，还需要
继续记录 EOS 概率、token entropy 和候选分布。
但显微镜已经架起来了。下一步不是猜一张更好的照片，而是在固定标本上画完焦距曲线，
再判断 TreeHeap 需要一个常量焦距，还是一套会自己调焦的观察协议。
9. 正式扫描结果：不是一个点，而是一片焦平面
文章写完后，正式任务在同一天完成了全部 1080 个固定单元。20 个标本、三个 depth、
九档尺度与两种 K_up 状态全部运行结束，没有按中途质量提前停止。
原生 K_up 下，通过成形、EOS 与空输出门槛的连续区间为：

  
      
          depth
          连续稳定尺度
      
  
  
      
          5
          0.375, 0.5, 0.625, 0.707
      
      
          6
          0.25, 0.375, 0.5, 0.625, 0.707
      
      
          7
          0.125, 0.25, 0.375, 0.5, 0.625, 0.707
      
  

所以“存在焦区”的 Claim 在三个 depth 上都通过了。它不是一个精确点，而是一段允许
Decoder 正常形成并结束文本的区间。
高尺度端点的失稳随深度明显增强：s=1 的 formed rate 从 depth 5 的 75%，下降到
depth 6 的 55% 和 depth 7 的 30%。depth 7 只有 40% 的输出在 64 pieces 内
产生 EOS。这比“看起来有点重复”更清楚：未经归一化的 parent 求和会沿递归逐层放大，
最终把冻结 Decoder 推出稳定坍缩区。
旁路 K_up 后，540 对单元中有 538 对生成文本发生变化。depth 5 的稳定区从
0.375..0.707 移到较低的 0..0.375，depth 6 也从 0.25..0.707 移到约
0..0.5。因此 K_up 的确参与调焦，但它不是简单地“补回丢失 parent”：在低尺度下，
关闭它有时反而更容易形成文本；在 0.625..0.8 附近，开启它通常带来更好的语义
相似度和稳定率。两条路径存在耦合。
更有意思的是不同倍率下的焦距分布。五类标本在 depth 5 的最佳 character-F2 尺度
IQR 为 0.375，没有共同焦点；depth 6 和 7 的 IQR 都缩小到 0.093，最佳尺度聚集在
0.707..0.8。
这给出了一个比“把常数改成 0.5”更谨慎也更有价值的方向：

TreeHeap 的焦距可能随递归深度变化；浅层更依赖标本，深层才逐渐形成共同观察尺度。
同时，最稳定的成句区通常比最佳字符相似度区更低、更宽。语义焦点靠近失稳边界，这意味着
未来的自适应调焦不能只追求更强信号，也必须同时约束 EOS、长度与重复。显微镜实验找到的
不是一个立即替换生产参数的答案，而是一张可以继续训练和验证的焦平面。
下一阶训练实验见
SPR-088：TreeHeap 可学习焦距。F01 的冻结扫描
继续作为只读证据保留，不追认成训练结果。

License: GPLv3。本文中的 TreeHeap 显微镜实验、参数干预设计、ARA 判定与 evidence
按项目许可证公开，欢迎复现、批评与提出反证。



[SPR-088] TreeHeap 可学习焦距：让递归深度自己选择观察尺度
Tue, 08 Sep 2026 00:00:00 +0000
从转动旋钮，到让模型自己调焦
SPR-087 做的是一项冻结实验：固定训练完成的
TreeHeap-106M，逐档改变 FOLD parent 的尺度，然后直接看 Decoder 生成什么。
它观察到了三个事实：

尺度过低时，部分输出为空或只剩短片段；
中间存在连续的稳定成句区；
尺度过高时，递归越深，越容易长度膨胀、重复并失去 EOS。

depth 6 和 depth 7 的字符相似度焦点还开始聚集到 0.707..0.8。但这仍然只是研究者
替模型转动旋钮。它没有回答更关键的问题：

如果把旋钮接上梯度，TreeHeap 能不能自己学会调焦？
这就是 F02 的目标。
最小训练原型：只增加三个参数
我们没有立即加入样本级控制网络。那会同时改变容量、路由和优化空间，即使结果变好，也
很难知道究竟是不是焦距在起作用。
F02 只给 depth 5、6、7 各增加一个坐标，共三个可训练参数。尺度写成：
u_d = tanh(theta_d)

s_d = sqrt(0.5) + (1 - sqrt(0.5)) * u_d,  u_d >= 0
s_d = sqrt(0.5) + sqrt(0.5) * u_d,        u_d < 0

parent = s_d * (left + right)
当 theta_d=0 时，尺度严格回到生产实现的 sqrt(0.5)。向两个方向移动时，尺度保持在
开区间 (0,1)，不会因为三个新参数直接把递归能量推到无界区域。
除了这三个坐标，TreeHeap-106M checkpoint 的旧参数全部冻结：

source encoder 不更新；
compressor 不更新；
FOLD 之外的协议参数不更新；
K_up 保持训练后的原生状态，但不更新；
语言 Decoder 不更新。

因此，训练后任何输出变化都只能来自三个深度焦距，而不是整个模型重新记住了一遍语料。
为什么训练仍然使用 token loss
F02 的主观察对象是直接 Decode，但焦距参数仍需要一个可信信号。当前最可靠的信号仍是
teacher-forced token cross entropy：它负责告诉三个旋钮梯度方向。
这不等于重新把 NLL 当作唯一结论。每个正式 wake 还会在锁定的 20 个显微镜标本上，对
三个 depth 直接生成文本，记录：

原始译文；
formed rate；
EOS rate；
输出长度与参考长度比；
相邻重复率；
character-F2 diagnostic。

训练 loss 是推动旋钮的手，直接 Decode 才是我们透过目镜看到的图像。
第一次 smoke 为什么失败
初始 smoke taskd 370 确实完成了 30 steps，但被 P0 拒绝。失败不是 OOM，也不是生成
文本不同：直接文本逐字一致，基座哈希、三层梯度和 reload 都正常。
问题出在最初的参数化：
s = sigmoid(logit(sqrt(0.5)))
数学上它等于 sqrt(0.5)，但 float32 经过逆函数往返后产生了微小舍入，step-0 NLL 相差
3.110864e-8，超过预注册的 1e-9 同函数门。
我们没有把门槛改宽，也没有删除失败记录。r1 改为以 sqrt(0.5) 为绝对零点的双侧坐标，
使 theta=0 不再经过逆函数往返。
这个失败很小，但值得留下：当实验只研究三个标量时，起点的微小不一致也可能被误认成
训练收益。
Smoke r1：梯度已经到达焦距
修正后的 taskd 371 跑满 30 steps，全部安全门通过：

  
      
          检查
          结果
      
  
  
      
          step-0 NLL 差
          0
      
      
          step-0 直接文本
          逐字一致
      
      
          三个 depth 的梯度
          全部非零且有限
      
      
          原 106M 基座
          哈希不变
      
      
          checkpoint reload
          NLL 误差为 0
      
      
          formed rate
          1.0 -> 1.0
      
  

30 步后的尺度已经出现分化：

  
      
          depth
          初始尺度
          30-step 尺度
      
  
  
      
          5
          0.70710677
          0.70969760
      
      
          6
          0.70710677
          0.70627469
      
      
          7
          0.70710677
          0.70328337
      
  

valid mean NLL 暂时改善 0.00102895。两个 smoke 标本的字符 F2 没有变化，所以现在只能
说“梯度能够调焦”，还不能说“调焦改善了翻译”。
正式训练合同
正式 taskd 372 已启动，合同固定为：

TreeHeap-106M pass-2 checkpoint；
只训练三个焦距坐标；
batch 64；
固定 5,000 steps；
约 32 万条训练样本暴露；
depth 5/6/7 循环训练；
每 500 steps 保存 wake、直接译文与小型 focus checkpoint；
质量曲线即使非单调也不提前停止。

只有 OOM、CUDA/Xid、NaN/Inf、基座哈希改变、reload 损坏、270W 功率限制解除或 step
停止推进，才允许中断。
我们准备怎样判断结果
F02 不要求三个尺度必须朝某个预想方向运动。正式结果分四层解释：

三个参数是否持续收到有限梯度；
任意两个最终尺度是否相差至少 0.02，形成可测的深度分化；
固定 valid mean NLL 是否改善至少 0.01；
20 句直接 Decode 的字符 F2 是否改善，同时 formed 与 EOS 不明显退化。

如果 NLL 改善而直接文本退化，这不是成功，也不是废数据，而是一笔明确的交换。如果三个
尺度最终重新靠拢，则说明当前 token loss 更偏好共享焦距。如果它们继续分开，我们才得到
“递归深度会训练出不同观察尺度”的第一阶证据。
边界
F02 不是完整的自适应显微镜。三个参数只看递归深度，不看输入句子、类别或当前隐态；它也
没有联合训练新的语义压缩目标。
这一级阶梯只回答一个问题：

在冻结 TreeHeap 其余部分以后，梯度能否让不同递归深度主动选择自己的 FOLD 焦距，并
在直接生成中留下可见、可复现的变化？
taskd 372 已在 io 的 RTX 3090 上跑满 5,000/5,000 steps。10 个 500-step wake
完整存在，基座哈希前后一致，checkpoint reload NLL 差为 0，没有出现 OOM、
CUDA/Xid 或 NaN/Inf。
正式判定为：

  
      
          门
          结果
          主要证据
      
  
  
      
          P0 同起点
          通过
          step-0 NLL 差为 0，60 条 depth 展开输出逐字一致
      
      
          P1 梯度到达
          通过
          三个 depth 均收到非零有限梯度，基座保持冻结，reload 精确
      
      
          P2 深度分化
          未支持
          最终焦距 [0.71405, 0.70081, 0.70542]，最大差 0.01324 < 0.02
      
      
          P3 预测收益
          未支持
          mean NLL 3.85521 -> 3.85463，改善 0.00058 < 0.01
      
      
          P4 直接 Decode
          未支持
          character-F2 下降 0.00071；formed 与 EOS 均保持不变
      
  

训练证明焦距坐标可以被梯度访问、保存和重载，但三个尺度持续振荡，没有收敛为稳定分离的
深度焦距。只训练三个全局标量也没有产生可测的预测或直接生成收益。因此它们不会进入默认
架构。
这不是“调焦方向失败”，而是把候选范围缩小了一步：下一次若继续，需要先解释振荡，或者
让焦距由样本与隐态条件化；不能继续假设每个深度只需要一个固定常数，也不能把本次结果
追认为成功。失败记录、每个 wake 和原始译文均已按 ARA 合同保留。

License: GPLv3。本文中的可学习焦距参数化、实验合同、失败记录和 ARA evidence 按项目
许可证公开，欢迎复现、批评与提出反证。



[SPR-089] 一个词怎样在 TreeHeap 中找到位置
Sun, 20 Sep 2026 00:00:00 +0000
先用三分钟读懂问题
这是一篇设计确认稿，不是实验胜利公告。
我们要解决的问题可以不使用任何项目术语来表达：

给定许多词和它们在语料中的使用关系，能否让每个词在一棵树中逐层找到位置，并使相近的
词更容易经过相近的分支？
旧方法会为每个词统计“它经常和哪些词一起出现”，再用同一张统计表从树根一路比较到叶子。
它可以给词分配稳定地址，却不等于每一层都发现了新的分类特征。语种、数字和标点等表面差异
可能在上层就消耗了大部分区分能力。
新设计尝试让每个树节点只观察到达本地的词，并重新计算本地最有区分力的方向。于是，根节点
可能先区分语种，下一层可能区分词类，更深一层才可能区分具体语义。这里的“可能”非常重要：
这是设计目标，还没有被实验充分证明。
整篇文章只做四件事：

用一个概率向量表示词在所有叶子之间的位置；
让每个节点从到达本地的词重新计算分类方向；
把分类结果写成向左或向右的概率，而不是一次不可撤销的硬选择；
反复更新位置与路径，检查它们能否达到稳定状态。

只关心结论的读者读到这里，再看“当前结论”即可。需要检查数学定义的读者可以继续向下。
最少术语表
下面区分三类名称，避免把项目内部语言伪装成通用理论。完整版本见
TreeHeap 开放术语表。

  
      
          名称
          类别
          本文中的含义
      
  
  
      
          token
          通用机器学习术语
          文本被切分后的一个计算单位，可以是字、词或子词
      
      
          embedding
          通用机器学习术语
          把 token 映射为可参与距离、分类和预测计算的数值向量
      
      
          leaf / 叶子
          通用树结构术语
          树最末端的节点；本文把所有叶子当作位置坐标
      
      
          概率单纯形
          标准数学术语
          所有“非负且总和为 1”的概率向量组成的空间
      
      
          协方差、主轴
          标准统计术语
          描述一组点主要沿什么方向变化；第一主轴就是变化最大的方向
      
      
          JS 散度
          标准信息论术语
          比较两个概率分布差异的对称指标
      
      
          概率路由
          TreeHeap 项目术语
          token 在一个节点向左、向右传播的概率
      
      
          下坠
          TreeHeap 项目术语
          token 从根经过若干内部节点到达叶子的路由过程，不是物理重力
      
      
          概率 Hash
          本文的诊断性称呼
          旧方法能生成稳定地址，但未证明地址具有逐层语义
      
      
          固定点
          标准数学术语
          再更新一次仍保持不变的状态，即 $r^*=F(r^*)$
      
      
          Claim / Evidence
          ARA 研究记录术语
          Claim 是可被反驳的主张，Evidence 是支持或否定它的记录
      
  

这篇文章固定什么
我们最近重新检查了 TreeHeap token embedding 的“下坠”含义。旧实现把 token 的上下文共现
概率当作坐标，在每一层与左右节点的平均分布计算 JS 散度，再把连续选择压成一条路径。
这能分类，也能生成稳定地址，但它更接近递归概率 Hash：同一份共现分布被重复比较，没有一
个明确的局部几何算子保证特征逐层形成。
现在形成的新共识是：

  Claim SPR-089-C1design
  token 的状态应当位于 leaf 概率构成的单纯形中；每个节点从到达本地的 token 点云重新
计算自己的观测主轴；同一个概率点经过不同局部坐标系时产生不同左右倾向，最终形成一条
高维滚落路径。



这不是把二维小球比喻强行贴到神经网络上。下面给出它的可计算定义、尚未解决的启动问题和
可以否证它的实验边界。
为什么旧算法还不能叫特征下坠
这里的 A09 是项目内部实验编号，指“用上下文共现概率逐层分配 token 地址”的实验，
不是公开领域中的算法名称。它的输入是 token 的上下文概率分布：
$$
p_w \in \Delta^{K-1}
$$节点保存落入本节点的平均上下文原型。token 每到一个节点，都重新计算：
$$
d_L=JS(p_w,q_L),\qquad d_R=JS(p_w,q_R)
$$然后根据距离决定左右路径。但下坠过程中：
$$
p_w^{(d+1)}=p_w^{(d)}
$$输入本身没有进入新的局部坐标，也没有从当前概率场产生新的观测方向。树只是在不同子集中
反复比较同一个分布。
A10 是后续审计实验：它冻结 A09 的最佳配置，逐值重建结果，并检查每层究竟在区分什么。
“冻结合同”表示代码、数据、随机种子和参数均保持不变，以排除重跑时偷偷换题。结果完全复现：

  
      
          指标
          结果
      
  
  
      
          活跃 token
          945
      
      
          leaf
          32
      
      
          sealed-C NLL
          4.992762973593261
      
      
          leaf utilization
          29/32 = 0.90625
      
      
          root child JS
          0.5713615
      
  


  Evidence E2A10 frozen reconstruction
  A10 支持“现有概率 Hash 已形成稳定、可解剖的数值分区”，但不支持“该分区已经形成逐层
语义特征”。后者仍是本文新设计需要验证的 Claim。



节点确实形成了可解释的数值判别特征，但最强轴首先是中文与英文/拉丁字符，其后是数字、
标点、子词形态和语料风格。各深度平均 child JS 为：
depth 0: 0.5714
depth 1: 0.2993
depth 2: 0.2076
depth 3: 0.0520
depth 4: 0.0361
这说明“数值特征存在”已经有证据，“逐层形成语义特征”仍然没有。粗层迅速消耗了语种与
表面形式差异，深层虽然质量更均匀，但左右原型的可分性已经很弱。
一般的 L-leaf 单纯形
16 个 leaf 只是讨论时的例子。正式定义不锁死 leaf 数量。
设 TreeHeap 有 $L$ 个 leaf，token $w$ 的状态为：
$$
r_w=(r_{w1},\ldots,r_{wL}),\qquad
r_{wi}\ge 0,\qquad
\sum_{i=1}^{L}r_{wi}=1
$$因此：
$$
r_w\in\Delta^{L-1}
$$它有 $L$ 个概率坐标和 $L-1$ 个自由度：

  
      
          leaf 数量
          单纯形自由度
      
  
  
      
          8
          7
      
      
          16
          15
      
      
          32
          31
      
      
          64
          63
      
  

这里的 $r_w$ 才是 token 在 TreeHeap 中的几何位置。它不是旧实现里的 $K$ 维共现统计表。
例如在四个叶子的玩具树中，
$$
r_w=(0.6,0.2,0.1,0.1)
$$表示 token 当前有 60% 的质量位于第一个叶子，另外 40% 分布在其余三个叶子。它不是说这个
词“有 60% 的语义”，而是一个可被训练和比较的位置表示。
切空间：概率怎样合法移动
因为概率和始终为 1，合法移动方向 $u$ 必须满足：
$$
\sum_i u_i=0
$$所有这样的方向构成单纯形的切空间。主轴、梯度投影和局部旋转都必须留在这个空间内，否则
一次更新就可能把总概率从 1 推走。
例如：
$$
u=(0.1,-0.1,0,\ldots,0)
$$表示从第二个 leaf 向第一个 leaf 搬运 0.1 的概率，总质量保持不变。
每个节点观察自己的局部词群
“点云”是统计与几何中的常用说法，意思是一批向量点。本文的每个点就是一个 token 的位置
$r_w$；“局部点云”就是有一定概率到达当前节点的那批 token，而不是一种新的数据结构。
令 $m_{wv}$ 表示 token $w$ 到达节点 $v$ 的概率。节点 $v$ 只观察到达本地的加权点云。
它的局部中心为：
$$
\mu_v=
\frac{\sum_wm_{wv}r_w}
{\sum_wm_{wv}}
$$局部协方差为：
$$
C_v=
\frac{
\sum_wm_{wv}(r_w-\mu_v)(r_w-\mu_v)^\top
}{
\sum_wm_{wv}
}
$$因为不同节点接收到的 token 和权重不同，所以通常有：
$$
C_{\mathrm{root}}
\ne C_{\mathrm{left}}
\ne C_{\mathrm{right}}
$$这正是“每个路由点的观测主轴不同”的数学来源。
主轴不是随意增加的一组参数
对局部协方差求特征分解：
$$
C_vu_{v,k}=\lambda_{v,k}u_{v,k}
$$最大的特征值对应第一主轴：
$$
u_v=\operatorname{eigmax}(C_v)
$$$u_v$ 表示本节点中概率点变化最大的方向，$\lambda_v$ 表示沿这个方向的变化强度。这里使用的
是标准主成分分析（PCA）的局部版本，不是 TreeHeap 新发明的数学定理。
当前共识不是让梯度直接随意修改 $u_v$。更符合几何含义的做法是：

关系损失推动 token 位置 $r_w$ 变化；
节点重新观察局部点云；
协方差 $C_v$ 随之变化；
主轴 $u_v$ 由新的协方差重新计算。

因此主轴是局部概率场的观测结果，而不是人工塞进节点的左右偏见。
从主轴产生概率路径
token 相对节点中心的位置投影到主轴：
$$
z_{wv}=u_v^\top(r_w-\mu_v)
$$为了让不同节点的尺度可比较，可以使用主特征值标准化：
$$
\hat z_{wv}=
\frac{z_{wv}}
{\sqrt{\lambda_v+\varepsilon}}
$$再把它变成连续路由概率：
$$
P(L\mid w,v)=\sigma(\hat z_{wv})
$$$$
P(R\mid w,v)=1-P(L\mid w,v)
$$这里不提供最低基数流量，不设置先强制均匀、后逐步撤销的保护项，也不加入容量平衡惩罚。
左右概率只由 token 在当前局部坐标系中的位置决定。
如果采用硬路由，超平面：
$$
u_v^\top(r-\mu_v)=0
$$会把一个凸区域继续切成两个凸区域。采用软路由时，它变成一条概率过渡带，每个节点对应
一个加权局部区域。
共现信息放在哪里
共现关系仍然有用，但它不再是下坠坐标，也不需要作为一个大概率数组沿树传递。
它只负责提供训练关系。语料中的一次事件：
center token w -> observed context c
要求当前位置 $r_w$ 能够预测实际上下文：
$$
\mathcal L_{\mathrm{context}}
-\log P(c\mid r_w)
$$
这条梯度推动 token 的单纯形位置变化。位置变化以后，局部中心、协方差、主轴和路径再依次
变化。
因此链路应当是：
$$
\text{语料关系}
\rightarrow
\text{位置梯度}
\rightarrow
r_w
\rightarrow
C_v
\rightarrow
u_v
\rightarrow
\text{概率路径}
$$共现只是可选的关系来源。句序、翻译对齐、问答关系或任务损失也可以承担同一角色。如果完
全没有关系数据，token ID 只是编号，任何语义排列都无法从编号本身推导出来。
为什么选择固定点
token 位置决定局部主轴，局部主轴又改变 token 的下坠路径。它们不是一次前向计算就能独
立确定的：
$$
r^{(t)}
\rightarrow
C^{(t)}
\rightarrow
u^{(t)}
\rightarrow
\operatorname{route}^{(t)}
\rightarrow
r^{(t+1)}
$$目标是找到自洽状态：
$$
r^*=F(r^*)
$$这里至少需要同时观察两种收敛：
第一种是 token 位置变化：
$$
\frac1N\sum_wJS(r_w^{(t+1)},r_w^{(t)})\rightarrow0
$$第二种是节点主轴旋转：
$$
\theta_v^{(t)}=
\arccos\left(
\left|{u_v^{(t+1)}}^\top u_v^{(t)}\right|
\right)\rightarrow0
$$绝对值用于消除特征向量的符号歧义：$u$ 与 $-u$ 是同一根轴，只是左右名称互换。
尚未闭合的核心：更新函数 F 到底是什么
这篇文章没有假装最后一个公式已经解决。
我们已经一致确认：

token 状态属于一般 $L$-leaf 单纯形；
每个节点从局部点云计算不同主轴；
路由是局部投影产生的连续概率；
关系数据只通过 loss 推动位置，不作为下坠坐标；
系统应通过迭代寻找固定点。

但仍缺少一个关键定义：

一轮所有节点的概率路由，怎样严格构造下一轮 token 状态
$r^{(t+1)}=F(r^{(t)})$？
这里的 $F$ 不是一个已经找到的神秘函数，只是“用旧状态计算新状态”这一步的统一记号。
如果直接把 root-to-leaf 路径概率当成新的 $r$，可能出现自我强化和早期路径锁定。如果把
它与旧状态简单平均，又引入了人为时间常数。如果让任务梯度独立更新 $r$，则必须说明
TreeHeap 路由在状态形成中究竟承担什么因果作用。
因此 $F$ 是下一阶段的算法核心，而不是可以藏在实现细节里的一个赋值语句。
启动时的对称性问题
若所有 token 严格从同一个均匀点开始：
$$
r_w^{(0)}=(1/L,\ldots,1/L)
$$那么所有 token 的局部协方差为零：
$$
C_v^{(0)}=0
$$此时不存在可识别主轴。系统必须由关系损失、可审计的确定性扰动或一个明确的启动阶段打破
对称性。这个启动过程必须单独登记，不能把随机初始化偷偷当成已经形成的语义。
下一步怎样验证，而不是继续造术语
下一阶段暂称 A11“自洽单纯形下坠”。A11 也只是实验编号。它应当先经过可人工检查的小型
数据实验（toy experiment），而不是直接消耗大规模语料。
建议的尺度不是固定 16，而是：
$$
L\in\{8,16,32,64\}
$$需要记录：

均匀状态能否在明确关系力下启动；
不同节点的主轴夹角是否真正分化；
leaf 状态与主轴是否收敛，还是周期振荡；
是否有大量 token 或节点坍缩到同一位置；
去掉局部主轴后，关系预测是否显著变差；
增加 $L$ 是否带来连续容量收益；
结果是否跨 seed 保持，而不是一次随机坐标排列。

任何一次较低 loss 都不能单独证明这套几何成立。真正的支持证据必须同时包含：固定点、局部
主轴分化、结构消融和可解释的路径变化。
当前结论
旧路线已经证明：递归概率 Hash 可以形成稳定地址，也可以形成数值判别特征。但它没有证明
特征会逐层下沉。
新的方向把问题重新定义为：

在 $L-1$ 维概率单纯形中，让每个 TreeHeap 节点观察自己的局部点云和主轴；让 token
在一系列不同的局部坐标系中形成概率路径；再寻找位置、主轴与路径共同自洽的固定点。
我们现在已经对几何对象和信息来源达成一致，但固定点算子 $F$ 仍然开放。下一步不是宣布
架构完成，而是把这个开放位置写成代码、toy 和可以失败的 Claim。
给第一次进入这个项目的人
你不需要接受 TreeHeap 的整套语言，才能检查本文。可独立复核的问题只有三个：

旧方法是否只是在不同节点重复比较同一个共现分布？
局部 PCA 是否真的让不同节点形成不同分类方向？
位置、分类方向和路径能否稳定收敛，而不是坍缩或循环？

如果这三个问题中任何一个失败，这个设计都需要修改。项目编号、故事和术语不能替它免于
反证。我们公开术语，不是为了建立只有内部成员能读懂的语言，而是为了让外部读者更容易指出
我们哪里错了。

License: GPLv3。本文中的概率单纯形、局部主轴、固定点定义、实验边界与后续 ARA
设计按项目许可证公开，欢迎复现、批评与提出反证。



[SPR-090] F 不是一个神秘公式：用全局概率场搜索 TreeHeap
Wed, 23 Sep 2026 00:00:00 +0000
先说我们究竟在找什么
这篇文章讨论的是 token embedding 的形成，不是翻译，也不是 Decoder 怎样生成下一个词。
问题可以用一句普通话表达：

已经统计出每个词经常出现在什么上下文中以后，怎样让这些词在一棵 TreeHeap 中找到稳定、
可解释、可以逐层细化的位置？
这里的 F 只是“由当前状态生成下一步树结构和 token 位置”的函数名称：
$$
F:\text{全局背景概率场}\longrightarrow
\text{TreeHeap 结构、节点原型和 token 路径}
$$它不是预先知道答案的公式。当前工作正是寻找 F 的结构。
SPR-089 尝试从概率单纯形和局部主轴理解 token 怎样下落，但留下一个核心空位：局部路由完成
以后，怎样得到下一轮状态？最近的实验又暴露出一个更基础的因果问题：如果直接用“预测下一词”
训练 embedding 和 F，那么下一词答案会通过梯度进入参数。最后得到的表示可能很好用，却不能
证明 embedding 是由背景概率场自然形成的。
因此我们决定把两件事拆开：
阶段一：只用全语料共现统计寻找 embedding F
阶段二：冻结 embedding，再检查它能否帮助下游任务
本文只讨论阶段一。
最少术语表

  
      
          名称
          本文含义
      
  
  
      
          token
          文本经过分词后得到的字、词或子词单位
      
      
          embedding
          token 的数值坐标，使 token 可以被比较、组合和读取
      
      
          上下文概率场
          对每个 token 统计它周围出现各种 context token 的条件概率
      
      
          FOLD
          把两个 child 的状态合成 parent
      
      
          UNFOLD
          从 parent 出发，根据当前 token 的概率特征选择左右 child
      
      
          原型
          到达某个节点的 token 所共有的平均上下文分布
      
      
          残差
          child 原型相对 parent 原型增加或减少的概率成分
      
      
          蒙特卡洛搜索
          随机提出结构修改，根据全局评分接受或拒绝，而不是穷举全部结构
      
      
          sealed test
          搜索过程中不可查看，只在 F 选定后打开一次的测试数据
      
  

为什么单句梯度不够
假设一条句子产生损失：
$$
\ell(x;\theta)
$$它只能提供这条句子的梯度：
$$
g_x=\nabla_\theta\ell(x;\theta)
$$而我们真正关心的是整套语料分布上的目标：
$$
L(\theta)=
\mathbb E_{x\sim D}[\ell(x;\theta)]
$$在理想随机采样条件下，单句梯度的期望可能等于全局梯度：
$$
\mathbb E[g_x]=\nabla_\theta L(\theta)
$$但这不表示每个单句梯度都指向正确方向，也不保证非凸参数空间能到达全局最优点。
例如，包含 “bank account” 的句子会把 bank 推向“银行”，包含 “river bank” 的句子会把
bank 推向“河岸”。如果每来一句话就不可逆地改写 TreeHeap 路径，路径会受到语料顺序、
高频样本和最近样本影响。系统可能发生漂移、遗忘或早期分支锁定。
我们的处理方式是：句子先更新统计状态，不直接更新 F。
句子
  -> 更新 token-context 共现计数
  -> 累积成全局背景场
  -> F 在背景场上统一搜索
这与动态规划保存中间状态的思想相似。历史不是只保存在当前参数里，而是保存在可检查的共现
计数和条件概率中。
一个重要的实验纠正
我们曾做过如下实验：
四个输入 token
  -> embedding
  -> FOLD
  -> parent
  -> 预测第五个 token
第五个 token 没有进入前向输入，但它进入了交叉熵：
$$
\mathcal L=-\log P(t_5\mid t_1,t_2,t_3,t_4)
$$这个 loss 同时更新 embedding、F 和 Decoder。因此 parent 中存在下一词信息并不奇怪：
训练目标主动要求它保存下一词信息。
那个实验仍能回答“哪种 F 更适合下一词预测”，却不能回答“哪种 F 会由全局背景场自然形成”。
这两个问题都合理，但证据不能混用。
本文的新实验彻底移除下一词标签、翻译标签、Decoder、递归 READ 和单句在线参数更新。它只
留下 token 与 context 的累计共现概率。
背景场的数据结构
对 token \(t\)，统计它与每个 context \(c_j\) 的共现次数：
$$
C_{tj}
$$经过平滑和归一化，得到条件概率：
$$
p_t(j)=P(c_j\mid t)=\frac{C_{tj}+\alpha}{\sum_k C_{tk}+\alpha K}
$$因此每个 token 都对应一个概率向量：
$$
p_t\in\Delta^{K-1}
$$这里的 \(\Delta^{K-1}\) 是概率单纯形：每个分量非负，并且总和为 1。
为了让概率距离更适合欧氏几何计算，实验采用平方根坐标：
$$
x_t=\sqrt{p_t}
$$这与 Hellinger 距离相容。需要强调的是，\(x_t\) 仍然来自全局共现概率，不是随机初始化的
可训练 token 表。
F 的最小结构：概率残差树
我们把 F 的候选结果设计成一棵二叉 TreeHeap。每个内部节点保存：
Node {
    mass          到达节点的语料概率质量
    prototype μ   本节点 token 的平均 context 概率
    axis a        本节点观察 token 差异的方向
    threshold b   左右分支的切分位置
    left, right   两个 child
}
token 到达节点后计算：
$$
z_t=a^\top x_t
$$再与阈值比较：
$$
z_t\le b\Rightarrow L,\qquad
z_t>b\Rightarrow R
$$第一版 smoke 使用硬路由，因为我们先要检查搜索是否能找到结构。将来可以把它放松成连续后验：
$$
P(R\mid t,v)=\sigma\left(
\frac{a_v^\top x_t-b_v}{\tau_v}
\right)
$$FOLD 为什么有明确含义
设左右 child 的质量为 \(m_L,m_R\)，上下文原型为 \(\mu_L,\mu_R\)。parent 定义为：
$$
m_P=m_L+m_R
$$$$
\mu_P=
\frac{m_L\mu_L+m_R\mu_R}{m_L+m_R}
$$这不是任意神经网络层。它是条件概率统计的质量加权合并，parent 与 child 的数据类型相同，
量纲也相同。
如果所有 token 在 child 中的计数全部加起来，必然得到 parent 的计数。因此可以直接检查：
$$
m_P\mu_P=m_L\mu_L+m_R\mu_R
$$若实现不满足这个等式，说明代码或数据定义有问题，而不是“模型还没学会”。
残差怎样形成多分辨率
child 相对 parent 的变化定义为：
$$
\Delta\mu_C=\mu_C-\mu_P
$$沿 root 到 leaf 的路径累加：
$$
\mu_{\text{leaf}}=\mu_{\text{root}}+\Delta\mu_{n_1}+\Delta\mu_{n_2}+\cdots+\Delta\mu_{n_d}
$$中间项会望远镜式抵消，所以这个等式应当达到浮点误差级闭合。
它提供了清晰的分辨率解释：

root 保存全语料公共背景；
浅层残差提供粗区分；
深层残差逐步补充局部细节；
leaf 保存当前路径能达到的最细背景分布。

这并不自动等于“语义”。语种、标点、领域和频率也可能形成强分支。语义性质需要额外审计，
不能只看树长得像分类学。
蒙特卡洛到底搜索什么
F 可以写成：
$$
F=(T,\{a_v,b_v\}_{v\in T})
$$其中 \(T\) 是树，\(a_v,b_v\) 是每个内部节点的轴和阈值。
第一轮 smoke 固定完全二叉树的深度，只搜索各节点的局部切分规则。一次动作是：

从当前仍有多个 token 的内部节点中选一个；
从该节点的 token 中抽两个点，用二者差形成候选轴，或者小幅扰动现有轴；
从本地投影分布中选择候选阈值；
重新让全部 token 下落；
根据全局背景重建质量评分；
接受更优方案，也以逐渐降低的概率接受暂时更差的方案。

偶尔接受更差方案，是为了跳出当前位置附近的局部极小值。接受概率采用 Metropolis 形式：
$$
P(\text{accept})=
\min\left(
1,
\exp\frac{J_{\text{current}}-J_{\text{proposal}}}{T}
\right)
$$温度 \(T\) 随迭代下降。搜索同时保留一个 global best，所以临时探索不会覆盖已经找到的最好 F。
搜索评分来自哪里
我们不能用最终 test 集反复选择 F，否则 test 就变成了训练数据。
因此原训练共现计数再次按固定 seed 拆成：
$$
C_{\text{fit}}+C_{\text{dev}}=C_{\text{train}}
$$搜索过程只做：
用 fit 计算每个 leaf 的 context 原型
用 dev 计算该结构的 context NLL
评分为：
$$
J(F)=
-\frac{
\sum_{t,j}C_{\text{dev},tj}
\log\hat P_F(c_j\mid t)
}{
\sum_{t,j}C_{\text{dev},tj}
}
$$搜索结束后，才打开原来就保存好的 WMT sealed test，比较初始树、搜索所得树和随机路径。
这里没有手工要求左右流量各占 50%，也没有给饥饿分支强行输送 token。链表式或极不均衡结构
可以存在，但它必须在未参与原型估计的 dev 共现上获得更低 NLL。复杂结构未来还需要加入节点
成本；本轮树深固定，因此结构复杂度相同。
A11 smoke 怎样判定
这次实验编号为 A11，Claim 为：

  Claim S1-F-MC-A11-C01supported-smoke
  在冻结的真实 WMT token-context 概率场上，蒙特卡洛搜索局部 TreeHeap 切分规则，可以改善
确定性初始树的 dev 背景重建，同时保持 FOLD 质量守恒与路径残差闭合。



机械条件：
所有数值有限
sealed test 不参与 proposal 评分
至少接受一个 proposal
FOLD 守恒误差 <= 1e-10
路径残差闭合误差 <= 1e-10
经验条件：
dev NLL 至少改善 0.005
sealed-test NLL 不比初始树恶化超过 0.01
sealed-test NLL 优于随机路径
leaf utilization 至少 50%
如果 dev 改善而 sealed test 恶化，说明搜索过拟合。如果概率恒等式不闭合，说明实现无效。
如果随机路径同样好，说明当前 F 搜索没有提取有用背景结构。
实验结果：搜索确实找到了更好的概率树
任务 561 在 io 的 RTX 3090 上完成，共搜索 256 个候选动作，接受了 175 次。输入是冻结的
真实 WMT 512 x 1024 token-context 计数场；fit、dev 和 sealed test 分别包含约 528 万、132 万
和 74 万次共现计数。
                         初始树          搜索所得树       随机路径
dev NLL                  5.373436        5.357366         -
sealed-test NLL          5.396372        5.378041         5.457888

dev 改善                                  0.016070
sealed test 相对初始改善                  0.018331
sealed test 相对随机改善                  0.079847
结构检查也通过：32 个 leaf 全部得到 token，leaf utilization 为 1.0，占用熵为 0.9131。
FOLD 质量守恒的最大绝对误差为 1.39e-17，root 加路径残差重建 leaf 的最大绝对误差为
3.47e-18。这些误差处于双精度浮点舍入尺度，没有发现公式或实现层面的破坏。
这组数字支持一个很窄但重要的结论：在没有句子答案、Decoder 和 READ 参与的情况下，按
全局上下文重建评分搜索 F，能够找到比确定性初始树和随机树都更好的概率残差结构。
它还是 smoke 证据，而不是最终架构结论。目前只有一个 seed、一个深度和一份背景场。下一步
需要复现 seed，并做受控深度阶梯；在这些结果稳定以前，不应把搜索所得树直接装进主模型。
这次实验没有证明什么
即使全部条件通过，也只能说明：

在一个固定的真实语料背景场上，概率守恒的局部切分规则可以通过全局搜索得到改善。
它仍然不能证明 leaf 已经代表人类语义类别、TreeHeap 优于 SGNS 或 Transformer、多义词已经
得到上下文条件路径、Decoder 能读取这些残差，或者 F 可以直接用于翻译与生成。
当前路线图
全局语料
  -> token-context 计数状态
  -> 条件概率背景场
  -> 蒙特卡洛搜索节点轴和阈值
  -> 概率残差 TreeHeap
  -> 冻结 embedding
  -> 独立下游任务检查
  -> 最后才接 READ 和 Decoder
这条路线回答了两个此前混在一起的问题：

embedding 的空间从哪里来？
下游任务怎样使用这个空间？

前一个问题由全局概率场和 F 搜索回答；后一个问题必须在冻结 F 后单独验证。若下游失败，我们
才能区分“背景空间没有形成”和“读取协议没有学会”。
给第一次进入项目的人
检查本文不需要先相信 TreeHeap。只需检查四件事：

单句是否只更新了可审计的共现统计，而没有直接改树；
搜索是否完全没有查看 sealed test；
parent 是否真由 child 概率质量守恒地合并；
搜索所得结构是否在新共现样本上优于初始树和随机路径。

只要任何一点失败，A11 Claim 就不成立。实验编号、叙事和漂亮的树图都不能替代这些条件。

License: GPLv3。本文的概率残差树定义、搜索合同、否证条件和 ARA 实验设计按项目许可证公开。



[SPR-091] TreeHeap 的 F 函数：它是什么、怎样学习、现在走到了哪里
Sat, 26 Sep 2026 00:00:00 +0000
先用一句话回答
TreeHeap 的 F 函数，是决定“细粒度状态怎样组成粗粒度状态，以及状态怎样沿树继续传播”的规则。
它不是某一个已经找到的神秘公式，也不只是一个 loss。更准确地说，我们正在寻找的是一族函数：
输入：token 或 child 的状态、当前节点状态、可选的上下文
输出：parent 状态、左右路由概率、残差，以及下一层可继续使用的状态
如果 F 合理，TreeHeap 的每一层都保存同一种可继续计算的数据，只是分辨率不同；如果 F 不合理，
树仍然可以运行，却可能只是把数组换成树形摆放，或者在递归中丢掉 Decoder 真正需要的信息。
本文不要求读者先了解此前九十篇日志。我们从一个四 token 的例子开始，逐步说明 F 的对象、参数、
训练方法、实验结果和当前卡点。
为什么必须单独讨论 F
假设输入是：
西西弗 / 推 / 石头 / 上山
一个二叉 TreeHeap 可以先合并相邻状态，再继续向上：
西西弗 ─┐
         ├─ parent A ─┐
推 ──────┘             │
                       ├─ root
石头 ────┐             │
         ├─ parent B ─┘
上山 ────┘
树形拓扑只告诉我们“谁和谁先计算”，没有告诉我们“怎样计算”。真正决定 parent A 是普通平均、
概率混合、可逆编码，还是一个完全不可读向量的，就是 F。
因此，下面三件事不能混为一谈：

拓扑：哪些节点相连，计算顺序是什么；
F 函数：相连以后执行什么状态变换；
READ/Decoder：怎样从这些状态取信息并生成输出。

拓扑像函数调用图，F 像每次调用的函数体，READ/Decoder 则是状态的消费者。只改变其中一个，
另外两个不会自动正确。
先解决一个历史歧义：F 曾经指三种东西
过去的研究记录为了交流方便，把三种相关对象都简称为 F。这会造成“F 是共享参数吗”“F 是搜索
算法还是递归公式”之类的混乱。本文开始采用三个名字。
1. 节点函数 f_v
节点 v 上执行的局部规则记为：
$$f_v(x;\theta_v)$$其中 x 是到达节点的状态，θ_v 是该节点自己的参数。当前概率路由版本中，θ_v 主要包含
观察轴 w_v 和阈值 b_v。
2. 整树函数 F_Θ
把所有节点函数按树的拓扑连接起来，得到整棵树的计算：
$$F_{\Theta}=f_{v_n}\circ\cdots\circ f_{v_2}\circ f_{v_1}$$这里的 Θ 是全部节点参数的集合。输入一个 token 状态后，F_Θ 给出它的路径、各层状态、
leaf 位置和可供 READ 使用的多分辨率表示。
3. 学习算法 A
搜索或训练 Θ 的算法另记为：
$$A(D,F_{\Theta})\longrightarrow\Theta'$$D 是语料统计或训练样本。蒙特卡洛、梯度下降、离散结构搜索都属于 A，而不是 F 本身。
这一区分非常重要：一次搜索失败，不等于 F 族必然错误；一个可微 F，也不等于训练目标能够
找到有用参数。
当前概率残差版本的数据是什么
当前实验没有把 token ID 直接当作可以计算的数。它先统计 token t 周围出现 context c 的
次数，再得到条件概率：
$$p_t(c)=P(c\mid t)$$所以一个 token 的基础状态不是单个整数，而是一行概率：
token t -> [P(c1|t), P(c2|t), ..., P(cK|t)]
这行数据各分量非负、总和为 1，属于概率单纯形。它的物理含义也明确：描述“看到这个 token
时，它周围通常出现什么”。
为了计算路由，实验使用平方根概率坐标：
$$x_t=\sqrt{p_t}$$这样，概率分布之间的几何距离与 Hellinger 距离相容。它不是任意随机摆放的 embedding；坐标
来自可重复计算的全语料背景场。
一个节点究竟怎样路由
在节点 v，token 状态 x_t 先投影到该节点的局部观察轴：
$$z_v(t)=x_t^{\mathsf T}w_v-b_v$$w_v 决定这个节点观察哪些方向，b_v 决定切分位置。
硬路由只选择一侧：
$$z_v(t)\le0\Rightarrow L,\qquad z_v(t)>0\Rightarrow R$$软路由则保留两侧概率：
$$r_v(t)=P(R\mid t,v)=\sigma\left(z_v(t)/\tau\right)$$其中 τ 是温度。温度较低时接近硬选择；温度较高时，概率质量可以同时流向左右 child。
参数到底共享不共享
答案是：规则共享，节点参数通常不共享。
所有节点都使用同一种投影与 sigmoid 公式，这是共享的计算规则；但每个节点有自己的 w_v 和
b_v，因此它们可以观察不同的局部主轴。若所有节点强行共享同一组数值参数，树的不同位置会
反复采用同一个切分面，很难形成逐层细化的分辨率。
另一方面，FOLD 的概率守恒公式目前没有可训练参数，它是全树共享的数学合同。不要把“共享
公式”和“共享参数值”当成同一件事。
child 怎样合成 parent
设左右 child 的概率质量为 m_L、m_R，它们的 context 原型为 μ_L、μ_R。当前 FOLD 是
质量加权平均：
$$m_P=m_L+m_R,\qquad \mu_P=\frac{m_L\mu_L+m_R\mu_R}{m_L+m_R}$$这个 parent 仍然是一行 context 概率，与 child 的数据类型和量纲一致。它不是把两个向量相加后
任其能量随深度增长。
更关键的是，它满足守恒关系：
$$m_P\mu_P=m_L\mu_L+m_R\mu_R$$因此 root 是整批 token 的公共背景；向下走时，child 相对 parent 增加的细节记为残差：
$$\Delta\mu_C=\mu_C-\mu_P$$沿路径累加即可恢复某一层的原型：
$$\mu_d=\mu_{root}+\sum_{k=1}^{d}\Delta\mu_k$$这给“多分辨率”一个可检查的定义：浅层保存公共背景，深层逐步增加区分信息。它仍不等于自然
语言中的缩句或语义层级；那需要下游证据。
F 影响架构中的哪些位置
F 不是只影响一个路由开关。它至少影响四处。

  
      
          位置
          F 的作用
          错误时的现象
      
  
  
      
          embedding 安装
          决定 token 在树中的路径与邻居
          同类不聚合、路径随 seed 漂移
      
      
          FOLD
          决定 parent 保存什么以及量纲是否闭合
          深层爆炸、消失或成为不可读数据
      
      
          多分辨率状态
          决定粗层与细层的差值
          每层重复，或高层完全收不到细节
      
      
          READ 接口
          决定下游能否沿路径恢复有用概率场
          训练 loss 下降但生成或 masked read 退化
      
  

Decoder 不必和 F 共享同一组参数，但两者必须通过串联训练或冻结接口形成协议。只要 READ/Decoder
的 loss 能通过可微状态回传到 F，F 就能接收下游任务的方向信息；是否应该允许它这样训练，取决
于我们正在检验“背景 embedding”还是“端到端任务表示”。二者不能用同一份证据替代。
怎样寻找 F
目前有三条不同路线。
路线一：蒙特卡洛搜索硬树
固定树深，每次修改一个节点的观察轴或阈值，让所有 token 重新下落，然后在未参与原型估计的
dev 共现数据上计算重建 NLL。更优方案被接受，少量更差方案按退火概率暂时接受，以跳出局部
极小值。
优点是硬树可以直接审计，路径和概率守恒都清楚。缺点是高维搜索昂贵，而且梯度不能直接告诉
离散提案下一步往哪里走。
路线二：梯度训练软树
把左右选择改成连续概率，让 loss 通过全部 soft path 回传到每个 w_v,b_v。这证明 F 的参数
可以被普通优化器更新，也能与 READ 串联。
难点在于训练得到的是概率混合场。训练结束后直接以 0.5 阈值硬化，会丢掉混合状态携带的
信息。软模型学得好，不代表硬路径导出后仍然好。
路线三：结构与参数联合搜索
更完整的 F 还可能改变树的连接方式，而不只是固定拓扑上的轴和阈值。拓扑是离散变量，节点
参数是连续变量，因此这是混合优化问题。
当前项目尚未证明动态拓扑可用。曾经比较过 left_deep、balanced、right_deep 等人工枚举
拓扑，结果说明组合顺序会改变 parent 的可读信息；它不能证明路由器自己会找到这些拓扑。
证据走到了哪里
下面不用编号代替结论，编号只作为复现入口。

  
      
          实验
          实际建立的证据
          仍然没有建立
      
  
  
      
          A11
          在固定真实语料背景场上，硬树蒙特卡洛搜索优于初始树和随机路由
          通用语义 F
      
      
          A12
          3 个搜索 seed、4 个深度均复现重建收益
          最佳深度或稳定语义拓扑
      
      
          A13
          F 可保存为自描述 checkpoint，并精确重载
          下游可用性
      
      
          A14
          更多语料使背景概率几何更稳定，但树分区仍明显漂移
          搜索已收敛
      
      
          A15
          冻结坐标可被 Token READ 和 Echo 使用；masked 语义门不胜随机码
          最终 embedding
      
      
          A16
          无训练 Bayesian READ 证明更深层保留更多背景预测信息
          当前 F 已无损或最优
      
      
          A17
          软路由可微、可训练、会改变路径且不坍缩
          重建 loss 能保护 READ
      
      
          A18
          READ 梯度改善了未见数据上的软概率场
          硬化后的 checkpoint 可用
      
  

两组关键数字最能说明现状。
A12 中，在同一个冻结语料场上，深度 3、4、5、6 的三 seed 搜索都通过，sealed-test NLL 的
中位改善分别约为 0.0540、0.0451、0.0505、0.0296。这说明 F 不是完全随机的摆放。
但 A18 中，READ-coupled 训练后的软场 NLL 为 4.758578，硬化后变为 4.899335，损失
0.140757。这把当前卡点定位到了 soft-to-hard 交接，而不是“梯度无法穿过树”。

  Claim SPR-091-F-STATUSmixed
  当前证据支持：概率守恒的 TreeHeap F 可以被搜索、保存、读取和微分训练，并能形成具有因果预测
信息的多分辨率概率场。当前证据不支持：已经找到稳定的最终 F，或软路由可以无损硬化为单路径。



为什么不能直接宣布“embedding 已完成”
一个表示系统至少要通过三个不同门槛：
可编码：token 能稳定进入数值空间
可组织：背景关系能形成非随机、可复现的层级
可消费：READ/Decoder 能利用它完成未见任务
当前结果已经较好地通过“可编码”，部分通过“可组织”，但“可消费”仍是混合结果。Token READ
达到 100% 只说明 token 身份能从坐标中恢复；没有 hash 碰撞时，这本来就是较低的门槛。真正
困难的是：遮住 token 后，剩余背景关系是否比随机码提供更多有效信息，以及这些信息能否经过
递归 READ 进入生成。
当前最合理的下一步
当前不应继续无约束地搜索更低的 embedding NLL，也不应立刻把所有路由硬化。更直接的工程路线是：

保留 A18 已经表现更好的软路由，作为第一版有效 F；
让 READ 和 Decoder 在连续路径质量上工作，先建立端到端可用性门；
单独加入 soft/hard 一致性目标，逐步稀疏化，而不是训练结束后突然阈值切断；
同时记录每层残差、路径熵、节点占用和梯度贡献，确认收益来自哪些深度；
只有软模型达到应用门禁后，再比较硬路由、Top-k 路由和稀疏概率路由的成本。

这里采用的是门禁思路，不要求一次找到全局最优 F。第一阶段只要求：有限、守恒、可训练、可
重载、比随机路由有信息，并能把梯度和状态可靠交给 READ。达到以后再优化速度、稀疏度和拓扑。
如何反驳这条路线
F 路线应当被降级或修改，如果出现以下任一稳定结果：

在相同数据、容量和预算下，搜索树长期不能胜过随机或简单 flat baseline；
parent 概率质量不能闭合，残差不能重建对应层状态；
打乱 token 与概率行的对应关系后，READ 质量不下降；
多个 seed 下树结构完全漂移，并且下游关系也无法复现；
软路由的收益只能依赖稠密全路径计算，任何可接受成本的稀疏化都会消失；
matched Transformer、SGNS 或简单概率模型在同等资源下稳定占优，而 TreeHeap 没有提供新的
能力或成本优势。

负结果不是项目失败，而是缩小 F 的候选集合。我们寻找的不是一个必须存在的答案，而是一条能
被公式、代码和未见数据共同约束的函数族。
最后的简化图
语料
  -> token-context 共现计数
  -> 每个 token 的条件概率行 p_t
  -> 节点函数 f_v 计算局部路由
  -> 整树函数 F_Theta 形成多层原型与残差
  -> READ 取得一个或多个分辨率状态
  -> Decoder 形成输出概率

学习算法 A：
  Monte Carlo / gradient / topology search
              |
              +----> 更新 Theta，而不是取代 F
所以，F 函数问题最终可以压缩成一句工程问题：

能否找到一种逐层相容、概率守恒、可微、可稀疏化的状态变换，使粗层保留公共背景，深层补充
区分信息，并让 READ/Decoder 不必绕过 TreeHeap 就能使用这些信息？
我们已经知道这条链路可以开始工作，也知道它目前断在什么地方。尚未找到终点，但问题已经从
“寻找一个神秘公式”，变成了可以逐项实现、测量和反驳的架构任务。

License: GPLv3。本文中的定义、证据边界和实验入口随 SameTime / TreeHeap 项目公开。

符号	含义
\(q\)	query，当前要查找或写入的目标
\(S_i\)	第 \(i\) 个局部子堆
\(W\)	world model，也就是背景参考系
\(\theta\)	kernel 的可学习参数
\(y_i\)	匹配、路由、写入或合并输出

符号	含义
\(v_i\)	value，节点向量
\(a_i\)	address/path，节点地址
\(\tau_i\)	topology，局部拓扑关系

符号	含义
\(q\)	query，要找或要写的目标
\(S_a\)	地址 \(a\) 处的局部子堆
\(W\)	world model / 背景场
\(\theta\)	kernel 参数，可以固定，也可以学习

模型	输入	预期
fixed distance kernel	手写 \( -\lVert patch-query\rVert^2 \)	上限参考，不算学习
linear raw kernel	raw query + raw patch	应该失败或较弱
MLP raw kernel	raw query + raw patch	应该明显强于 linear
TreeHeap convolution kernel	raw query + raw patch + path/topology	应该在 OOD 地址上最好

符号	含义
\(H\)	当前 TreeHeap 内存态
\(q\)	query
\(a\)	候选操作或候选地址
\(\theta\)	可学习参数

符号	含义
\(M\)	TreeHeap memory
\(s\)	slot，比如 root / subject / object
\(v\)	token
\(p\)	输入位置
\(P(s \mid p)\)	第 p 个 token 写入 slot s 的概率

Encoder	输入能保留什么？
BoW	英文 token 的平均向量，不保留顺序。
Flat GRU	有序英文 token 序列。
TreeHeap	英文叶子、递归内部子堆、root。

Model	Test NLL ↓	PPL ↓	token-BLEU4 ↑
TreeHeap	5.129	168.8	1.48
BoW	4.948	140.9	1.43
Flat GRU	4.799	121.4	2.87

指标	开始	结束
验证 NLL	9.658	5.519
验证 PPL	15,626	249.4
训练时间	-	48.0 分钟

模型	如何把英文压成四个状态
Learned TreeHeap	根据节点内容学习每次合并哪两个相邻子堆
Fixed TreeHeap	按固定、较平衡的规则合并
Random TreeHeap	按不可训练的随机规则合并
Flat K=4	把句子顺序切成四段，每段直接求平均
Leaf Oracle	GRU 读取全部 token，不受四状态限制，只作为上界

Encoder	Test NLL ↓	PPL ↓	token-BLEU4 ↑
Learned TreeHeap	6.5988	734.2	0.226
Fixed TreeHeap	6.6012	736.0	0.159
Random TreeHeap	6.7020	814.0	0.185
Flat K=4	6.5080	670.5	0.431
Leaf Oracle	6.3541	574.8	0.792

同一 checkpoint 的测试 route	NLL	相对 learned
Learned route	6.5988	-
Fixed route	6.6085	+0.0097
Random route	6.6272	+0.0285

对象	含义	是否学习
$H$	当前 TreeHeap 数据状态	每个样本不同
$\theta$	识别操作程序的共享 kernel	梯度学习
地址和算子	`2i/2i+1`、mirror、subtree plus	固定数学规则

测试	地址	操作深度
IID	训练范围内	1–2
OOD address	从未训练的深地址	1–2
OOD depth	浅地址	从未训练的 3–4
OOD joint	深地址	3–4

测试	结构程序 + 固定算子	Flat 程序	Flat 直接改写	判断
IID	92.70%	15.35%	72.05%	强阳性
未见地址	84.00%	0%	0%	强阳性
未见深度	4.40%	0%	0%	不合格
地址与深度同时未见	5.80%	0%	0%	不合格

模型	参数量
结构程序 encoder	41,671
Flat 程序预测	235,913
Flat 直接改写	196,927

指标	结果
验证 NLL，越低越好	6.2365
Top-1	11.96%
Top-5	23.29%
root variance	0.05843

detail宽度 $k$	总浮点数	原始容量占比
0	192	1.56%
8	696	5.66%
16	1,200	9.77%
32	2,208	17.97%
64	4,224	34.38%
原始叶子	12,288	100%

指标	检查什么
root next-token NLL	全局预测能力是否被破坏
leaf embedding MSE	连续状态恢复
token Top-1/Top-5	词面恢复
sequence token accuracy	整句恢复
edit similarity	顺序接近程度
bag overlap	内容是否回来
position accuracy	地址与次序是否回来
floats/token	付出了多少容量

detail $k$	TreeHeap存储	Flat存储	TreeHeap MSE	Flat MSE	Haar MSE	Token Top-1	64-token整段Exact
0	192	192	1.9334	1.9104	1.9110	6.50%	0.00%
8	696	768	0.8803	1.8416	1.8232	51.05%	0.00%
16	1,200	1,344	0.7622	1.7459	1.7471	76.84%	0.00%
32	2,208	2,304	0.6516	1.7047	1.5979	95.01%	5.99%
64	4,224	4,224	0.5526	1.6042	1.2881	99.64%	82.68%

TreeHeap / SPR：递归树堆 AI 架构研究档案 on GrepCode

[SPR-001] 问题定义：为什么要研究路径路由

问题定义：为什么要研究路径路由

SPR 想替代什么

SPR 不应该被误解成什么

ARA 方式怎么约束 SPR

本专题的核心问题

[SPR-002] S1 实验：Echo、顺序哈希与容量证据

S1 实验：Echo、顺序哈希与容量证据

实验脚本

1. pure roll 的顺序碰撞

2. roll + sign_alt

3. 分解路由容量

4. 这个结果证明了什么

[SPR-003] S1 反证：token-only 路由不是语义路由

S1 反证：token-only 路由不是语义路由

实验设计

结果

解释

这个失败说明什么

ARA 状态

下一步

[SPR-004] 架构决策：把 SPR 拆成三层

架构决策：把 SPR 拆成三层

S1a：Token Path Hash

S1b：Context-conditioned Routing

S2：Fold Stack / Structure Routing

新接口

决策

[SPR-005] S2 结构路线：Fold Stack 的位置

S2 结构路线：Fold Stack 的位置

S2 的问题

已有证据的含义

S2 的关键指标

S1 与 S2 怎么连接

S2 的下一步

[SPR-006] 下一轮实验：从 proof 走向真实基线战

下一轮实验：从 proof 走向真实基线战

最小模型

第一关：真实语料多义词

第二关：随机哈希

第三关：BoW 小模型

第四关：接 S2 fold state

输出要求

通过标准

[SPR-007] S1b proof：上下文条件路由到底证明了什么

S1b proof：上下文条件路由到底证明了什么

实验脚本

设计要点

结果

它证明什么

它不证明什么

历史结论怎么修正

架构决策

下一道门

[SPR-008] S2 策略审计：TreeHeap、Role Slots 和概率容器

S2 策略审计：TreeHeap、Role Slots 和概率容器

背景：我们到底想解决什么

ARA 方式

/logic：先预测，再实验

/logic：新的四层理解

实验一：当前 TreeHeap 128D 是否适合直接做语法能量

实验二：非交换张量能不能直接选出正确结构

实验三：Role Slots 是否真的存在

实验四：概率容器是否有必要

夜间任务的部分结果

/logic：我们现在怎么判断

当前架构决策

继续推进

暂停放大的 claim

/evidence：证据在哪里

给初学者的最后总结

[SPR-009] 世界模型与参考系：TreeHeap 术语统一

世界模型与参考系：TreeHeap 术语统一

为什么要叫世界模型

术语表

一个例子：足球和篮球

为什么不能只看 raw cosine

Latent Slot 不是主谓宾

概率容器的位置

`/logic`：先预测，再实验

`/logic`：新的四层理解

`/logic`：我们现在怎么判断

`/evidence`：证据在哪里

Predict	结果	判定
P1 root NLL不变	audit NLL `6.2997973263 -> 6.2997973263`，参数指纹相同	通过
P2 MSE随容量单调下降	三个 seed 全部严格单调	通过
P3 Spearman至少0.9	三个 seed 均约1.0	通过
P4 k=64至少减半MSE	降至root-only的28.6%	通过
P5 地址破坏明显伤害	MSE增加约500%	通过
P6 击败已实现同码率对照	k=8到64均优于flat/Haar	有界通过

扰动方式	操作对象	想检查的能力
leaf mask	单个叶子	局部共现
sibling mask	一对孩子	parent 是否保存摘要
subheap cut	完整子堆	ancestor 是否保存更大范围信息
detail dropout	某层 detail	粗粒度状态能否补回细节
subtree replacement	用别的子堆替换	模型能否发现上下文不一致
address shift	detail 移到错误地址	路径和地址是否有真实作用
mirror perturbation	子堆左右翻转	顺序与手性信息是否被编码

模型	训练问题	训练时间
Echo	所有 detail 完整，恢复全部 token	46.5 秒
Multiscale Mask	移除随机子堆内部 detail，只恢复受损区域	51.0 秒

被移除的 token 数	Mask NLL，越低越好	Mask Top-1	Echo Top-1
2	6.526	14.26%	24.61%
4	7.277	8.69%	3.32%
8	7.567	7.50%	1.46%
16	7.843	6.42%	0.78%
32	7.915	6.36%	0.81%

Mask 大小	正常 NLL	Root 清零 NLL	换错 Root NLL
2	6.526	7.369	6.861
4	7.277	7.775	7.623
8	7.567	7.898	7.920
16	7.843	8.131	8.194
32	7.915	8.188	8.276

Gate	结果
P1 深层 Mask 优于未训练 Mask 的 Echo	通过
P2 span-32 的 root-zero 有明显伤害	通过
P3 root 贡献随 Mask 深度上升	失败，Spearman = -1.0
P4 Mask 训练比 Echo 更依赖 root	通过
P5 换错 root 有明显伤害	通过
P6 所有递归算子都有梯度	通过

项目	设置
训练数据	200,000 个真实中文 block
每个 block	64 token
TreeHeap 深度	6
节点 state	64D
验证数据	512 个未参与训练的 block
设备	io / RTX 3090

节点	实际覆盖文本	Bag 读出 cosine	Adjacency 读出 cosine
0	蔓交错，到四月花期，就是一扇开满花的拱……	0.379	0.129
1	门。清唱咖啡，有一面墙的书架，尚有空……	0.597	-0.087
2	余，总有客人愿意将看过的，或者喜欢的书放在书架……	0.216	-0.044
3	上给大家分享。这里有个赠书的江湖。鼎韵艺术沙龙	0.644	-0.142

指标	数值
state cosine	0.9848
两段文本的精确 Bag cosine	0.2242
两段文本的精确 Adjacency cosine	-0.1449

覆盖 token	2	4	8	16	32	64
Bag READ cosine	0.267	0.286	0.306	0.334	0.377	0.436
Bag Query 增益	0.184	0.122	0.095	0.086	0.071	0.077
Adjacency READ cosine	0.010	0.012	0.015	0.017	0.021	0.027