use spiral_rs::poly::{
add_into, stack_ntt, to_ntt_alloc, PolyMatrix, PolyMatrixNTT, PolyMatrixRaw,
};
use crate::error::InspiringError;
use crate::lwe::LweBatch;
use crate::preprocess::PackPreprocessed;
pub struct RlweCiphertext<'a> {
pub inner: PolyMatrixNTT<'a>,
}
pub fn pack<'a>(
b: &LweBatch,
pre: &'a PackPreprocessed<'a>,
) -> Result<RlweCiphertext<'a>, InspiringError> {
b.validate(pre.params)?;
let mut b_tilde = PolyMatrixRaw::zero(&pre.params.spiral, 1, 1);
for (idx, ct) in b.inner.iter().enumerate() {
b_tilde.get_poly_mut(0, 0)[idx] = ct.b % pre.params.q;
}
let mut b_final = to_ntt_alloc(&b_tilde);
add_into(&mut b_final, &pre.collapse_b_offset_ntt);
Ok(RlweCiphertext {
inner: stack_ntt(&pre.collapse_a_final_ntt, &b_final),
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::key_switching::{ks_call_count, KeySwitchingMatrix};
use crate::params::GadgetParams;
use crate::preprocess::PackPreprocessed;
use spiral_rs::poly::{from_ntt_alloc, to_ntt_alloc};
fn params() -> crate::RlweParams {
crate::RlweParams::new(
8,
12289,
4,
3.2,
GadgetParams {
bits_per: 3,
ell: 5,
},
)
.expect("valid params")
}
fn zero_ks<'a>(params: &'a crate::RlweParams) -> KeySwitchingMatrix<'a> {
KeySwitchingMatrix {
mat: PolyMatrixNTT::zero(¶ms.spiral, 2, params.gadget.ell),
params,
}
}
fn crs<'a>(params: &'a crate::RlweParams) -> PolyMatrixNTT<'a> {
let mut raw = PolyMatrixRaw::zero(¶ms.spiral, params.d, 1);
for row in 0..params.d {
for col in 0..params.d {
raw.get_poly_mut(row, 0)[col] = (row * 3 + col + 1) as u64;
}
}
to_ntt_alloc(&raw)
}
fn batch(params: &crate::RlweParams, b_values: &[u64], a_seed: u64) -> LweBatch {
LweBatch {
inner: b_values
.iter()
.enumerate()
.map(|(idx, b)| crate::LweCiphertext {
a: vec![a_seed + idx as u64; params.d],
b: *b,
})
.collect(),
}
}
#[test]
fn pack_uses_preprocessed_a_and_online_b_values() {
let params = params();
let crs = crs(¶ms);
let kg = zero_ks(¶ms);
let kh = zero_ks(¶ms);
let pre = PackPreprocessed::build(¶ms, &crs, &kg, &kh).expect("valid preprocessing");
let b_values: Vec<_> = (0..params.d).map(|idx| idx as u64 + 10).collect();
let left = batch(¶ms, &b_values, 1);
let right = batch(¶ms, &b_values, 999);
let ct_left = pack(&left, &pre).expect("pack succeeds");
let ct_right = pack(&right, &pre).expect("pack succeeds");
assert_eq!(ct_left.inner.as_slice(), ct_right.inner.as_slice());
let raw = from_ntt_alloc(&ct_left.inner);
assert_eq!(
raw.get_poly(1, 0),
b_values.iter().map(|v| v % params.q).collect::<Vec<_>>()
);
}
#[test]
fn pack_runs_no_online_key_switch_products() {
let params = params();
let crs = crs(¶ms);
let kg = zero_ks(¶ms);
let kh = zero_ks(¶ms);
let pre = PackPreprocessed::build(¶ms, &crs, &kg, &kh).expect("valid preprocessing");
let b_values: Vec<_> = (0..params.d).map(|idx| idx as u64).collect();
let batch = batch(¶ms, &b_values, 0);
ks_call_count::reset();
let _ = pack(&batch, &pre).expect("pack succeeds");
assert_eq!(ks_call_count::get(), 0);
}
}