Files
ssw-mpc/docs/IR.md
T
rong 65e199c406 feat(sql): MIN/MAX 换树形归约,轮数从线性变对数
影响:`MIN`/`MAX` 的往返数不再随行数线性增长,1000 行的五聚合查询从
约 9995 轮降到 115 轮。**这是本仓第一次改增长阶,不是压常数因子。**

- `secure_graph::minmax` 从「best 与每一行比一次」改成逐层两两归约:
  叶子层是 `len` 个本地 slice,每层 9 轮比较 + 1 轮选择 = 10 轮,
  深度 ⌈log₂ len⌉。奇数个元素时最后一个轮空(补哑元素要多一次比较)。
- 每行翻一倍正好 +10 轮:4/8/16/32/64/128/256 行 → 23/33/43/53/63/73/83。
- 5 行 55 → 45 轮;1000 行 ~9995 → 115;10000 行 ~99995 → 155。

数值上等价:min/max 可结合,全程只有 cmp + select、不经过 truncate,
换结合顺序不引入任何差。`where_aggregate_matches_legacy_for_every_cmp_op`
仍要求 `MIN`/`MAX` 与手写序列逐位相同。

顺带修 `nax-cli` 的阶段表:本地算子列改成同名折叠(`slice ×2000`)。
1000 行时原来会把上千个 slice 逐个列出来,表格 300 KB 且不可读;
折叠之后树的结构反而一眼可见(`cmp ×1000 → ×500 → ×250 → ×124 → …`)。

修正一处自己写错的论断:`minmax` 原注释与 `docs/IR.md` 说「树形不省轮数,
因为串行依赖不变」—— 深度不同,`行数−1` vs `⌈log₂行数⌉`,而且同层比较
互不依赖可以合批。文档已改,另加 2 条测试钉住增长阶与非 2 的幂的正确性。

验证:471 用例全绿(+2),-Dwarnings 零告警,no_std 守线过,rustfmt 无 diff。
变异 3 条全部按预期红后还原:退回线性链(4→8 行多 40 轮)、落单元素不轮空
(n=3 MAX 错)、比较方向取反(n=2 MIN 错)。
2026-11-02 11:39:43 +08:00

