Files
ssw-mpc/docs/IR.md
T
rong 0204e1fb21 docs(ir): 补多项式深度表与结合顺序的结论
- §3 的 degree 表加「深度 `⌈log₂ d⌉`」与「sigmoid 块往返」两行,
  说明多项式块是 `2·⌈log₂ d⌉ + 1`,并点明 degree 5 与 7 同价。
- 新增 §3.1:三条求值顺序的实测对比(7 / 8 / 9),结论是这条路没有杠杆。
- §5 变异表加两行反向守卫(改坏求幂顺序必红、改坏截断粒度必须不红),
  §6 把「换顺序」从待办里划掉。
2026-11-02 12:13:46 +08:00

29 KiB
Raw Blame History

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(构造期自动插)。
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 上:

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 阶段与轮数

base(n) = max(end(前驱))
end(n)  = base(n) + cost(n)

同 base 的交互算子互不依赖(依赖了的话 base 会被抬到对方的 end), 所以可以一起发、一起收。

轮数不是 max(end)。第一版这么写,结果在「同一阶段既有 scale 又有 open」 时少算一轮 —— 这两者串行,搭不上车。现在的数法跟执行器逐条对齐:阶段之间 串行,阶段内按类批量。

阶段耗时 = (有乘类   则 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 的次数决定多项式求值的深度,也就决定了轮数:

--sigmoid-degree 3 5 7(默认) 9
多项式深度 ⌈log₂ d⌉ 2 3 3 4
sigmoid 块往返(含 t = z/R 那次缩放) 6 8 8 10
每轮迭代往返 11 13 13 15

两条能直接拿来选参数的结论:

  • degree 5 与 7 轮数完全一样:多出来的那一项乘落在已经有乘的阶段里,被批量 吃掉,深度都是 3 层。选 5 还是 7 只看拟合精度,与代价无关。
  • 多项式块是 2·⌈log₂ d⌉ + 1:每层乘 2 轮(乘批 1 + 舍入 open 1), 收尾那次线性组合的截断 1 轮。

--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.1 换多项式求值顺序省不下轮数(量过了)

很自然的想法是换个结合顺序缩短依赖链。结论是现状已经最优 —— crates/nax-ml/tests/reassoc.rs 把三条路都建了图量过:

写法 7 次的轮数 为什么
现状:先算齐各次幂,再乘公开系数做一次组合,只截一次 7 3 层乘 + 1 次收尾截断
Estrin t·(c₁+c₃u) + u²·t·(c₅+c₇u),u = t² 8 每组系数乘要回到本尺度才能再乘,多一次截断
Horner c₀ + t·(c₁ + u·(c₃ + u·(c₅ + c₇u))) 9 每层密文乘自带截断,串成一条链

根因是 Op::Mul 自带一次舍入 open(见 §2.2):一层乘就是 2 轮,而 degree 7 的深度下界是 ⌈log₂7⌉ = 3 层。现状把 4 次「乘公开系数 + 加」 (本地、0 轮)全推到最后,只在最外层舍入一次。

顺带修掉一句批量之后失效的旧注释:emit_poly 原来写「最后只截一次…… 比每项各截一次省 3 个往返」。批量之前(R13 前)确实如此,每次截断各占一轮; 同阶段截断合批之后,逐项截断搭的是本来就要付的那一轮,轮数一分不多 (truncating_each_term_costs_precision_not_rounds)。「只截一次」仍然是对 的写法,但理由是精度(一次舍入 vs 四次),不是往返数。 这是第二批「批量让旧论证自动失效」的实例 —— 与 §2.2 里 mul 的 2 轮同源。

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
多项式求幂改成顺序链(tᵏ = t^(k−1)·t) tests/reassoc.rs 四条一起失败:degree 7 的多项式 7 → 13 轮(深度 3 → 6)
多项式改成逐项截断 四条全过 —— 截断合批,轮数不变。这就是 §3.1 里那句失效注释的证据

批量那三行是关键:它们说明 nax sql-plan 报出来的 45 轮不是「自己跟自己一致」, 而是锚在真协议的收发次数上。轮数模型和实测是两条独立的链 —— 只改模型 报 90、只改执行器报 90,两边都改对才 45 == 45。

MIN/MAX 那三行是算法层的守卫:前一行防「改回线性扫描」(轮数增长阶 会变),后两行防「树形写错」(数值会错)。算法改动只有这两种失败形态, 两种都得有测试兜着。

Select 那一行尤其说明问题:它不截断,但如果模型多给它算一轮,五个聚合函数 的计划就比实测多 5 轮。这种偏差不会让任何数值错,只会让报出来的数虚高 —— 所以只能靠对账测试抓。

多项式那两行是一对反向守卫:改坏求幂顺序会让轮数涨(必须红),而改坏 截断粒度不会(红反而是误报)。前者钉住「深度」,后者钉住「别拿往返数论证 精度上的选择」。变异验证不只能确认「测试在测东西」,也能确认哪条结论本身 是虚的 —— 后一行就是这么找出 §3.1 那句失效注释的。

第三条尤其说明问题:静态分析说「合并了」不等于运行时真的合并, 所以 tests/schedule.rs 用一个记录调用序的明文档执行器把这件事钉住。

6. 这一层不做什么

写清楚比假装完整有用:

  • 不是 MLIR。 没有通用 pass 框架、没有 shape 多态、没有多后端 lowering。
  • 不做协议选择。 mul 永远是 Beaver,不会因为参与方数变 3 就换 ABY3 —— nax-vault 目前只有一套协议,编译期假装能选是骗人。
  • 不做恶意安全。 轮次合并不改变半诚实模型下的语义:合并的两个 open 本来就互不依赖,只是把等待叠在一起。
  • 同类批量,跨类别不共享。 同阶段的乘 / 截断 / open / 比较各自合成一批; 但 mul 的两段(乘、截断)不与 open 的批交叉共享,matmul 也还没进乘批 —— 那要求把 Beaver 的收发完全摊到 IR 层。所以现在的估计仍是上界, 真跑只快不慢。
  • 批量只在同阶段内。跨阶段一定有数据依赖,合并就是错。这不是保守,是正确性。
  • 换多项式求值顺序不是个杠杆。 量过了(§3.1):现状已是深度最优,Estrin 8 轮、 Horner 9 轮都比现状的 7 轮贵。别再把它当待办。
  • 没有前端。 图用 Rust 手写(Graph::matmul(...)),不做语言绑定。

7. 与 nax-runtime::device 的关系

两个模块回答不同的问题,不要混:

nax-runtime::device nax-ir
回答 「这个值现在在哪一域」 「这次计算要几个往返」
时机 运行期 编译期
粒度 单个值 整张图
对非线性算子 显式拒绝,指向 nax-sql::secure 标上代价,交给调度

两者都建立在同一个前提上:域/可见性是值的属性。所以 Vis 和 DeviceKind 语义一致,只是 nax-ir 多带了一份「谁依赖谁」的信息。