Files
ssw-mpc/crates/nax-sql/tests/migration.rs
T
rong 903f14efb2 feat(sql): GROUP BY 走整数码前缀和,8 组 162 → 92 轮
影响:`secure_group_by` 新增 `GroupMode::IntegerCode` 路径,每组相等判断
(`bit_eq` = 两次 `bit_lt`,18 轮/组、串行累加)换成 `N+1` 个单调前缀
「码 ≤ g」,`COUNT` 取前缀位之和、`SUM` 取 `mul_raw(前缀位, 列)`,所有 `open`
落在同一阶段合成一次,**组内值在明文侧差分**,没有第二段图。默认仍是
`GroupMode::Exact`,语义不变。

实测(`nax sql-plan --rows 8 --aggs count,sum`):2 组 42→32、4 组 82→52、
8 组 162→92;每组建图成本约 20 → 11 轮。带 WHERE 的增量是「一次比较 + 一次
搬家乘」10~11 轮。

新增:

- `secure_graph::build_prefix_stage` —— 谓词 → 码搬家 → N+1 个前缀 → 累积和
- `secure_group_by_coded` / `secure_group_by_pred_coded`,`query_rounds` 收
  `GroupMode`,`nax sql-plan --group-mode coded`、`nax sql --group-mode coded`
- `crates/nax-sql/tests/coded.rs` 12 条:与 Exact 对拍(`COUNT`/`SUM` 逐位、
  `AVG` 相对 1e-4)、复合谓词、越界/非整数码契约、空组、k-匿名、单组、轮数钉值

三条契约(写进 `docs/IR.md` §3.3,不隐藏代价):分组码必须是整数(非整数落
到上方最近一组);不支持 MIN/MAX(前缀和还原不出极值,直接报错不降级);
越界码丢弃(与逐组比较一致,两端边界 `−0.5` / `N−0.5` 就是为它留的)。

WHERE 未命中行不逐组乘 `base`(`2N` 轮),而是把码搬到 `−1000·2^fxp` 让它在
差分中自动抵消。**第一版把 `−1000` 当 raw 用**:分组码列是 fxp 编码,
`0.5` 编出来是 `131072`,于是 `−1000` 比每个边界都小,全部行被算进每个前缀
(行数变全表、SUM 变全表之和且不报错)。改为按 `2^fxp` 缩放,`fxp > 40` 拒绝。

变异验证 4 条全部按预期变红后还原:停放值不缩放(2 红)、边界少 `−0.5`
(只有非整数码契约那条红,整数码下 `<g` 与 `<g+0.5` 等价)、累积和忘记差分
(7 红)。

全量 462 用例通过 / 0 失败,`-Dwarnings` 零告警,`nax-core` no_std 守线过。
2026-11-01 19:49:16 +08:00

