假设系统读到一句话：

西西弗斯在推着石头上山。

过一会儿，我们希望它记得这件事。怎样才算“记得”？至少可以有两种完全不同的行为。

第一种像 GrepCode：

查询：西西弗斯 石头
返回：西西弗斯在推着石头上山。

第二种像问答系统：

问题：谁在推石头？
回答：西西弗斯。

一开始，我们很容易把第一种称为“原文存储”，把第二种称为“理解式记忆”，仿佛第二种更接近真正的记忆。这个说法并不准确。

Houming818 指出了更根本的定义：

它们都是记忆协议。区别不在于哪一种才算记忆，而在于写入端和读取端共同约定了什么行为。

GrepCode 协议按照词面、地址或索引找回原文；问答协议按照问题生成答案。它们的状态表示、写入方式和读取方法都可以不同。即使底层保存的是同一段经历，协议不同，能得到的结果也不同。

这成为 TNM（TreeHeap Native Memory，TreeHeap 原生记忆协议）专题的起点。

1. 什么叫“协议”

协议不是一句神秘的比喻。它是一组参与者都遵守的计算约定。

最小的记忆协议可以写成：

其中：

如果缺少读取协议，一串比特即使保存了全部历史，也未必能被当前系统解释。如果缺少写入协议，系统只知道怎样读，却不知道新的经历应当放在哪里。如果缺少更新协议，记忆会不断膨胀，或者新信息覆盖旧信息而不自知。

所以记忆不是单独的 \(H\)。更完整的说法是：

记忆是状态与读写规则共同形成的系统。

2. Encoder 与 Decoder 已经是一套协议

在普通 Encoder–Decoder 系统中，Encoder 把输入变成内部状态：

Decoder 再解释这个状态：

只要两端一起训练，它们就可能形成一套人类看不懂、但彼此能够使用的内部编码。这就是我们在 TreeHeap 研究中反复讨论的私有协议。

这里的“对称”不能简单理解为两个函数长得一样。它真正表示的是读写之间存在配合：

Encoder 怎么写
        ↓
中间状态怎样变化
        ↓
Decoder 就学会怎样读

在精确 Echo 任务中，Decoder 近似执行 Encoder 的逆：

但在翻译、问答和续写中，Decoder 并不是 Encoder 的数学逆函数。它读取同一个内部状态，却按照任务协议产生另一种输出。

因此，“Encoder 与 Decoder 共同形成私有协议”这句话本身没有错。问题在于：它描述的通常还是一次输入、一次输出。

3. 从编解码协议到记忆协议，增加了时间

一次性编解码可以这样工作：

输入 x
  ↓
临时状态 Hx
  ↓
输出 y
  ↓
Hx 被丢弃

记忆系统不能在输出后丢掉全部状态。它必须把旧状态带到下一次：

以后再接受查询：

例如：

H0
 + “西西弗斯在推着石头上山”
 ↓ 写入
H1
 + 后续经历
 ↓ 继续写入
H2
 + “谁在推石头？”
 ↓ 读取
“西西弗斯”

与普通 Encoder–Decoder 相比，记忆协议至少多了三项约束：

1. 持续性：处理结束后，状态仍然存在；
2. 增量性：新经历进入时，不必从零重建全部历史；
3. 干扰管理：连续写入以后，旧协议不能立刻失效。

因此，两者的关系不是互相替代，而是包含关系：

私有编解码协议是记忆的读写语言；持续状态、冲突处理和遗忘机制构成它的时间部分。

4. TreeHeap merge 在协议中负责什么

TreeHeap 已经有一个明确的局部 FOLD：

这里 \(L\) 和 \(R\) 是左右子状态，\(D\) 是 detail，\(U\) 是向上递归的 parent。给定 \(U,D\)，可以恢复：

这说明 TreeHeap merge 已经拥有可逆 lifting transform 的数学基础。这里值得把推导完全公开，因为可逆性不是依靠“神经网络也许能学会”，而是由算子结构直接保证。

先把 FOLD 拆成两个三角变换。第一步是 Predict：

第二步是 Update：

Predict 没有修改 \(L\)，所以知道 \(L,D\) 就能恢复 \(R\)。Update 没有修改 \(D\)，所以知道 \(U,D\) 就能恢复 \(L\)。把两步逆序执行，就得到前面的 UNFOLD 公式。

这一结论不要求 \(P_{\theta}\) 或 \(A_{\theta}\) 是线性函数，也不要求单独求它们的逆。只要 FOLD 和 UNFOLD 调用同一组确定参数，显式逆就成立。

如果 \(P\) 和 \(A\) 可微，两步的 Jacobian 分别具有分块三角结构：

两个行列式都为 1，因此完整局部变换满足：

这意味着在理想连续算术中，它是一个体积保持的双射。实际程序仍会受到浮点误差、mask、量化和参数版本不一致的影响，所以代码必须继续做数值闭合测试。

4.1 整棵树为什么也能闭合