448 lines
26 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# `nax-ir`:算子图与轮次规划
> 这一层是被隐语(SecretFlow)逼出来的。
> SPU 的链路是 `JAX → XLA HLO → PPHLO → MPC 运行时`,其中 PPHLO 做的正是
> 「可见性推导 + MPC 专用优化」。nax 之前没有这一层:每个协议调用都是手写的,
> 写的人要同时知道「数学上算什么」和「哪几步过网络」,两件事糊在一起。
## 1. 没有这一层时,哪里疼
三个具体的疼法,都真实发生过:
1. **轮数没人能回答。** 「纵向 LR 一步要几个往返」以前只能靠读代码数,
而且数完还是错的(`mul` 内部有两次 open)。
2. **公开值只能出现一次,这条约束没有地方表达。** `truncate` 的 `cs`、
`poly` 的 `c₀` 各栽过一次:每方都带一份 → 结果变成 n 倍,**不报错**。
以前靠 review 和测试兜。
3. **本地算子和交互算子混在一起写。** 一段纯线性的预处理(加、减、转置、
整数缩放)在代码里长得很像交互算子,读的人不知道它其实零通信。
## 2. 三层,各管一件事
```
Graph 构造期:形状检查、可见性、公开值进密态表达式时插 Lift
↓
Plan 编译期:base/end 推导 → 分阶段 → 同阶段 open 合并
↓
Exec 运行期:本地算子本地算,交互算子走 nax-vault
```
### 2.1 `Vis` 是值的属性,不是环境变量
这一点和 `nax-runtime::device` 的结论一致:域跟着数据走。
由此两条硬规则:
- `Open` 之后的值是 `Public`,拿它乘公开系数是**本地运算**,不再走协议;
- 公开值进入密态表达式**必须显式 `Lift`**(构造期自动插)。
```rust
let x = g.input(Shape::vec(3)); // Secret
let c = g.constant(vec![100, 100, 100], Shape::vec(3))?; // Public
let s = g.add(x, c)?; // 自动插 Lift
assert!(g.nodes().iter().any(|n| matches!(n.op, Op::Lift { .. })));
```
`Lift` 落成「**只有 0 号携带明文,其余方持 0**」。这是加性分片的一个合法表示
(三片加起来正好是明文),也正是 `truncate` 里 `cs` 的处理方式。
> 为什么不让每方都带一份?因为三方时和会变成 `3c`。能跑、能收敛、数是错的 ——
> 这类 bug 是 nax 历史上最贵的一类。
### 2.2 每个算子自带真实往返数
| 算子 | 往返 | 依据 |
|---|---|---|
| `matmul` / `mul` | 2 | `d`/`e` 合成一轮(`open_batch`),截断的 `c` 再一轮 |
| `mul_raw` | 1 | 精确乘,不截断 ⇒ 只要 `d`/`e` 那一轮 |
| `cmp` | 9 | 见下 |
| `select` | 1 | 一次精确乘 |
| `trunc` | 1 | 打开 `c = x + r` |
| `open` | 1 | 广播分片 |
| `scale`(小数系数) | 1 | 乘法把定点尺度翻倍,截断必须走协议 |
| `scale` / `scale_int`(**整数**系数) | 0 | 尺度不变,连右移都不需要 |
| `add` / `sub` / `sum` / `sum_rows` / `transpose` / `slice` / `concat` / `bit_not` / `lift` | 0 | 对加性分片透明 |
| `mul_public` | 0 | 本地乘公开常量向量(尺度 +1,后面补一次 `trunc`) |
最后一行里 `transpose` 值得单独说:分片按**同一布局**切,所以「转置后取分片」
就等于「取分片后转置」,纯本地置换。`slice` 同理 —— 取第 i 行是本地复制。
`cmp` 的 9 轮不是拍脑袋:`msb_raw` 里 1 次 `open`(打开被掩盖的差值)+
`bit_lt_public` 的 Hillis–Steele 扫描(63 位 → 6 次 Beaver 乘)+ 1 次 `z = p·d`
+ 1 次 `msb = t ⊕ borrow`。常量 `CMP_ROUNDS` 与真跑出来的突发次数由
`tests/cmp_rounds.rs` 对齐 —— 协议改了没同步改常量,那条测试会红。
这 9 轮是**整批的价**,不是每次比较的价:同一阶段的 k 个比较合成一批,
`bit_lt_batch` 把 Hillis–Steele 每一层的 k 个乘合成一个往返,于是轮数与 k
无关(k=1 与 k=5 都是 9 轮,逐个是 9k)。见 §2.4。
### 2.3 定点尺度挂在值上(这一节是踩出来的)
nax 的密文是定点数:一个值的编码是 `真实值 · 2^((k+1)·fxp)`,`k` 就是它的
**尺度**。基准值是 `k = 0`;乘一个 fxp 编码的**公开系数**会变成 `k = 1`
(`2·fxp`),必须 `trunc` 回 0 才能和别的基准值相加。
手写协议序列时这件事全靠人记,`nax-ml` 里就有注释在提醒:
> `scale_public` 把 grad 乘到 2·fxp,再和 w(fxp)相加需要对齐
漏了不是崩溃,是**结果差 2^fxp 倍**。所以 `k` 挂在 `Node` 上:
```rust
let x = g.input(Shape::vec(2));
let c = g.constant_f64(18, &[0.5, 0.5], Shape::vec(2))?;
let scaled = g.mul_public(x, c)?; // k = 1
g.add(x, scaled) // 构造期就拒:定点尺度不一致
```
两条由此得来的结论:
1. **截断可以延后。** 多项式先乘 4 个系数(都是 `k=1`)、加在一起、最后只
`trunc` 一次 —— 从 4 轮降到 1 轮。只要每一步的 `k` 对得上,延后就是安全的;
对不上,构造期就报错。
2. **整数系数和系数不是一回事。** `Scale` 走 `scale_public`(编系数再乘,
尺度 +1、必须截断);`ScaleInt` 是裸的 `wrapping_mul(k)`(尺度不变、0 轮)。
两者对整数系数的**结果**一样,代价差一轮。
> 第 2 条是这一层自己的第一个 bug:第一版让整数系数走 `Scale` 却跳过截断,
> 结果差 `2^fxp` 倍 —— 而且当时没有任何测试比对过整数系数的值。
> 现在 `tests/schedule.rs` 用「`scale` 调用次数必须是 0、`scale_int` 必须是 1」
> 把它钉住。
### 2.4 阶段与轮数
```text
base(n) = max(end(前驱))
end(n) = base(n) + cost(n)
```
同 `base` 的交互算子互不依赖(依赖了的话 `base` 会被抬到对方的 `end`),
所以可以**一起发、一起收**。
轮数不是 `max(end)`。第一版这么写,结果在「同一阶段既有 `scale` 又有 `open`」
时少算一轮 —— 这两者串行,搭不上车。现在的数法跟执行器逐条对齐:阶段之间
串行,阶段内**按类批量**。
```text
阶段耗时 = (有乘类 则 1) // Mul / MulRaw / Select 合成一个乘批
+ (有截断类 则 1) // Trunc / 小数 Scale / Mul 的内部截断
+ (有 open 则 1) // 所有 open 合成一个往返
+ (有 cmp 则 9) // 所有比较合成一批,CMP_ROUNDS 封顶
+ Σ 其余交互算子的 cost // 目前只有 matmul(2 轮)
```
四项都是「N 个合成一个」,因为执行器真的那样发:`mul` 走 `Vault::mul_batch`
(k 个乘 1 个往返)、截断走 `Vault::truncate_batch`、比较走 `Vault::bit_lt_batch`
(轮数与 k 无关)、open 走 `Vault::open_batch`。`Select` **不截断**,所以它只算
乘批那一项 —— 这条曾经写错过,5 个聚合的计划因此比实测多 5 轮。
这套账有独立的对账:`nax-sql` 的 `query_rounds_matches_the_measured_protocol`
真跑一遍数收发突发,与计划**逐轮相等**。模型和执行器是两条链,只改一边就红。
分阶段本身是 `O(n)`:`base` 的取值范围是 `0..=最大轮数`,所以按 `base` 直接
散列成桶,而不是「对每个去重后的 `base` 扫一遍全图」。后者是 `O(n·k)`,
`MIN`/`MAX` 那种逐行归约会造出几千个不同 `base` 的节点,图一大就废。
## 3. 实测
`nax plan` 把纵向 LR 的**一整次迭代**编一遍(`--rows/--features/--sigmoid-degree`
只影响形状和多项式次数,与数据无关):
```
$ nax plan --rows 8 --features 4 --lr 0.1
起始轮 | 交互算子 | 本地算子 | 交互数
-------+----------+----------------------------------------------------------------------------------------------+-------
1 | matmul | input, input, input, const, lift, concat, const, const, lift, const, const, const, transpose | 1
3 | scale | — | 1
4 | mul | mul_public, add | 1
6 | mul, mul | — | 2
8 | mul, mul | mul_public, add | 2
10 | trunc | mul_public, add, mul_public, add | 1
11 | matmul | sub | 1
13 | scale | — | 1
14 | — | sub | 0
编译结果
算子总数 | 33
交互算子 | 10
本地算子 | 23
公开值抬升 | 2
每轮迭代往返 | 13
```
`6 | mul, mul` 这一行是 2 轮而不是 4:两个乘合成一个乘批(1 轮),两个截断
合成一个截断批(1 轮)。**批量之前这里是 4 轮,迭代总计 17 轮。**
`sigmoid` 的次数决定多项式那几段 `mul` 的个数,也就决定了轮数:
| `--sigmoid-degree` | 3 | 5 | 7(默认) | 9 |
|---|---|---|---|---|
| 每轮迭代往返 | 11 | 13 | **13** | 15 |
degree 5 与 7 同为 13:多出来的那一项乘落在已经有乘的阶段里,被批量吃掉了。
`--l2 0.1` 恰好 **+1 轮**(13 → 14,多一条「乘公开系数 + 截断」),测试
`l2_costs_exactly_one_more_round` 钉住。`--lr` 不改变轮数:步长是 `lr/n`,
`lr=2` 时也还是 `0.25` 这种小数,照样 `scale` + `trunc`。
> **修正**:本节早前贴的是「14 个算子 / 5 交互 / 7 轮」,`--lr 2` 时 5 轮。
> 那是 `cmd_plan` 里手搭的最小 demo 图(线性梯度步,不含 `sigmoid` 多项式)。
> `nax-ml` 迁移之后 `nax plan` 直接调 `VerticalLR::build_epoch`,报的是真迭代,
> 数字随之变成 33 算子 / 17 轮(批量之后是 13 轮)。**旧数字按 demo 图理解是对的,按 `nax plan`
> 的输出理解是错的。** 整数系数 `scale` 零往返那条结论本身仍然成立
> (`Op::ScaleInt`),只是真迭代里步长不是整数,碰不到它 —— 由
> `schedule.rs` 的库级测试直接钉。
> 注意第一行那几个 `const` / `lift` / `concat`:33 个算子里 23 个是纯本地的,
> 包括 `transpose` 和偏置列拼接时的两次 `lift`。**图的规模不等于协议的规模**,
> 这是这一层最直接的产出。
### 3.2 密态 SQL 的 WHERE + 聚合
`nax sql-plan` 把一条掩码 WHERE + 聚合的查询编一遍(不联网、不需要数据 ——
图只依赖形状):
```
$ nax sql-plan --rows 5 --where "0<400" --aggs count,sum,avg,min,max
掩码段(谓词 → 0/1 位 → 掩码后列 → 命中数)
起始轮 | 交互算子 | 本地算子 | 交互数
-------+---------------+-------------------------------+-------
1 | cmp | input, const, lift | 1
10 | mul_raw, open | bit_not ×2, scale_int ×2, sum | 2
聚合段(SUM / AVG / MIN / MAX)
起始轮 | 交互算子 | 本地算子 | 交互数
-------+---------------------+-------------------------------------+-------
1 | open, scale, cmp ×4 | input ×3, sum ×2, add ×2, slice ×10 | 6
12 | open | — | 1
13 | select ×4 | — | 4
14 | cmp ×2 | — | 2
23 | select ×2 | — | 2
24 | cmp ×2 | — | 2
33 | select ×2 | — | 2
34 | open ×2 | — | 2
掩码段往返 | 11
聚合段往返 | 34
总往返 | 45
```
第一阶段的 `cmp ×4` 就是 `MIN`/`MAX` 两条树的第一层:5 行两两配对,每层
`⌊5/2⌋ = 2` 个比较,两条链共 4 个 —— 它们互不依赖,落在同一阶段,**9 轮封顶**。
三件事一眼可见,以前都读不出来:
1. **`slice ×10` 是零通信的。** `MIN`/`MAX` 的归约在图上长成 10 个本地切片,
但它们是纯本地复制 —— 图大不等于协议大。
2. **`MIN`/`MAX` 是绝对大头**:整条聚合段 34 轮里 30 轮是「3 层 × (9 轮比较 +
1 轮选择)」。**树形归约让层数跟行数的对数走,不跟行数走** —— 下面那张表是
这件事的直接后果。
3. **同一行的 `select ×4` 只花 1 轮**(乘批,无截断);`open ×2` 也只花 1 轮。
批量让「同阶段有几个」不再重要。
把行数从 5 推到 1000,聚合段只从 34 轮到 104 轮:
```
$ nax sql-plan --rows 1000 --where "0<400" --aggs count,sum,avg,min,max
起始轮 | 交互算子 | 本地算子 | 交互数
-------+------------------------+---------------------------------------+-------
1 | open, scale, cmp ×1000 | input ×3, sum ×2, add ×2, slice ×2000 | 1002
12 | open | — | 1
13 | select ×1000 | — | 1000
14 | cmp ×500 | — | 500
23 | select ×500 | — | 500
24 | cmp ×250 | — | 250
33 | select ×250 | — | 250
34 | cmp ×124 | — | 124
⋮ | 每层 10 轮 | |
104 | open ×2 | — | 2
聚合段往返 | 104
```
`1000 → 500 → 250 → 124 → 62 → 32 → 16 → 8 → 4 → 2`:十层。**行数翻 200 倍,
轮数只翻 3 倍**(34 → 104)。线性扫描在 1000 行要 `999 × 10 ≈ 9990` 轮。
| 行数 | 4 | 8 | 16 | 32 | 64 | 128 | 256 | 1000 |
|---|---|---|---|---|---|---|---|---|
| 总往返(`[MIN,MAX]`) | 23 | 33 | 43 | 53 | 63 | 73 | 83 | — |
| 总往返(五聚合 + WHERE) | — | — | — | — | — | — | — | 115 |
行数每翻一倍正好 **+10 轮**(9 轮比较 + 1 轮选择 = 一层)。这条由
`minmax_reduction_costs_logarithmic_rounds` 钉住 —— 改回线性链那条测试立刻红。
> 这张表改过三次,每次结论都不一样,值得记下来:
> 1. 手写序列:5 行 **96 轮**(`MIN`/`MAX` 各 `(行−1) × 10`,串行);
> 2. 上图:95 轮(省一次 `open` 合并);
> 3. 上批量:**55 轮**(同阶段的比较/选择/乘/open 各自合成一批);
> 4. 换树形归约:**45 轮**,且行数从「线性」变成「对数」。
>
> 前两次是「合并」,第三次是**换算法**。真正的数量级来自第三次 —— 合并只能
> 把常数因子压低,改归约深度才能改增长阶。
### 3.3 分组:相等判断换单调前缀
`GROUP BY` 的默认路径是「每组一次 `gcol == g`」,而 `bit_eq` 是两次比较。
批量之前这两次比较按组串行累加 —— `N` 个组光比较就要 `18N` 轮;现在所有组的
比较落在同一个阶段、合成一批,**9 轮封顶**。
如果分组码是**整数**,同一件事可以换个问法:不问「这行是不是第 g 组」,
而问「这行码 ≤ g 吗」。这 `N+1` 个单调前缀一次建完,组内值由**累积和相减**
得到,`COUNT` 甚至不用乘掩码(前缀是位,求和就是计数),所有 `open` 合并成
一次,`SUM`/`AVG` 直接落在明文上 —— 没有第二段图。
```
$ nax sql-plan --rows 8 --groups 8 --aggs count,sum --group-mode coded
前缀段(谓词 → 分组码搬家 → N+1 个单调前缀 → 累积和)
起始轮 | 交互算子 | 本地算子 | 交互数
-------+-----------------------+--------------------------+-------
1 | cmp × 9 | input, const, lift × 9 | 9
10 | open/mul_raw 交替 × 9 | sum × 9 | 18
12 | open × 9 | — | 9
掩码段往返 | 12
聚合段往返 | 0
总往返 | 12
```
第二行那 9 对 `open`/`mul_raw` 就是「累积计数」和「累积和」:计数只要
`sum(前缀位)`(本地),和要一次 `mul_raw(前缀位, 列)`。9 个 `mul_raw` 合成一个
乘批(1 轮),9 个 `open` 合成一个往返(1 轮)—— **这一行 2 轮,不是 10 轮**。
第三行是它们的输出全部落在同一阶段,一起出来。
| 组数 | 逐组比较(上图前,手写) | 逐组比较 | 整数码前缀和 |
|---|---|---|---|
| 2 | 44 | 13 | 12 |
| 4 | 88 | 13 | 12 |
| 8 | 176 | 13 | 12 |
> 这张表改写过两次,值得说清楚:迁移到 IR 时是 44/82/162(省的是 `open` 合并,
> 8~9%);**比较也批量之后,组数彻底不花钱**,逐组比较降到 13 轮、整数码 12 轮。
> 整数码原本省的是「串行比较的个数」—— 比较一批量,那笔账就没了,只剩 1 轮。
> 它现在的价值是「没有第二段图」和那三条显式契约,不再是轮数。
两处代价都写在这里,不藏:
* **分组码必须是整数**。非整数码会落到它上方最近的一组(`1.5 → 2 号组`),
而不是「哪组都不算」—— `tests/coded.rs` 里有一条测试专门钉这个语义;
* **不支持 `MIN`/`MAX`**。前缀和只知道「和」,不知道「谁最大」,所以请求它们
直接报错,不会静默降级。
越界码(负数、`≥ N`)被丢掉,这点与逐组比较一致:两端的边界 `−0.5` / `N−0.5`
就是为它留的。
`WHERE` 未命中的行不逐组乘 `base`,而是**把码搬到 −1000**(按 `2^fxp` 缩放的
raw 值)。这些行会出现在每一个前缀里,差分时自动抵消 —— 省掉 `2N` 轮。
第一版拿真值 `−1000` 直接当 raw 用,它比 `0.5·2^18` 还大,结果被算进了每一个
前缀:行数变成全表、`SUM` 变成全表之和,**且不报错**。这条坑写在
`secure_graph.rs` 的源码注释里。
## 4. 谁在用这一层
到目前为止两个消费者,迁移方式一样:**手写协议序列搬上图,轮数改由编译器报**。
| | `nax-ml` 纵向 LR | `nax-sql::secure` 掩码聚合 |
|---|---|---|
| 迁移前的形态 | 一次迭代一串 `matmul_trunc` / `truncate` / `scale_public` | 掩码 → `bit_mask` → 各聚合逐个 `reveal` |
| 图建几次 | 1 次(`build_epoch`),跑 `epochs` 遍 | 每条查询 2 段(`AVG` 的除数要执行后才知道) |
| 报出来的数 | `nax plan`:**13 轮/迭代**(degree 7),degree 3 是 11 轮 | `nax sql-plan`:见上,`[COUNT,SUM,AVG,MIN,MAX]` 5 行 **45 轮**、1000 行 **115 轮** |
| 回归判据 | 帧序列逐帧相同 + ≤64 ULP | `COUNT`/`SUM`/`MIN`/`MAX` **逐位相同**、`AVG` ≤1e-4、轮数不增 |
SQL 侧还有第三条路径不在上表里,因为它是**换算法**而不是搬家:
`--group-mode coded` 把逐组 `==` 换成整数码前缀和(§3.3)。它自带两条契约
(码是整数、不支持 `MIN`/`MAX`),所以是显式开关,默认仍是逐组比较。
批量之后它的轮数优势只剩 13 → 12 —— 原来省的是「串行比较的个数」。
两边的「为什么不是逐位相同」都指向同一处:`nax-vault::truncate` 是随机舍入
(`c = x + r`,`out = (c >> fxp) − (r >> fxp)`),只有 `x` 的低 `fxp` 位全 0 才
精确。所以**同一段手写代码换个 seed 结果都会变**(`nax-ml` 的
`legacy_is_seed_sensitive` 钉住这一点)。真正成立的判据是「协议形状相同 +
数值在舍入预算内」。
净收益分三笔,必须分开记(都是实测):
| 场景 | 手写序列 | 上图 | 上批量 | 换树形归约 |
|---|---|---|---|---|
| `[COUNT,SUM,AVG,MIN,MAX]`,5 行,`col < 400` | 96 轮 | 95 轮 | 55 轮 | **45 轮** |
| 同上,1000 行 | ~9996 轮 | ~9995 轮 | ~9995 轮 | **115 轮** |
| `GROUP BY` 2 组,`[COUNT,SUM]` | 44 轮 | 42 轮 | **13 轮** | 13 轮 |
| `GROUP BY` 4 组 | 88 轮 | 82 轮 | **13 轮** | 13 轮 |
| `GROUP BY` 8 组 | 176 轮 | 162 轮 | **13 轮** | 13 轮 |
**第一笔(上图)几乎没有提速**:省的是同阶段 `open` 合并,`GROUP BY` 是
`2N − 2` 轮、8~9%。当时的结论是「搬家的价值在能报出轮数,不在变快」。
**第二笔(上批量)把「k 次往返」变成「1 次往返」**,前提正是第一笔:只有先
知道「哪些算子在同一阶段」,才敢把它们的收发并成一次。8 组 `176 → 13`(13×),
5 聚合 `95 → 55`(1.7×)。
**第三笔(换树形归约)才是真正的数量级**:`MIN`/`MAX` 的依赖深度从 `行数−1`
降到 `⌈log₂ 行数⌉`。5 行小打小闹(55 → 45),1000 行是 `~9995 → 115`(**87×**)。
它和批量是两件不同的事 —— 批量压常数因子,树形改增长阶。
顺序不能反:没有 IR 就不知道谁和谁不依赖,批量就成了瞎猜;猜错不会算错
(最多退化成串行),但也就谈不上收益。树形归约反过来不依赖 IR,**但它能省
多少轮,只有 IR 能报出来** —— 手写序列里那段循环看起来只是「逐行比较」,
数不出深度。
## 5. 变异验证(验证测试真的在测东西)
按项目惯例,把实现改坏,确认对应测试**失败**:
| 改坏的地方 | 结果 |
|---|---|
| `Lift` 改成每方都带明文 | 3 条失败,报错是「公开常量被加了 2 次」 |
| 取消同阶段合并(每节点自成阶段) | `independent_opens_share_one_round` 失败;端到端那条以「两次 open 必须落在同一个阶段」失败 |
| 执行时逐个 `open` 而非批量 | 调用日志从 `open_batch:2` 变成 `open_batch:1, open_batch:1` |
| 整数系数改回走 `Scale` 却不截断 | `two_opens_are_issued_as_one_batch` 失败(`scale` 出现、`scale_int` 消失)—— 这就是当初真出的那个 bug |
| `bit_not` 的常量 1 每方都加 | n 方掩码测试整体错,两方用例仍过 —— 典型的「两方看不出、三方才分叉」 |
| `MIN` 补位符号取反(`+SENTINEL` → `−SENTINEL`) | `secure_where_aggregate_matches_engine` 与 `secure_cmp_col_matches_engine` 失败 |
| `CMP_ROUNDS` 改成 8 | `cmp_rounds_matches_the_real_protocol` **和** `query_rounds_matches_the_measured_protocol` 一起失败 |
| `bit_lt_public` 退回逐个(比较不批量) | `bit_lt_batch_costs_nine_rounds_whatever_k_is` 失败:9 → **37** 轮(k=5) |
| `mul_batch` 的 d/e 各自 `open` | `mul_batch_costs_one_round_trip` 失败:1 → **6** 轮 |
| `MIN`/`MAX` 退回线性扫描 | `minmax_reduction_costs_logarithmic_rounds` 失败:4→8 行多 **40** 轮而不是 10 |
| 树形落单元素不轮空(丢掉) | `minmax_tree_matches_plaintext_across_sizes` 失败:`n=3 MAX` |
| 树形比较方向取反 | 同一条失败:`n=2 MIN` |
| 编译期不给比较批量(执行器照旧) | `query_rounds_matches_the_measured_protocol`:计划 **90** vs 实测 45 |
| 执行器逐个比较(编译期照旧) | 同一条:计划 45 vs 实测 **90** |
| `Select` 当成需要截断 | 同一条:计划 **49** vs 实测 45 —— 这就是真踩到的那个 bug |
批量那三行是关键:它们说明 `nax sql-plan` 报出来的 45 轮不是「自己跟自己一致」,
而是锚在真协议的收发次数上。轮数模型和实测是**两条独立的链** —— 只改模型
报 90、只改执行器报 90,两边都改对才 45 == 45。
`MIN`/`MAX` 那三行是**算法层**的守卫:前一行防「改回线性扫描」(轮数增长阶
会变),后两行防「树形写错」(数值会错)。算法改动只有这两种失败形态,
两种都得有测试兜着。
`Select` 那一行尤其说明问题:它不截断,但如果模型多给它算一轮,五个聚合函数
的计划就比实测多 5 轮。**这种偏差不会让任何数值错**,只会让报出来的数虚高 ——
所以只能靠对账测试抓。
第三条尤其说明问题:**静态分析说「合并了」不等于运行时真的合并**,
所以 `tests/schedule.rs` 用一个记录调用序的明文档执行器把这件事钉住。
## 6. 这一层不做什么
写清楚比假装完整有用:
- **不是 MLIR。** 没有通用 pass 框架、没有 shape 多态、没有多后端 lowering。
- **不做协议选择。** `mul` 永远是 Beaver,不会因为参与方数变 3 就换 ABY3 ——
`nax-vault` 目前只有一套协议,编译期假装能选是骗人。
- **不做恶意安全。** 轮次合并不改变半诚实模型下的语义:合并的两个 `open`
本来就互不依赖,只是把等待叠在一起。
- **同类批量,跨类别不共享。** 同阶段的乘 / 截断 / `open` / 比较各自合成一批;
但 `mul` 的两段(乘、截断)不与 `open` 的批交叉共享,`matmul` 也还没进乘批 ——
那要求把 Beaver 的收发完全摊到 IR 层。所以现在的估计仍是**上界**,
真跑只快不慢。
- **批量只在同阶段内**。跨阶段一定有数据依赖,合并就是错。这不是保守,是正确性。
- **没有前端。** 图用 Rust 手写(`Graph::matmul(...)`),不做语言绑定。
## 7. 与 `nax-runtime::device` 的关系
两个模块回答不同的问题,不要混:
| | `nax-runtime::device` | `nax-ir` |
|---|---|---|
| 回答 | 「这个值现在在哪一域」 | 「这次计算要几个往返」 |
| 时机 | 运行期 | 编译期 |
| 粒度 | 单个值 | 整张图 |
| 对非线性算子 | 显式拒绝,指向 `nax-sql::secure` | 标上代价,交给调度 |
两者都建立在同一个前提上:**域/可见性是值的属性**。所以 `Vis` 和
`DeviceKind` 语义一致,只是 `nax-ir` 多带了一份「谁依赖谁」的信息。