664 lines
22 KiB
Rust
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.
//! 迁移回归:把手写协议序列留在测试里当 **oracle**,与图版本对话。
//!
//! # 为什么需要这个文件
//!
//! `secure.rs` 原有的验收是「与明文引擎对拍」。那条断言对**搬家**不够 ——
//! 把 `bit_not` 挪到 `scale_public` 之前、把掩码补位漏一次,很多组合下结果
//! 照样对得上(比如命中全满或全空时补位项恒为 0)。
//!
//! 这里把迁移前的实现原样抄下来(`legacy_*`),从两个角度比对:
//!
//! 1. **数值**:`COUNT` / `SUM` / `MIN` / `MAX` 必须**逐位相同**,`AVG` 落在
//! 舍入预算内(原因见下)。
//! 2. **轮数**:图版本不能比手写版本多花往返 —— 搬家的目的是让轮数可报,
//! 不是顺手让性能变差。
//!
//! # 为什么 `AVG` 不是逐位相同
//!
//! `AVG` 是唯一走过 `truncate` 的聚合,而 `nax-vault::truncate` 是**随机舍入**:
//!
//! ```text
//! c = x + r (r 是离线发的截断对,全环均匀)
//! cs = c >> fxp (算术右移)
//! out = cs − (r >> fxp)
//! ```
//!
//! 两条路径调用 dealer 取随机数的**次数**不同(Beaver 三元组的消耗方式不一样),
//! 所以拿到的那份 `r` 不同,结果差 ±1 ULP。`nax-ml` 的迁移回归踩过同样的坑,
//! 判据也一致:协议形状对得上 + 数值在舍入预算内,而不是「逐位相同」。
//!
//! `COUNT`(原始整数)、`SUM`(本地列和)、`MIN`/`MAX`(比较 + 选择,全程精确)
//! 都不经过截断,所以那四个必须是逐位相同。
use nax_core::ring;
use nax_proto::Frame;
use nax_sql::secure::{
query_rounds, secure_group_by, secure_predicate_mask, secure_where_aggregate, Agg, CmpOp,
GroupMode, Pred,
};
use nax_vault::{Pipe, Transport, Vault, VaultError};
use std::sync::{Arc, Mutex};
const FXP: u32 = 18;
fn enc(v: &[f64]) -> Vec<u64> {
v.iter().map(|x| ring::encode(*x, FXP).unwrap()).collect()
}
// --------------------------------------------------------------------------- //
// 迁移前的实现(逐字保留,只用来当 oracle)
// --------------------------------------------------------------------------- //
const LEGACY_SENTINEL: f64 = (1u64 << 30) as f64;
fn legacy_mask_for<T: Transport>(
vault: &mut Vault<T>,
col: &[u64],
thresh: &[u64],
op: CmpOp,
) -> Result<Vec<u64>, VaultError> {
match op {
CmpOp::Lt => vault.bit_lt(col, thresh),
CmpOp::Gt => vault.bit_gt(col, thresh),
CmpOp::Eq => vault.bit_eq(col, thresh),
CmpOp::Le => {
let gt = vault.bit_gt(col, thresh)?;
vault.bit_not(&gt)
}
CmpOp::Ge => {
let lt = vault.bit_lt(col, thresh)?;
vault.bit_not(&lt)
}
CmpOp::Ne => {
let eq = vault.bit_eq(col, thresh)?;
vault.bit_not(&eq)
}
}
}
fn legacy_aggregate_with_mask<T: Transport>(
vault: &mut Vault<T>,
col: &[u64],
mask: &[u64],
aggs: &[Agg],
) -> Result<(usize, Vec<f64>), VaultError> {
let fxp = vault.fxp();
let len = col.len();
let masked = vault.bit_mask(mask, col)?;
let mut count_sh = 0u64;
for &m in mask {
count_sh = count_sh.wrapping_add(m);
}
let count = vault.reveal(&[count_sh])?[0] as usize;
let mut out = Vec::with_capacity(aggs.len());
for &agg in aggs {
let v = match agg {
Agg::Count => count as f64,
Agg::Sum => {
let mut s = 0u64;
for &v in &masked {
s = s.wrapping_add(v);
}
ring::decode(vault.reveal(&[s])?[0], fxp)
}
Agg::Avg => {
if count == 0 {
f64::NAN
} else {
let mut s = 0u64;
for &v in &masked {
s = s.wrapping_add(v);
}
let scaled = vault.scale_public(&[s], 1.0 / count as f64)?;
let tr = vault.truncate(&scaled)?;
ring::decode(vault.reveal(&tr)?[0], fxp)
}
}
Agg::Min | Agg::Max => {
if count == 0 {
f64::NAN
} else {
let one_minus = vault.bit_not(mask)?;
let pad_sign = if agg == Agg::Min {
LEGACY_SENTINEL
} else {
-LEGACY_SENTINEL
};
let pad = vault.scale_public(&one_minus, pad_sign)?;
let padded = vault.add_local(&masked, &pad)?;
let mut best = padded[0..1].to_vec();
for i in 1..len {
let cur = padded[i..i + 1].to_vec();
let pick_cur = if agg == Agg::Min {
vault.bit_lt(&cur, &best)?
} else {
vault.bit_lt(&best, &cur)?
};
best = vault.select_raw(&pick_cur, &cur, &best)?;
}
ring::decode(vault.reveal(&best)?[0], fxp)
}
}
};
out.push(v);
}
Ok((count, out))
}
fn legacy_where_aggregate<T: Transport>(
vault: &mut Vault<T>,
col: &[u64],
threshold: f64,
op: CmpOp,
aggs: &[Agg],
) -> Result<Vec<f64>, VaultError> {
let th = vault.constant(threshold, col.len())?;
let mask = legacy_mask_for(vault, col, &th, op)?;
let (_count, vals) = legacy_aggregate_with_mask(vault, col, &mask, aggs)?;
Ok(vals)
}
fn legacy_group_by<T: Transport>(
vault: &mut Vault<T>,
col: &[u64],
gcol: &[u64],
n_groups: usize,
pred: Option<(f64, CmpOp)>,
aggs: &[Agg],
min_group_size: usize,
) -> Result<Vec<Vec<f64>>, VaultError> {
let len = col.len();
let base = match pred {
Some((t, op)) => {
let th = vault.constant(t, len)?;
legacy_mask_for(vault, col, &th, op)?
}
None => vault.bit_one(len),
};
let mut out = Vec::with_capacity(n_groups);
for g in 0..n_groups {
let gc = vault.constant(g as f64, len)?;
let gmask = vault.bit_eq(gcol, &gc)?;
let mask = vault.bit_and(&base, &gmask)?;
let (count, vals) = legacy_aggregate_with_mask(vault, col, &mask, aggs)?;
if min_group_size > 0 && count < min_group_size {
out.push(vec![f64::NAN; aggs.len()]);
} else {
out.push(vals);
}
}
Ok(out)
}
fn legacy_predicate_mask<T: Transport>(
vault: &mut Vault<T>,
cols: &[Vec<u64>],
pred: &Pred,
) -> Result<Vec<u64>, VaultError> {
match pred {
Pred::Cmp {
col,
op,
threshold,
} => {
let c = &cols[*col];
let th = vault.constant(*threshold, c.len())?;
legacy_mask_for(vault, c, &th, *op)
}
Pred::CmpCol { col, op, rhs_col } => {
legacy_mask_for(vault, &cols[*col], &cols[*rhs_col], *op)
}
Pred::In {
col,
values,
negated,
} => {
let c = &cols[*col];
let mut mask: Option<Vec<u64>> = None;
for &v in values {
let th = vault.constant(v, c.len())?;
let eq = vault.bit_eq(c, &th)?;
mask = Some(match mask {
None => eq,
Some(prev) => vault.bit_or(&prev, &eq)?,
});
}
let m = mask.unwrap();
if *negated {
vault.bit_not(&m)
} else {
Ok(m)
}
}
Pred::And(a, b) => {
let ma = legacy_predicate_mask(vault, cols, a)?;
let mb = legacy_predicate_mask(vault, cols, b)?;
vault.bit_and(&ma, &mb)
}
Pred::Or(a, b) => {
let ma = legacy_predicate_mask(vault, cols, a)?;
let mb = legacy_predicate_mask(vault, cols, b)?;
vault.bit_or(&ma, &mb)
}
Pred::Not(a) => {
let m = legacy_predicate_mask(vault, cols, a)?;
vault.bit_not(&m)
}
}
}
// --------------------------------------------------------------------------- //
// 脚手架
// --------------------------------------------------------------------------- //
/// 记收/发序列的传输层。
struct Recorder<T> {
inner: T,
log: Arc<Mutex<String>>,
}
impl<T: Transport> Transport for Recorder<T> {
fn send_to(&mut self, party: usize, frame: Frame) -> Result<(), VaultError> {
self.log.lock().unwrap().push('S');
self.inner.send_to(party, frame)
}
fn recv_from(&mut self, party: usize) -> Result<Frame, VaultError> {
self.log.lock().unwrap().push('R');
self.inner.recv_from(party)
}
}
/// 数往返:连续的 `S` 算一轮,「收到之后又发」才开新的一轮。
///
/// 数突发不数帧 —— 一次 `open_batch` 发两帧收两帧仍是一个往返。
fn count_rounds(log: &str) -> usize {
let (mut rounds, mut seen_send, mut seen_recv) = (0usize, false, false);
for c in log.chars() {
match c {
'S' => {
if seen_recv {
rounds += 1;
seen_recv = false;
}
if !seen_send {
seen_send = true;
rounds += 1;
}
}
'R' => seen_recv = true,
_ => {}
}
}
rounds
}
/// 把一份明文分好片,两方各持一片(用一个临时 Vault 做发牌)。
fn split(vals: &[f64]) -> (Vec<u64>, Vec<u64>) {
let mut v = Vault::new(Pipe::pair().0, "alice", &["alice", "bob"], [5u8; 32], FXP).unwrap();
let all = v.split(&enc(vals)).unwrap();
let len = vals.len();
(all[0..len].to_vec(), all[len..2 * len].to_vec())
}
/// 两方跑同一段查询,返回(alice 侧结果, alice 侧收/发序列)。
///
/// **先取日志再返回**:查询函数自己内部的 `reveal` 算在它自己的往返里,
/// 这里不做额外确认。
fn run_two<FA, FB, R>(pairs: Vec<(Vec<u64>, Vec<u64>)>, alice: FA, bob: FB) -> (R, usize)
where
FA: FnOnce(&mut Vault<Recorder<Pipe>>, Vec<Vec<u64>>) -> Result<R, VaultError> + Send + 'static,
FB: FnOnce(&mut Vault<Pipe>, Vec<Vec<u64>>) -> Result<R, VaultError> + Send + 'static,
R: Send + 'static,
{
let sites = ["alice", "bob"];
let seed = [11u8; 32];
let log = Arc::new(Mutex::new(String::new()));
let (pa, pb) = Pipe::pair();
let mut va = Vault::new(
Recorder {
inner: pa,
log: log.clone(),
},
"alice",
&sites,
seed,
FXP,
)
.unwrap();
let mut vb = Vault::new(pb, "bob", &sites, seed, FXP).unwrap();
let a_side: Vec<Vec<u64>> = pairs.iter().map(|(a, _)| a.clone()).collect();
let b_side: Vec<Vec<u64>> = pairs.iter().map(|(_, b)| b.clone()).collect();
let h = std::thread::spawn(move || bob(&mut vb, b_side));
let out = alice(&mut va, a_side).unwrap();
h.join().unwrap().unwrap();
let rounds = count_rounds(&log.lock().unwrap().clone());
(out, rounds)
}
fn shares_of(cols: &[&[f64]]) -> Vec<(Vec<u64>, Vec<u64>)> {
cols.iter().map(|c| split(c)).collect()
}
/// `AVG` 的容差。截断是 ±1 ULP 的随机舍入,五个元素凑一起也就几 ULP。
const AVG_TOL: f64 = 1e-4;
// --------------------------------------------------------------------------- //
// 1. WHERE + 聚合:逐位相同
// --------------------------------------------------------------------------- //
fn amounts() -> Vec<f64> {
vec![100.0, 500.0, 250.0, 600.0, 300.0]
}
const ALL_AGGS: [Agg; 5] = [Agg::Count, Agg::Sum, Agg::Avg, Agg::Min, Agg::Max];
#[test]
fn where_aggregate_matches_legacy_for_every_cmp_op() {
let data = amounts(); for op in [
CmpOp::Lt,
CmpOp::Le,
CmpOp::Gt,
CmpOp::Ge,
CmpOp::Eq,
CmpOp::Ne,
] {
let (want, legacy_rounds) = {
let sh = shares_of(&[&data]);
run_two(
sh,
move |v, s| legacy_where_aggregate(v, &s[0], 300.0, op, &ALL_AGGS),
move |v, s| legacy_where_aggregate(v, &s[0], 300.0, op, &ALL_AGGS),
)
};
let (got, graph_rounds) = {
let sh = shares_of(&[&data]);
run_two(
sh,
move |v, s| secure_where_aggregate(v, &s[0], 300.0, op, &ALL_AGGS),
move |v, s| secure_where_aggregate(v, &s[0], 300.0, op, &ALL_AGGS),
)
};
println!("where {op:?}: 迁移前 {legacy_rounds} 轮 → 迁移后 {graph_rounds} 轮");
assert_eq!(got[0], want[0], "{op:?} COUNT 必须逐位相同");
assert_eq!(got[1], want[1], "{op:?} SUM 必须逐位相同");
assert_eq!(got[3], want[3], "{op:?} MIN 必须逐位相同");
assert_eq!(got[4], want[4], "{op:?} MAX 必须逐位相同");
assert!(
(got[2] - want[2]).abs() < AVG_TOL,
"{op:?} AVG {} vs {},超出舍入预算",
got[2],
want[2]
);
assert!(
graph_rounds <= legacy_rounds,
"{op:?} 图版本花了 {graph_rounds} 轮,手写版只有 {legacy_rounds} 轮 —— 搬家不该更慢"
);
}
}
/// 空选择的语义:`SUM` 是 0,`AVG`/`MIN`/`MAX` 是 `NaN`。逐位对齐。
#[test]
fn empty_selection_matches_legacy() {
let data = amounts();
let (want, _) = {
let sh = shares_of(&[&data]);
run_two(
sh,
|v, s| legacy_where_aggregate(v, &s[0], 5.0, CmpOp::Lt, &ALL_AGGS),
|v, s| legacy_where_aggregate(v, &s[0], 5.0, CmpOp::Lt, &ALL_AGGS),
)
};
let (got, _) = {
let sh = shares_of(&[&data]);
run_two(
sh,
|v, s| secure_where_aggregate(v, &s[0], 5.0, CmpOp::Lt, &ALL_AGGS),
|v, s| secure_where_aggregate(v, &s[0], 5.0, CmpOp::Lt, &ALL_AGGS),
)
};
assert_eq!(got[0], 0.0, "COUNT");
assert_eq!(got[1], 0.0, "SUM 在空选择下是 0,不是 NaN");
assert!(got[2].is_nan(), "AVG");
assert!(got[3].is_nan(), "MIN");
assert!(got[4].is_nan(), "MAX");
assert_eq!(got[0], want[0]);
assert_eq!(got[1], want[1]);
assert_eq!(got[2].is_nan(), want[2].is_nan());
}
// --------------------------------------------------------------------------- //
// 2. GROUP BY:逐位相同,且轮数不增
// --------------------------------------------------------------------------- //
fn region_data() -> (Vec<f64>, Vec<f64>) {
(
vec![100.0, 500.0, 250.0, 600.0, 300.0, 450.0],
vec![0.0, 1.0, 0.0, 1.0, 0.0, 1.0],
)
}
#[test]
fn group_by_matches_legacy() {
let (x, g) = region_data();
let aggs = [Agg::Count, Agg::Sum];
// 组数也要扫:掩码是「基础掩码 AND 组码相等」,组数改变的是**分支个数**,
// 而分支个数正是「各组的 open 能不能合成一轮」的前提。2 组的用例看不出
// 合并,4 组才看得出(组 2/3 是空组,顺带覆盖命中数为 0 的分支)。
for n_groups in [2usize, 4, 8] {
for pred in [None, Some((400.0, CmpOp::Lt))] {
for min_size in [0usize, 2] {
let (want, legacy_rounds) = {
let sh = shares_of(&[&x, &g]);
run_two(
sh,
move |v, s| {
legacy_group_by(v, &s[0], &s[1], n_groups, pred, &aggs, min_size)
},
move |v, s| {
legacy_group_by(v, &s[0], &s[1], n_groups, pred, &aggs, min_size)
},
)
};
let (got, graph_rounds) = {
let sh = shares_of(&[&x, &g]);
run_two(
sh,
move |v, s| {
secure_group_by(v, &s[0], &s[1], n_groups, pred, &aggs, min_size)
},
move |v, s| {
secure_group_by(v, &s[0], &s[1], n_groups, pred, &aggs, min_size)
},
)
};
assert_eq!(got.len(), n_groups, "组数");
println!(
"group_by 组数={n_groups} pred={pred:?} min={min_size}: 迁移前 {legacy_rounds} 轮 → 迁移后 {graph_rounds} 轮"
);
for i in 0..got.len() {
// k-匿名抑制的两边都是 NaN,而 `NaN != NaN` —— 先比 NaN-ness,
// 再比值本身,否则「两边都抑制了」会被判成失败。
for (k, name) in [(0usize, "COUNT"), (1usize, "SUM")] {
assert_eq!(
got[i][k].is_nan(),
want[i][k].is_nan(),
"组 {i} {name} 的抑制状态不一致({n_groups} 组 pred={pred:?} min={min_size})"
);
if !want[i][k].is_nan() {
assert_eq!(
got[i][k], want[i][k],
"组 {i} {name}({n_groups} 组 pred={pred:?})"
);
}
}
}
assert!(
graph_rounds <= legacy_rounds,
"{n_groups} 组 pred={pred:?} min={min_size}:图 {graph_rounds} 轮 > 手写 {legacy_rounds} 轮"
);
}
}
}
}
// --------------------------------------------------------------------------- //
// 3. 复合谓词掩码:逐位相同
// --------------------------------------------------------------------------- //
#[test]
fn predicate_mask_matches_legacy() {
let x = amounts();
let g = vec![0.0f64, 1.0, 0.0, 1.0, 0.0];
let preds = [
Pred::Cmp {
col: 0,
op: CmpOp::Lt,
threshold: 400.0,
},
Pred::CmpCol {
col: 0,
op: CmpOp::Gt,
rhs_col: 1,
},
Pred::In {
col: 0,
values: vec![100.0, 250.0],
negated: false,
},
Pred::In {
col: 0,
values: vec![100.0, 250.0],
negated: true,
},
Pred::And(
Box::new(Pred::Cmp {
col: 0,
op: CmpOp::Lt,
threshold: 400.0,
}),
Box::new(Pred::Cmp {
col: 1,
op: CmpOp::Eq,
threshold: 0.0,
}),
),
Pred::Or(
Box::new(Pred::Cmp {
col: 0,
op: CmpOp::Lt,
threshold: 400.0,
}),
Box::new(Pred::Cmp {
col: 1,
op: CmpOp::Eq,
threshold: 1.0,
}),
),
Pred::Not(Box::new(Pred::Cmp {
col: 0,
op: CmpOp::Lt,
threshold: 400.0,
})),
];
for pred in preds {
// 四个闭包各要一份:两个给 legacy,两个给图版本。
let (p1, p2) = (pred.clone(), pred.clone());
let (p3, p4) = (pred.clone(), pred.clone());
let (want, _) = {
let sh = shares_of(&[&x, &g]);
run_two(
sh,
move |v, s| {
let m = legacy_predicate_mask(v, &s, &p1)?;
v.reveal(&m)
},
move |v, s| {
let m = legacy_predicate_mask(v, &s, &p2)?;
v.reveal(&m)
},
)
};
let (got, _) = {
let sh = shares_of(&[&x, &g]);
run_two(
sh,
move |v, s| {
let m = secure_predicate_mask(v, &s, &p3)?;
v.reveal(&m)
},
move |v, s| {
let m = secure_predicate_mask(v, &s, &p4)?;
v.reveal(&m)
},
)
};
assert_eq!(got, want, "掩码必须逐位相同(0/1 位是精确的,没有舍入余地)");
}
}
// --------------------------------------------------------------------------- //
// 4. 轮数:编译期报出来的数必须等于真跑出来的突发数
// --------------------------------------------------------------------------- //
/// `query_rounds` 是「建图不执行」报出来的上界。这里真跑一遍,数突发次数。
///
/// 两者必须**相等**:轮数模型对这个形状是精确的(同阶段 `open` 合一次、
/// 重交互算子各算各的),没有「保守多算」的余地。
#[test]
fn query_rounds_matches_the_measured_protocol() {
let data = amounts();
let pred = Pred::Cmp {
col: 0,
op: CmpOp::Lt,
threshold: 400.0,
};
// 命中 3 个(100/250/300),与 `query_rounds` 里的假设一致
let planned = query_rounds(data.len(), FXP, 1, Some(&pred), None, &ALL_AGGS, GroupMode::Exact).unwrap();
let (_, measured) = {
let sh = shares_of(&[&data]);
run_two(
sh,
move |v, s| secure_where_aggregate(v, &s[0], 400.0, CmpOp::Lt, &ALL_AGGS),
move |v, s| secure_where_aggregate(v, &s[0], 400.0, CmpOp::Lt, &ALL_AGGS),
)
};
assert_eq!(
planned.rounds(),
measured,
"计划说 {} 轮,真跑 {} 轮\n{}",
planned.rounds(),
measured,
planned.summary()
);
}
/// 分组数翻倍时,`open` 的轮数不跟着翻 —— 各组的 open 合到同一轮。
///
/// 注意:**总轮数仍会随组数上升**,因为每组的 `bit_eq` 是两次比较(18 轮),
/// 属于重交互算子,按组累加。这条测试钉住的是「open 合并」这一半。
#[test]
fn group_opens_are_batched_across_groups() {
let agg = [Agg::Count];
let one = query_rounds(8, FXP, 1, None, Some(1), &agg, GroupMode::Exact).unwrap();
let four = query_rounds(8, FXP, 1, None, Some(4), &agg, GroupMode::Exact).unwrap();
// 每组多 18 轮比较 + 1 轮 and + 1 轮 mul_raw;open 只多 0 轮
assert_eq!(
four.rounds() - one.rounds(),
3 * 20,
"4 组比 1 组多 {} 轮\n{}",
four.rounds() - one.rounds(),
four.summary()
);
}