arnaucube/poulpy
1
0
Fork 0
mirror of https://github.com/arnaucube/poulpy.git synced 2026-02-10 13:16:44 +01:00
Code Issues Packages Projects Releases Wiki Activity

fixed gadget product & related example

Browse Source
This commit is contained in:
Jean-Philippe Bossuat
2025-02-12 16:49:53 +01:00
parent dc2fab9a04
commit 7c25ad2eba
10 changed files with 128 additions and 172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
base2k/examples/rlwe_encrypt.rs
View File

@@ -71,7 +71,7 @@ fn main() {
module.vec_znx_idft_tmp_a(&mut buf_big, &mut buf_dft, b.limbs()); module.vec_znx_idft_tmp_a(&mut buf_big, &mut buf_dft, b.limbs());
// buf_big <- a * s + b // buf_big <- a * s + b
module.vec_znx_big_add_small_inplace(&mut buf_big, &b, b.limbs()); module.vec_znx_big_add_small_inplace(&mut buf_big, &b);
// res <- normalize(buf_big) // res <- normalize(buf_big)
module.vec_znx_big_normalize(log_base2k, &mut res, &buf_big, &mut carry); module.vec_znx_big_normalize(log_base2k, &mut res, &buf_big, &mut carry);

68
base2k/src/vec_znx_big.rs
View File

@@ -37,20 +37,13 @@ impl Module {
// b <- b - a // b <- b - a
pub fn vec_znx_big_sub_small_a_inplace(&self, b: &mut VecZnxBig, a: &VecZnx) { pub fn vec_znx_big_sub_small_a_inplace(&self, b: &mut VecZnxBig, a: &VecZnx) {
let limbs: usize = a.limbs();
assert!(
b.limbs() >= limbs,
"invalid c_vector: b.limbs()={} < a.limbs()={}",
b.limbs(),
limbs
);
unsafe { unsafe {
vec_znx_big::vec_znx_big_sub_small_a( vec_znx_big::vec_znx_big_sub_small_a(
self.0, self.0,
b.0, b.0,
b.limbs() as u64, b.limbs() as u64,
a.as_ptr(), a.as_ptr(),
limbs as u64, a.limbs() as u64,
a.n() as u64, a.n() as u64,
b.0, b.0,
b.limbs() as u64, b.limbs() as u64,
@@ -60,26 +53,13 @@ impl Module {
// c <- b - a // c <- b - a
pub fn vec_znx_big_sub_small_a(&self, c: &mut VecZnxBig, a: &VecZnx, b: &VecZnxBig) { pub fn vec_znx_big_sub_small_a(&self, c: &mut VecZnxBig, a: &VecZnx, b: &VecZnxBig) {
let limbs: usize = a.limbs();
assert!(
b.limbs() >= limbs,
"invalid c: b.limbs()={} < a.limbs()={}",
b.limbs(),
limbs
);
assert!(
c.limbs() >= limbs,
"invalid c: c.limbs()={} < a.limbs()={}",
c.limbs(),
limbs
);
unsafe { unsafe {
vec_znx_big::vec_znx_big_sub_small_a( vec_znx_big::vec_znx_big_sub_small_a(
self.0, self.0,
c.0, c.0,
c.limbs() as u64, c.limbs() as u64,
a.as_ptr(), a.as_ptr(),
limbs as u64, a.limbs() as u64,
a.n() as u64, a.n() as u64,
b.0, b.0,
b.limbs() as u64, b.limbs() as u64,
@@ -89,50 +69,31 @@ impl Module {
// c <- b + a // c <- b + a
pub fn vec_znx_big_add_small(&self, c: &mut VecZnxBig, a: &VecZnx, b: &VecZnxBig) { pub fn vec_znx_big_add_small(&self, c: &mut VecZnxBig, a: &VecZnx, b: &VecZnxBig) {
let limbs: usize = a.limbs();
assert!(
b.limbs() >= limbs,
"invalid c: b.limbs()={} < a.limbs()={}",
b.limbs(),
limbs
);
assert!(
c.limbs() >= limbs,
"invalid c: c.limbs()={} < a.limbs()={}",
c.limbs(),
limbs
);
unsafe { unsafe {
vec_znx_big::vec_znx_big_add_small( vec_znx_big::vec_znx_big_add_small(
self.0, self.0,
c.0, c.0,
limbs as u64, c.limbs() as u64,
b.0, b.0,
limbs as u64, a.limbs() as u64,
a.as_ptr(), a.as_ptr(),
limbs as u64, b.limbs() as u64,
a.n() as u64, a.n() as u64,
) )
} }
} }
// b <- b + a // b <- b + a
pub fn vec_znx_big_add_small_inplace(&self, b: &mut VecZnxBig, a: &VecZnx, a_limbs: usize) { pub fn vec_znx_big_add_small_inplace(&self, b: &mut VecZnxBig, a: &VecZnx) {
assert!(
b.limbs() >= a_limbs,
"invalid c_vector: b.limbs()={} < a.limbs()={}",
b.limbs(),
a_limbs
);
unsafe { unsafe {
vec_znx_big::vec_znx_big_add_small( vec_znx_big::vec_znx_big_add_small(
self.0, self.0,
b.0, b.0,
a_limbs as u64, b.limbs() as u64,
b.0, b.0,
a_limbs as u64, a.limbs() as u64,
a.as_ptr(), a.as_ptr(),
a_limbs as u64, a.limbs() as u64,
a.n() as u64, a.n() as u64,
) )
} }
@@ -150,13 +111,6 @@ impl Module {
a: &VecZnxBig, a: &VecZnxBig,
tmp_bytes: &mut [u8], tmp_bytes: &mut [u8],
) { ) {
let limbs: usize = b.limbs();
assert!(
b.limbs() >= limbs,
"invalid c_vector: b.limbs()={} < a.limbs()={}",
b.limbs(),
limbs
);
assert!( assert!(
tmp_bytes.len() >= self.vec_znx_big_normalize_tmp_bytes(), tmp_bytes.len() >= self.vec_znx_big_normalize_tmp_bytes(),
"invalid tmp_bytes: tmp_bytes.len()={} <= self.vec_znx_big_normalize_tmp_bytes()={}", "invalid tmp_bytes: tmp_bytes.len()={} <= self.vec_znx_big_normalize_tmp_bytes()={}",
@@ -168,10 +122,10 @@ impl Module {
self.0, self.0,
log_base2k as u64, log_base2k as u64,
b.as_mut_ptr(), b.as_mut_ptr(),
limbs as u64, b.limbs() as u64,
b.n() as u64, b.n() as u64,
a.0, a.0,
limbs as u64, a.limbs() as u64,
tmp_bytes.as_mut_ptr(), tmp_bytes.as_mut_ptr(),
) )
} }

137
rlwe/examples/gadget_product.rs
View File

@@ -1,9 +1,13 @@
use base2k::{Encoding, FFT64, SvpPPolOps}; use base2k::{FFT64, Infos, Sampling, Scalar, SvpPPolOps, VecZnx, VecZnxBig, VecZnxDft, VecZnxOps};
use rlwe::{ use rlwe::{
ciphertext::Ciphertext, ciphertext::{Ciphertext, GadgetCiphertext},
decryptor::{decrypt_rlwe_thread_safe_tmp_byte, Decryptor}, decryptor::{Decryptor, decrypt_rlwe_thread_safe, decrypt_rlwe_thread_safe_tmp_byte},
encryptor::{encrypt_grlwe_sk_tmp_bytes, encrypt_rlwe_sk_tmp_bytes, EncryptorSk}, elem::Elem,
evaluator::{gadget_product_thread_safe, gadget_product_inplace_thread_safe, gadget_product_tmp_bytes}, encryptor::{
EncryptorSk, encrypt_grlwe_sk_thread_safe, encrypt_grlwe_sk_tmp_bytes,
encrypt_rlwe_sk_tmp_bytes,
},
evaluator::{gadget_product_thread_safe, gadget_product_tmp_bytes},
key_generator::{gen_switching_key_thread_safe, gen_switching_key_thread_safe_tmp_bytes}, key_generator::{gen_switching_key_thread_safe, gen_switching_key_thread_safe_tmp_bytes},
keys::{SecretKey, SwitchingKey}, keys::{SecretKey, SwitchingKey},
parameters::{Parameters, ParametersLiteral}, parameters::{Parameters, ParametersLiteral},
@@ -41,19 +45,20 @@ fn main() {
params.log_q(), params.log_q(),
params.limbs_q(), params.limbs_q(),
params.log_qp() params.log_qp()
) | encrypt_grlwe_sk_tmp_bytes(params.module(), params.log_base2k(), params.limbs_qp(), params.log_qp()) )
| encrypt_grlwe_sk_tmp_bytes(
params.module(),
params.log_base2k(),
params.limbs_qp(),
params.log_qp()
)
]; ];
println!("limbsQP: {}", params.limbs_qp());
let mut source: Source = Source::new([3; 32]); let mut source: Source = Source::new([3; 32]);
let mut sk0: SecretKey = SecretKey::new(params.module()); let mut sk: SecretKey = SecretKey::new(params.module());
let mut sk1: SecretKey = SecretKey::new(params.module());
sk0.fill_ternary_hw(params.xs(), &mut source);
sk1.fill_ternary_hw(params.xs(), &mut source);
sk.fill_ternary_hw(params.xs(), &mut source);
let mut want = vec![i64::default(); params.n()]; let mut want = vec![i64::default(); params.n()];
@@ -61,82 +66,82 @@ fn main() {
let log_base2k = params.log_base2k(); let log_base2k = params.log_base2k();
let log_k: usize = params.log_q() - 2*log_base2k; let log_k: usize = params.log_q() - 2 * log_base2k;
let mut ct: Ciphertext = params.new_ciphertext(params.log_qp());
let mut source_xe: Source = Source::new([4; 32]); let mut source_xe: Source = Source::new([4; 32]);
let mut source_xa: Source = Source::new([5; 32]); let mut source_xa: Source = Source::new([5; 32]);
let mut sk0_svp_ppol: base2k::SvpPPol = params.module().new_svp_ppol(); let mut sk_svp_ppol: base2k::SvpPPol = params.module().new_svp_ppol();
params.module().svp_prepare(&mut sk0_svp_ppol, &sk0.0); params.module().svp_prepare(&mut sk_svp_ppol, &sk.0);
let mut sk1_svp_ppol: base2k::SvpPPol = params.module().new_svp_ppol(); let mut gadget_ct: GadgetCiphertext = GadgetCiphertext::new(
params.module().svp_prepare(&mut sk1_svp_ppol, &sk1.0);
let mut pt_out: Plaintext = Plaintext::new(params.module(), params.log_base2k(), params.log_qp(), ct.log_scale());
//pt_out.0.value[0].encode_vec_i64(log_base2k, log_k, &want, 32);
//pt_out.0.value[0].normalize(log_base2k, &mut tmp_bytes);
params.encrypt_rlwe_sk_thread_safe(
&mut ct,
Some(&pt_out),
&sk0_svp_ppol,
&mut source_xa,
&mut source_xe,
&mut tmp_bytes,
);
params.decrypt_rlwe_thread_safe(&mut pt_out, &ct, &sk0_svp_ppol, &mut tmp_bytes);
println!("DECRYPT");
pt_out.0.value[0].print_limbs(pt_out.limbs(), 16);
let mut swk: SwitchingKey = SwitchingKey::new(
params.module(), params.module(),
params.log_base2k(), log_base2k,
params.limbs_qp(), params.limbs_q(),
params.log_qp(), params.log_qp(),
); );
gen_switching_key_thread_safe( let mut m: Scalar = Scalar::new(params.n());
m.fill_ternary_prob(0.5, &mut source_xa);
encrypt_grlwe_sk_thread_safe(
params.module(), params.module(),
&mut swk, &mut gadget_ct,
&sk0, &m,
&sk1_svp_ppol, &sk_svp_ppol,
&mut source_xa, &mut source_xa,
&mut source_xe, &mut source_xe,
params.xe(), params.xe(),
&mut tmp_bytes, &mut tmp_bytes,
); );
println!("{}", swk.cols()); let mut res: Elem = Elem::new(params.module(), log_base2k, params.log_q(), 1, 0);
let mut a: VecZnx = VecZnx::new(params.module().n(), params.limbs_q());
a.fill_uniform(params.log_base2k(), a.limbs(), &mut source_xa);
gadget_product_thread_safe(params.module(), &mut res, &a, &gadget_ct, &mut tmp_bytes);
let mut ct_out: Ciphertext = Ciphertext::new(params.module(), params.log_base2k(), params.log_q()+17, 1, ct.log_scale()); println!("a.limbs()={}", a.limbs());
println!("gadget_ct.rows()={}", gadget_ct.rows());
println!("gadget_ct.cols()={}", gadget_ct.cols());
println!("res.limbs()={}", res.limbs());
println!();
gadget_product_thread_safe(params.module(), &mut ct_out, &ct, &swk.0, &mut tmp_bytes); println!("a:");
a.print_limbs(a.limbs(), 16);
println!();
pt_out.zero(); println!("m:");
println!("{:?}", &m.0[..16]);
println!();
params.decrypt_rlwe_thread_safe(&mut pt_out, &ct_out, &sk1_svp_ppol, &mut tmp_bytes); let mut a_res: Elem = Elem::new(params.module(), params.log_base2k(), params.log_q(), 0, 0);
pt_out.0.value[0].print_limbs(pt_out.limbs(), 16); decrypt_rlwe_thread_safe(
params.module(),
&mut a_res,
&res,
&sk_svp_ppol,
&mut tmp_bytes,
);
let mut have = vec![i64::default(); params.n()]; let mut m_svp_ppol = params.module().new_svp_ppol();
params.module().svp_prepare(&mut m_svp_ppol, &m);
//println!("pt_out: {}", log_k); let mut a_dft: VecZnxDft = params.module().new_vec_znx_dft(a.limbs());
//pt_out.0.value[0].decode_vec_i64(pt_out.log_base2k(), log_k, &mut have); let mut a_big: VecZnxBig = a_dft.as_vec_znx_big();
//println!("want: {:?}", &want[..16]); params
//println!("have: {:?}", &have[..16]); .module()
.svp_apply_dft(&mut a_dft, &m_svp_ppol, &a, a.limbs());
params
.module()
.vec_znx_idft_tmp_a(&mut a_big, &mut a_dft, a.limbs());
params
.module()
.vec_znx_big_normalize(params.log_base2k(), &mut a, &a_big, &mut tmp_bytes);
} params.module().vec_znx_sub_inplace(&mut a, &a_res.value[0]);
println!("a*m - dec(a * GRLWE(m))");
pub fn cast_mut_u64_to_mut_u8_slice(data: &mut [u64]) -> &mut [u8] { a.print_limbs(a.limbs(), 16);
let ptr: *mut u8 = data.as_mut_ptr() as *mut u8;
let len: usize = data.len() * std::mem::size_of::<u64>();
unsafe { std::slice::from_raw_parts_mut(ptr, len) }
} }

2
rlwe/src/ciphertext.rs
View File

@@ -48,7 +48,7 @@ impl Ciphertext {
self.0.log_scale self.0.log_scale
} }
pub fn zero(&mut self){ pub fn zero(&mut self) {
self.0.zero() self.0.zero()
} }

22
rlwe/src/decryptor.rs
View File

@@ -1,5 +1,9 @@
use crate::{ use crate::{
ciphertext::{Ciphertext, GadgetCiphertext}, elem::Elem, keys::SecretKey, parameters::Parameters, plaintext::Plaintext ciphertext::{Ciphertext, GadgetCiphertext},
elem::Elem,
keys::SecretKey,
parameters::Parameters,
plaintext::Plaintext,
}; };
use base2k::{Module, SvpPPol, SvpPPolOps, VecZnxDft}; use base2k::{Module, SvpPPol, SvpPPolOps, VecZnxDft};
use std::cmp::min; use std::cmp::min;
@@ -46,26 +50,24 @@ pub fn decrypt_rlwe_thread_safe(
sk: &SvpPPol, sk: &SvpPPol,
tmp_bytes: &mut [u8], tmp_bytes: &mut [u8],
) { ) {
let limbs: usize = min(res.limbs(), a.limbs());
assert!( assert!(
tmp_bytes.len() >= decrypt_rlwe_thread_safe_tmp_byte(module, limbs), tmp_bytes.len() >= decrypt_rlwe_thread_safe_tmp_byte(module, a.limbs()),
"invalid tmp_bytes: tmp_bytes.len()={} < decrypt_rlwe_thread_safe_tmp_byte={}", "invalid tmp_bytes: tmp_bytes.len()={} < decrypt_rlwe_thread_safe_tmp_byte={}",
tmp_bytes.len(), tmp_bytes.len(),
decrypt_rlwe_thread_safe_tmp_byte(module, limbs) decrypt_rlwe_thread_safe_tmp_byte(module, a.limbs())
); );
let res_dft_bytes: usize = module.bytes_of_vec_znx_dft(limbs); let res_dft_bytes: usize = module.bytes_of_vec_znx_dft(a.limbs());
let mut res_dft: VecZnxDft = VecZnxDft::from_bytes(limbs, tmp_bytes); let mut res_dft: VecZnxDft = VecZnxDft::from_bytes(a.limbs(), tmp_bytes);
let mut res_big: base2k::VecZnxBig = res_dft.as_vec_znx_big(); let mut res_big: base2k::VecZnxBig = res_dft.as_vec_znx_big();
// res_dft <- DFT(ct[1]) * DFT(sk) // res_dft <- DFT(ct[1]) * DFT(sk)
module.svp_apply_dft(&mut res_dft, sk, &a.value[1], limbs); module.svp_apply_dft(&mut res_dft, sk, &a.value[1], a.limbs());
// res_big <- ct[1] x sk // res_big <- ct[1] x sk
module.vec_znx_idft_tmp_a(&mut res_big, &mut res_dft, limbs); module.vec_znx_idft_tmp_a(&mut res_big, &mut res_dft, a.limbs());
// res_big <- ct[1] x sk + ct[0] // res_big <- ct[1] x sk + ct[0]
module.vec_znx_big_add_small_inplace(&mut res_big, &a.value[0], limbs); module.vec_znx_big_add_small_inplace(&mut res_big, &a.value[0]);
// res <- normalize(ct[1] x sk + ct[0]) // res <- normalize(ct[1] x sk + ct[0])
module.vec_znx_big_normalize( module.vec_znx_big_normalize(
a.log_base2k(), a.log_base2k(),

2
rlwe/src/elem.rs
View File

@@ -91,7 +91,7 @@ impl Elem {
&mut self.value[i] &mut self.value[i]
} }
pub fn zero(&mut self){ pub fn zero(&mut self) {
self.value.iter_mut().for_each(|i| i.zero()); self.value.iter_mut().for_each(|i| i.zero());
} }
} }

4
rlwe/src/encryptor.rs
View File

@@ -175,7 +175,7 @@ pub fn encrypt_rlwe_sk_thread_safe(
} }
// c0 <- -s x c1 + m + e // c0 <- -s x c1 + m + e
//c0.add_normal(log_base2k, log_q, source_xe, sigma, (sigma * 6.0).ceil()); c0.add_normal(log_base2k, log_q, source_xe, sigma, (sigma * 6.0).ceil());
} }
pub fn encrypt_grlwe_sk_tmp_bytes( pub fn encrypt_grlwe_sk_tmp_bytes(
@@ -245,6 +245,7 @@ pub fn encrypt_grlwe_sk_thread_safe(
// Zeroes the ith-row of tmp_pt // Zeroes the ith-row of tmp_pt
tmp_pt.0.value[0].at_mut(row_i).fill(0); tmp_pt.0.value[0].at_mut(row_i).fill(0);
/*
let mut res: Elem = Elem::new(module, log_base2k, log_q, 0, tmp_elem.log_scale); let mut res: Elem = Elem::new(module, log_base2k, log_q, 0, tmp_elem.log_scale);
decrypt_rlwe_thread_safe(module, &mut res, &tmp_elem, sk, tmp_bytes_encrypt_sk); decrypt_rlwe_thread_safe(module, &mut res, &tmp_elem, sk, tmp_bytes_encrypt_sk);
@@ -252,6 +253,7 @@ pub fn encrypt_grlwe_sk_thread_safe(
println!("row:{}", row_i); println!("row:{}", row_i);
res.value[0].print_limbs(res.limbs(), 16); res.value[0].print_limbs(res.limbs(), 16);
println!(); println!();
*/
// GRLWE[row_i][0] = -as + m * 2^{-i*log_base2k} + e*2^{-log_q} // GRLWE[row_i][0] = -as + m * 2^{-i*log_base2k} + e*2^{-log_q}
module.vmp_prepare_row( module.vmp_prepare_row(

51
rlwe/src/evaluator.rs
View File

@@ -1,5 +1,8 @@
use crate::ciphertext::{Ciphertext, GadgetCiphertext}; use crate::{
use base2k::{Module, VecZnxBig, VecZnxDft, VmpPMatOps}; ciphertext::{Ciphertext, GadgetCiphertext},
elem::Elem,
};
use base2k::{Infos, Module, VecZnx, VecZnxBig, VecZnxDft, VmpPMatOps};
pub fn gadget_product_tmp_bytes( pub fn gadget_product_tmp_bytes(
module: &Module, module: &Module,
@@ -16,34 +19,27 @@ pub fn gadget_product_tmp_bytes(
+ 2 * module.bytes_of_vec_znx_dft(gct_cols) + 2 * module.bytes_of_vec_znx_dft(gct_cols)
} }
pub fn gadget_product_inplace_thread_safe( /// Evaluates the gadget product res <- a x b.
module: &Module, ///
a: &mut Ciphertext, /// # Arguments
b: &GadgetCiphertext, ///
tmp_bytes: &mut [u8], /// * `module`: backend support for operations mod (X^N + 1)
) { /// * `res`: an [Elem] to store (-cs + m * a + e, c) with res_ncols limbs.
// This is safe to do because the relevant values of a are copied to a buffer before being /// * `a`: a [VecZnx] of a_ncols limbs.
// overwritten. /// * `b`: a [GadgetCiphertext] as a vector of (-Bs + m * 2^{-k} + E, B)
unsafe { /// containing b_nrows [VecZnx], each of b_ncols limbs.
let a_ptr: *mut Ciphertext = a; ///
gadget_product_thread_safe(module, a, &*a_ptr, b, tmp_bytes) /// # Computation
} ///
} /// res = sum[min(a_ncols, b_nrows)] decomp(a, i) * (-B[i]s + m * 2^{-k*i} + E[i], B[i])
/// = (cs + m * a + e, c) with min(res_limbs, b_cols) limbs.
pub fn gadget_product_thread_safe( pub fn gadget_product_thread_safe(
module: &Module, module: &Module,
res: &mut Ciphertext, res: &mut Elem,
a: &Ciphertext, a: &VecZnx,
b: &GadgetCiphertext, b: &GadgetCiphertext,
tmp_bytes: &mut [u8], tmp_bytes: &mut [u8],
) { ) {
assert!(
a.log_base2k() == b.log_base2k(),
"invalid inputs: a.log_base2k={} != b.log_base2k={}",
a.log_base2k(),
b.log_base2k()
);
let log_base2k: usize = b.log_base2k(); let log_base2k: usize = b.log_base2k();
let cols: usize = b.cols(); let cols: usize = b.cols();
@@ -57,7 +53,7 @@ pub fn gadget_product_thread_safe(
let mut res_big: VecZnxBig = res_dft.as_vec_znx_big(); let mut res_big: VecZnxBig = res_dft.as_vec_znx_big();
// c1_dft <- DFT(c1) [cols] // c1_dft <- DFT(c1) [cols]
module.vec_znx_dft(&mut c1_dft, a.at(1), a.limbs()); module.vec_znx_dft(&mut c1_dft, a, a.limbs());
// res_dft <- sum[rows] DFT(c1)[cols] x GadgetCiphertext[0][cols] // res_dft <- sum[rows] DFT(c1)[cols] x GadgetCiphertext[0][cols]
module.vmp_apply_dft_to_dft(&mut res_dft, &c1_dft, &b.value[0], tmp_bytes_vmp_apply_dft); module.vmp_apply_dft_to_dft(&mut res_dft, &c1_dft, &b.value[0], tmp_bytes_vmp_apply_dft);
@@ -65,9 +61,6 @@ pub fn gadget_product_thread_safe(
// res_big <- IDFT(DFT(c1) x GadgetCiphertext[0]) // res_big <- IDFT(DFT(c1) x GadgetCiphertext[0])
module.vec_znx_idft_tmp_a(&mut res_big, &mut res_dft, cols); module.vec_znx_idft_tmp_a(&mut res_big, &mut res_dft, cols);
// res_big <- c0 + c1_dft x GadgetCiphertext[0]
module.vec_znx_big_add_small_inplace(&mut res_big, a.at(0), cols);
// res[0] = normalize(c0 + c1_dft x GadgetCiphertext[0]) // res[0] = normalize(c0 + c1_dft x GadgetCiphertext[0])
module.vec_znx_big_normalize(log_base2k, res.at_mut(0), &res_big, tmp_bytes_vmp_apply_dft); module.vec_znx_big_normalize(log_base2k, res.at_mut(0), &res_big, tmp_bytes_vmp_apply_dft);

8
rlwe/src/keys.rs
View File

@@ -65,19 +65,19 @@ impl SwitchingKey {
SwitchingKey(GadgetCiphertext::new(module, log_base2k, rows, log_q)) SwitchingKey(GadgetCiphertext::new(module, log_base2k, rows, log_q))
} }
pub fn n(&self) -> usize{ pub fn n(&self) -> usize {
self.0.n() self.0.n()
} }
pub fn rows(&self) -> usize{ pub fn rows(&self) -> usize {
self.0.rows() self.0.rows()
} }
pub fn cols(&self) -> usize{ pub fn cols(&self) -> usize {
self.0.cols() self.0.cols()
} }
pub fn log_base2k(&self) -> usize{ pub fn log_base2k(&self) -> usize {
self.0.log_base2k() self.0.log_base2k()
} }
} }

2
rlwe/src/plaintext.rs
View File

@@ -64,7 +64,7 @@ impl Plaintext {
self.0.log_scale() self.0.log_scale()
} }
pub fn zero(&mut self){ pub fn zero(&mut self) {
self.0.zero() self.0.zero()
} }