wip on gadget product

rlwe/src/ciphertext.rs

@@ -48,6 +48,10 @@ impl Ciphertext {
         self.0.log_scale
     }
 
+    pub fn zero(&mut self){
+        self.0.zero()
+    }
+
     pub fn as_plaintext(&self) -> Plaintext {
         unsafe { Plaintext(std::ptr::read(&self.0)) }
     }

rlwe/src/decryptor.rs

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

rlwe/src/elem.rs

@@ -90,6 +90,10 @@ impl Elem {
         assert!(i <= self.degree());
         &mut self.value[i]
     }
+
+    pub fn zero(&mut self){
+        self.value.iter_mut().for_each(|i| i.zero());
+    }
 }
 
 impl Parameters {

rlwe/src/encryptor.rs

@@ -1,4 +1,5 @@
 use crate::ciphertext::{Ciphertext, GadgetCiphertext};
+use crate::decryptor::decrypt_rlwe_thread_safe;
 use crate::elem::Elem;
 use crate::keys::SecretKey;
 use crate::parameters::Parameters;
@@ -174,7 +175,7 @@ pub fn encrypt_rlwe_sk_thread_safe(
     }
 
     // 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(
@@ -244,6 +245,14 @@ pub fn encrypt_grlwe_sk_thread_safe(
         // Zeroes the ith-row of tmp_pt
         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);
+
+        decrypt_rlwe_thread_safe(module, &mut res, &tmp_elem, sk, tmp_bytes_encrypt_sk);
+
+        println!("row:{}", row_i);
+        res.value[0].print_limbs(res.limbs(), 16);
+        println!();
+
         // GRLWE[row_i][0] = -as + m * 2^{-i*log_base2k} + e*2^{-log_q}
         module.vmp_prepare_row(
             &mut ct.value[0],

rlwe/src/evaluator.rs

@@ -16,7 +16,7 @@ pub fn gadget_product_tmp_bytes(
         + 2 * module.bytes_of_vec_znx_dft(gct_cols)
 }
 
-pub fn gadget_product_inplace(
+pub fn gadget_product_inplace_thread_safe(
     module: &Module,
     a: &mut Ciphertext,
     b: &GadgetCiphertext,
@@ -26,11 +26,11 @@ pub fn gadget_product_inplace(
     // overwritten.
     unsafe {
         let a_ptr: *mut Ciphertext = a;
-        gadget_product(module, a, &*a_ptr, b, tmp_bytes)
+        gadget_product_thread_safe(module, a, &*a_ptr, b, tmp_bytes)
     }
 }
 
-pub fn gadget_product(
+pub fn gadget_product_thread_safe(
     module: &Module,
     res: &mut Ciphertext,
     a: &Ciphertext,
@@ -56,10 +56,10 @@ pub fn gadget_product(
     let mut res_dft: VecZnxDft = module.new_vec_znx_from_bytes(cols, tmp_bytes_res_dft);
     let mut res_big: VecZnxBig = res_dft.as_vec_znx_big();
 
-    // c1_dft <- DFT(b[1])
+    // c1_dft <- DFT(c1) [cols]
     module.vec_znx_dft(&mut c1_dft, a.at(1), a.limbs());
 
-    // res_dft <- DFT(c1) x GadgetCiphertext[0]
+    // 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);
 
     // res_big <- IDFT(DFT(c1) x GadgetCiphertext[0])

rlwe/src/keys.rs

@@ -65,14 +65,19 @@ impl SwitchingKey {
         SwitchingKey(GadgetCiphertext::new(module, log_base2k, rows, log_q))
     }
 
-    pub fn gen_thread_safe(
-        &mut self,
-        params: &mut Parameters,
-        sk_in: &SvpPPol,
-        sk_out: &SvpPPol,
-        xa_source: &mut Source,
-        xe_source: &mut Source,
-        tmp_bytes: &mut [u8],
-    ) {
+    pub fn n(&self) -> usize{
+        self.0.n()
+    }
+
+    pub fn rows(&self) -> usize{
+        self.0.rows()
+    }
+
+    pub fn cols(&self) -> usize{
+        self.0.cols()
+    }
+
+    pub fn log_base2k(&self) -> usize{
+        self.0.log_base2k()
     }
 }

rlwe/src/plaintext.rs

@@ -64,6 +64,10 @@ impl Plaintext {
         self.0.log_scale()
     }
 
+    pub fn zero(&mut self){
+        self.0.zero()
+    }
+
     pub fn as_ciphertext(&self) -> Ciphertext {
         unsafe { Ciphertext(std::ptr::read(&self.0)) }
     }