设有 \(N=2^h\) 个 leaf，每个状态维度为 \(d\)。第一层产生 \(N/2\) 个 parent 和 \(N/2\) 个 detail；第二层继续产生 \(N/4\) 个 parent 和 \(N/4\) 个 detail，直到只剩 root。

所有 detail 的数量是：

加上一个 root，状态块总数仍然是：

因此完整 TreeHeap 变换保持总自由度：

从 root 开始，只要按照深度逆序使用每层 detail，就能恢复全部 leaf。这个结论可以由深度归纳直接得到：深度 1 的局部 FOLD 可逆；若深度 \(h\) 的两棵子树可逆，再加一个可逆顶层 FOLD，深度 \(h+1\) 也可逆。

4.2 “压缩”到底发生在哪里

完整保留 root 和全部 detail 时，TreeHeap 完成的是可逆坐标变换，不是减少字节数。真正的有损压缩发生在：

1. 只读取 root 或较浅 frontier；
2. 对较深 detail 进行低精度量化；
3. 删除、稀疏化或熵编码低价值 detail；
4. 在固定读取预算下，不把全部 detail 搬入现实 \(H\)。

因此 TNM 当前首先利用的是访问压缩和分辨率压缩。它是否还能获得存储压缩，必须由后续 rate–distortion 实验回答，不能从 lifting 公式直接推出。

但是，这还不是记忆协议。

merge 目前回答的是：

两个局部状态怎样变成 parent 与 detail，并且以后可以展开？

记忆协议还必须回答：

新经历应该与哪一个 subheap 合并？旧状态哪些部分要保留？查询 kernel 怎样找到与问题有关的部分？重复、冲突和遗忘怎样处理？

因此，先把长期状态明确记为 \(M\)，TreeHeap 中更完整的数据流应当是：

其中：

• Encoder 把新观察变成可写入状态；
• Merge 决定它怎样进入已有 TreeHeap；
• Query kernel 从长期 TreeHeap 中形成取回状态 \(R_t\)；
• Decoder 与现实状态的融合过程将在下一节展开。

merge 是协议的状态更新算子，不是协议的全部。

5. 记忆系统不是把全部过去塞进现实 H

到这里还缺少一个重要的工程边界。真正使用记忆时，当前问题首先形成现实状态 \(H_t\)，然后从长期记忆系统中提取一小块状态 \(R_t\)，再把它混入现实：

这里必须区分四个对象：

参数 \(B\) 是读取预算，包括最多访问多少节点、展开多少次、搬入多少状态以及允许多少延迟。一个系统即使最终能从 12 TB 数据中找到“西西弗斯”，如果查询需要一个小时，它也不是可用的实时记忆。

因此 TNM 不能只报告回答准确率。它还必须报告访问节点数、读取带宽、延迟和记忆容量。

6. 为什么不能退化成 B 或 B+ 检索树

最直接的实现是把记忆分区：每个内部节点保存范围或类别，query 沿树比较，最后到 leaf 取出一条记录。

query
-> 比较分区
-> 沿树寻找 leaf
-> 返回 record

这当然可以工作，但本质上是可训练的 B/B+ Tree。TreeHeap 只提供了树形地址，没有使用此前建立的 FOLD、detail 和多分辨率压缩协议。

TNM 希望测试另一种机制：

长期记忆 \(M\) 本身就是经过递归 FOLD 的多分辨率 TreeHeap；读取不是定位某条记录，而是在 query 条件下局部 UNFOLD，逐步合成足以回答问题的 \(R\)。

两者的区别是：

这不意味着 B+ Tree 不好。它只是另一个成熟协议，不是 TNM 当前要验证的 TreeHeap 原生机制。

7. Query-Conditioned Partial UNFOLD

我们把这个候选逻辑原型暂称为 Query-Conditioned Partial UNFOLD，即“查询条件下的局部展开”。

假设长期记忆由 leaf 状态递归 FOLD 得到：

其中 root 是全局粗分辨率状态，各层 detail 保存继续提高分辨率所需的信息。

7.1 记忆怎样写成 M

先把第 \(j\) 条经历 \(x_j\) 编成一个 leaf 状态：

固定容量为 \(N\) 时，当前 leaf 层记为：

空位置由显式 mask 标记，不能把 PAD 的数值大小误当成有效记忆。对整个 leaf 层执行递归 FOLD：

如果只替换一个 leaf，树外所有不在其祖先路径上的状态保持不变。需要重新计算的节点数至多等于树高：

所以固定地址下的一次局部更新可以在 \(O(\log N)\) 个 merge 中完成。这里的地址更新规则仍然是第一版待定项；这个复杂度结论只描述“已知写入位置以后”怎样维护 TreeHeap，不证明系统已经学会把新经历放到正确位置。

7.2 mixed-resolution frontier

Partial UNFOLD 不把整棵树恢复成 leaf 数组。它维护一个 frontier，即当前已经足以代表整棵记忆的、不重叠的节点集合。

