Files
ssw-mpc/crates/mpc-sql/tests/migration.rs
T
admin 54781b3f83
ci / gate (push) Waiting to run
refactor: 项目改名 ssw-mpc,crate 统一到 mpc-* 前缀
- 项目与文档标题:nax-rs → ssw-mpc(尚数网-多方安全计算),二进制 nax → mpc
- 18 个 crate 及目录 nax-* → mpc-*,Rust 引用 nax_* → mpc_*
- 环境变量、C 符号、构建/部署脚本:NAX_* → MPC_*、libnax_ray.so → libmpc_ray.so
- 保留协议域分隔常量与 refs/nax 参考实现路径,维持 golden 向量与历史数据兼容
- 新增 [profile.dev] incremental=false
2026-11-05 15:06:12 +08:00

727 lines
25 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` 的聚合,而 `mpc-vault::truncate` 是**随机舍入**:
//!
//! ```text
//! c = x + r (r 是离线发的截断对,全环均匀)
//! cs = c >> fxp (算术右移)
//! out = cs − (r >> fxp)
//! ```
//!
//! 两条路径调用 dealer 取随机数的**次数**不同(Beaver 三元组的消耗方式不一样),
//! 所以拿到的那份 `r` 不同,结果差 ±1 ULP。`mpc-ml` 的迁移回归踩过同样的坑,
//! 判据也一致:协议形状对得上 + 数值在舍入预算内,而不是「逐位相同」。
//!
//! `COUNT`(原始整数)、`SUM`(本地列和)、`MIN`/`MAX`(比较 + 选择,全程精确)
//! 都不经过截断,所以那四个必须是逐位相同。
use mpc_core::ring;
use mpc_proto::Frame;
use mpc_sql::secure::{
query_rounds, secure_aggregate_all, secure_group_by, secure_predicate_mask,
secure_where_aggregate, Agg, CmpOp, GroupMode, Pred,
};
use mpc_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()
);
}
/// **组数完全不影响轮数**:各组的东西落在同一个阶段,逐类各合成一批。
///
/// 这条测试两度反转,记下来:迁移到 IR 之后是「每组 +20 轮」(每组的 `bit_eq`
/// 是两次串行比较),现在比较也批量了(`sec_cmp_batch` → `bit_lt_batch`,
/// 9 轮封顶),于是 4 组和 1 组**一样多**。
///
/// 这也解释了为什么 `GroupMode::IntegerCode` 在批量之前能把 8 组从 162 压到 92:
/// 它省的是「串行比较的个数」。比较一旦批量,那笔账就没了 —— 现在 13 → 12。
#[test]
fn group_count_no_longer_costs_rounds() {
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();
assert_eq!(
four.rounds(),
one.rounds(),
"4 组与 1 组的轮数应当相同(同类批量),实际 {} vs {}\n{}",
four.rounds(),
one.rounds(),
four.summary()
);
}
/// **树形归约的轮数随行数对数增长**,不是线性。
///
/// 第一版照抄手写循环(线性扫描),注释里写「树形不省轮数,因为串行依赖不变」——
/// 错的:依赖的**深度**从 `n−1` 变成 `⌈log₂n⌉`,而且同一层的比较互不依赖,
/// 会合成一批(9 轮封顶)。所以这里要钉住的是「行数翻倍只多一层」。
///
/// 一层 = 9 轮比较 + 1 轮选择 = 10 轮。
#[test]
fn minmax_reduction_costs_logarithmic_rounds() {
let aggs = [Agg::Min, Agg::Max];
let mut prev: Option<usize> = None;
let mut last = 0usize;
for n in [4usize, 8, 16, 32, 64, 128, 256] {
let r = query_rounds(n, FXP, 1, None, None, &aggs, GroupMode::Exact)
.unwrap()
.rounds();
if let Some(p) = prev {
assert_eq!(
r - p,
10,
"行数翻倍只该多一层(9 轮比较 + 1 轮选择),实际 {p} → {r}(n={n})"
);
}
prev = Some(r);
last = r;
}
// 256 行 83 轮。线性扫描要 255 × 10 = 2550 轮,差 30 倍 —— 这条断言就是
// 防着有人把它改回线性链。
assert_eq!(last, 83, "256 行的轮数变了,实际 {last}");
assert!(
last < 255 * 10 / 10,
"256 行 {last} 轮,已经不像对数了(线性约 2550 轮)"
);
}
/// 树形归约的**数值**必须与明文一致,尤其非 2 的幂(最后一个是轮空,不是补哑元素)。
///
/// 也顺带覆盖负数:`MAX` 的补位是负哨兵,符号与补位交互错过的话这里会红。
#[test]
fn minmax_tree_matches_plaintext_across_sizes() {
for n in [1usize, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 33] {
let data: Vec<f64> = (0..n).map(|i| ((i * 37 % 1001) as f64) - 400.0).collect();
let want_min = data.iter().copied().fold(f64::INFINITY, f64::min);
let want_max = data.iter().copied().fold(f64::NEG_INFINITY, f64::max);
let aggs = [Agg::Count, Agg::Min, Agg::Max];
let (got, _) = {
let sh = shares_of(&[&data]);
run_two(
sh,
move |v, s| secure_aggregate_all(v, &s[0], &aggs),
move |v, s| secure_aggregate_all(v, &s[0], &aggs),
)
};
assert_eq!(got[0], n as f64, "n={n} COUNT");
assert_eq!(got[1], want_min, "n={n} MIN");
assert_eq!(got[2], want_max, "n={n} MAX");
}
}