diff --git a/base2k/examples/rlwe_encrypt.rs b/base2k/examples/rlwe_encrypt.rs index 4db6ef5..e73db89 100644 --- a/base2k/examples/rlwe_encrypt.rs +++ b/base2k/examples/rlwe_encrypt.rs @@ -130,6 +130,4 @@ fn main() { .for_each(|(i, (a, b))| { println!("{}: {} {}", i, a, (*b as f64) / scale); }); - - module.free(); } diff --git a/base2k/src/lib.rs b/base2k/src/lib.rs index b6ed099..89a52ef 100644 --- a/base2k/src/lib.rs +++ b/base2k/src/lib.rs @@ -150,8 +150,7 @@ impl Scratch { unsafe { &mut *(data as *mut [u8] as *mut Self) } } - #[allow(dead_code)] - fn available(&self) -> usize { + pub fn available(&self) -> usize { let ptr: *const u8 = self.data.as_ptr(); let self_len: usize = self.data.len(); let aligned_offset: usize = ptr.align_offset(DEFAULTALIGN); diff --git a/base2k/src/mat_znx_dft_ops.rs b/base2k/src/mat_znx_dft_ops.rs index f302e9b..7b4ac36 100644 --- a/base2k/src/mat_znx_dft_ops.rs +++ b/base2k/src/mat_znx_dft_ops.rs @@ -337,8 +337,6 @@ mod tests { assert_eq!(a_dft.raw(), b_dft.raw()); } } - - module.free(); } #[test] @@ -425,7 +423,5 @@ mod tests { }); }); }); - - module.free(); } } diff --git a/core/src/gglwe_ciphertext.rs b/core/src/gglwe_ciphertext.rs index ae4329c..d20072a 100644 --- a/core/src/gglwe_ciphertext.rs +++ b/core/src/gglwe_ciphertext.rs @@ -255,6 +255,17 @@ where assert_eq!(self.n(), module.n()); assert_eq!(res.n(), module.n()); assert_eq!(a.n(), module.n()); + assert!( + scratch.available() + >= GGLWECiphertext::prod_with_glwe_scratch_space( + module, + res.size(), + a.size(), + self.size(), + self.rank_in(), + self.rank_out() + ) + ); } let cols_in: usize = self.rank_in(); diff --git a/core/src/glwe_ciphertext_fourier.rs b/core/src/glwe_ciphertext_fourier.rs index b302d5e..fe2a50d 100644 --- a/core/src/glwe_ciphertext_fourier.rs +++ b/core/src/glwe_ciphertext_fourier.rs @@ -98,25 +98,25 @@ impl GLWECiphertextFourier, FFT64> { rank_in: usize, rank_out: usize, ) -> usize { - , FFT64> as VecGLWEProductScratchSpace>::prod_with_glwe_scratch_space( + , FFT64> as VecGLWEProductScratchSpace>::prod_with_glwe_fourier_scratch_space( module, res_size, lhs, rhs, rank_in, rank_out, ) } pub fn keyswitch_inplace_scratch_space(module: &Module, res_size: usize, rhs: usize, rank: usize) -> usize { - , FFT64> as VecGLWEProductScratchSpace>::prod_with_glwe_inplace_scratch_space( + , FFT64> as VecGLWEProductScratchSpace>::prod_with_glwe_fourier_inplace_scratch_space( module, res_size, rhs, rank, ) } pub fn external_product_scratch_space(module: &Module, res_size: usize, lhs: usize, rhs: usize, rank: usize) -> usize { - , FFT64> as VecGLWEProductScratchSpace>::prod_with_glwe_scratch_space( + , FFT64> as VecGLWEProductScratchSpace>::prod_with_glwe_fourier_scratch_space( module, res_size, lhs, rhs, rank, rank, ) } pub fn external_product_inplace_scratch_space(module: &Module, res_size: usize, rhs: usize, rank: usize) -> usize { - , FFT64> as VecGLWEProductScratchSpace>::prod_with_glwe_inplace_scratch_space( + , FFT64> as VecGLWEProductScratchSpace>::prod_with_glwe_fourier_inplace_scratch_space( module, res_size, rhs, rank, ) } diff --git a/core/src/test_fft64/ggsw.rs b/core/src/test_fft64/ggsw.rs index 9420831..eb8c532 100644 --- a/core/src/test_fft64/ggsw.rs +++ b/core/src/test_fft64/ggsw.rs @@ -567,7 +567,7 @@ // }); // }); // } -pub(crate) fn noise_rgsw_product( +pub(crate) fn noise_ggsw_gglwe_product( n: f64, log_base2k: usize, var_xs: f64, diff --git a/core/src/test_fft64/glwe.rs b/core/src/test_fft64/glwe.rs index 4ceac95..21bae6d 100644 --- a/core/src/test_fft64/glwe.rs +++ b/core/src/test_fft64/glwe.rs @@ -13,7 +13,7 @@ use crate::{ glwe_plaintext::GLWEPlaintext, keys::{GLWEPublicKey, SecretKey, SecretKeyFourier}, keyswitch_key::GLWESwitchingKey, - test_fft64::{gglwe::noise_gglwe_product, ggsw::noise_rgsw_product}, + test_fft64::{gglwe::noise_gglwe_product, ggsw::noise_ggsw_gglwe_product}, }; #[test] @@ -58,6 +58,22 @@ fn keyswitch_inplace() { }); } +#[test] +fn external_product() { + (1..4).for_each(|rank| { + println!("test external_product rank: {}", rank); + test_external_product(12, 12, 60, 45, 60, rank, 3.2); + }); +} + +#[test] +fn external_product_inplace() { + (1..4).for_each(|rank| { + println!("test external_product rank: {}", rank); + test_external_product_inplace(12, 15, 60, 60, rank, 3.2); + }); +} + fn test_encrypt_sk(log_n: usize, basek: usize, k_ct: usize, k_pt: usize, sigma: f64, rank: usize) { let module: Module = Module::::new(1 << log_n); @@ -399,14 +415,6 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k_ksk: usize, k_ct: usize, ); } -#[test] -fn external_product() { - (1..4).for_each(|rank| { - println!("test external_product rank: {}", rank); - test_external_product(12, 12, 60, 45, 60, rank, 3.2); - }); -} - fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, k_ct_in: usize, k_ct_out: usize, rank: usize, sigma: f64) { let module: Module = Module::::new(1 << log_n); @@ -490,7 +498,7 @@ fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, k_ct_in: usi let var_a0_err: f64 = sigma * sigma; let var_a1_err: f64 = 1f64 / 12f64; - let noise_want: f64 = noise_rgsw_product( + let noise_want: f64 = noise_ggsw_gglwe_product( module.n() as f64, basek, 0.5, @@ -512,14 +520,6 @@ fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, k_ct_in: usi ); } -#[test] -fn external_product_inplace() { - (1..4).for_each(|rank| { - println!("test external_product rank: {}", rank); - test_external_product_inplace(12, 15, 60, 60, rank, 3.2); - }); -} - fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, k_ct: usize, rank: usize, sigma: f64) { let module: Module = Module::::new(1 << log_n); let rows: usize = (k_ct + basek - 1) / basek; @@ -595,7 +595,7 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, k_ct let var_a0_err: f64 = sigma * sigma; let var_a1_err: f64 = 1f64 / 12f64; - let noise_want: f64 = noise_rgsw_product( + let noise_want: f64 = noise_ggsw_gglwe_product( module.n() as f64, basek, 0.5, diff --git a/core/src/test_fft64/glwe_fourier.rs b/core/src/test_fft64/glwe_fourier.rs index f25bac9..d5ed622 100644 --- a/core/src/test_fft64/glwe_fourier.rs +++ b/core/src/test_fft64/glwe_fourier.rs @@ -1,438 +1,445 @@ -// use crate::{ -// elem::Infos, -// ggsw_ciphertext::GGSWCiphertext, -// glwe_ciphertext::GLWECiphertext, -// glwe_ciphertext_fourier::GLWECiphertextFourier, -// glwe_plaintext::GLWEPlaintext, -// keys::{SecretKey, SecretKeyFourier}, -// keyswitch_key::GLWESwitchingKey, -// test_fft64::{gglwe::noise_grlwe_rlwe_product, ggsw::noise_rgsw_product}, -// }; -// use base2k::{FFT64, FillUniform, Module, ScalarZnx, ScalarZnxAlloc, ScratchOwned, Stats, VecZnxOps, VecZnxToMut, ZnxViewMut}; -// use sampling::source::Source; -// -// #[test] -// fn keyswitch() { -// let module: Module = Module::::new(2048); -// let log_base2k: usize = 12; -// let log_k_grlwe: usize = 60; -// let log_k_rlwe_in: usize = 45; -// let log_k_rlwe_out: usize = 60; -// let rows: usize = (log_k_rlwe_in + log_base2k - 1) / log_base2k; -// -// let rank: usize = 1; -// -// let sigma: f64 = 3.2; -// -// let mut ct_grlwe: GLWESwitchingKey, FFT64> = -// GLWESwitchingKey::new(&module, log_base2k, log_k_grlwe, rows, rank, rank); -// let mut ct_rlwe_in: GLWECiphertext> = GLWECiphertext::new(&module, log_base2k, log_k_rlwe_in, rank); -// let mut ct_rlwe_in_dft: GLWECiphertextFourier, FFT64> = -// GLWECiphertextFourier::new(&module, log_base2k, log_k_rlwe_in, rank); -// let mut ct_rlwe_out: GLWECiphertext> = GLWECiphertext::new(&module, log_base2k, log_k_rlwe_out, rank); -// let mut ct_rlwe_out_dft: GLWECiphertextFourier, FFT64> = -// GLWECiphertextFourier::new(&module, log_base2k, log_k_rlwe_out, rank); -// let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, log_base2k, log_k_rlwe_in); -// let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, log_base2k, log_k_rlwe_out); -// -// let mut source_xs: Source = Source::new([0u8; 32]); -// let mut source_xe: Source = Source::new([0u8; 32]); -// let mut source_xa: Source = Source::new([0u8; 32]); -// -// Random input plaintext -// pt_want -// .data -// .fill_uniform(log_base2k, 0, pt_want.size(), &mut source_xa); -// -// let mut scratch: ScratchOwned = ScratchOwned::new( -// GLWESwitchingKey::encrypt_sk_scratch_space(&module, rank, ct_grlwe.size()) -// | GLWECiphertext::decrypt_scratch_space(&module, ct_rlwe_out.size()) -// | GLWECiphertext::encrypt_sk_scratch_space(&module, rank, ct_rlwe_in.size()) -// | GLWECiphertextFourier::keyswitch_scratch_space( -// &module, -// ct_rlwe_out.size(), -// ct_rlwe_in.size(), -// ct_grlwe.size(), -// ), -// ); -// -// let mut sk0: SecretKey> = SecretKey::new(&module, rank); -// sk0.fill_ternary_prob(0.5, &mut source_xs); -// -// let mut sk0_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); -// sk0_dft.dft(&module, &sk0); -// -// let mut sk1: SecretKey> = SecretKey::new(&module, rank); -// sk1.fill_ternary_prob(0.5, &mut source_xs); -// -// let mut sk1_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); -// sk1_dft.dft(&module, &sk1); -// -// ct_grlwe.encrypt_sk( -// &module, -// &sk0.data, -// &sk1_dft, -// &mut source_xa, -// &mut source_xe, -// sigma, -// scratch.borrow(), -// ); -// -// ct_rlwe_in.encrypt_sk( -// &module, -// &pt_want, -// &sk0_dft, -// &mut source_xa, -// &mut source_xe, -// sigma, -// scratch.borrow(), -// ); -// -// ct_rlwe_in.dft(&module, &mut ct_rlwe_in_dft); -// ct_rlwe_out_dft.keyswitch(&module, &ct_rlwe_in_dft, &ct_grlwe, scratch.borrow()); -// ct_rlwe_out_dft.idft(&module, &mut ct_rlwe_out, scratch.borrow()); -// -// ct_rlwe_out.decrypt(&module, &mut pt_have, &sk1_dft, scratch.borrow()); -// -// module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); -// -// let noise_have: f64 = pt_have.data.std(0, log_base2k).log2(); -// let noise_want: f64 = noise_grlwe_rlwe_product( -// module.n() as f64, -// log_base2k, -// 0.5, -// 0.5, -// 0f64, -// sigma * sigma, -// 0f64, -// log_k_rlwe_in, -// log_k_grlwe, -// ); -// -// assert!( -// (noise_have - noise_want).abs() <= 0.1, -// "{} {}", -// noise_have, -// noise_want -// ); -// } -// -// #[test] -// fn keyswich_inplace() { -// let module: Module = Module::::new(2048); -// let log_base2k: usize = 12; -// let log_k_grlwe: usize = 60; -// let log_k_rlwe: usize = 45; -// let rows: usize = (log_k_rlwe + log_base2k - 1) / log_base2k; -// let rank: usize = 1; -// -// let sigma: f64 = 3.2; -// -// let mut ct_grlwe: GLWESwitchingKey, FFT64> = -// GLWESwitchingKey::new(&module, log_base2k, log_k_grlwe, rows, rank, rank); -// let mut ct_rlwe: GLWECiphertext> = GLWECiphertext::new(&module, log_base2k, log_k_rlwe, rank); -// let mut ct_rlwe_dft: GLWECiphertextFourier, FFT64> = -// GLWECiphertextFourier::new(&module, log_base2k, log_k_rlwe, rank); -// let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, log_base2k, log_k_rlwe); -// let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, log_base2k, log_k_rlwe); -// -// let mut source_xs: Source = Source::new([0u8; 32]); -// let mut source_xe: Source = Source::new([0u8; 32]); -// let mut source_xa: Source = Source::new([0u8; 32]); -// -// Random input plaintext -// pt_want -// .data -// .fill_uniform(log_base2k, 0, pt_want.size(), &mut source_xa); -// -// let mut scratch: ScratchOwned = ScratchOwned::new( -// GLWESwitchingKey::encrypt_sk_scratch_space(&module, rank, ct_grlwe.size()) -// | GLWECiphertext::decrypt_scratch_space(&module, ct_rlwe.size()) -// | GLWECiphertext::encrypt_sk_scratch_space(&module, rank, ct_rlwe.size()) -// | GLWECiphertextFourier::keyswitch_inplace_scratch_space(&module, ct_rlwe_dft.size(), ct_grlwe.size()), -// ); -// -// let mut sk0: SecretKey> = SecretKey::new(&module, rank); -// sk0.fill_ternary_prob(0.5, &mut source_xs); -// -// let mut sk0_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); -// sk0_dft.dft(&module, &sk0); -// -// let mut sk1: SecretKey> = SecretKey::new(&module, rank); -// sk1.fill_ternary_prob(0.5, &mut source_xs); -// -// let mut sk1_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); -// sk1_dft.dft(&module, &sk1); -// -// ct_grlwe.encrypt_sk( -// &module, -// &sk0.data, -// &sk1_dft, -// &mut source_xa, -// &mut source_xe, -// sigma, -// scratch.borrow(), -// ); -// -// ct_rlwe.encrypt_sk( -// &module, -// &pt_want, -// &sk0_dft, -// &mut source_xa, -// &mut source_xe, -// sigma, -// scratch.borrow(), -// ); -// -// ct_rlwe.dft(&module, &mut ct_rlwe_dft); -// ct_rlwe_dft.keyswitch_inplace(&module, &ct_grlwe, scratch.borrow()); -// ct_rlwe_dft.idft(&module, &mut ct_rlwe, scratch.borrow()); -// -// ct_rlwe.decrypt(&module, &mut pt_have, &sk1_dft, scratch.borrow()); -// -// module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); -// -// let noise_have: f64 = pt_have.data.std(0, log_base2k).log2(); -// let noise_want: f64 = noise_grlwe_rlwe_product( -// module.n() as f64, -// log_base2k, -// 0.5, -// 0.5, -// 0f64, -// sigma * sigma, -// 0f64, -// log_k_rlwe, -// log_k_grlwe, -// ); -// -// assert!( -// (noise_have - noise_want).abs() <= 0.1, -// "{} {}", -// noise_have, -// noise_want -// ); -// } -// -// #[test] -// fn external_product() { -// let module: Module = Module::::new(2048); -// let log_base2k: usize = 12; -// let log_k_grlwe: usize = 60; -// let log_k_rlwe_in: usize = 45; -// let log_k_rlwe_out: usize = 60; -// let rows: usize = (log_k_rlwe_in + log_base2k - 1) / log_base2k; -// let rank: usize = 1; -// -// let sigma: f64 = 3.2; -// -// let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, log_base2k, log_k_grlwe, rows, rank); -// let mut ct_rlwe_in: GLWECiphertext> = GLWECiphertext::new(&module, log_base2k, log_k_rlwe_in, rank); -// let mut ct_rlwe_out: GLWECiphertext> = GLWECiphertext::new(&module, log_base2k, log_k_rlwe_out, rank); -// let mut ct_rlwe_dft_in: GLWECiphertextFourier, FFT64> = -// GLWECiphertextFourier::new(&module, log_base2k, log_k_rlwe_in, rank); -// let mut ct_rlwe_dft_out: GLWECiphertextFourier, FFT64> = -// GLWECiphertextFourier::new(&module, log_base2k, log_k_rlwe_out, rank); -// let mut pt_rgsw: ScalarZnx> = module.new_scalar_znx(1); -// let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, log_base2k, log_k_rlwe_in); -// let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, log_base2k, log_k_rlwe_out); -// -// let mut source_xs: Source = Source::new([0u8; 32]); -// let mut source_xe: Source = Source::new([0u8; 32]); -// let mut source_xa: Source = Source::new([0u8; 32]); -// -// Random input plaintext -// pt_want -// .data -// .fill_uniform(log_base2k, 0, pt_want.size(), &mut source_xa); -// -// pt_want.to_mut().at_mut(0, 0)[1] = 1; -// -// let k: usize = 1; -// -// pt_rgsw.raw_mut()[k] = 1; // X^{k} -// -// let mut scratch: ScratchOwned = ScratchOwned::new( -// GGSWCiphertext::encrypt_sk_scratch_space(&module, rank, ct_rgsw.size()) -// | GLWECiphertext::decrypt_scratch_space(&module, ct_rlwe_out.size()) -// | GLWECiphertext::encrypt_sk_scratch_space(&module, rank, ct_rlwe_in.size()) -// | GLWECiphertext::external_product_scratch_space( -// &module, -// ct_rlwe_out.size(), -// ct_rlwe_in.size(), -// ct_rgsw.size(), -// ), -// ); -// -// let mut sk: SecretKey> = SecretKey::new(&module, rank); -// sk.fill_ternary_prob(0.5, &mut source_xs); -// -// let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); -// sk_dft.dft(&module, &sk); -// -// ct_rgsw.encrypt_sk( -// &module, -// &pt_rgsw, -// &sk_dft, -// &mut source_xa, -// &mut source_xe, -// sigma, -// scratch.borrow(), -// ); -// -// ct_rlwe_in.encrypt_sk( -// &module, -// &pt_want, -// &sk_dft, -// &mut source_xa, -// &mut source_xe, -// sigma, -// scratch.borrow(), -// ); -// -// ct_rlwe_in.dft(&module, &mut ct_rlwe_dft_in); -// ct_rlwe_dft_out.external_product(&module, &ct_rlwe_dft_in, &ct_rgsw, scratch.borrow()); -// ct_rlwe_dft_out.idft(&module, &mut ct_rlwe_out, scratch.borrow()); -// -// ct_rlwe_out.decrypt(&module, &mut pt_have, &sk_dft, scratch.borrow()); -// -// module.vec_znx_rotate_inplace(k as i64, &mut pt_want, 0); -// -// module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); -// -// let noise_have: f64 = pt_have.data.std(0, log_base2k).log2(); -// -// let var_gct_err_lhs: f64 = sigma * sigma; -// let var_gct_err_rhs: f64 = 0f64; -// -// let var_msg: f64 = 1f64 / module.n() as f64; // X^{k} -// let var_a0_err: f64 = sigma * sigma; -// let var_a1_err: f64 = 1f64 / 12f64; -// -// let noise_want: f64 = noise_rgsw_product( -// module.n() as f64, -// log_base2k, -// 0.5, -// var_msg, -// var_a0_err, -// var_a1_err, -// var_gct_err_lhs, -// var_gct_err_rhs, -// log_k_rlwe_in, -// log_k_grlwe, -// ); -// -// assert!( -// (noise_have - noise_want).abs() <= 0.1, -// "{} {}", -// noise_have, -// noise_want -// ); -// } -// -// #[test] -// fn external_product_inplace() { -// let module: Module = Module::::new(2048); -// let log_base2k: usize = 12; -// let log_k_grlwe: usize = 60; -// let log_k_rlwe_in: usize = 45; -// let log_k_rlwe_out: usize = 60; -// let rows: usize = (log_k_rlwe_in + log_base2k - 1) / log_base2k; -// let rank: usize = 1; -// -// let sigma: f64 = 3.2; -// -// let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, log_base2k, log_k_grlwe, rows, rank); -// let mut ct_rlwe: GLWECiphertext> = GLWECiphertext::new(&module, log_base2k, log_k_rlwe_in, rank); -// let mut ct_rlwe_dft: GLWECiphertextFourier, FFT64> = -// GLWECiphertextFourier::new(&module, log_base2k, log_k_rlwe_in, rank); -// let mut pt_rgsw: ScalarZnx> = module.new_scalar_znx(1); -// let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, log_base2k, log_k_rlwe_in); -// let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, log_base2k, log_k_rlwe_out); -// -// let mut source_xs: Source = Source::new([0u8; 32]); -// let mut source_xe: Source = Source::new([0u8; 32]); -// let mut source_xa: Source = Source::new([0u8; 32]); -// -// Random input plaintext -// pt_want -// .data -// .fill_uniform(log_base2k, 0, pt_want.size(), &mut source_xa); -// -// pt_want.to_mut().at_mut(0, 0)[1] = 1; -// -// let k: usize = 1; -// -// pt_rgsw.raw_mut()[k] = 1; // X^{k} -// -// let mut scratch: ScratchOwned = ScratchOwned::new( -// GGSWCiphertext::encrypt_sk_scratch_space(&module, rank, ct_rgsw.size()) -// | GLWECiphertext::decrypt_scratch_space(&module, ct_rlwe.size()) -// | GLWECiphertext::encrypt_sk_scratch_space(&module, rank, ct_rlwe.size()) -// | GLWECiphertext::external_product_inplace_scratch_space(&module, ct_rlwe.size(), ct_rgsw.size()), -// ); -// -// let mut sk: SecretKey> = SecretKey::new(&module, rank); -// sk.fill_ternary_prob(0.5, &mut source_xs); -// -// let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); -// sk_dft.dft(&module, &sk); -// -// ct_rgsw.encrypt_sk( -// &module, -// &pt_rgsw, -// &sk_dft, -// &mut source_xa, -// &mut source_xe, -// sigma, -// scratch.borrow(), -// ); -// -// ct_rlwe.encrypt_sk( -// &module, -// &pt_want, -// &sk_dft, -// &mut source_xa, -// &mut source_xe, -// sigma, -// scratch.borrow(), -// ); -// -// ct_rlwe.dft(&module, &mut ct_rlwe_dft); -// ct_rlwe_dft.external_product_inplace(&module, &ct_rgsw, scratch.borrow()); -// ct_rlwe_dft.idft(&module, &mut ct_rlwe, scratch.borrow()); -// -// ct_rlwe.decrypt(&module, &mut pt_have, &sk_dft, scratch.borrow()); -// -// module.vec_znx_rotate_inplace(k as i64, &mut pt_want, 0); -// -// module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); -// -// let noise_have: f64 = pt_have.data.std(0, log_base2k).log2(); -// -// let var_gct_err_lhs: f64 = sigma * sigma; -// let var_gct_err_rhs: f64 = 0f64; -// -// let var_msg: f64 = 1f64 / module.n() as f64; // X^{k} -// let var_a0_err: f64 = sigma * sigma; -// let var_a1_err: f64 = 1f64 / 12f64; -// -// let noise_want: f64 = noise_rgsw_product( -// module.n() as f64, -// log_base2k, -// 0.5, -// var_msg, -// var_a0_err, -// var_a1_err, -// var_gct_err_lhs, -// var_gct_err_rhs, -// log_k_rlwe_in, -// log_k_grlwe, -// ); -// -// assert!( -// (noise_have - noise_want).abs() <= 0.1, -// "{} {}", -// noise_have, -// noise_want -// ); -// } +use crate::{ + elem::Infos, + ggsw_ciphertext::GGSWCiphertext, + glwe_ciphertext::GLWECiphertext, + glwe_ciphertext_fourier::GLWECiphertextFourier, + glwe_plaintext::GLWEPlaintext, + keys::{SecretKey, SecretKeyFourier}, + keyswitch_key::GLWESwitchingKey, + test_fft64::{gglwe::noise_gglwe_product, ggsw::noise_ggsw_gglwe_product}, +}; +use base2k::{FFT64, FillUniform, Module, ScalarZnx, ScalarZnxAlloc, ScratchOwned, Stats, VecZnxOps, VecZnxToMut, ZnxViewMut}; +use sampling::source::Source; + +#[test] +fn keyswitch() { + (1..4).for_each(|rank_in| { + (1..4).for_each(|rank_out| { + println!("test keyswitch rank_in: {} rank_out: {}", rank_in, rank_out); + test_keyswitch(12, 12, 60, 45, 60, rank_in, rank_out, 3.2); + }); + }); +} + +#[test] +fn keyswitch_inplace() { + (1..4).for_each(|rank| { + println!("test keyswitch_inplace rank: {}", rank); + test_keyswitch_inplace(12, 12, 60, 45, rank, 3.2); + }); +} + +#[test] +fn external_product() { + (1..4).for_each(|rank| { + println!("test external_product rank: {}", rank); + test_external_product(12, 12, 60, 45, 60, rank, 3.2); + }); +} + +#[test] +fn external_product_inplace() { + (1..4).for_each(|rank| { + println!("test external_product rank: {}", rank); + test_external_product_inplace(12, 15, 60, 60, rank, 3.2); + }); +} + +fn test_keyswitch( + log_n: usize, + basek: usize, + k_ksk: usize, + k_ct_in: usize, + k_ct_out: usize, + rank_in: usize, + rank_out: usize, + sigma: f64, +) { + let module: Module = Module::::new(1 << log_n); + + let rows: usize = (k_ct_in + basek - 1) / basek; + + let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank_in, rank_out); + let mut ct_glwe_in: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_in, rank_in); + let mut ct_glwe_dft_in: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ct_in, rank_in); + let mut ct_glwe_out: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_out, rank_out); + let mut ct_glwe_dft_out: GLWECiphertextFourier, FFT64> = + GLWECiphertextFourier::new(&module, basek, k_ct_out, rank_out); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_in); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_out); + + let mut source_xs: Source = Source::new([0u8; 32]); + let mut source_xe: Source = Source::new([0u8; 32]); + let mut source_xa: Source = Source::new([0u8; 32]); + + // Random input plaintext + pt_want + .data + .fill_uniform(basek, 0, pt_want.size(), &mut source_xa); + + let mut scratch: ScratchOwned = ScratchOwned::new( + GLWESwitchingKey::encrypt_sk_scratch_space(&module, rank_out, ksk.size()) + | GLWECiphertext::decrypt_scratch_space(&module, ct_glwe_out.size()) + | GLWECiphertext::encrypt_sk_scratch_space(&module, ct_glwe_in.size()) + | GLWECiphertextFourier::keyswitch_scratch_space( + &module, + ct_glwe_out.size(), + ct_glwe_in.size(), + ksk.size(), + rank_in, + rank_out, + ), + ); + + let mut sk_in: SecretKey> = SecretKey::new(&module, rank_in); + sk_in.fill_ternary_prob(0.5, &mut source_xs); + + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_in); + sk_in_dft.dft(&module, &sk_in); + + let mut sk_out: SecretKey> = SecretKey::new(&module, rank_out); + sk_out.fill_ternary_prob(0.5, &mut source_xs); + + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_out); + sk_out_dft.dft(&module, &sk_out); + + ksk.encrypt_sk( + &module, + &sk_in, + &sk_out_dft, + &mut source_xa, + &mut source_xe, + sigma, + scratch.borrow(), + ); + + ct_glwe_in.encrypt_sk( + &module, + &pt_want, + &sk_in_dft, + &mut source_xa, + &mut source_xe, + sigma, + scratch.borrow(), + ); + + ct_glwe_in.dft(&module, &mut ct_glwe_dft_in); + ct_glwe_dft_out.keyswitch(&module, &ct_glwe_dft_in, &ksk, scratch.borrow()); + ct_glwe_dft_out.idft(&module, &mut ct_glwe_out, scratch.borrow()); + + ct_glwe_out.decrypt(&module, &mut pt_have, &sk_out_dft, scratch.borrow()); + + module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); + + let noise_have: f64 = pt_have.data.std(0, basek).log2(); + let noise_want: f64 = noise_gglwe_product( + module.n() as f64, + basek, + 0.5, + 0.5, + 0f64, + sigma * sigma, + 0f64, + rank_in as f64, + k_ct_in, + k_ksk, + ); + + assert!( + (noise_have - noise_want).abs() <= 0.1, + "{} {}", + noise_have, + noise_want + ); +} + +fn test_keyswitch_inplace(log_n: usize, basek: usize, k_ksk: usize, k_ct: usize, rank: usize, sigma: f64) { + let module: Module = Module::::new(1 << log_n); + let rows: usize = (k_ct + basek - 1) / basek; + + let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank, rank); + let mut ct_glwe: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct, rank); + let mut ct_rlwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ct, rank); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); + + let mut source_xs: Source = Source::new([0u8; 32]); + let mut source_xe: Source = Source::new([0u8; 32]); + let mut source_xa: Source = Source::new([0u8; 32]); + + // Random input plaintext + pt_want + .data + .fill_uniform(basek, 0, pt_want.size(), &mut source_xa); + + let mut scratch: ScratchOwned = ScratchOwned::new( + GLWESwitchingKey::encrypt_sk_scratch_space(&module, rank, ksk.size()) + | GLWECiphertext::decrypt_scratch_space(&module, ct_glwe.size()) + | GLWECiphertext::encrypt_sk_scratch_space(&module, ct_glwe.size()) + | GLWECiphertextFourier::keyswitch_inplace_scratch_space(&module, ct_rlwe_dft.size(), ksk.size(), rank), + ); + + let mut sk_in: SecretKey> = SecretKey::new(&module, rank); + sk_in.fill_ternary_prob(0.5, &mut source_xs); + + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + sk_in_dft.dft(&module, &sk_in); + + let mut sk_out: SecretKey> = SecretKey::new(&module, rank); + sk_out.fill_ternary_prob(0.5, &mut source_xs); + + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + sk_out_dft.dft(&module, &sk_out); + + ksk.encrypt_sk( + &module, + &sk_in, + &sk_out_dft, + &mut source_xa, + &mut source_xe, + sigma, + scratch.borrow(), + ); + + ct_glwe.encrypt_sk( + &module, + &pt_want, + &sk_in_dft, + &mut source_xa, + &mut source_xe, + sigma, + scratch.borrow(), + ); + + ct_glwe.dft(&module, &mut ct_rlwe_dft); + ct_rlwe_dft.keyswitch_inplace(&module, &ksk, scratch.borrow()); + ct_rlwe_dft.idft(&module, &mut ct_glwe, scratch.borrow()); + + ct_glwe.decrypt(&module, &mut pt_have, &sk_out_dft, scratch.borrow()); + + module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); + + let noise_have: f64 = pt_have.data.std(0, basek).log2(); + let noise_want: f64 = noise_gglwe_product( + module.n() as f64, + basek, + 0.5, + 0.5, + 0f64, + sigma * sigma, + 0f64, + rank as f64, + k_ct, + k_ksk, + ); + + assert!( + (noise_have - noise_want).abs() <= 0.1, + "{} {}", + noise_have, + noise_want + ); +} + +fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, k_ct_in: usize, k_ct_out: usize, rank: usize, sigma: f64) { + let module: Module = Module::::new(1 << log_n); + + let rows: usize = (k_ct_in + basek - 1) / basek; + + let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); + let mut ct_in: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_in, rank); + let mut ct_out: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_out, rank); + let mut ct_in_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ct_in, rank); + let mut ct_out_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ct_out, rank); + let mut pt_rgsw: ScalarZnx> = module.new_scalar_znx(1); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_in); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_out); + + let mut source_xs: Source = Source::new([0u8; 32]); + let mut source_xe: Source = Source::new([0u8; 32]); + let mut source_xa: Source = Source::new([0u8; 32]); + + // Random input plaintext + pt_want + .data + .fill_uniform(basek, 0, pt_want.size(), &mut source_xa); + + pt_want.to_mut().at_mut(0, 0)[1] = 1; + + let k: usize = 1; + + pt_rgsw.raw_mut()[k] = 1; // X^{k} + + let mut scratch: ScratchOwned = ScratchOwned::new( + GGSWCiphertext::encrypt_sk_scratch_space(&module, rank, ct_rgsw.size()) + | GLWECiphertext::decrypt_scratch_space(&module, ct_out.size()) + | GLWECiphertext::encrypt_sk_scratch_space(&module, ct_in.size()) + | GLWECiphertextFourier::external_product_scratch_space(&module, ct_out.size(), ct_in.size(), ct_rgsw.size(), rank), + ); + + let mut sk: SecretKey> = SecretKey::new(&module, rank); + sk.fill_ternary_prob(0.5, &mut source_xs); + + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + sk_dft.dft(&module, &sk); + + ct_rgsw.encrypt_sk( + &module, + &pt_rgsw, + &sk_dft, + &mut source_xa, + &mut source_xe, + sigma, + scratch.borrow(), + ); + + ct_in.encrypt_sk( + &module, + &pt_want, + &sk_dft, + &mut source_xa, + &mut source_xe, + sigma, + scratch.borrow(), + ); + + ct_in.dft(&module, &mut ct_in_dft); + ct_out_dft.external_product(&module, &ct_in_dft, &ct_rgsw, scratch.borrow()); + ct_out_dft.idft(&module, &mut ct_out, scratch.borrow()); + + ct_out.decrypt(&module, &mut pt_have, &sk_dft, scratch.borrow()); + + module.vec_znx_rotate_inplace(k as i64, &mut pt_want, 0); + + module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); + + let noise_have: f64 = pt_have.data.std(0, basek).log2(); + + let var_gct_err_lhs: f64 = sigma * sigma; + let var_gct_err_rhs: f64 = 0f64; + + let var_msg: f64 = 1f64 / module.n() as f64; // X^{k} + let var_a0_err: f64 = sigma * sigma; + let var_a1_err: f64 = 1f64 / 12f64; + + let noise_want: f64 = noise_ggsw_gglwe_product( + module.n() as f64, + basek, + 0.5, + var_msg, + var_a0_err, + var_a1_err, + var_gct_err_lhs, + var_gct_err_rhs, + rank as f64, + k_ct_in, + k_ggsw, + ); + + assert!( + (noise_have - noise_want).abs() <= 0.1, + "{} {}", + noise_have, + noise_want + ); +} + +fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, k_ct: usize, rank: usize, sigma: f64) { + let module: Module = Module::::new(1 << log_n); + let rows: usize = (k_ct + basek - 1) / basek; + + let mut ct_ggsw: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); + let mut ct: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct, rank); + let mut ct_rlwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ct, rank); + let mut pt_rgsw: ScalarZnx> = module.new_scalar_znx(1); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); + + let mut source_xs: Source = Source::new([0u8; 32]); + let mut source_xe: Source = Source::new([0u8; 32]); + let mut source_xa: Source = Source::new([0u8; 32]); + + // Random input plaintext + pt_want + .data + .fill_uniform(basek, 0, pt_want.size(), &mut source_xa); + + pt_want.to_mut().at_mut(0, 0)[1] = 1; + + let k: usize = 1; + + pt_rgsw.raw_mut()[k] = 1; // X^{k} + + let mut scratch: ScratchOwned = ScratchOwned::new( + GGSWCiphertext::encrypt_sk_scratch_space(&module, rank, ct_ggsw.size()) + | GLWECiphertext::decrypt_scratch_space(&module, ct.size()) + | GLWECiphertext::encrypt_sk_scratch_space(&module, ct.size()) + | GLWECiphertextFourier::external_product_inplace_scratch_space(&module, ct.size(), ct_ggsw.size(), rank), + ); + + let mut sk: SecretKey> = SecretKey::new(&module, rank); + sk.fill_ternary_prob(0.5, &mut source_xs); + + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + sk_dft.dft(&module, &sk); + + ct_ggsw.encrypt_sk( + &module, + &pt_rgsw, + &sk_dft, + &mut source_xa, + &mut source_xe, + sigma, + scratch.borrow(), + ); + + ct.encrypt_sk( + &module, + &pt_want, + &sk_dft, + &mut source_xa, + &mut source_xe, + sigma, + scratch.borrow(), + ); + + ct.dft(&module, &mut ct_rlwe_dft); + ct_rlwe_dft.external_product_inplace(&module, &ct_ggsw, scratch.borrow()); + ct_rlwe_dft.idft(&module, &mut ct, scratch.borrow()); + + ct.decrypt(&module, &mut pt_have, &sk_dft, scratch.borrow()); + + module.vec_znx_rotate_inplace(k as i64, &mut pt_want, 0); + + module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); + + let noise_have: f64 = pt_have.data.std(0, basek).log2(); + + let var_gct_err_lhs: f64 = sigma * sigma; + let var_gct_err_rhs: f64 = 0f64; + + let var_msg: f64 = 1f64 / module.n() as f64; // X^{k} + let var_a0_err: f64 = sigma * sigma; + let var_a1_err: f64 = 1f64 / 12f64; + + let noise_want: f64 = noise_ggsw_gglwe_product( + module.n() as f64, + basek, + 0.5, + var_msg, + var_a0_err, + var_a1_err, + var_gct_err_lhs, + var_gct_err_rhs, + rank as f64, + k_ct, + k_ggsw, + ); + + assert!( + (noise_have - noise_want).abs() <= 0.1, + "{} {}", + noise_have, + noise_want + ); +} diff --git a/core/src/vec_glwe_product.rs b/core/src/vec_glwe_product.rs index d3e6636..08afa1e 100644 --- a/core/src/vec_glwe_product.rs +++ b/core/src/vec_glwe_product.rs @@ -23,7 +23,7 @@ pub(crate) trait VecGLWEProductScratchSpace { Self::prod_with_glwe_scratch_space(module, res_size, res_size, rhs, rank, rank) } - fn prod_with_glwe_dft_scratch_space( + fn prod_with_glwe_fourier_scratch_space( module: &Module, res_size: usize, lhs: usize, @@ -32,11 +32,11 @@ pub(crate) trait VecGLWEProductScratchSpace { rank_out: usize, ) -> usize { (Self::prod_with_glwe_scratch_space(module, res_size, lhs, rhs, rank_in, rank_out) | module.vec_znx_idft_tmp_bytes()) - + module.bytes_of_vec_znx(rank_in, lhs) - + module.bytes_of_vec_znx(rank_out, res_size) + + module.bytes_of_vec_znx(rank_in + 1, lhs) + + module.bytes_of_vec_znx(rank_out + 1, res_size) } - fn prod_with_glwe_dft_inplace_scratch_space(module: &Module, res_size: usize, rhs: usize, rank: usize) -> usize { + fn prod_with_glwe_fourier_inplace_scratch_space(module: &Module, res_size: usize, rhs: usize, rank: usize) -> usize { (Self::prod_with_glwe_inplace_scratch_space(module, res_size, rhs, rank) | module.vec_znx_idft_tmp_bytes()) + module.bytes_of_vec_znx(rank + 1, res_size) } @@ -49,13 +49,13 @@ pub(crate) trait VecGLWEProductScratchSpace { rank_in: usize, rank_out: usize, ) -> usize { - Self::prod_with_glwe_dft_scratch_space(module, res_size, lhs, rhs, rank_in, rank_out) + Self::prod_with_glwe_fourier_scratch_space(module, res_size, lhs, rhs, rank_in, rank_out) + module.bytes_of_vec_znx_dft(rank_in + 1, lhs) + module.bytes_of_vec_znx_dft(rank_out + 1, res_size) } fn prod_with_vec_glwe_inplace_scratch_space(module: &Module, res_size: usize, rhs: usize, rank: usize) -> usize { - Self::prod_with_glwe_dft_inplace_scratch_space(module, res_size, rhs, rank) + Self::prod_with_glwe_fourier_inplace_scratch_space(module, res_size, rhs, rank) + module.bytes_of_vec_znx_dft(rank + 1, res_size) } }