初始 frontier 只有 root：

如果选择展开节点 \(i\)，就用它的两个子节点替换它：

[ \mathcal{F}_{t+1}

\left(\mathcal{F}_t\setminus{i}\right) \cup {\operatorname{left}(i),\operatorname{right}(i)} ]

设 \(\operatorname{Leaves}(i)\) 表示节点 \(i\) 覆盖的原始 leaf 地址。每次替换都满足：

[ \operatorname{Leaves}(i)

\operatorname{Leaves}(\operatorname{left}(i)) \mathbin{\dot\cup} \operatorname{Leaves}(\operatorname{right}(i)) ]

符号 \(\dot\cup\) 表示不相交并集。因此任意时刻都有两个不变量：

[ \bigcup_{i\in\mathcal{F}_t}\operatorname{Leaves}(i)

\operatorname{Leaves}(\mathrm{root}) ]

也就是说，frontier 始终无遗漏、无重复地覆盖完整记忆，只是不同区域采用不同分辨率。展开 \(B\) 次以后：

这个不变量是 Partial UNFOLD 与“随便取几个节点”之间的数学区别。

7.3 query 怎样控制展开

读取从 root 开始，每到一个 frontier 节点，kernel 接收：

然后产生一个局部概率桶：

四个动作分别表示：

• stop：当前分辨率已经足够；
• left：展开当前节点后，优先继续细化左侧；右侧仍作为粗节点保留在 frontier；
• right：展开当前节点后，优先继续细化右侧；左侧仍作为粗节点保留；
• both：两个子节点都进入后续可展开集合。

一旦展开，就直接使用 TreeHeap 已有的 UNFOLD：

在预算耗尽或全部选择 stop 后，系统得到的不是某条原始记录，而是一棵混合分辨率的小 TreeHeap：有的区域已经展开到细节，有的区域仍然保留粗轮廓。

更具体地说，\(R_t\) 不是简单求和后的单向量，而是带地址、深度和 query 权重的 frontier：

其中 \(w_i\) 由读取 kernel 产生。保留 path 和 depth 是为了不把 mixed-resolution TreeHeap 再次压平为无序 word bag。

7.4 可执行伪代码

frontier = {root}
expandable = {root}

repeat at most B times:
    对 expandable 中已暴露的节点计算 kernel(q, U, D, path, depth)
    选择一个允许展开的节点 i
    如果所有节点都选择 stop:
        break

    (left, right) = UNFOLD(U_i, D_i)
    frontier 删除 i
    frontier 加入 left 和 right

    根据 left/right/both 动作更新 expandable

return 带地址和深度的 frontier 作为 R

这个算法只读取已经暴露节点的局部 detail，不需要先扫描全部 leaf。若实现为了算所有节点分数而预先读取整棵树，就已经破坏了预算定义。

同一个 \(M\) 面对不同问题，可以合成不同的 \(R\)：

“谁在推石头？”
-> 展开能改变人物回答的内部状态

“石头被推向哪里？”
-> 展开另一组内部状态

“原话是什么？”
-> 继续展开更多 detail，接近 leaf 分辨率

这些例子描述的是外部行为，不要求树中预先存在“人物槽”或“地点槽”。内部协议仍然可以是训练形成的私有编码。

8. 时间复杂度从展开预算产生

每展开一个节点，只读取该节点附近的 parent/detail，并恢复两个子状态。设：

其中 \(C_P\) 和 \(C_A\) 分别是一次 predictor 与 update 的成本，\(C_U\) 是一次 UNFOLD 的成本；再设一次读取 kernel 的成本为 \(C_K\)。

如果节点分数只依赖 \((q,U_i,D_i,\operatorname{path}_i,\operatorname{depth}_i)\)，新节点暴露时计算一次分数，并用优先队列维护候选，那么展开 \(B\) 次的成本是：

[ T_{\mathrm{read}}

O!\left(B(C_U+C_K)+B\log B\right) ]

若忽略固定维度 kernel 和优先队列常数，才可以简写为近似 \(O(B)\)。如果实现每一步都重新扫描整个 frontier，累计成本会退化为 \(O(B^2)\)；如果为了打分先读取全部 \(N\) 个节点，则直接退化为 \(O(N)\)。这些实现不能被包装成快速 Partial UNFOLD。

如果只沿一条路径走到深层：

如果问题需要多个区域：

展开 4 个节点  -> 回答准确率 ?
展开 8 个节点  -> 回答准确率 ?
展开 16 个节点 -> 回答准确率 ?
展开全部节点   -> 回答准确率 ?

写入：蓝七正在把紫色方块搬进北屋。
查询：谁在搬紫色方块？
期望：蓝七。

查询：方块被搬到哪里？
期望：北屋。

长期记忆 M
   + 当前现实 H
   ↓ query 条件下的局部 UNFOLD
取回状态 R
   ↓ Mix
新的现实状态 H'
   ↓ Decoder
结果