Ref. + AVX code & generic tests + benches (#85)

poulpy-core/Cargo.toml

@@ -15,6 +15,7 @@ poulpy-hal = {path="../poulpy-hal"}
 poulpy-backend = {path="../poulpy-backend"}
 itertools = {workspace = true}
 byteorder = {workspace = true}
+once_cell = {workspace = true}
 
 [[bench]]
 name = "external_product_glwe_fft64"

poulpy-core/benches/external_product_glwe_fft64.rs

@@ -6,7 +6,7 @@ use std::hint::black_box;
 
 use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
 
-use poulpy_backend::cpu_spqlios::FFT64;
+use poulpy_backend::cpu_spqlios::FFT64Spqlios;
 use poulpy_hal::{
     api::{ModuleNew, ScratchOwnedAlloc, ScratchOwnedBorrow},
     layouts::{Module, ScalarZnx, ScratchOwned},
@@ -26,7 +26,7 @@ fn bench_external_product_glwe_fft64(c: &mut Criterion) {
     }
 
     fn runner(p: Params) -> impl FnMut() {
-        let module: Module<FFT64> = Module::<FFT64>::new(1 << p.log_n);
+        let module: Module<FFT64Spqlios> = Module::<FFT64Spqlios>::new(1 << p.log_n);
 
         let n: usize = module.n();
         let basek: usize = p.basek;
@@ -43,7 +43,7 @@ fn bench_external_product_glwe_fft64(c: &mut Criterion) {
         let mut ct_glwe_out: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_ct_out, rank);
         let pt_rgsw: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
 
-        let mut scratch: ScratchOwned<FFT64> = ScratchOwned::alloc(
+        let mut scratch: ScratchOwned<FFT64Spqlios> = ScratchOwned::alloc(
             GGSWCiphertext::encrypt_sk_scratch_space(&module, basek, ct_ggsw.k(), rank)
                 | GLWECiphertext::encrypt_sk_scratch_space(&module, basek, ct_glwe_in.k())
                 | GLWECiphertext::external_product_scratch_space(
@@ -63,7 +63,7 @@ fn bench_external_product_glwe_fft64(c: &mut Criterion) {
 
         let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
         sk.fill_ternary_prob(0.5, &mut source_xs);
-        let sk_dft: GLWESecretPrepared<Vec<u8>, FFT64> = sk.prepare_alloc(&module, scratch.borrow());
+        let sk_dft: GLWESecretPrepared<Vec<u8>, FFT64Spqlios> = sk.prepare_alloc(&module, scratch.borrow());
 
         ct_ggsw.encrypt_sk(
             &module,
@@ -82,7 +82,7 @@ fn bench_external_product_glwe_fft64(c: &mut Criterion) {
             scratch.borrow(),
         );
 
-        let ggsw_prepared: GGSWCiphertextPrepared<Vec<u8>, FFT64> = ct_ggsw.prepare_alloc(&module, scratch.borrow());
+        let ggsw_prepared: GGSWCiphertextPrepared<Vec<u8>, FFT64Spqlios> = ct_ggsw.prepare_alloc(&module, scratch.borrow());
 
         move || {
             ct_glwe_out.external_product(&module, &ct_glwe_in, &ggsw_prepared, scratch.borrow());
@@ -120,7 +120,7 @@ fn bench_external_product_glwe_inplace_fft64(c: &mut Criterion) {
     }
 
     fn runner(p: Params) -> impl FnMut() {
-        let module: Module<FFT64> = Module::<FFT64>::new(1 << p.log_n);
+        let module: Module<FFT64Spqlios> = Module::<FFT64Spqlios>::new(1 << p.log_n);
 
         let n = module.n();
         let basek: usize = p.basek;
@@ -135,7 +135,7 @@ fn bench_external_product_glwe_inplace_fft64(c: &mut Criterion) {
         let mut ct_glwe: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_glwe, rank);
         let pt_rgsw: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
 
-        let mut scratch: ScratchOwned<FFT64> = ScratchOwned::alloc(
+        let mut scratch: ScratchOwned<FFT64Spqlios> = ScratchOwned::alloc(
             GGSWCiphertext::encrypt_sk_scratch_space(&module, basek, ct_ggsw.k(), rank)
                 | GLWECiphertext::encrypt_sk_scratch_space(&module, basek, ct_glwe.k())
                 | GLWECiphertext::external_product_inplace_scratch_space(&module, basek, ct_glwe.k(), ct_ggsw.k(), digits, rank),
@@ -147,7 +147,7 @@ fn bench_external_product_glwe_inplace_fft64(c: &mut Criterion) {
 
         let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
         sk.fill_ternary_prob(0.5, &mut source_xs);
-        let sk_dft: GLWESecretPrepared<Vec<u8>, FFT64> = sk.prepare_alloc(&module, scratch.borrow());
+        let sk_dft: GLWESecretPrepared<Vec<u8>, FFT64Spqlios> = sk.prepare_alloc(&module, scratch.borrow());
 
         ct_ggsw.encrypt_sk(
             &module,
@@ -166,7 +166,7 @@ fn bench_external_product_glwe_inplace_fft64(c: &mut Criterion) {
             scratch.borrow(),
         );
 
-        let ggsw_prepared: GGSWCiphertextPrepared<Vec<u8>, FFT64> = ct_ggsw.prepare_alloc(&module, scratch.borrow());
+        let ggsw_prepared: GGSWCiphertextPrepared<Vec<u8>, FFT64Spqlios> = ct_ggsw.prepare_alloc(&module, scratch.borrow());
 
         move || {
             let scratch_borrow = scratch.borrow();

poulpy-core/benches/keyswitch_glwe_fft64.rs

@@ -5,7 +5,7 @@ use poulpy_core::layouts::{
 use std::{hint::black_box, time::Duration};
 
 use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
-use poulpy_backend::cpu_spqlios::FFT64;
+use poulpy_backend::cpu_spqlios::FFT64Spqlios;
 use poulpy_hal::{
     api::{ModuleNew, ScratchOwnedAlloc, ScratchOwnedBorrow},
     layouts::{Module, ScratchOwned},
@@ -27,7 +27,7 @@ fn bench_keyswitch_glwe_fft64(c: &mut Criterion) {
     }
 
     fn runner(p: Params) -> impl FnMut() {
-        let module: Module<FFT64> = Module::<FFT64>::new(1 << p.log_n);
+        let module: Module<FFT64Spqlios> = Module::<FFT64Spqlios>::new(1 << p.log_n);
 
         let n = module.n();
         let basek: usize = p.basek;
@@ -44,7 +44,7 @@ fn bench_keyswitch_glwe_fft64(c: &mut Criterion) {
         let mut ct_in: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_rlwe_in, rank_in);
         let mut ct_out: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_rlwe_out, rank_out);
 
-        let mut scratch: ScratchOwned<FFT64> = ScratchOwned::alloc(
+        let mut scratch: ScratchOwned<FFT64Spqlios> = ScratchOwned::alloc(
             GGLWESwitchingKey::encrypt_sk_scratch_space(&module, basek, ksk.k(), rank_in, rank_out)
                 | GLWECiphertext::encrypt_sk_scratch_space(&module, basek, ct_in.k())
                 | GLWECiphertext::keyswitch_scratch_space(
@@ -65,7 +65,7 @@ fn bench_keyswitch_glwe_fft64(c: &mut Criterion) {
 
         let mut sk_in: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_in);
         sk_in.fill_ternary_prob(0.5, &mut source_xs);
-        let sk_in_dft: GLWESecretPrepared<Vec<u8>, FFT64> = sk_in.prepare_alloc(&module, scratch.borrow());
+        let sk_in_dft: GLWESecretPrepared<Vec<u8>, FFT64Spqlios> = sk_in.prepare_alloc(&module, scratch.borrow());
 
         let mut sk_out: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_out);
         sk_out.fill_ternary_prob(0.5, &mut source_xs);
@@ -132,7 +132,7 @@ fn bench_keyswitch_glwe_inplace_fft64(c: &mut Criterion) {
     }
 
     fn runner(p: Params) -> impl FnMut() {
-        let module: Module<FFT64> = Module::<FFT64>::new(1 << p.log_n);
+        let module: Module<FFT64Spqlios> = Module::<FFT64Spqlios>::new(1 << p.log_n);
 
         let n = module.n();
         let basek: usize = p.basek;
@@ -146,7 +146,7 @@ fn bench_keyswitch_glwe_inplace_fft64(c: &mut Criterion) {
         let mut ksk: GGLWESwitchingKey<Vec<u8>> = GGLWESwitchingKey::alloc(n, basek, k_ksk, rows, digits, rank, rank);
         let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_ct, rank);
 
-        let mut scratch: ScratchOwned<FFT64> = ScratchOwned::alloc(
+        let mut scratch: ScratchOwned<FFT64Spqlios> = ScratchOwned::alloc(
             GGLWESwitchingKey::encrypt_sk_scratch_space(&module, basek, ksk.k(), rank, rank)
                 | GLWECiphertext::encrypt_sk_scratch_space(&module, basek, ct.k())
                 | GLWECiphertext::keyswitch_inplace_scratch_space(&module, basek, ct.k(), ksk.k(), digits, rank),
@@ -158,7 +158,7 @@ fn bench_keyswitch_glwe_inplace_fft64(c: &mut Criterion) {
 
         let mut sk_in: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
         sk_in.fill_ternary_prob(0.5, &mut source_xs);
-        let sk_in_dft: GLWESecretPrepared<Vec<u8>, FFT64> = sk_in.prepare_alloc(&module, scratch.borrow());
+        let sk_in_dft: GLWESecretPrepared<Vec<u8>, FFT64Spqlios> = sk_in.prepare_alloc(&module, scratch.borrow());
 
         let mut sk_out: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
         sk_out.fill_ternary_prob(0.5, &mut source_xs);
@@ -180,7 +180,7 @@ fn bench_keyswitch_glwe_inplace_fft64(c: &mut Criterion) {
             scratch.borrow(),
         );
 
-        let ksk_prepared: GGLWESwitchingKeyPrepared<Vec<u8>, FFT64> = ksk.prepare_alloc(&module, scratch.borrow());
+        let ksk_prepared: GGLWESwitchingKeyPrepared<Vec<u8>, FFT64Spqlios> = ksk.prepare_alloc(&module, scratch.borrow());
 
         move || {
             ct.keyswitch_inplace(&module, &ksk_prepared, scratch.borrow());

poulpy-core/examples/encryption.rs

@@ -1,4 +1,4 @@
-use poulpy_backend::cpu_spqlios::FFT64;
+use poulpy_backend::cpu_spqlios::FFT64Spqlios;
 use poulpy_core::{
     GLWEOperations, SIGMA,
     layouts::{
@@ -31,7 +31,7 @@ fn main() {
     let rank: usize = 1;
 
     // Instantiate Module (DFT Tables)
-    let module: Module<FFT64> = Module::<FFT64>::new(n as u64);
+    let module: Module<FFT64Spqlios> = Module::<FFT64Spqlios>::new(n as u64);
 
     // Allocates ciphertext & plaintexts
     let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_ct, rank);
@@ -44,7 +44,7 @@ fn main() {
     let mut source_xa: Source = Source::new([2u8; 32]);
 
     // Scratch space
-    let mut scratch: ScratchOwned<FFT64> = ScratchOwned::alloc(
+    let mut scratch: ScratchOwned<FFT64Spqlios> = ScratchOwned::alloc(
         GLWECiphertext::encrypt_sk_scratch_space(&module, basek, ct.k())
             | GLWECiphertext::decrypt_scratch_space(&module, basek, ct.k()),
     );
@@ -54,10 +54,10 @@ fn main() {
     sk.fill_ternary_prob(0.5, &mut source_xs);
 
     // Backend-prepared secret
-    let sk_prepared: GLWESecretPrepared<Vec<u8>, FFT64> = sk.prepare_alloc(&module, scratch.borrow());
+    let sk_prepared: GLWESecretPrepared<Vec<u8>, FFT64Spqlios> = sk.prepare_alloc(&module, scratch.borrow());
 
     // Uniform plaintext
-    module.vec_znx_fill_uniform(basek, &mut pt_want.data, 0, k_pt, &mut source_xa);
+    module.vec_znx_fill_uniform(basek, &mut pt_want.data, 0, &mut source_xa);
 
     // Encryption
     ct.encrypt_sk(

poulpy-core/src/automorphism/gglwe_atk.rs

@@ -1,8 +1,8 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, TakeVecZnxDft, VecZnxAutomorphism, VecZnxAutomorphismInplace,
-        VecZnxBigAddSmallInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxDftAllocBytes, VmpApplyDftToDft,
-        VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+        ScratchAvailable, TakeVecZnxDft, VecZnxAutomorphism, VecZnxAutomorphismInplace, VecZnxBigAddSmallInplace,
+        VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume,
+        VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch, ZnxZero},
 };
@@ -54,12 +54,12 @@ impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
             + VecZnxAutomorphism
-            + VecZnxAutomorphismInplace,
+            + VecZnxAutomorphismInplace<B>,
         Scratch<B>: ScratchAvailable + TakeVecZnxDft<B>,
     {
         #[cfg(debug_assertions)]
@@ -72,7 +72,7 @@ impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
                 lhs.rank_in()
             );
             assert_eq!(
-                lhs.rank_out(),
+                self.rank_out(),
                 rhs.rank_in(),
                 "ksk_in output rank: {} != ksk_apply input rank: {}",
                 self.rank_out(),
@@ -113,7 +113,7 @@ impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
 
                 // Applies back the automorphism X^{-k}: (-pi^{-1}_{k'}(s)a + pi_{k}(s), a) to (-pi^{-1}_{k'+k}(s)a + s, a)
                 (0..cols_out).for_each(|i| {
-                    module.vec_znx_automorphism_inplace(p_inv, &mut res_ct.data, i);
+                    module.vec_znx_automorphism_inplace(p_inv, &mut res_ct.data, i, scratch);
                 });
             });
         });
@@ -138,17 +138,56 @@ impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
             + VecZnxAutomorphism
-            + VecZnxAutomorphismInplace,
+            + VecZnxAutomorphismInplace<B>,
         Scratch<B>: ScratchAvailable + TakeVecZnxDft<B>,
     {
-        unsafe {
-            let self_ptr: *mut GGLWEAutomorphismKey<DataSelf> = self as *mut GGLWEAutomorphismKey<DataSelf>;
-            self.automorphism(module, &*self_ptr, rhs, scratch);
+        #[cfg(debug_assertions)]
+        {
+            assert_eq!(
+                self.rank_out(),
+                rhs.rank_in(),
+                "ksk_in output rank: {} != ksk_apply input rank: {}",
+                self.rank_out(),
+                rhs.rank_in()
+            );
+            assert_eq!(
+                self.rank_out(),
+                rhs.rank_out(),
+                "ksk_out output rank: {} != ksk_apply output rank: {}",
+                self.rank_out(),
+                rhs.rank_out()
+            );
         }
+
+        let cols_out: usize = rhs.rank_out() + 1;
+
+        let p: i64 = self.p();
+        let p_inv = module.galois_element_inv(p);
+
+        (0..self.rank_in()).for_each(|col_i| {
+            (0..self.rows()).for_each(|row_j| {
+                let mut res_ct: GLWECiphertext<&mut [u8]> = self.at_mut(row_j, col_i);
+
+                // Reverts the automorphism X^{-k}: (-pi^{-1}_{k}(s)a + s, a) to (-sa + pi_{k}(s), a)
+                (0..cols_out).for_each(|i| {
+                    module.vec_znx_automorphism_inplace(p_inv, &mut res_ct.data, i, scratch);
+                });
+
+                // Key-switch (-sa + pi_{k}(s), a) to (-pi^{-1}_{k'}(s)a + pi_{k}(s), a)
+                res_ct.keyswitch_inplace(module, &rhs.key, scratch);
+
+                // Applies back the automorphism X^{-k}: (-pi^{-1}_{k'}(s)a + pi_{k}(s), a) to (-pi^{-1}_{k'+k}(s)a + s, a)
+                (0..cols_out).for_each(|i| {
+                    module.vec_znx_automorphism_inplace(p_inv, &mut res_ct.data, i, scratch);
+                });
+            });
+        });
+
+        self.p = (self.p * rhs.p) % (module.cyclotomic_order() as i64);
     }
 }

poulpy-core/src/automorphism/ggsw_ct.rs

@@ -1,8 +1,8 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, IDFTTmpA, ScratchAvailable, TakeVecZnxBig, TakeVecZnxDft, VecZnxAutomorphismInplace,
-        VecZnxBigAddSmallInplace, VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxDftAddInplace,
-        VecZnxDftAllocBytes, VecZnxDftCopy, VecZnxNormalizeTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd,
+        ScratchAvailable, TakeVecZnxBig, TakeVecZnxDft, VecZnxAutomorphismInplace, VecZnxBigAddSmallInplace, VecZnxBigAllocBytes,
+        VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxDftAddInplace, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxDftCopy,
+        VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA, VecZnxNormalizeTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd,
         VmpApplyDftToDftTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch},
@@ -79,16 +79,16 @@ impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
-            + VecZnxAutomorphismInplace
+            + VecZnxAutomorphismInplace<B>
             + VecZnxBigAllocBytes
             + VecZnxNormalizeTmpBytes
             + VecZnxDftCopy<B>
             + VecZnxDftAddInplace<B>
-            + IDFTTmpA<B>,
+            + VecZnxIdftApplyTmpA<B>,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnxBig<B>,
     {
         #[cfg(debug_assertions)]
@@ -133,7 +133,13 @@ impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
             )
         };
 
-        self.automorphism_internal(module, lhs, auto_key, scratch);
+        // Keyswitch the j-th row of the col 0
+        (0..lhs.rows()).for_each(|row_i| {
+            // Key-switch column 0, i.e.
+            // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0, a1, a2) -> (-(a0pi^-1(s0) + a1pi^-1(s1) + a2pi^-1(s2)) + M[i], a0, a1, a2)
+            self.at_mut(row_i, 0)
+                .automorphism(module, &lhs.at(row_i, 0), auto_key, scratch);
+        });
         self.expand_row(module, tensor_key, scratch);
     }
 
@@ -149,49 +155,25 @@ impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
-            + VecZnxAutomorphismInplace
+            + VecZnxAutomorphismInplace<B>
             + VecZnxBigAllocBytes
             + VecZnxNormalizeTmpBytes
             + VecZnxDftCopy<B>
             + VecZnxDftAddInplace<B>
-            + IDFTTmpA<B>,
+            + VecZnxIdftApplyTmpA<B>,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnxBig<B>,
-    {
-        unsafe {
-            let self_ptr: *mut GGSWCiphertext<DataSelf> = self as *mut GGSWCiphertext<DataSelf>;
-            self.automorphism(module, &*self_ptr, auto_key, tensor_key, scratch);
-        }
-    }
-
-    fn automorphism_internal<DataLhs: DataRef, DataAk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        lhs: &GGSWCiphertext<DataLhs>,
-        auto_key: &GGLWEAutomorphismKeyPrepared<DataAk, B>,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxBigNormalizeTmpBytes
-            + VmpApplyDftToDft<B>
-            + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
-            + VecZnxBigAddSmallInplace<B>
-            + VecZnxBigNormalize<B>
-            + VecZnxAutomorphismInplace,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable,
     {
         // Keyswitch the j-th row of the col 0
-        (0..lhs.rows()).for_each(|row_i| {
+        (0..self.rows()).for_each(|row_i| {
             // Key-switch column 0, i.e.
             // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0, a1, a2) -> (-(a0pi^-1(s0) + a1pi^-1(s1) + a2pi^-1(s2)) + M[i], a0, a1, a2)
             self.at_mut(row_i, 0)
-                .automorphism(module, &lhs.at(row_i, 0), auto_key, scratch);
+                .automorphism_inplace(module, auto_key, scratch);
         });
+        self.expand_row(module, tensor_key, scratch);
     }
 }

poulpy-core/src/automorphism/glwe_ct.rs

@@ -1,8 +1,9 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, TakeVecZnxDft, VecZnxAutomorphismInplace, VecZnxBigAddSmallInplace,
-        VecZnxBigAutomorphismInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxBigSubSmallAInplace,
-        VecZnxBigSubSmallBInplace, VecZnxDftAllocBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+        ScratchAvailable, TakeVecZnxDft, VecZnxAutomorphismInplace, VecZnxBigAddSmallInplace, VecZnxBigAutomorphismInplace,
+        VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxBigSubSmallAInplace, VecZnxBigSubSmallBInplace,
+        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume, VmpApplyDftToDft, VmpApplyDftToDftAdd,
+        VmpApplyDftToDftTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch, VecZnxBig},
 };
@@ -54,16 +55,16 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
-            + VecZnxAutomorphismInplace,
+            + VecZnxAutomorphismInplace<B>,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable,
     {
         self.keyswitch(module, lhs, &rhs.key, scratch);
         (0..self.rank() + 1).for_each(|i| {
-            module.vec_znx_automorphism_inplace(rhs.p(), &mut self.data, i);
+            module.vec_znx_automorphism_inplace(rhs.p(), &mut self.data, i, scratch);
         })
     }
 
@@ -78,16 +79,16 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
-            + VecZnxAutomorphismInplace,
+            + VecZnxAutomorphismInplace<B>,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable,
     {
         self.keyswitch_inplace(module, &rhs.key, scratch);
         (0..self.rank() + 1).for_each(|i| {
-            module.vec_znx_automorphism_inplace(rhs.p(), &mut self.data, i);
+            module.vec_znx_automorphism_inplace(rhs.p(), &mut self.data, i, scratch);
         })
     }
 
@@ -103,8 +104,8 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
             + VecZnxBigAutomorphismInplace<B>,
@@ -114,12 +115,12 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
         {
             self.assert_keyswitch(module, lhs, &rhs.key, scratch);
         }
-        let (res_dft, scratch1) = scratch.take_vec_znx_dft(self.n(), self.cols(), rhs.size()); // TODO: optimise size
-        let mut res_big: VecZnxBig<_, B> = lhs.keyswitch_internal(module, res_dft, &rhs.key, scratch1);
+        let (res_dft, scratch_1) = scratch.take_vec_znx_dft(self.n(), self.cols(), rhs.size()); // TODO: optimise size
+        let mut res_big: VecZnxBig<_, B> = lhs.keyswitch_internal(module, res_dft, &rhs.key, scratch_1);
         (0..self.cols()).for_each(|i| {
-            module.vec_znx_big_automorphism_inplace(rhs.p(), &mut res_big, i);
+            module.vec_znx_big_automorphism_inplace(rhs.p(), &mut res_big, i, scratch_1);
             module.vec_znx_big_add_small_inplace(&mut res_big, i, &lhs.data, i);
-            module.vec_znx_big_normalize(self.basek(), &mut self.data, i, &res_big, i, scratch1);
+            module.vec_znx_big_normalize(self.basek(), &mut self.data, i, &res_big, i, scratch_1);
         })
     }
 
@@ -134,17 +135,24 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
             + VecZnxBigAutomorphismInplace<B>,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable,
     {
-        unsafe {
-            let self_ptr: *mut GLWECiphertext<DataSelf> = self as *mut GLWECiphertext<DataSelf>;
-            self.automorphism_add(module, &*self_ptr, rhs, scratch);
+        #[cfg(debug_assertions)]
+        {
+            self.assert_keyswitch_inplace(module, &rhs.key, scratch);
         }
+        let (res_dft, scratch_1) = scratch.take_vec_znx_dft(self.n(), self.cols(), rhs.size()); // TODO: optimise size
+        let mut res_big: VecZnxBig<_, B> = self.keyswitch_internal(module, res_dft, &rhs.key, scratch_1);
+        (0..self.cols()).for_each(|i| {
+            module.vec_znx_big_automorphism_inplace(rhs.p(), &mut res_big, i, scratch_1);
+            module.vec_znx_big_add_small_inplace(&mut res_big, i, &self.data, i);
+            module.vec_znx_big_normalize(self.basek(), &mut self.data, i, &res_big, i, scratch_1);
+        })
     }
 
     pub fn automorphism_sub_ab<DataLhs: DataRef, DataRhs: DataRef, B: Backend>(
@@ -159,8 +167,8 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
             + VecZnxBigAutomorphismInplace<B>
@@ -171,12 +179,12 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
         {
             self.assert_keyswitch(module, lhs, &rhs.key, scratch);
         }
-        let (res_dft, scratch1) = scratch.take_vec_znx_dft(self.n(), self.cols(), rhs.size()); // TODO: optimise size
-        let mut res_big: VecZnxBig<_, B> = lhs.keyswitch_internal(module, res_dft, &rhs.key, scratch1);
+        let (res_dft, scratch_1) = scratch.take_vec_znx_dft(self.n(), self.cols(), rhs.size()); // TODO: optimise size
+        let mut res_big: VecZnxBig<_, B> = lhs.keyswitch_internal(module, res_dft, &rhs.key, scratch_1);
         (0..self.cols()).for_each(|i| {
-            module.vec_znx_big_automorphism_inplace(rhs.p(), &mut res_big, i);
+            module.vec_znx_big_automorphism_inplace(rhs.p(), &mut res_big, i, scratch_1);
             module.vec_znx_big_sub_small_a_inplace(&mut res_big, i, &lhs.data, i);
-            module.vec_znx_big_normalize(self.basek(), &mut self.data, i, &res_big, i, scratch1);
+            module.vec_znx_big_normalize(self.basek(), &mut self.data, i, &res_big, i, scratch_1);
         })
     }
 
@@ -191,18 +199,25 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
             + VecZnxBigAutomorphismInplace<B>
             + VecZnxBigSubSmallAInplace<B>,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable,
     {
-        unsafe {
-            let self_ptr: *mut GLWECiphertext<DataSelf> = self as *mut GLWECiphertext<DataSelf>;
-            self.automorphism_sub_ab(module, &*self_ptr, rhs, scratch);
+        #[cfg(debug_assertions)]
+        {
+            self.assert_keyswitch_inplace(module, &rhs.key, scratch);
         }
+        let (res_dft, scratch_1) = scratch.take_vec_znx_dft(self.n(), self.cols(), rhs.size()); // TODO: optimise size
+        let mut res_big: VecZnxBig<_, B> = self.keyswitch_internal(module, res_dft, &rhs.key, scratch_1);
+        (0..self.cols()).for_each(|i| {
+            module.vec_znx_big_automorphism_inplace(rhs.p(), &mut res_big, i, scratch_1);
+            module.vec_znx_big_sub_small_a_inplace(&mut res_big, i, &self.data, i);
+            module.vec_znx_big_normalize(self.basek(), &mut self.data, i, &res_big, i, scratch_1);
+        })
     }
 
     pub fn automorphism_sub_ba<DataLhs: DataRef, DataRhs: DataRef, B: Backend>(
@@ -217,8 +232,8 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
             + VecZnxBigAutomorphismInplace<B>
@@ -229,12 +244,12 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
         {
             self.assert_keyswitch(module, lhs, &rhs.key, scratch);
         }
-        let (res_dft, scratch1) = scratch.take_vec_znx_dft(self.n(), self.cols(), rhs.size()); // TODO: optimise size
-        let mut res_big: VecZnxBig<_, B> = lhs.keyswitch_internal(module, res_dft, &rhs.key, scratch1);
+        let (res_dft, scratch_1) = scratch.take_vec_znx_dft(self.n(), self.cols(), rhs.size()); // TODO: optimise size
+        let mut res_big: VecZnxBig<_, B> = lhs.keyswitch_internal(module, res_dft, &rhs.key, scratch_1);
         (0..self.cols()).for_each(|i| {
-            module.vec_znx_big_automorphism_inplace(rhs.p(), &mut res_big, i);
+            module.vec_znx_big_automorphism_inplace(rhs.p(), &mut res_big, i, scratch_1);
             module.vec_znx_big_sub_small_b_inplace(&mut res_big, i, &lhs.data, i);
-            module.vec_znx_big_normalize(self.basek(), &mut self.data, i, &res_big, i, scratch1);
+            module.vec_znx_big_normalize(self.basek(), &mut self.data, i, &res_big, i, scratch_1);
         })
     }
 
@@ -249,17 +264,24 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
             + VecZnxBigAutomorphismInplace<B>
             + VecZnxBigSubSmallBInplace<B>,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable,
     {
-        unsafe {
-            let self_ptr: *mut GLWECiphertext<DataSelf> = self as *mut GLWECiphertext<DataSelf>;
-            self.automorphism_sub_ba(module, &*self_ptr, rhs, scratch);
+        #[cfg(debug_assertions)]
+        {
+            self.assert_keyswitch_inplace(module, &rhs.key, scratch);
         }
+        let (res_dft, scratch_1) = scratch.take_vec_znx_dft(self.n(), self.cols(), rhs.size()); // TODO: optimise size
+        let mut res_big: VecZnxBig<_, B> = self.keyswitch_internal(module, res_dft, &rhs.key, scratch_1);
+        (0..self.cols()).for_each(|i| {
+            module.vec_znx_big_automorphism_inplace(rhs.p(), &mut res_big, i, scratch_1);
+            module.vec_znx_big_sub_small_b_inplace(&mut res_big, i, &self.data, i);
+            module.vec_znx_big_normalize(self.basek(), &mut self.data, i, &res_big, i, scratch_1);
+        })
     }
 }

poulpy-core/src/conversion/glwe_to_lwe.rs

@@ -1,7 +1,8 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, TakeVecZnxDft, VecZnxBigAddSmallInplace, VecZnxBigNormalize,
-        VecZnxBigNormalizeTmpBytes, VecZnxDftAllocBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+        ScratchAvailable, TakeVecZnxDft, VecZnxBigAddSmallInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
+        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume, VmpApplyDftToDft, VmpApplyDftToDftAdd,
+        VmpApplyDftToDftTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch, ZnxView, ZnxViewMut, ZnxZero},
 };
@@ -60,8 +61,8 @@ impl<DLwe: DataMut> LWECiphertext<DLwe> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>,
         Scratch<B>: ScratchAvailable + TakeVecZnxDft<B> + TakeGLWECt,
@@ -71,8 +72,8 @@ impl<DLwe: DataMut> LWECiphertext<DLwe> {
             assert_eq!(self.basek(), a.basek());
             assert_eq!(a.n(), ks.n());
         }
-        let (mut tmp_glwe, scratch1) = scratch.take_glwe_ct(a.n(), a.basek(), self.k(), 1);
-        tmp_glwe.keyswitch(module, a, &ks.0, scratch1);
+        let (mut tmp_glwe, scratch_1) = scratch.take_glwe_ct(a.n(), a.basek(), self.k(), 1);
+        tmp_glwe.keyswitch(module, a, &ks.0, scratch_1);
         self.sample_extract(&tmp_glwe);
     }
 }

poulpy-core/src/conversion/lwe_to_glwe.rs

@@ -1,7 +1,8 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, TakeVecZnxDft, VecZnxBigAddSmallInplace, VecZnxBigNormalize,
-        VecZnxBigNormalizeTmpBytes, VecZnxDftAllocBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+        ScratchAvailable, TakeVecZnxDft, VecZnxBigAddSmallInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
+        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume, VmpApplyDftToDft, VmpApplyDftToDftAdd,
+        VmpApplyDftToDftTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch, ZnxView, ZnxViewMut, ZnxZero},
 };
@@ -43,8 +44,8 @@ impl<D: DataMut> GLWECiphertext<D> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>,
         Scratch<B>: ScratchAvailable + TakeVecZnxDft<B> + TakeGLWECt,
@@ -55,7 +56,7 @@ impl<D: DataMut> GLWECiphertext<D> {
             assert_eq!(self.basek(), self.basek());
         }
 
-        let (mut glwe, scratch1) = scratch.take_glwe_ct(ksk.n(), lwe.basek(), lwe.k(), 1);
+        let (mut glwe, scratch_1) = scratch.take_glwe_ct(ksk.n(), lwe.basek(), lwe.k(), 1);
         glwe.data.zero();
 
         let n_lwe: usize = lwe.n();
@@ -66,6 +67,6 @@ impl<D: DataMut> GLWECiphertext<D> {
             glwe.data.at_mut(1, i)[..n_lwe].copy_from_slice(&data_lwe[1..]);
         });
 
-        self.keyswitch(module, &glwe, &ksk.0, scratch1);
+        self.keyswitch(module, &glwe, &ksk.0, scratch_1);
     }
 }

poulpy-core/src/decryption/glwe_ct.rs

@@ -1,7 +1,7 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, SvpApplyInplace, TakeVecZnxBig, TakeVecZnxDft, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
-        VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxNormalizeTmpBytes,
+        SvpApplyDftToDftInplace, TakeVecZnxBig, TakeVecZnxDft, VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigNormalize,
+        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume, VecZnxNormalizeTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, DataViewMut, Module, Scratch},
 };
@@ -26,9 +26,9 @@ impl<DataSelf: DataRef> GLWECiphertext<DataSelf> {
         sk: &GLWESecretPrepared<DataSk, B>,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+        Module<B>: VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddInplace<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>,
@@ -50,9 +50,9 @@ impl<DataSelf: DataRef> GLWECiphertext<DataSelf> {
             (1..cols).for_each(|i| {
                 // ci_dft = DFT(a[i]) * DFT(s[i])
                 let (mut ci_dft, _) = scratch_1.take_vec_znx_dft(self.n(), 1, self.size()); // TODO optimize size when pt << ct
-                module.dft(1, 0, &mut ci_dft, 0, &self.data, i);
-                module.svp_apply_inplace(&mut ci_dft, 0, &sk.data, i - 1);
-                let ci_big = module.vec_znx_idft_consume(ci_dft);
+                module.vec_znx_dft_apply(1, 0, &mut ci_dft, 0, &self.data, i);
+                module.svp_apply_dft_to_dft_inplace(&mut ci_dft, 0, &sk.data, i - 1);
+                let ci_big = module.vec_znx_idft_apply_consume(ci_dft);
 
                 // c0_big += a[i] * s[i]
                 module.vec_znx_big_add_inplace(&mut c0_big, 0, &ci_big, 0);

poulpy-core/src/encryption/compressed/gglwe_atk.rs

@@ -1,9 +1,9 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, SvpApplyInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx,
-        TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism, VecZnxBigNormalize,
-        VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub,
-        VecZnxSubABInplace, VecZnxSwithcDegree,
+        ScratchAvailable, SvpApplyDftToDftInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx, TakeVecZnxDft,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism, VecZnxBigNormalize, VecZnxDftAllocBytes,
+        VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace,
+        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VecZnxSwitchRing,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch},
     source::Source,
@@ -41,12 +41,12 @@ impl<DataSelf: DataMut> GGLWEAutomorphismKeyCompressed<DataSelf> {
         Module<B>: VecZnxAutomorphism
             + SvpPrepare<B>
             + SvpPPolAllocBytes
-            + VecZnxSwithcDegree
+            + VecZnxSwitchRing
             + VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace

poulpy-core/src/encryption/compressed/gglwe_ct.rs

@@ -1,8 +1,8 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, SvpApplyInplace, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal,
-        VecZnxAddScalarInplace, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize,
-        VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
+        ScratchAvailable, SvpApplyDftToDftInplace, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal,
+        VecZnxAddScalarInplace, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform,
+        VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
     },
     layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, Scratch, ZnxZero},
     source::Source,
@@ -37,9 +37,9 @@ impl<D: DataMut> GGLWECiphertextCompressed<D> {
         Module<B>: VecZnxAddScalarInplace
             + VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace

poulpy-core/src/encryption/compressed/gglwe_ksk.rs

@@ -1,9 +1,9 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, SvpApplyInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx,
-        TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigNormalize, VecZnxDftAllocBytes,
-        VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
-        VecZnxSwithcDegree,
+        ScratchAvailable, SvpApplyDftToDftInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx, TakeVecZnxDft,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply,
+        VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub,
+        VecZnxSubABInplace, VecZnxSwitchRing,
     },
     layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, Scratch},
     source::Source,
@@ -44,12 +44,12 @@ impl<DataSelf: DataMut> GGLWESwitchingKeyCompressed<DataSelf> {
     ) where
         Module<B>: SvpPrepare<B>
             + SvpPPolAllocBytes
-            + VecZnxSwithcDegree
+            + VecZnxSwitchRing
             + VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace
@@ -90,9 +90,9 @@ impl<DataSelf: DataMut> GGLWESwitchingKeyCompressed<DataSelf> {
 
         let n: usize = sk_in.n().max(sk_out.n());
 
-        let (mut sk_in_tmp, scratch1) = scratch.take_scalar_znx(n, sk_in.rank());
+        let (mut sk_in_tmp, scratch_1) = scratch.take_scalar_znx(n, sk_in.rank());
         (0..sk_in.rank()).for_each(|i| {
-            module.vec_znx_switch_degree(
+            module.vec_znx_switch_ring(
                 &mut sk_in_tmp.as_vec_znx_mut(),
                 i,
                 &sk_in.data.as_vec_znx(),
@@ -100,11 +100,11 @@ impl<DataSelf: DataMut> GGLWESwitchingKeyCompressed<DataSelf> {
             );
         });
 
-        let (mut sk_out_tmp, scratch2) = scratch1.take_glwe_secret_prepared(n, sk_out.rank());
+        let (mut sk_out_tmp, scratch_2) = scratch_1.take_glwe_secret_prepared(n, sk_out.rank());
         {
-            let (mut tmp, _) = scratch2.take_scalar_znx(n, 1);
+            let (mut tmp, _) = scratch_2.take_scalar_znx(n, 1);
             (0..sk_out.rank()).for_each(|i| {
-                module.vec_znx_switch_degree(&mut tmp.as_vec_znx_mut(), 0, &sk_out.data.as_vec_znx(), i);
+                module.vec_znx_switch_ring(&mut tmp.as_vec_znx_mut(), 0, &sk_out.data.as_vec_znx(), i);
                 module.svp_prepare(&mut sk_out_tmp.data, i, &tmp, 0);
             });
         }
@@ -115,7 +115,7 @@ impl<DataSelf: DataMut> GGLWESwitchingKeyCompressed<DataSelf> {
             &sk_out_tmp,
             seed_xa,
             source_xe,
-            scratch2,
+            scratch_2,
         );
         self.sk_in_n = sk_in.n();
         self.sk_out_n = sk_out.n();

poulpy-core/src/encryption/compressed/gglwe_tsk.rs

@@ -1,9 +1,9 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, IDFTTmpA, ScratchAvailable, SvpApply, SvpApplyInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
-        TakeScalarZnx, TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace,
-        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace,
-        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VecZnxSwithcDegree,
+        ScratchAvailable, SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx,
+        TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAllocBytes,
+        VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA,
+        VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VecZnxSwitchRing,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch},
     source::Source,
@@ -33,13 +33,13 @@ impl<DataSelf: DataMut> GGLWETensorKeyCompressed<DataSelf> {
         source_xe: &mut Source,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: SvpApply<B>
-            + IDFTTmpA<B>
+        Module<B>: SvpApplyDftToDft<B>
+            + VecZnxIdftApplyTmpA<B>
             + VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace
@@ -48,7 +48,7 @@ impl<DataSelf: DataMut> GGLWETensorKeyCompressed<DataSelf> {
             + VecZnxAddNormal
             + VecZnxNormalize<B>
             + VecZnxSub
-            + VecZnxSwithcDegree
+            + VecZnxSwitchRing
             + VecZnxAddScalarInplace
             + SvpPrepare<B>
             + SvpPPolAllocBytes
@@ -70,39 +70,39 @@ impl<DataSelf: DataMut> GGLWETensorKeyCompressed<DataSelf> {
         let n: usize = sk.n();
         let rank: usize = self.rank();
 
-        let (mut sk_dft_prep, scratch1) = scratch.take_glwe_secret_prepared(n, rank);
-        sk_dft_prep.prepare(module, sk, scratch1);
+        let (mut sk_dft_prep, scratch_1) = scratch.take_glwe_secret_prepared(n, rank);
+        sk_dft_prep.prepare(module, sk, scratch_1);
 
-        let (mut sk_dft, scratch2) = scratch1.take_vec_znx_dft(n, rank, 1);
+        let (mut sk_dft, scratch_2) = scratch_1.take_vec_znx_dft(n, rank, 1);
 
         (0..rank).for_each(|i| {
-            module.dft(1, 0, &mut sk_dft, i, &sk.data.as_vec_znx(), i);
+            module.vec_znx_dft_apply(1, 0, &mut sk_dft, i, &sk.data.as_vec_znx(), i);
         });
 
-        let (mut sk_ij_big, scratch3) = scratch2.take_vec_znx_big(n, 1, 1);
-        let (mut sk_ij, scratch4) = scratch3.take_glwe_secret(n, 1);
-        let (mut sk_ij_dft, scratch5) = scratch4.take_vec_znx_dft(n, 1, 1);
+        let (mut sk_ij_big, scratch_3) = scratch_2.take_vec_znx_big(n, 1, 1);
+        let (mut sk_ij, scratch_4) = scratch_3.take_glwe_secret(n, 1);
+        let (mut sk_ij_dft, scratch_5) = scratch_4.take_vec_znx_dft(n, 1, 1);
 
         let mut source_xa: Source = Source::new(seed_xa);
 
         (0..rank).for_each(|i| {
             (i..rank).for_each(|j| {
-                module.svp_apply(&mut sk_ij_dft, 0, &sk_dft_prep.data, j, &sk_dft, i);
+                module.svp_apply_dft_to_dft(&mut sk_ij_dft, 0, &sk_dft_prep.data, j, &sk_dft, i);
 
-                module.idft_tmp_a(&mut sk_ij_big, 0, &mut sk_ij_dft, 0);
+                module.vec_znx_idft_apply_tmpa(&mut sk_ij_big, 0, &mut sk_ij_dft, 0);
                 module.vec_znx_big_normalize(
                     self.basek(),
                     &mut sk_ij.data.as_vec_znx_mut(),
                     0,
                     &sk_ij_big,
                     0,
-                    scratch5,
+                    scratch_5,
                 );
 
                 let (seed_xa_tmp, _) = source_xa.branch();
 
                 self.at_mut(i, j)
-                    .encrypt_sk(module, &sk_ij, sk, seed_xa_tmp, source_xe, scratch5);
+                    .encrypt_sk(module, &sk_ij, sk, seed_xa_tmp, source_xe, scratch_5);
             });
         })
     }

poulpy-core/src/encryption/compressed/ggsw_ct.rs

@@ -1,8 +1,8 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, SvpApplyInplace, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal,
-        VecZnxAddScalarInplace, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize,
-        VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
+        ScratchAvailable, SvpApplyDftToDftInplace, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal,
+        VecZnxAddScalarInplace, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform,
+        VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
     },
     layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, Scratch, ZnxZero},
     source::Source,
@@ -37,9 +37,9 @@ impl<DataSelf: DataMut> GGSWCiphertextCompressed<DataSelf> {
         Module<B>: VecZnxAddScalarInplace
             + VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace

poulpy-core/src/encryption/compressed/glwe_ct.rs

@@ -1,8 +1,8 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, SvpApplyInplace, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal,
-        VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace,
-        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
+        ScratchAvailable, SvpApplyDftToDftInplace, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal,
+        VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize,
+        VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch},
     source::Source,
@@ -35,9 +35,9 @@ impl<D: DataMut> GLWECiphertextCompressed<D> {
     ) where
         Module<B>: VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace
@@ -63,9 +63,9 @@ impl<D: DataMut> GLWECiphertextCompressed<D> {
     ) where
         Module<B>: VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace

poulpy-core/src/encryption/gglwe_atk.rs

@@ -1,9 +1,9 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, SvpApplyInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx,
-        TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism, VecZnxBigNormalize,
-        VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub,
-        VecZnxSubABInplace, VecZnxSwithcDegree,
+        ScratchAvailable, SvpApplyDftToDftInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx, TakeVecZnxDft,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism, VecZnxBigNormalize, VecZnxDftAllocBytes,
+        VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace,
+        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VecZnxSwitchRing,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch},
     source::Source,
@@ -41,9 +41,9 @@ impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
         Module<B>: VecZnxAddScalarInplace
             + VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace
@@ -53,7 +53,7 @@ impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
             + VecZnxNormalize<B>
             + VecZnxSub
             + SvpPrepare<B>
-            + VecZnxSwithcDegree
+            + VecZnxSwitchRing
             + SvpPPolAllocBytes
             + VecZnxAutomorphism,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx + TakeScalarZnx + TakeGLWESecretPrepared<B>,

poulpy-core/src/encryption/gglwe_ct.rs

@@ -1,8 +1,8 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, SvpApplyInplace, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal,
-        VecZnxAddScalarInplace, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize,
-        VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
+        ScratchAvailable, SvpApplyDftToDftInplace, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal,
+        VecZnxAddScalarInplace, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform,
+        VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
     },
     layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, Scratch, ZnxZero},
     source::Source,
@@ -41,9 +41,9 @@ impl<DataSelf: DataMut> GGLWECiphertext<DataSelf> {
         Module<B>: VecZnxAddScalarInplace
             + VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace

poulpy-core/src/encryption/gglwe_ksk.rs

@@ -1,9 +1,9 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, SvpApplyInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx,
-        TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigNormalize, VecZnxDftAllocBytes,
-        VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
-        VecZnxSwithcDegree,
+        ScratchAvailable, SvpApplyDftToDftInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx, TakeVecZnxDft,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply,
+        VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub,
+        VecZnxSubABInplace, VecZnxSwitchRing,
     },
     layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, Scratch},
     source::Source,
@@ -55,9 +55,9 @@ impl<DataSelf: DataMut> GGLWESwitchingKey<DataSelf> {
         Module<B>: VecZnxAddScalarInplace
             + VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace
@@ -67,7 +67,7 @@ impl<DataSelf: DataMut> GGLWESwitchingKey<DataSelf> {
             + VecZnxNormalize<B>
             + VecZnxSub
             + SvpPrepare<B>
-            + VecZnxSwithcDegree
+            + VecZnxSwitchRing
             + SvpPPolAllocBytes,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx + TakeScalarZnx + TakeGLWESecretPrepared<B>,
     {
@@ -100,9 +100,9 @@ impl<DataSelf: DataMut> GGLWESwitchingKey<DataSelf> {
 
         let n: usize = sk_in.n().max(sk_out.n());
 
-        let (mut sk_in_tmp, scratch1) = scratch.take_scalar_znx(n, sk_in.rank());
+        let (mut sk_in_tmp, scratch_1) = scratch.take_scalar_znx(n, sk_in.rank());
         (0..sk_in.rank()).for_each(|i| {
-            module.vec_znx_switch_degree(
+            module.vec_znx_switch_ring(
                 &mut sk_in_tmp.as_vec_znx_mut(),
                 i,
                 &sk_in.data.as_vec_znx(),
@@ -110,11 +110,11 @@ impl<DataSelf: DataMut> GGLWESwitchingKey<DataSelf> {
             );
         });
 
-        let (mut sk_out_tmp, scratch2) = scratch1.take_glwe_secret_prepared(n, sk_out.rank());
+        let (mut sk_out_tmp, scratch_2) = scratch_1.take_glwe_secret_prepared(n, sk_out.rank());
         {
-            let (mut tmp, _) = scratch2.take_scalar_znx(n, 1);
+            let (mut tmp, _) = scratch_2.take_scalar_znx(n, 1);
             (0..sk_out.rank()).for_each(|i| {
-                module.vec_znx_switch_degree(&mut tmp.as_vec_znx_mut(), 0, &sk_out.data.as_vec_znx(), i);
+                module.vec_znx_switch_ring(&mut tmp.as_vec_znx_mut(), 0, &sk_out.data.as_vec_znx(), i);
                 module.svp_prepare(&mut sk_out_tmp.data, i, &tmp, 0);
             });
         }
@@ -125,7 +125,7 @@ impl<DataSelf: DataMut> GGLWESwitchingKey<DataSelf> {
             &sk_out_tmp,
             source_xa,
             source_xe,
-            scratch2,
+            scratch_2,
         );
         self.sk_in_n = sk_in.n();
         self.sk_out_n = sk_out.n();

poulpy-core/src/encryption/gglwe_tsk.rs

@@ -1,9 +1,9 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, IDFTTmpA, ScratchAvailable, SvpApply, SvpApplyInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx,
-        TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAllocBytes,
-        VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace,
-        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VecZnxSwithcDegree,
+        ScratchAvailable, SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx,
+        TakeVecZnxBig, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAllocBytes,
+        VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA,
+        VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VecZnxSwitchRing,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch},
     source::Source,
@@ -41,14 +41,14 @@ impl<DataSelf: DataMut> GGLWETensorKey<DataSelf> {
         source_xe: &mut Source,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: SvpApply<B>
-            + IDFTTmpA<B>
+        Module<B>: SvpApplyDftToDft<B>
+            + VecZnxIdftApplyTmpA<B>
             + VecZnxAddScalarInplace
             + VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace
@@ -58,7 +58,7 @@ impl<DataSelf: DataMut> GGLWETensorKey<DataSelf> {
             + VecZnxNormalize<B>
             + VecZnxSub
             + SvpPrepare<B>
-            + VecZnxSwithcDegree
+            + VecZnxSwitchRing
             + SvpPPolAllocBytes,
         Scratch<B>:
             TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx + TakeScalarZnx + TakeGLWESecretPrepared<B> + TakeVecZnxBig<B>,
@@ -73,35 +73,35 @@ impl<DataSelf: DataMut> GGLWETensorKey<DataSelf> {
 
         let rank: usize = self.rank();
 
-        let (mut sk_dft_prep, scratch1) = scratch.take_glwe_secret_prepared(n, rank);
-        sk_dft_prep.prepare(module, sk, scratch1);
+        let (mut sk_dft_prep, scratch_1) = scratch.take_glwe_secret_prepared(n, rank);
+        sk_dft_prep.prepare(module, sk, scratch_1);
 
-        let (mut sk_dft, scratch2) = scratch1.take_vec_znx_dft(n, rank, 1);
+        let (mut sk_dft, scratch_2) = scratch_1.take_vec_znx_dft(n, rank, 1);
 
         (0..rank).for_each(|i| {
-            module.dft(1, 0, &mut sk_dft, i, &sk.data.as_vec_znx(), i);
+            module.vec_znx_dft_apply(1, 0, &mut sk_dft, i, &sk.data.as_vec_znx(), i);
         });
 
-        let (mut sk_ij_big, scratch3) = scratch2.take_vec_znx_big(n, 1, 1);
-        let (mut sk_ij, scratch4) = scratch3.take_glwe_secret(n, 1);
-        let (mut sk_ij_dft, scratch5) = scratch4.take_vec_znx_dft(n, 1, 1);
+        let (mut sk_ij_big, scratch_3) = scratch_2.take_vec_znx_big(n, 1, 1);
+        let (mut sk_ij, scratch_4) = scratch_3.take_glwe_secret(n, 1);
+        let (mut sk_ij_dft, scratch_5) = scratch_4.take_vec_znx_dft(n, 1, 1);
 
         (0..rank).for_each(|i| {
             (i..rank).for_each(|j| {
-                module.svp_apply(&mut sk_ij_dft, 0, &sk_dft_prep.data, j, &sk_dft, i);
+                module.svp_apply_dft_to_dft(&mut sk_ij_dft, 0, &sk_dft_prep.data, j, &sk_dft, i);
 
-                module.idft_tmp_a(&mut sk_ij_big, 0, &mut sk_ij_dft, 0);
+                module.vec_znx_idft_apply_tmpa(&mut sk_ij_big, 0, &mut sk_ij_dft, 0);
                 module.vec_znx_big_normalize(
                     self.basek(),
                     &mut sk_ij.data.as_vec_znx_mut(),
                     0,
                     &sk_ij_big,
                     0,
-                    scratch5,
+                    scratch_5,
                 );
 
                 self.at_mut(i, j)
-                    .encrypt_sk(module, &sk_ij, sk, source_xa, source_xe, scratch5);
+                    .encrypt_sk(module, &sk_ij, sk, source_xa, source_xe, scratch_5);
             });
         })
     }

poulpy-core/src/encryption/ggsw_ct.rs

@@ -1,8 +1,8 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, SvpApplyInplace, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal,
-        VecZnxAddScalarInplace, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize,
-        VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
+        ScratchAvailable, SvpApplyDftToDftInplace, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal,
+        VecZnxAddScalarInplace, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform,
+        VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
     },
     layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, Scratch, VecZnx, ZnxZero},
     source::Source,
@@ -40,9 +40,9 @@ impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
         Module<B>: VecZnxAddScalarInplace
             + VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace
@@ -67,14 +67,14 @@ impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
         let rank: usize = self.rank();
         let digits: usize = self.digits();
 
-        let (mut tmp_pt, scratch1) = scratch.take_glwe_pt(self.n(), basek, k);
+        let (mut tmp_pt, scratch_1) = scratch.take_glwe_pt(self.n(), basek, k);
 
         (0..self.rows()).for_each(|row_i| {
             tmp_pt.data.zero();
 
             // Adds the scalar_znx_pt to the i-th limb of the vec_znx_pt
             module.vec_znx_add_scalar_inplace(&mut tmp_pt.data, 0, (digits - 1) + row_i * digits, pt, 0);
-            module.vec_znx_normalize_inplace(basek, &mut tmp_pt.data, 0, scratch1);
+            module.vec_znx_normalize_inplace(basek, &mut tmp_pt.data, 0, scratch_1);
 
             (0..rank + 1).for_each(|col_j| {
                 // rlwe encrypt of vec_znx_pt into vec_znx_ct
@@ -85,7 +85,7 @@ impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
                     sk,
                     source_xa,
                     source_xe,
-                    scratch1,
+                    scratch_1,
                 );
             });
         });

poulpy-core/src/encryption/glwe_ct.rs

@@ -1,9 +1,9 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, SvpApply, SvpApplyInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeSvpPPol,
+        ScratchAvailable, SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeSvpPPol,
         TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal, VecZnxBigAddNormal, VecZnxBigAddSmallInplace,
-        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace,
-        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
+        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume,
+        VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
     },
     layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, Scratch, VecZnx, VecZnxBig, ZnxInfos, ZnxZero},
     source::Source,
@@ -53,9 +53,9 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
     ) where
         Module<B>: VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace
@@ -92,9 +92,9 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
     ) where
         Module<B>: VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace
@@ -138,9 +138,9 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
     ) where
         Module<B>: VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace
@@ -179,8 +179,8 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
         scratch: &mut Scratch<B>,
     ) where
         Module<B>: SvpPrepare<B>
-            + SvpApply<B>
-            + IDFTConsume<B>
+            + SvpApplyDftToDft<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddNormal<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>,
@@ -198,8 +198,8 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
         scratch: &mut Scratch<B>,
     ) where
         Module<B>: SvpPrepare<B>
-            + SvpApply<B>
-            + IDFTConsume<B>
+            + SvpApplyDftToDft<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddNormal<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>,
@@ -226,8 +226,8 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
         scratch: &mut Scratch<B>,
     ) where
         Module<B>: SvpPrepare<B>
-            + SvpApply<B>
-            + IDFTConsume<B>
+            + SvpApplyDftToDft<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddNormal<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>,
@@ -273,10 +273,10 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
         (0..cols).for_each(|i| {
             let (mut ci_dft, scratch_2) = scratch_1.take_vec_znx_dft(self.n(), 1, size_pk);
             // ci_dft = DFT(u) * DFT(pk[i])
-            module.svp_apply(&mut ci_dft, 0, &u_dft, 0, &pk.data, i);
+            module.svp_apply_dft_to_dft(&mut ci_dft, 0, &u_dft, 0, &pk.data, i);
 
             // ci_big = u * p[i]
-            let mut ci_big = module.vec_znx_idft_consume(ci_dft);
+            let mut ci_big = module.vec_znx_idft_apply_consume(ci_dft);
 
             // ci_big = u * pk[i] + e
             module.vec_znx_big_add_normal(basek, &mut ci_big, 0, pk.k(), source_xe, SIGMA, SIGMA_BOUND);
@@ -311,9 +311,9 @@ pub(crate) fn glwe_encrypt_sk_internal<DataCt: DataMut, DataPt: DataRef, DataSk:
 ) where
     Module<B>: VecZnxDftAllocBytes
         + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
         + VecZnxNormalizeTmpBytes
         + VecZnxFillUniform
         + VecZnxSubABInplace
@@ -350,7 +350,7 @@ pub(crate) fn glwe_encrypt_sk_internal<DataCt: DataMut, DataPt: DataRef, DataSk:
             let col_ct: usize = if compressed { 0 } else { i };
 
             // ct[i] = uniform (+ pt)
-            module.vec_znx_fill_uniform(basek, ct, col_ct, k, source_xa);
+            module.vec_znx_fill_uniform(basek, ct, col_ct, source_xa);
 
             let (mut ci_dft, scratch_3) = scratch_2.take_vec_znx_dft(ct.n(), 1, size);
 
@@ -361,16 +361,16 @@ pub(crate) fn glwe_encrypt_sk_internal<DataCt: DataMut, DataPt: DataRef, DataSk:
                 if i == col {
                     module.vec_znx_sub(&mut ci, 0, ct, col_ct, &pt.data, 0);
                     module.vec_znx_normalize_inplace(basek, &mut ci, 0, scratch_3);
-                    module.dft(1, 0, &mut ci_dft, 0, &ci, 0);
+                    module.vec_znx_dft_apply(1, 0, &mut ci_dft, 0, &ci, 0);
                 } else {
-                    module.dft(1, 0, &mut ci_dft, 0, ct, col_ct);
+                    module.vec_znx_dft_apply(1, 0, &mut ci_dft, 0, ct, col_ct);
                 }
             } else {
-                module.dft(1, 0, &mut ci_dft, 0, ct, col_ct);
+                module.vec_znx_dft_apply(1, 0, &mut ci_dft, 0, ct, col_ct);
             }
 
-            module.svp_apply_inplace(&mut ci_dft, 0, &sk.data, i - 1);
-            let ci_big: VecZnxBig<&mut [u8], B> = module.vec_znx_idft_consume(ci_dft);
+            module.svp_apply_dft_to_dft_inplace(&mut ci_dft, 0, &sk.data, i - 1);
+            let ci_big: VecZnxBig<&mut [u8], B> = module.vec_znx_idft_apply_consume(ci_dft);
 
             // use c[0] as buffer, which is overwritten later by the normalization step
             module.vec_znx_big_normalize(basek, &mut ci, 0, &ci_big, 0, scratch_3);

poulpy-core/src/encryption/glwe_pk.rs

@@ -1,7 +1,7 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyInplace, VecZnxAddInplace, VecZnxAddNormal,
-        VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace,
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDftInplace, VecZnxAddInplace, VecZnxAddNormal, VecZnxBigNormalize,
+        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace,
         VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
     },
     layouts::{Backend, DataMut, DataRef, Module, ScratchOwned},
@@ -22,9 +22,9 @@ impl<D: DataMut> GLWEPublicKey<D> {
         Module<B>:,
         Module<B>: VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace

poulpy-core/src/encryption/glwe_to_lwe_ksk.rs

@@ -1,9 +1,9 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, SvpApplyInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx,
-        TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphismInplace, VecZnxBigNormalize,
-        VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub,
-        VecZnxSubABInplace, VecZnxSwithcDegree,
+        ScratchAvailable, SvpApplyDftToDftInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx, TakeVecZnxDft,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphismInplace, VecZnxBigNormalize,
+        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace,
+        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VecZnxSwitchRing,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch, ZnxView, ZnxViewMut, ZnxZero},
     source::Source,
@@ -38,13 +38,13 @@ impl<D: DataMut> GLWEToLWESwitchingKey<D> {
     ) where
         DLwe: DataRef,
         DGlwe: DataRef,
-        Module<B>: VecZnxAutomorphismInplace
+        Module<B>: VecZnxAutomorphismInplace<B>
             + VecZnxAddScalarInplace
             + VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace
@@ -54,7 +54,7 @@ impl<D: DataMut> GLWEToLWESwitchingKey<D> {
             + VecZnxNormalize<B>
             + VecZnxSub
             + SvpPrepare<B>
-            + VecZnxSwithcDegree
+            + VecZnxSwitchRing
             + SvpPPolAllocBytes,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx + TakeScalarZnx + TakeGLWESecretPrepared<B>,
     {
@@ -63,10 +63,10 @@ impl<D: DataMut> GLWEToLWESwitchingKey<D> {
             assert!(sk_lwe.n() <= module.n());
         }
 
-        let (mut sk_lwe_as_glwe, scratch1) = scratch.take_glwe_secret(sk_glwe.n(), 1);
+        let (mut sk_lwe_as_glwe, scratch_1) = scratch.take_glwe_secret(sk_glwe.n(), 1);
         sk_lwe_as_glwe.data.zero();
         sk_lwe_as_glwe.data.at_mut(0, 0)[..sk_lwe.n()].copy_from_slice(sk_lwe.data.at(0, 0));
-        module.vec_znx_automorphism_inplace(-1, &mut sk_lwe_as_glwe.data.as_vec_znx_mut(), 0);
+        module.vec_znx_automorphism_inplace(-1, &mut sk_lwe_as_glwe.data.as_vec_znx_mut(), 0, scratch_1);
 
         self.0.encrypt_sk(
             module,
@@ -74,7 +74,7 @@ impl<D: DataMut> GLWEToLWESwitchingKey<D> {
             &sk_lwe_as_glwe,
             source_xa,
             source_xe,
-            scratch1,
+            scratch_1,
         );
     }
 }

poulpy-core/src/encryption/lwe_ct.rs

@@ -32,7 +32,7 @@ impl<DataSelf: DataMut> LWECiphertext<DataSelf> {
         let basek: usize = self.basek();
         let k: usize = self.k();
 
-        module.zn_fill_uniform(self.n() + 1, basek, &mut self.data, 0, k, source_xa);
+        module.zn_fill_uniform(self.n() + 1, basek, &mut self.data, 0, source_xa);
 
         let mut tmp_znx: Zn<Vec<u8>> = Zn::alloc(1, 1, self.size());
 

poulpy-core/src/encryption/lwe_ksk.rs

@@ -1,9 +1,9 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, SvpApplyInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx,
-        TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphismInplace, VecZnxBigNormalize,
-        VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub,
-        VecZnxSubABInplace, VecZnxSwithcDegree,
+        ScratchAvailable, SvpApplyDftToDftInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx, TakeVecZnxDft,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphismInplace, VecZnxBigNormalize,
+        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace,
+        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VecZnxSwitchRing,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch, ZnxView, ZnxViewMut},
     source::Source,
@@ -38,13 +38,13 @@ impl<D: DataMut> LWESwitchingKey<D> {
     ) where
         DIn: DataRef,
         DOut: DataRef,
-        Module<B>: VecZnxAutomorphismInplace
+        Module<B>: VecZnxAutomorphismInplace<B>
             + VecZnxAddScalarInplace
             + VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace
@@ -54,7 +54,7 @@ impl<D: DataMut> LWESwitchingKey<D> {
             + VecZnxNormalize<B>
             + VecZnxSub
             + SvpPrepare<B>
-            + VecZnxSwithcDegree
+            + VecZnxSwitchRing
             + SvpPPolAllocBytes,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx + TakeScalarZnx + TakeGLWESecretPrepared<B>,
     {
@@ -65,16 +65,16 @@ impl<D: DataMut> LWESwitchingKey<D> {
             assert!(self.n() <= module.n());
         }
 
-        let (mut sk_in_glwe, scratch1) = scratch.take_glwe_secret(self.n(), 1);
-        let (mut sk_out_glwe, scratch2) = scratch1.take_glwe_secret(self.n(), 1);
+        let (mut sk_in_glwe, scratch_1) = scratch.take_glwe_secret(self.n(), 1);
+        let (mut sk_out_glwe, scratch_2) = scratch_1.take_glwe_secret(self.n(), 1);
 
         sk_out_glwe.data.at_mut(0, 0)[..sk_lwe_out.n()].copy_from_slice(sk_lwe_out.data.at(0, 0));
         sk_out_glwe.data.at_mut(0, 0)[sk_lwe_out.n()..].fill(0);
-        module.vec_znx_automorphism_inplace(-1, &mut sk_out_glwe.data.as_vec_znx_mut(), 0);
+        module.vec_znx_automorphism_inplace(-1, &mut sk_out_glwe.data.as_vec_znx_mut(), 0, scratch_2);
 
         sk_in_glwe.data.at_mut(0, 0)[..sk_lwe_in.n()].copy_from_slice(sk_lwe_in.data.at(0, 0));
         sk_in_glwe.data.at_mut(0, 0)[sk_lwe_in.n()..].fill(0);
-        module.vec_znx_automorphism_inplace(-1, &mut sk_in_glwe.data.as_vec_znx_mut(), 0);
+        module.vec_znx_automorphism_inplace(-1, &mut sk_in_glwe.data.as_vec_znx_mut(), 0, scratch_2);
 
         self.0.encrypt_sk(
             module,
@@ -82,7 +82,7 @@ impl<D: DataMut> LWESwitchingKey<D> {
             &sk_out_glwe,
             source_xa,
             source_xe,
-            scratch2,
+            scratch_2,
         );
     }
 }

poulpy-core/src/encryption/lwe_to_glwe_ksk.rs

@@ -1,9 +1,9 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, SvpApplyInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx,
-        TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphismInplace, VecZnxBigNormalize,
-        VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub,
-        VecZnxSubABInplace, VecZnxSwithcDegree,
+        ScratchAvailable, SvpApplyDftToDftInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx, TakeVecZnxDft,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphismInplace, VecZnxBigNormalize,
+        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace,
+        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VecZnxSwitchRing,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch, ZnxView, ZnxViewMut},
     source::Source,
@@ -36,13 +36,13 @@ impl<D: DataMut> LWEToGLWESwitchingKey<D> {
     ) where
         DLwe: DataRef,
         DGlwe: DataRef,
-        Module<B>: VecZnxAutomorphismInplace
+        Module<B>: VecZnxAutomorphismInplace<B>
             + VecZnxAddScalarInplace
             + VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace
@@ -52,7 +52,7 @@ impl<D: DataMut> LWEToGLWESwitchingKey<D> {
             + VecZnxNormalize<B>
             + VecZnxSub
             + SvpPrepare<B>
-            + VecZnxSwithcDegree
+            + VecZnxSwitchRing
             + SvpPPolAllocBytes,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx + TakeScalarZnx + TakeGLWESecretPrepared<B>,
     {
@@ -61,10 +61,10 @@ impl<D: DataMut> LWEToGLWESwitchingKey<D> {
             assert!(sk_lwe.n() <= module.n());
         }
 
-        let (mut sk_lwe_as_glwe, scratch1) = scratch.take_glwe_secret(sk_glwe.n(), 1);
+        let (mut sk_lwe_as_glwe, scratch_1) = scratch.take_glwe_secret(sk_glwe.n(), 1);
         sk_lwe_as_glwe.data.at_mut(0, 0)[..sk_lwe.n()].copy_from_slice(sk_lwe.data.at(0, 0));
         sk_lwe_as_glwe.data.at_mut(0, 0)[sk_lwe.n()..].fill(0);
-        module.vec_znx_automorphism_inplace(-1, &mut sk_lwe_as_glwe.data.as_vec_znx_mut(), 0);
+        module.vec_znx_automorphism_inplace(-1, &mut sk_lwe_as_glwe.data.as_vec_znx_mut(), 0, scratch_1);
 
         self.0.encrypt_sk(
             module,
@@ -72,7 +72,7 @@ impl<D: DataMut> LWEToGLWESwitchingKey<D> {
             sk_glwe,
             source_xa,
             source_xe,
-            scratch1,
+            scratch_1,
         );
     }
 }

poulpy-core/src/external_product/gglwe_atk.rs

@@ -1,7 +1,7 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, TakeVecZnxDft, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxNormalizeTmpBytes,
-        VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+        ScratchAvailable, TakeVecZnxDft, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume,
+        VecZnxNormalizeTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch},
 };
@@ -51,10 +51,10 @@ impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
         Module<B>: VecZnxDftAllocBytes
             + VmpApplyDftToDftTmpBytes
             + VecZnxNormalizeTmpBytes
-            + DFT<B>
+            + VecZnxDftApply<B>
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + IDFTConsume<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigNormalize<B>,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable,
     {
@@ -70,10 +70,10 @@ impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
         Module<B>: VecZnxDftAllocBytes
             + VmpApplyDftToDftTmpBytes
             + VecZnxNormalizeTmpBytes
-            + DFT<B>
+            + VecZnxDftApply<B>
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + IDFTConsume<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigNormalize<B>,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable,
     {

poulpy-core/src/external_product/gglwe_ksk.rs

@@ -1,7 +1,7 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, TakeVecZnxDft, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxNormalizeTmpBytes,
-        VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+        ScratchAvailable, TakeVecZnxDft, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume,
+        VecZnxNormalizeTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch, ZnxZero},
 };
@@ -51,10 +51,10 @@ impl<DataSelf: DataMut> GGLWESwitchingKey<DataSelf> {
         Module<B>: VecZnxDftAllocBytes
             + VmpApplyDftToDftTmpBytes
             + VecZnxNormalizeTmpBytes
-            + DFT<B>
+            + VecZnxDftApply<B>
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + IDFTConsume<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigNormalize<B>,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable,
     {
@@ -106,10 +106,10 @@ impl<DataSelf: DataMut> GGLWESwitchingKey<DataSelf> {
         Module<B>: VecZnxDftAllocBytes
             + VmpApplyDftToDftTmpBytes
             + VecZnxNormalizeTmpBytes
-            + DFT<B>
+            + VecZnxDftApply<B>
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + IDFTConsume<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigNormalize<B>,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable,
     {

poulpy-core/src/external_product/ggsw_ct.rs

@@ -1,7 +1,7 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, TakeVecZnxDft, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxNormalizeTmpBytes,
-        VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+        ScratchAvailable, TakeVecZnxDft, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume,
+        VecZnxNormalizeTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch, ZnxZero},
 };
@@ -51,10 +51,10 @@ impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
         Module<B>: VecZnxDftAllocBytes
             + VmpApplyDftToDftTmpBytes
             + VecZnxNormalizeTmpBytes
-            + DFT<B>
+            + VecZnxDftApply<B>
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + IDFTConsume<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigNormalize<B>,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable,
     {
@@ -116,10 +116,10 @@ impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
         Module<B>: VecZnxDftAllocBytes
             + VmpApplyDftToDftTmpBytes
             + VecZnxNormalizeTmpBytes
-            + DFT<B>
+            + VecZnxDftApply<B>
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + IDFTConsume<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigNormalize<B>,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable,
     {

poulpy-core/src/external_product/glwe_ct.rs

@@ -1,7 +1,7 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, TakeVecZnxDft, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxNormalizeTmpBytes,
-        VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+        ScratchAvailable, TakeVecZnxDft, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume,
+        VecZnxNormalizeTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, DataViewMut, Module, Scratch, VecZnxBig},
 };
@@ -65,10 +65,10 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
         Module<B>: VecZnxDftAllocBytes
             + VmpApplyDftToDftTmpBytes
             + VecZnxNormalizeTmpBytes
-            + DFT<B>
+            + VecZnxDftApply<B>
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + IDFTConsume<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigNormalize<B>,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable,
     {
@@ -101,8 +101,8 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
         let cols: usize = rhs.rank() + 1;
         let digits: usize = rhs.digits();
 
-        let (mut res_dft, scratch1) = scratch.take_vec_znx_dft(self.n(), cols, rhs.size()); // Todo optimise
-        let (mut a_dft, scratch2) = scratch1.take_vec_znx_dft(self.n(), cols, lhs.size().div_ceil(digits));
+        let (mut res_dft, scratch_1) = scratch.take_vec_znx_dft(self.n(), cols, rhs.size()); // Todo optimise
+        let (mut a_dft, scratch_2) = scratch_1.take_vec_znx_dft(self.n(), cols, lhs.size().div_ceil(digits));
 
         a_dft.data_mut().fill(0);
 
@@ -121,21 +121,21 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
                 res_dft.set_size(rhs.size() - ((digits - di) as isize - 2).max(0) as usize);
 
                 (0..cols).for_each(|col_i| {
-                    module.dft(digits, digits - 1 - di, &mut a_dft, col_i, &lhs.data, col_i);
+                    module.vec_znx_dft_apply(digits, digits - 1 - di, &mut a_dft, col_i, &lhs.data, col_i);
                 });
 
                 if di == 0 {
-                    module.vmp_apply_dft_to_dft(&mut res_dft, &a_dft, &rhs.data, scratch2);
+                    module.vmp_apply_dft_to_dft(&mut res_dft, &a_dft, &rhs.data, scratch_2);
                 } else {
-                    module.vmp_apply_dft_to_dft_add(&mut res_dft, &a_dft, &rhs.data, di, scratch2);
+                    module.vmp_apply_dft_to_dft_add(&mut res_dft, &a_dft, &rhs.data, di, scratch_2);
                 }
             });
         }
 
-        let res_big: VecZnxBig<&mut [u8], B> = module.vec_znx_idft_consume(res_dft);
+        let res_big: VecZnxBig<&mut [u8], B> = module.vec_znx_idft_apply_consume(res_dft);
 
         (0..cols).for_each(|i| {
-            module.vec_znx_big_normalize(basek, &mut self.data, i, &res_big, i, scratch1);
+            module.vec_znx_big_normalize(basek, &mut self.data, i, &res_big, i, scratch_1);
         });
     }
 
@@ -148,16 +148,81 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
         Module<B>: VecZnxDftAllocBytes
             + VmpApplyDftToDftTmpBytes
             + VecZnxNormalizeTmpBytes
-            + DFT<B>
+            + VecZnxDftApply<B>
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + IDFTConsume<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigNormalize<B>,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable,
     {
-        unsafe {
-            let self_ptr: *mut GLWECiphertext<DataSelf> = self as *mut GLWECiphertext<DataSelf>;
-            self.external_product(module, &*self_ptr, rhs, scratch);
+        let basek: usize = self.basek();
+
+        #[cfg(debug_assertions)]
+        {
+            use poulpy_hal::api::ScratchAvailable;
+
+            assert_eq!(rhs.rank(), self.rank());
+            assert_eq!(self.basek(), basek);
+            assert_eq!(rhs.n(), self.n());
+            assert!(
+                scratch.available()
+                    >= GLWECiphertext::external_product_scratch_space(
+                        module,
+                        self.basek(),
+                        self.k(),
+                        self.k(),
+                        rhs.k(),
+                        rhs.digits(),
+                        rhs.rank(),
+                    )
+            );
         }
+
+        let cols: usize = rhs.rank() + 1;
+        let digits: usize = rhs.digits();
+
+        let (mut res_dft, scratch_1) = scratch.take_vec_znx_dft(self.n(), cols, rhs.size()); // Todo optimise
+        let (mut a_dft, scratch_2) = scratch_1.take_vec_znx_dft(self.n(), cols, self.size().div_ceil(digits));
+
+        a_dft.data_mut().fill(0);
+
+        {
+            (0..digits).for_each(|di| {
+                // (lhs.size() + di) / digits = (a - (digit - di - 1)).div_ceil(digits)
+                a_dft.set_size((self.size() + di) / digits);
+
+                // Small optimization for digits > 2
+                // VMP produce some error e, and since we aggregate vmp * 2^{di * B}, then
+                // we also aggregate ei * 2^{di * B}, with the largest error being ei * 2^{(digits-1) * B}.
+                // As such we can ignore the last digits-2 limbs safely of the sum of vmp products.
+                // It is possible to further ignore the last digits-1 limbs, but this introduce
+                // ~0.5 to 1 bit of additional noise, and thus not chosen here to ensure that the same
+                // noise is kept with respect to the ideal functionality.
+                res_dft.set_size(rhs.size() - ((digits - di) as isize - 2).max(0) as usize);
+
+                (0..cols).for_each(|col_i| {
+                    module.vec_znx_dft_apply(
+                        digits,
+                        digits - 1 - di,
+                        &mut a_dft,
+                        col_i,
+                        &self.data,
+                        col_i,
+                    );
+                });
+
+                if di == 0 {
+                    module.vmp_apply_dft_to_dft(&mut res_dft, &a_dft, &rhs.data, scratch_2);
+                } else {
+                    module.vmp_apply_dft_to_dft_add(&mut res_dft, &a_dft, &rhs.data, di, scratch_2);
+                }
+            });
+        }
+
+        let res_big: VecZnxBig<&mut [u8], B> = module.vec_znx_idft_apply_consume(res_dft);
+
+        (0..cols).for_each(|i| {
+            module.vec_znx_big_normalize(basek, &mut self.data, i, &res_big, i, scratch_1);
+        });
     }
 }

poulpy-core/src/glwe_packing.rs

@@ -2,9 +2,9 @@ use std::collections::HashMap;
 
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAutomorphismInplace,
-        VecZnxBigAddSmallInplace, VecZnxBigAutomorphismInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
-        VecZnxBigSubSmallBInplace, VecZnxCopy, VecZnxDftAllocBytes, VecZnxNegateInplace, VecZnxNormalizeInplace, VecZnxRotate,
+        ScratchAvailable, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAutomorphismInplace, VecZnxBigAddSmallInplace,
+        VecZnxBigAutomorphismInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxBigSubSmallBInplace, VecZnxCopy,
+        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume, VecZnxNegateInplace, VecZnxNormalizeInplace, VecZnxRotate,
         VecZnxRotateInplace, VecZnxRshInplace, VecZnxSub, VecZnxSubABInplace, VmpApplyDftToDft, VmpApplyDftToDftAdd,
         VmpApplyDftToDftTmpBytes,
     },
@@ -126,20 +126,20 @@ impl GLWEPacker {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
             + VecZnxCopy
-            + VecZnxRotateInplace
+            + VecZnxRotateInplace<B>
             + VecZnxSub
             + VecZnxNegateInplace
-            + VecZnxRshInplace
+            + VecZnxRshInplace<B>
             + VecZnxAddInplace
             + VecZnxNormalizeInplace<B>
             + VecZnxSubABInplace
             + VecZnxRotate
-            + VecZnxAutomorphismInplace
+            + VecZnxAutomorphismInplace<B>
             + VecZnxBigSubSmallBInplace<B>
             + VecZnxBigAutomorphismInplace<B>,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
@@ -204,20 +204,20 @@ fn pack_core<D: DataRef, DataAK: DataRef, B: Backend>(
         + VecZnxBigNormalizeTmpBytes
         + VmpApplyDftToDft<B>
         + VmpApplyDftToDftAdd<B>
-        + DFT<B>
-        + IDFTConsume<B>
+        + VecZnxDftApply<B>
+        + VecZnxIdftApplyConsume<B>
         + VecZnxBigAddSmallInplace<B>
         + VecZnxBigNormalize<B>
         + VecZnxCopy
-        + VecZnxRotateInplace
+        + VecZnxRotateInplace<B>
         + VecZnxSub
         + VecZnxNegateInplace
-        + VecZnxRshInplace
+        + VecZnxRshInplace<B>
         + VecZnxAddInplace
         + VecZnxNormalizeInplace<B>
         + VecZnxSubABInplace
         + VecZnxRotate
-        + VecZnxAutomorphismInplace
+        + VecZnxAutomorphismInplace<B>
         + VecZnxBigSubSmallBInplace<B>
         + VecZnxBigAutomorphismInplace<B>,
     Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
@@ -301,20 +301,20 @@ fn combine<D: DataRef, DataAK: DataRef, B: Backend>(
         + VecZnxBigNormalizeTmpBytes
         + VmpApplyDftToDft<B>
         + VmpApplyDftToDftAdd<B>
-        + DFT<B>
-        + IDFTConsume<B>
+        + VecZnxDftApply<B>
+        + VecZnxIdftApplyConsume<B>
         + VecZnxBigAddSmallInplace<B>
         + VecZnxBigNormalize<B>
         + VecZnxCopy
-        + VecZnxRotateInplace
+        + VecZnxRotateInplace<B>
         + VecZnxSub
         + VecZnxNegateInplace
-        + VecZnxRshInplace
+        + VecZnxRshInplace<B>
         + VecZnxAddInplace
         + VecZnxNormalizeInplace<B>
         + VecZnxSubABInplace
         + VecZnxRotate
-        + VecZnxAutomorphismInplace
+        + VecZnxAutomorphismInplace<B>
         + VecZnxBigSubSmallBInplace<B>
         + VecZnxBigAutomorphismInplace<B>,
     Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
@@ -349,15 +349,15 @@ fn combine<D: DataRef, DataAK: DataRef, B: Backend>(
             let (mut tmp_b, scratch_1) = scratch.take_glwe_ct(n, basek, k, rank);
 
             // a = a * X^-t
-            a.rotate_inplace(module, -t);
+            a.rotate_inplace(module, -t, scratch_1);
 
             // tmp_b = a * X^-t - b
             tmp_b.sub(module, a, b);
-            tmp_b.rsh(module, 1);
+            tmp_b.rsh(module, 1, scratch_1);
 
             // a = a * X^-t + b
             a.add_inplace(module, b);
-            a.rsh(module, 1);
+            a.rsh(module, 1, scratch_1);
 
             tmp_b.normalize_inplace(module, scratch_1);
 
@@ -375,9 +375,9 @@ fn combine<D: DataRef, DataAK: DataRef, B: Backend>(
             // a = a + b * X^t - phi(a * X^-t - b) * X^t
             //   = a + b * X^t - phi(a * X^-t - b) * - phi(X^t)
             //   = a + b * X^t + phi(a - b * X^t)
-            a.rotate_inplace(module, t);
+            a.rotate_inplace(module, t, scratch_1);
         } else {
-            a.rsh(module, 1);
+            a.rsh(module, 1, scratch);
             // a = a + phi(a)
             if let Some(key) = auto_keys.get(&gal_el) {
                 a.automorphism_add_inplace(module, key, scratch);
@@ -388,7 +388,7 @@ fn combine<D: DataRef, DataAK: DataRef, B: Backend>(
     } else if let Some(b) = b {
         let (mut tmp_b, scratch_1) = scratch.take_glwe_ct(n, basek, k, rank);
         tmp_b.rotate(module, 1 << (log_n - i - 1), b);
-        tmp_b.rsh(module, 1);
+        tmp_b.rsh(module, 1, scratch_1);
 
         // a = (b* X^t - phi(b* X^t))
         if let Some(key) = auto_keys.get(&gal_el) {

poulpy-core/src/glwe_trace.rs

@@ -2,9 +2,9 @@ use std::collections::HashMap;
 
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, TakeVecZnxDft, VecZnxBigAddSmallInplace, VecZnxBigAutomorphismInplace,
-        VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxCopy, VecZnxDftAllocBytes, VecZnxRshInplace, VmpApplyDftToDft,
-        VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+        ScratchAvailable, TakeVecZnxDft, VecZnxBigAddSmallInplace, VecZnxBigAutomorphismInplace, VecZnxBigNormalize,
+        VecZnxBigNormalizeTmpBytes, VecZnxCopy, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume, VecZnxRshInplace,
+        VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch},
 };
@@ -73,12 +73,12 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
             + VecZnxBigAutomorphismInplace<B>
-            + VecZnxRshInplace
+            + VecZnxRshInplace<B>
             + VecZnxCopy,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable,
     {
@@ -99,16 +99,16 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
             + VecZnxBigAutomorphismInplace<B>
-            + VecZnxRshInplace,
+            + VecZnxRshInplace<B>,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable,
     {
         (start..end).for_each(|i| {
-            self.rsh(module, 1);
+            self.rsh(module, 1, scratch);
 
             let p: i64 = if i == 0 {
                 -1

poulpy-core/src/keyswitching/gglwe_ct.rs

@@ -1,7 +1,8 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, TakeVecZnxDft, VecZnxBigAddSmallInplace, VecZnxBigNormalize,
-        VecZnxBigNormalizeTmpBytes, VecZnxDftAllocBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+        ScratchAvailable, TakeVecZnxDft, VecZnxBigAddSmallInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
+        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume, VmpApplyDftToDft, VmpApplyDftToDftAdd,
+        VmpApplyDftToDftTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch, ZnxZero},
 };
@@ -56,8 +57,8 @@ impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable,
@@ -76,8 +77,8 @@ impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable,
@@ -132,8 +133,8 @@ impl<DataSelf: DataMut> GGLWESwitchingKey<DataSelf> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>,
         Scratch<B>: ScratchAvailable + TakeVecZnxDft<B>,
@@ -161,6 +162,12 @@ impl<DataSelf: DataMut> GGLWESwitchingKey<DataSelf> {
                 self.rank_out(),
                 rhs.rank_out()
             );
+            assert!(
+                self.rows() <= lhs.rows(),
+                "self.rows()={} > lhs.rows()={}",
+                self.rows(),
+                lhs.rows()
+            );
         }
 
         (0..self.rank_in()).for_each(|col_i| {
@@ -188,8 +195,8 @@ impl<DataSelf: DataMut> GGLWESwitchingKey<DataSelf> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>,
         Scratch<B>: ScratchAvailable + TakeVecZnxDft<B>,

poulpy-core/src/keyswitching/ggsw_ct.rs

@@ -1,8 +1,8 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, IDFTTmpA, ScratchAvailable, TakeVecZnxBig, TakeVecZnxDft, VecZnxBigAddSmallInplace,
-        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxCopy, VecZnxDftAddInplace,
-        VecZnxDftAllocBytes, VecZnxDftCopy, VecZnxNormalizeTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd,
+        ScratchAvailable, TakeVecZnxBig, TakeVecZnxDft, VecZnxBigAddSmallInplace, VecZnxBigAllocBytes, VecZnxBigNormalize,
+        VecZnxBigNormalizeTmpBytes, VecZnxCopy, VecZnxDftAddInplace, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxDftCopy,
+        VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA, VecZnxNormalizeTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd,
         VmpApplyDftToDftTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch, VecZnx, VmpPMat, ZnxInfos},
@@ -114,13 +114,13 @@ impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
             + VmpApplyDftToDftTmpBytes
             + VecZnxBigAllocBytes
             + VecZnxNormalizeTmpBytes
-            + DFT<B>
+            + VecZnxDftApply<B>
             + VecZnxDftCopy<B>
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
             + VecZnxDftAddInplace<B>
             + VecZnxBigNormalize<B>
-            + IDFTTmpA<B>,
+            + VecZnxIdftApplyTmpA<B>,
         Scratch<B>: ScratchAvailable + TakeVecZnxDft<B> + TakeVecZnxBig<B>,
     {
         #[cfg(debug_assertions)]
@@ -150,8 +150,8 @@ impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
             + VecZnxDftAllocBytes
@@ -159,10 +159,15 @@ impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
             + VecZnxNormalizeTmpBytes
             + VecZnxDftCopy<B>
             + VecZnxDftAddInplace<B>
-            + IDFTTmpA<B>,
+            + VecZnxIdftApplyTmpA<B>,
         Scratch<B>: ScratchAvailable + TakeVecZnxDft<B> + TakeVecZnxBig<B>,
     {
-        self.keyswitch_internal(module, lhs, ksk, scratch);
+        (0..lhs.rows()).for_each(|row_i| {
+            // Key-switch column 0, i.e.
+            // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0, a1, a2) -> (-(a0s0' + a1s1' + a2s2') + M[i], a0, a1, a2)
+            self.at_mut(row_i, 0)
+                .keyswitch(module, &lhs.at(row_i, 0), ksk, scratch);
+        });
         self.expand_row(module, tsk, scratch);
     }
 
@@ -178,8 +183,8 @@ impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
             + VecZnxDftAllocBytes
@@ -187,13 +192,16 @@ impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
             + VecZnxNormalizeTmpBytes
             + VecZnxDftCopy<B>
             + VecZnxDftAddInplace<B>
-            + IDFTTmpA<B>,
+            + VecZnxIdftApplyTmpA<B>,
         Scratch<B>: ScratchAvailable + TakeVecZnxDft<B> + TakeVecZnxBig<B>,
     {
-        unsafe {
-            let self_ptr: *mut GGSWCiphertext<DataSelf> = self as *mut GGSWCiphertext<DataSelf>;
-            self.keyswitch(module, &*self_ptr, ksk, tsk, scratch);
-        }
+        (0..self.rows()).for_each(|row_i| {
+            // Key-switch column 0, i.e.
+            // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0, a1, a2) -> (-(a0s0' + a1s1' + a2s2') + M[i], a0, a1, a2)
+            self.at_mut(row_i, 0)
+                .keyswitch_inplace(module, ksk, scratch);
+        });
+        self.expand_row(module, tsk, scratch);
     }
 
     pub fn expand_row<DataTsk: DataRef, B: Backend>(
@@ -206,13 +214,13 @@ impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
             + VmpApplyDftToDftTmpBytes
             + VecZnxBigAllocBytes
             + VecZnxNormalizeTmpBytes
-            + DFT<B>
+            + VecZnxDftApply<B>
             + VecZnxDftCopy<B>
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
             + VecZnxDftAddInplace<B>
             + VecZnxBigNormalize<B>
-            + IDFTTmpA<B>,
+            + VecZnxIdftApplyTmpA<B>,
         Scratch<B>: ScratchAvailable + TakeVecZnxDft<B> + TakeVecZnxBig<B>,
     {
         assert!(
@@ -234,9 +242,9 @@ impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
         // Keyswitch the j-th row of the col 0
         (0..self.rows()).for_each(|row_i| {
             // Pre-compute DFT of (a0, a1, a2)
-            let (mut ci_dft, scratch1) = scratch.take_vec_znx_dft(n, cols, self.size());
+            let (mut ci_dft, scratch_1) = scratch.take_vec_znx_dft(n, cols, self.size());
             (0..cols).for_each(|i| {
-                module.dft(1, 0, &mut ci_dft, i, &self.at(row_i, 0).data, i);
+                module.vec_znx_dft_apply(1, 0, &mut ci_dft, i, &self.at(row_i, 0).data, i);
             });
 
             (1..cols).for_each(|col_j| {
@@ -262,8 +270,8 @@ impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
 
                 let digits: usize = tsk.digits();
 
-                let (mut tmp_dft_i, scratch2) = scratch1.take_vec_znx_dft(n, cols, tsk.size());
-                let (mut tmp_a, scratch3) = scratch2.take_vec_znx_dft(n, 1, ci_dft.size().div_ceil(digits));
+                let (mut tmp_dft_i, scratch_2) = scratch_1.take_vec_znx_dft(n, cols, tsk.size());
+                let (mut tmp_a, scratch_3) = scratch_2.take_vec_znx_dft(n, 1, ci_dft.size().div_ceil(digits));
 
                 {
                     // Performs a key-switch for each combination of s[i]*s[j], i.e. for a0, a1, a2
@@ -295,9 +303,9 @@ impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
 
                             module.vec_znx_dft_copy(digits, digits - 1 - di, &mut tmp_a, 0, &ci_dft, col_i);
                             if di == 0 && col_i == 1 {
-                                module.vmp_apply_dft_to_dft(&mut tmp_dft_i, &tmp_a, pmat, scratch3);
+                                module.vmp_apply_dft_to_dft(&mut tmp_dft_i, &tmp_a, pmat, scratch_3);
                             } else {
-                                module.vmp_apply_dft_to_dft_add(&mut tmp_dft_i, &tmp_a, pmat, di, scratch3);
+                                module.vmp_apply_dft_to_dft_add(&mut tmp_dft_i, &tmp_a, pmat, di, scratch_3);
                             }
                         });
                     });
@@ -313,46 +321,19 @@ impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
                 // =
                 // (-(x0s0 + x1s1 + x2s2), x0 + M[i], x1, x2)
                 module.vec_znx_dft_add_inplace(&mut tmp_dft_i, col_j, &ci_dft, 0);
-                let (mut tmp_idft, scratch3) = scratch2.take_vec_znx_big(n, 1, tsk.size());
+                let (mut tmp_idft, scratch_3) = scratch_2.take_vec_znx_big(n, 1, tsk.size());
                 (0..cols).for_each(|i| {
-                    module.idft_tmp_a(&mut tmp_idft, 0, &mut tmp_dft_i, i);
+                    module.vec_znx_idft_apply_tmpa(&mut tmp_idft, 0, &mut tmp_dft_i, i);
                     module.vec_znx_big_normalize(
                         self.basek(),
                         &mut self.at_mut(row_i, col_j).data,
                         i,
                         &tmp_idft,
                         0,
-                        scratch3,
+                        scratch_3,
                     );
                 });
             })
         })
     }
-
-    fn keyswitch_internal<DataLhs: DataRef, DataKsk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        lhs: &GGSWCiphertext<DataLhs>,
-        ksk: &GGLWESwitchingKeyPrepared<DataKsk, B>,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxBigNormalizeTmpBytes
-            + VmpApplyDftToDft<B>
-            + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
-            + VecZnxBigAddSmallInplace<B>
-            + VecZnxBigNormalize<B>,
-        Scratch<B>: ScratchAvailable + TakeVecZnxDft<B>,
-    {
-        // Keyswitch the j-th row of the col 0
-        (0..lhs.rows()).for_each(|row_i| {
-            // Key-switch column 0, i.e.
-            // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0, a1, a2) -> (-(a0s0' + a1s1' + a2s2') + M[i], a0, a1, a2)
-            self.at_mut(row_i, 0)
-                .keyswitch(module, &lhs.at(row_i, 0), ksk, scratch);
-        })
-    }
 }

poulpy-core/src/keyswitching/glwe_ct.rs

@@ -1,7 +1,8 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, TakeVecZnxDft, VecZnxBigAddSmallInplace, VecZnxBigNormalize,
-        VecZnxBigNormalizeTmpBytes, VecZnxDftAllocBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+        ScratchAvailable, TakeVecZnxDft, VecZnxBigAddSmallInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
+        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume, VmpApplyDftToDft, VmpApplyDftToDftAdd,
+        VmpApplyDftToDftTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, DataViewMut, Module, Scratch, VecZnx, VecZnxBig, VecZnxDft, VmpPMat, ZnxInfos},
 };
@@ -117,6 +118,63 @@ impl<DataSelf: DataRef> GLWECiphertext<DataSelf> {
             )
         );
     }
+
+    #[allow(dead_code)]
+    pub(crate) fn assert_keyswitch_inplace<B: Backend, DataRhs>(
+        &self,
+        module: &Module<B>,
+        rhs: &GGLWESwitchingKeyPrepared<DataRhs, B>,
+        scratch: &Scratch<B>,
+    ) where
+        DataRhs: DataRef,
+        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes,
+        Scratch<B>: ScratchAvailable,
+    {
+        let basek: usize = self.basek();
+        assert_eq!(
+            self.rank(),
+            rhs.rank_out(),
+            "self.rank(): {} != rhs.rank_out(): {}",
+            self.rank(),
+            rhs.rank_out()
+        );
+        assert_eq!(self.basek(), basek);
+        assert_eq!(rhs.n(), self.n());
+        assert!(
+            scratch.available()
+                >= GLWECiphertext::keyswitch_scratch_space(
+                    module,
+                    self.basek(),
+                    self.k(),
+                    self.k(),
+                    rhs.k(),
+                    rhs.digits(),
+                    rhs.rank_in(),
+                    rhs.rank_out(),
+                ),
+            "scratch.available()={} < GLWECiphertext::keyswitch_scratch_space(
+                    module,
+                    self.basek(),
+                    self.k(),
+                    self.k(),
+                    rhs.k(),
+                    rhs.digits(),
+                    rhs.rank_in(),
+                    rhs.rank_out(),
+                )={}",
+            scratch.available(),
+            GLWECiphertext::keyswitch_scratch_space(
+                module,
+                self.basek(),
+                self.k(),
+                self.k(),
+                rhs.k(),
+                rhs.digits(),
+                rhs.rank_in(),
+                rhs.rank_out(),
+            )
+        );
+    }
 }
 
 impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
@@ -130,11 +188,10 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
         Module<B>: VecZnxDftAllocBytes
             + VmpApplyDftToDftTmpBytes
             + VecZnxBigNormalizeTmpBytes
-            + VmpApplyDftToDftTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>,
         Scratch<B>: ScratchAvailable + TakeVecZnxDft<B>,
@@ -143,10 +200,10 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
         {
             self.assert_keyswitch(module, lhs, rhs, scratch);
         }
-        let (res_dft, scratch1) = scratch.take_vec_znx_dft(self.n(), self.cols(), rhs.size()); // Todo optimise
-        let res_big: VecZnxBig<_, B> = lhs.keyswitch_internal(module, res_dft, rhs, scratch1);
+        let (res_dft, scratch_1) = scratch.take_vec_znx_dft(self.n(), self.cols(), rhs.size()); // Todo optimise
+        let res_big: VecZnxBig<_, B> = lhs.keyswitch_internal(module, res_dft, rhs, scratch_1);
         (0..self.cols()).for_each(|i| {
-            module.vec_znx_big_normalize(self.basek(), &mut self.data, i, &res_big, i, scratch1);
+            module.vec_znx_big_normalize(self.basek(), &mut self.data, i, &res_big, i, scratch_1);
         })
     }
 
@@ -162,16 +219,21 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
             + VmpApplyDftToDftTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>,
         Scratch<B>: ScratchAvailable + TakeVecZnxDft<B>,
     {
-        unsafe {
-            let self_ptr: *mut GLWECiphertext<DataSelf> = self as *mut GLWECiphertext<DataSelf>;
-            self.keyswitch(module, &*self_ptr, rhs, scratch);
+        #[cfg(debug_assertions)]
+        {
+            self.assert_keyswitch_inplace(module, rhs, scratch);
         }
+        let (res_dft, scratch_1) = scratch.take_vec_znx_dft(self.n(), self.cols(), rhs.size()); // Todo optimise
+        let res_big: VecZnxBig<_, B> = self.keyswitch_internal(module, res_dft, rhs, scratch_1);
+        (0..self.cols()).for_each(|i| {
+            module.vec_znx_big_normalize(self.basek(), &mut self.data, i, &res_big, i, scratch_1);
+        })
     }
 }
 
@@ -192,8 +254,8 @@ impl<D: DataRef> GLWECiphertext<D> {
             + VmpApplyDftToDftTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>,
         Scratch<B>: TakeVecZnxDft<B>,
@@ -224,16 +286,17 @@ where
     DataRes: DataMut,
     DataIn: DataRef,
     DataVmp: DataRef,
-    Module<B>: VecZnxDftAllocBytes + DFT<B> + VmpApplyDftToDft<B> + IDFTConsume<B> + VecZnxBigAddSmallInplace<B>,
+    Module<B>:
+        VecZnxDftAllocBytes + VecZnxDftApply<B> + VmpApplyDftToDft<B> + VecZnxIdftApplyConsume<B> + VecZnxBigAddSmallInplace<B>,
     Scratch<B>: TakeVecZnxDft<B>,
 {
     let cols: usize = a.cols();
-    let (mut ai_dft, scratch1) = scratch.take_vec_znx_dft(a.n(), cols - 1, a.size());
+    let (mut ai_dft, scratch_1) = scratch.take_vec_znx_dft(a.n(), cols - 1, a.size());
     (0..cols - 1).for_each(|col_i| {
-        module.dft(1, 0, &mut ai_dft, col_i, a, col_i + 1);
+        module.vec_znx_dft_apply(1, 0, &mut ai_dft, col_i, a, col_i + 1);
     });
-    module.vmp_apply_dft_to_dft(&mut res_dft, &ai_dft, mat, scratch1);
-    let mut res_big: VecZnxBig<DataRes, B> = module.vec_znx_idft_consume(res_dft);
+    module.vmp_apply_dft_to_dft(&mut res_dft, &ai_dft, mat, scratch_1);
+    let mut res_big: VecZnxBig<DataRes, B> = module.vec_znx_idft_apply_consume(res_dft);
     module.vec_znx_big_add_small_inplace(&mut res_big, 0, a, 0);
     res_big
 }
@@ -251,16 +314,16 @@ where
     DataIn: DataRef,
     DataVmp: DataRef,
     Module<B>: VecZnxDftAllocBytes
-        + DFT<B>
+        + VecZnxDftApply<B>
         + VmpApplyDftToDft<B>
         + VmpApplyDftToDftAdd<B>
-        + IDFTConsume<B>
+        + VecZnxIdftApplyConsume<B>
         + VecZnxBigAddSmallInplace<B>,
     Scratch<B>: TakeVecZnxDft<B>,
 {
     let cols: usize = a.cols();
     let size: usize = a.size();
-    let (mut ai_dft, scratch1) = scratch.take_vec_znx_dft(a.n(), cols - 1, size.div_ceil(digits));
+    let (mut ai_dft, scratch_1) = scratch.take_vec_znx_dft(a.n(), cols - 1, size.div_ceil(digits));
 
     ai_dft.data_mut().fill(0);
 
@@ -277,18 +340,18 @@ where
         res_dft.set_size(mat.size() - ((digits - di) as isize - 2).max(0) as usize);
 
         (0..cols - 1).for_each(|col_i| {
-            module.dft(digits, digits - di - 1, &mut ai_dft, col_i, a, col_i + 1);
+            module.vec_znx_dft_apply(digits, digits - di - 1, &mut ai_dft, col_i, a, col_i + 1);
         });
 
         if di == 0 {
-            module.vmp_apply_dft_to_dft(&mut res_dft, &ai_dft, mat, scratch1);
+            module.vmp_apply_dft_to_dft(&mut res_dft, &ai_dft, mat, scratch_1);
         } else {
-            module.vmp_apply_dft_to_dft_add(&mut res_dft, &ai_dft, mat, di, scratch1);
+            module.vmp_apply_dft_to_dft_add(&mut res_dft, &ai_dft, mat, di, scratch_1);
         }
     });
 
     res_dft.set_size(res_dft.max_size());
-    let mut res_big: VecZnxBig<DataRes, B> = module.vec_znx_idft_consume(res_dft);
+    let mut res_big: VecZnxBig<DataRes, B> = module.vec_znx_idft_apply_consume(res_dft);
     module.vec_znx_big_add_small_inplace(&mut res_big, 0, a, 0);
     res_big
 }

poulpy-core/src/keyswitching/lwe_ct.rs

@@ -1,7 +1,8 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchAvailable, TakeVecZnx, TakeVecZnxDft, VecZnxBigAddSmallInplace, VecZnxBigNormalize,
-        VecZnxBigNormalizeTmpBytes, VecZnxDftAllocBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+        ScratchAvailable, TakeVecZnx, TakeVecZnxDft, VecZnxBigAddSmallInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
+        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume, VmpApplyDftToDft, VmpApplyDftToDftAdd,
+        VmpApplyDftToDftTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch, ZnxView, ZnxViewMut, ZnxZero},
 };
@@ -26,8 +27,8 @@ impl LWECiphertext<Vec<u8>> {
             + VmpApplyDftToDftTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>,
     {
@@ -51,8 +52,8 @@ impl<DLwe: DataMut> LWECiphertext<DLwe> {
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + DFT<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>,
         Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
@@ -67,7 +68,7 @@ impl<DLwe: DataMut> LWECiphertext<DLwe> {
         let max_k: usize = self.k().max(a.k());
         let basek: usize = self.basek();
 
-        let (mut glwe, scratch1) = scratch.take_glwe_ct(ksk.n(), basek, max_k, 1);
+        let (mut glwe, scratch_1) = scratch.take_glwe_ct(ksk.n(), basek, max_k, 1);
         glwe.data.zero();
 
         let n_lwe: usize = a.n();
@@ -78,7 +79,7 @@ impl<DLwe: DataMut> LWECiphertext<DLwe> {
             glwe.data.at_mut(1, i)[..n_lwe].copy_from_slice(&data_lwe[1..]);
         });
 
-        glwe.keyswitch_inplace(module, &ksk.0, scratch1);
+        glwe.keyswitch_inplace(module, &ksk.0, scratch_1);
 
         self.sample_extract(&glwe);
     }

poulpy-core/src/layouts/compressed/gglwe_atk.rs

@@ -24,8 +24,8 @@ impl<D: DataRef> fmt::Debug for GGLWEAutomorphismKeyCompressed<D> {
 }
 
 impl<D: DataMut> FillUniform for GGLWEAutomorphismKeyCompressed<D> {
-    fn fill_uniform(&mut self, source: &mut Source) {
-        self.key.fill_uniform(source);
+    fn fill_uniform(&mut self, log_bound: usize, source: &mut Source) {
+        self.key.fill_uniform(log_bound, source);
     }
 }
 

poulpy-core/src/layouts/compressed/gglwe_ct.rs

@@ -28,8 +28,8 @@ impl<D: DataRef> fmt::Debug for GGLWECiphertextCompressed<D> {
 }
 
 impl<D: DataMut> FillUniform for GGLWECiphertextCompressed<D> {
-    fn fill_uniform(&mut self, source: &mut Source) {
-        self.data.fill_uniform(source);
+    fn fill_uniform(&mut self, log_bound: usize, source: &mut Source) {
+        self.data.fill_uniform(log_bound, source);
     }
 }
 

poulpy-core/src/layouts/compressed/gglwe_ksk.rs

@@ -25,8 +25,8 @@ impl<D: DataRef> fmt::Debug for GGLWESwitchingKeyCompressed<D> {
 }
 
 impl<D: DataMut> FillUniform for GGLWESwitchingKeyCompressed<D> {
-    fn fill_uniform(&mut self, source: &mut Source) {
-        self.key.fill_uniform(source);
+    fn fill_uniform(&mut self, log_bound: usize, source: &mut Source) {
+        self.key.fill_uniform(log_bound, source);
     }
 }
 

poulpy-core/src/layouts/compressed/gglwe_tsk.rs

@@ -23,10 +23,10 @@ impl<D: DataRef> fmt::Debug for GGLWETensorKeyCompressed<D> {
 }
 
 impl<D: DataMut> FillUniform for GGLWETensorKeyCompressed<D> {
-    fn fill_uniform(&mut self, source: &mut Source) {
+    fn fill_uniform(&mut self, log_bound: usize, source: &mut Source) {
         self.keys
             .iter_mut()
-            .for_each(|key: &mut GGLWESwitchingKeyCompressed<D>| key.fill_uniform(source))
+            .for_each(|key: &mut GGLWESwitchingKeyCompressed<D>| key.fill_uniform(log_bound, source))
     }
 }
 

poulpy-core/src/layouts/compressed/ggsw_ct.rs

@@ -49,8 +49,8 @@ impl<D: DataMut> Reset for GGSWCiphertextCompressed<D> {
 }
 
 impl<D: DataMut> FillUniform for GGSWCiphertextCompressed<D> {
-    fn fill_uniform(&mut self, source: &mut Source) {
-        self.data.fill_uniform(source);
+    fn fill_uniform(&mut self, log_bound: usize, source: &mut Source) {
+        self.data.fill_uniform(log_bound, source);
     }
 }
 

poulpy-core/src/layouts/compressed/glwe_ct.rs

@@ -48,8 +48,8 @@ impl<D: DataMut> Reset for GLWECiphertextCompressed<D> {
 }
 
 impl<D: DataMut> FillUniform for GLWECiphertextCompressed<D> {
-    fn fill_uniform(&mut self, source: &mut Source) {
-        self.data.fill_uniform(source);
+    fn fill_uniform(&mut self, log_bound: usize, source: &mut Source) {
+        self.data.fill_uniform(log_bound, source);
     }
 }
 
@@ -160,7 +160,8 @@ impl<D: DataMut> GLWECiphertext<D> {
     {
         #[cfg(debug_assertions)]
         {
-            assert_eq!(self.rank(), other.rank())
+            assert_eq!(self.rank(), other.rank());
+            debug_assert_eq!(self.size(), other.size());
         }
 
         let k: usize = other.k;
@@ -168,7 +169,7 @@ impl<D: DataMut> GLWECiphertext<D> {
         let cols: usize = other.rank() + 1;
         module.vec_znx_copy(&mut self.data, 0, &other.data, 0);
         (1..cols).for_each(|i| {
-            module.vec_znx_fill_uniform(basek, &mut self.data, i, k, source);
+            module.vec_znx_fill_uniform(basek, &mut self.data, i, source);
         });
 
         self.basek = basek;

poulpy-core/src/layouts/compressed/glwe_to_lwe_ksk.rs

@@ -2,9 +2,9 @@ use std::fmt;
 
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, SvpApplyInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare, VecZnxAddInplace, VecZnxAddNormal,
-        VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace,
-        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
+        SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare, VecZnxAddInplace, VecZnxAddNormal,
+        VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize,
+        VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
     },
     layouts::{Backend, Data, DataMut, DataRef, FillUniform, MatZnx, Module, ReaderFrom, Reset, WriterTo},
     source::Source,
@@ -22,8 +22,8 @@ impl<D: DataRef> fmt::Debug for GLWEToLWESwitchingKeyCompressed<D> {
 }
 
 impl<D: DataMut> FillUniform for GLWEToLWESwitchingKeyCompressed<D> {
-    fn fill_uniform(&mut self, source: &mut Source) {
-        self.0.fill_uniform(source);
+    fn fill_uniform(&mut self, log_bound: usize, source: &mut Source) {
+        self.0.fill_uniform(log_bound, source);
     }
 }
 
@@ -96,9 +96,9 @@ impl GLWEToLWESwitchingKeyCompressed<Vec<u8>> {
     where
         Module<B>: VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace

poulpy-core/src/layouts/compressed/lwe_ct.rs

@@ -50,8 +50,8 @@ where
 }
 
 impl<D: DataMut> FillUniform for LWECiphertextCompressed<D> {
-    fn fill_uniform(&mut self, source: &mut Source) {
-        self.data.fill_uniform(source);
+    fn fill_uniform(&mut self, log_bound: usize, source: &mut Source) {
+        self.data.fill_uniform(log_bound, source);
     }
 }
 
@@ -124,15 +124,9 @@ where
     Module<B>: ZnFillUniform,
 {
     fn decompress(&mut self, module: &Module<B>, other: &LWECiphertextCompressed<DR>) {
+        debug_assert_eq!(self.size(), other.size());
         let mut source: Source = Source::new(other.seed);
-        module.zn_fill_uniform(
-            self.n(),
-            other.basek(),
-            &mut self.data,
-            0,
-            other.k(),
-            &mut source,
-        );
+        module.zn_fill_uniform(self.n(), other.basek(), &mut self.data, 0, &mut source);
         (0..self.size()).for_each(|i| {
             self.data.at_mut(0, i)[0] = other.data.at(0, i)[0];
         });

poulpy-core/src/layouts/compressed/lwe_ksk.rs

@@ -1,8 +1,8 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, SvpApplyInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare, VecZnxAddInplace, VecZnxAddNormal,
-        VecZnxBigNormalize, VecZnxCopy, VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace,
-        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
+        SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare, VecZnxAddInplace, VecZnxAddNormal,
+        VecZnxBigNormalize, VecZnxCopy, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume,
+        VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
     },
     layouts::{Backend, Data, DataMut, DataRef, FillUniform, MatZnx, Module, ReaderFrom, Reset, WriterTo},
     source::Source,
@@ -24,8 +24,8 @@ impl<D: DataRef> fmt::Debug for LWESwitchingKeyCompressed<D> {
 }
 
 impl<D: DataMut> FillUniform for LWESwitchingKeyCompressed<D> {
-    fn fill_uniform(&mut self, source: &mut Source) {
-        self.0.fill_uniform(source);
+    fn fill_uniform(&mut self, log_bound: usize, source: &mut Source) {
+        self.0.fill_uniform(log_bound, source);
     }
 }
 
@@ -98,9 +98,9 @@ impl LWESwitchingKeyCompressed<Vec<u8>> {
     where
         Module<B>: VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace

poulpy-core/src/layouts/compressed/lwe_to_glwe_ksk.rs

@@ -1,8 +1,8 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, SvpApplyInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare, VecZnxAddInplace, VecZnxAddNormal,
-        VecZnxBigNormalize, VecZnxCopy, VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace,
-        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
+        SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare, VecZnxAddInplace, VecZnxAddNormal,
+        VecZnxBigNormalize, VecZnxCopy, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume,
+        VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
     },
     layouts::{Backend, Data, DataMut, DataRef, FillUniform, MatZnx, Module, ReaderFrom, Reset, WriterTo},
     source::Source,
@@ -24,8 +24,8 @@ impl<D: DataRef> fmt::Debug for LWEToGLWESwitchingKeyCompressed<D> {
 }
 
 impl<D: DataMut> FillUniform for LWEToGLWESwitchingKeyCompressed<D> {
-    fn fill_uniform(&mut self, source: &mut Source) {
-        self.0.fill_uniform(source);
+    fn fill_uniform(&mut self, log_bound: usize, source: &mut Source) {
+        self.0.fill_uniform(log_bound, source);
     }
 }
 
@@ -98,9 +98,9 @@ impl LWEToGLWESwitchingKeyCompressed<Vec<u8>> {
     where
         Module<B>: VecZnxDftAllocBytes
             + VecZnxBigNormalize<B>
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxFillUniform
             + VecZnxSubABInplace

poulpy-core/src/layouts/gglwe_atk.rs

@@ -21,8 +21,8 @@ impl<D: DataRef> fmt::Debug for GGLWEAutomorphismKey<D> {
 }
 
 impl<D: DataMut> FillUniform for GGLWEAutomorphismKey<D> {
-    fn fill_uniform(&mut self, source: &mut Source) {
-        self.key.fill_uniform(source);
+    fn fill_uniform(&mut self, log_bound: usize, source: &mut Source) {
+        self.key.fill_uniform(log_bound, source);
     }
 }
 

poulpy-core/src/layouts/gglwe_ct.rs

@@ -23,8 +23,8 @@ impl<D: DataRef> fmt::Debug for GGLWECiphertext<D> {
 }
 
 impl<D: DataMut> FillUniform for GGLWECiphertext<D> {
-    fn fill_uniform(&mut self, source: &mut Source) {
-        self.data.fill_uniform(source);
+    fn fill_uniform(&mut self, log_bound: usize, source: &mut Source) {
+        self.data.fill_uniform(log_bound, source);
     }
 }
 

poulpy-core/src/layouts/gglwe_ksk.rs

@@ -32,8 +32,8 @@ impl<D: DataRef> fmt::Display for GGLWESwitchingKey<D> {
 }
 
 impl<D: DataMut> FillUniform for GGLWESwitchingKey<D> {
-    fn fill_uniform(&mut self, source: &mut Source) {
-        self.key.fill_uniform(source);
+    fn fill_uniform(&mut self, log_bound: usize, source: &mut Source) {
+        self.key.fill_uniform(log_bound, source);
     }
 }
 

poulpy-core/src/layouts/gglwe_tsk.rs

@@ -20,10 +20,10 @@ impl<D: DataRef> fmt::Debug for GGLWETensorKey<D> {
 }
 
 impl<D: DataMut> FillUniform for GGLWETensorKey<D> {
-    fn fill_uniform(&mut self, source: &mut Source) {
+    fn fill_uniform(&mut self, log_bound: usize, source: &mut Source) {
         self.keys
             .iter_mut()
-            .for_each(|key: &mut GGLWESwitchingKey<D>| key.fill_uniform(source))
+            .for_each(|key: &mut GGLWESwitchingKey<D>| key.fill_uniform(log_bound, source))
     }
 }
 

poulpy-core/src/layouts/ggsw_ct.rs

@@ -40,8 +40,8 @@ impl<D: DataMut> Reset for GGSWCiphertext<D> {
 }
 
 impl<D: DataMut> FillUniform for GGSWCiphertext<D> {
-    fn fill_uniform(&mut self, source: &mut Source) {
-        self.data.fill_uniform(source);
+    fn fill_uniform(&mut self, log_bound: usize, source: &mut Source) {
+        self.data.fill_uniform(log_bound, source);
     }
 }
 

poulpy-core/src/layouts/glwe_ct.rs

@@ -55,8 +55,8 @@ where
 }
 
 impl<D: DataMut> FillUniform for GLWECiphertext<D> {
-    fn fill_uniform(&mut self, source: &mut Source) {
-        self.data.fill_uniform(source);
+    fn fill_uniform(&mut self, log_bound: usize, source: &mut Source) {
+        self.data.fill_uniform(log_bound, source);
     }
 }
 

poulpy-core/src/layouts/glwe_to_lwe_ksk.rs

@@ -18,8 +18,8 @@ impl<D: DataRef> fmt::Debug for GLWEToLWESwitchingKey<D> {
 }
 
 impl<D: DataMut> FillUniform for GLWEToLWESwitchingKey<D> {
-    fn fill_uniform(&mut self, source: &mut Source) {
-        self.0.fill_uniform(source);
+    fn fill_uniform(&mut self, log_bound: usize, source: &mut Source) {
+        self.0.fill_uniform(log_bound, source);
     }
 }
 

poulpy-core/src/layouts/lwe_ct.rs

@@ -54,8 +54,8 @@ impl<D: DataMut> FillUniform for LWECiphertext<D>
 where
     Zn<D>: FillUniform,
 {
-    fn fill_uniform(&mut self, source: &mut Source) {
-        self.data.fill_uniform(source);
+    fn fill_uniform(&mut self, log_bound: usize, source: &mut Source) {
+        self.data.fill_uniform(log_bound, source);
     }
 }
 

poulpy-core/src/layouts/lwe_ksk.rs

@@ -23,8 +23,8 @@ impl<D: DataRef> fmt::Debug for LWESwitchingKey<D> {
 }
 
 impl<D: DataMut> FillUniform for LWESwitchingKey<D> {
-    fn fill_uniform(&mut self, source: &mut Source) {
-        self.0.fill_uniform(source);
+    fn fill_uniform(&mut self, log_bound: usize, source: &mut Source) {
+        self.0.fill_uniform(log_bound, source);
     }
 }
 

poulpy-core/src/layouts/lwe_to_glwe_ksk.rs

@@ -17,8 +17,8 @@ impl<D: DataRef> fmt::Debug for LWEToGLWESwitchingKey<D> {
 }
 
 impl<D: DataMut> FillUniform for LWEToGLWESwitchingKey<D> {
-    fn fill_uniform(&mut self, source: &mut Source) {
-        self.0.fill_uniform(source);
+    fn fill_uniform(&mut self, log_bound: usize, source: &mut Source) {
+        self.0.fill_uniform(log_bound, source);
     }
 }
 

poulpy-core/src/layouts/prepared/glwe_pk.rs

@@ -1,5 +1,5 @@
 use poulpy_hal::{
-    api::{DFT, VecZnxDftAlloc, VecZnxDftAllocBytes},
+    api::{VecZnxDftAlloc, VecZnxDftAllocBytes, VecZnxDftApply},
     layouts::{Backend, Data, DataMut, DataRef, Module, Scratch, VecZnxDft},
 };
 
@@ -64,7 +64,7 @@ impl<B: Backend> GLWEPublicKeyPrepared<Vec<u8>, B> {
 
 impl<D: DataRef, B: Backend> PrepareAlloc<B, GLWEPublicKeyPrepared<Vec<u8>, B>> for GLWEPublicKey<D>
 where
-    Module<B>: VecZnxDftAlloc<B> + DFT<B>,
+    Module<B>: VecZnxDftAlloc<B> + VecZnxDftApply<B>,
 {
     fn prepare_alloc(&self, module: &Module<B>, scratch: &mut Scratch<B>) -> GLWEPublicKeyPrepared<Vec<u8>, B> {
         let mut pk_prepared: GLWEPublicKeyPrepared<Vec<u8>, B> =
@@ -76,7 +76,7 @@ where
 
 impl<DM: DataMut, DR: DataRef, B: Backend> Prepare<B, GLWEPublicKey<DR>> for GLWEPublicKeyPrepared<DM, B>
 where
-    Module<B>: DFT<B>,
+    Module<B>: VecZnxDftApply<B>,
 {
     fn prepare(&mut self, module: &Module<B>, other: &GLWEPublicKey<DR>, _scratch: &mut Scratch<B>) {
         #[cfg(debug_assertions)]
@@ -86,7 +86,7 @@ where
         }
 
         (0..self.cols()).for_each(|i| {
-            module.dft(1, 0, &mut self.data, i, &other.data, i);
+            module.vec_znx_dft_apply(1, 0, &mut self.data, i, &other.data, i);
         });
         self.k = other.k;
         self.basek = other.basek;

poulpy-core/src/noise/gglwe_ct.rs

@@ -1,7 +1,8 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
-        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxNormalizeTmpBytes, VecZnxSubScalarInplace,
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDftInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
+        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume,
+        VecZnxNormalizeTmpBytes, VecZnxSubScalarInplace,
     },
     layouts::{Backend, DataRef, Module, ScalarZnx, ScratchOwned, ZnxZero},
     oep::{ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeVecZnxBigImpl, TakeVecZnxDftImpl},
@@ -21,9 +22,9 @@ impl<D: DataRef> GGLWECiphertext<D> {
         DataWant: DataRef,
         Module<B>: VecZnxDftAllocBytes
             + VecZnxBigAllocBytes
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddInplace<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>

poulpy-core/src/noise/ggsw_ct.rs

@@ -1,8 +1,9 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, IDFTTmpA, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyInplace, VecZnxAddScalarInplace,
-        VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAlloc, VecZnxBigAllocBytes, VecZnxBigNormalize,
-        VecZnxBigNormalizeTmpBytes, VecZnxDftAlloc, VecZnxDftAllocBytes, VecZnxNormalizeTmpBytes, VecZnxSubABInplace,
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDftInplace, VecZnxAddScalarInplace, VecZnxBigAddInplace,
+        VecZnxBigAddSmallInplace, VecZnxBigAlloc, VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
+        VecZnxDftAlloc, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA,
+        VecZnxNormalizeTmpBytes, VecZnxSubABInplace,
     },
     layouts::{Backend, DataRef, Module, ScalarZnx, ScratchOwned, VecZnxBig, VecZnxDft, ZnxZero},
     oep::{ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeVecZnxBigImpl, TakeVecZnxDftImpl},
@@ -22,9 +23,9 @@ impl<D: DataRef> GGSWCiphertext<D> {
         DataScalar: DataRef,
         Module<B>: VecZnxDftAllocBytes
             + VecZnxBigAllocBytes
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddInplace<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
@@ -32,7 +33,7 @@ impl<D: DataRef> GGSWCiphertext<D> {
             + VecZnxBigAlloc<B>
             + VecZnxDftAlloc<B>
             + VecZnxBigNormalizeTmpBytes
-            + IDFTTmpA<B>
+            + VecZnxIdftApplyTmpA<B>
             + VecZnxAddScalarInplace
             + VecZnxSubABInplace,
         B: Backend + TakeVecZnxDftImpl<B> + TakeVecZnxBigImpl<B> + ScratchOwnedAllocImpl<B> + ScratchOwnedBorrowImpl<B>,
@@ -56,9 +57,9 @@ impl<D: DataRef> GGSWCiphertext<D> {
 
                 // mul with sk[col_j-1]
                 if col_j > 0 {
-                    module.dft(1, 0, &mut pt_dft, 0, &pt.data, 0);
-                    module.svp_apply_inplace(&mut pt_dft, 0, &sk_prepared.data, col_j - 1);
-                    module.idft_tmp_a(&mut pt_big, 0, &mut pt_dft, 0);
+                    module.vec_znx_dft_apply(1, 0, &mut pt_dft, 0, &pt.data, 0);
+                    module.svp_apply_dft_to_dft_inplace(&mut pt_dft, 0, &sk_prepared.data, col_j - 1);
+                    module.vec_znx_idft_apply_tmpa(&mut pt_big, 0, &mut pt_dft, 0);
                     module.vec_znx_big_normalize(basek, &mut pt.data, 0, &pt_big, 0, scratch.borrow());
                 }
 
@@ -89,9 +90,9 @@ impl<D: DataRef> GGSWCiphertext<D> {
         DataScalar: DataRef,
         Module<B>: VecZnxDftAllocBytes
             + VecZnxBigAllocBytes
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddInplace<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
@@ -99,7 +100,7 @@ impl<D: DataRef> GGSWCiphertext<D> {
             + VecZnxBigAlloc<B>
             + VecZnxDftAlloc<B>
             + VecZnxBigNormalizeTmpBytes
-            + IDFTTmpA<B>
+            + VecZnxIdftApplyTmpA<B>
             + VecZnxAddScalarInplace
             + VecZnxSubABInplace,
         B: Backend + TakeVecZnxDftImpl<B> + TakeVecZnxBigImpl<B> + ScratchOwnedAllocImpl<B> + ScratchOwnedBorrowImpl<B>,
@@ -122,9 +123,9 @@ impl<D: DataRef> GGSWCiphertext<D> {
 
                 // mul with sk[col_j-1]
                 if col_j > 0 {
-                    module.dft(1, 0, &mut pt_dft, 0, &pt.data, 0);
-                    module.svp_apply_inplace(&mut pt_dft, 0, &sk_prepared.data, col_j - 1);
-                    module.idft_tmp_a(&mut pt_big, 0, &mut pt_dft, 0);
+                    module.vec_znx_dft_apply(1, 0, &mut pt_dft, 0, &pt.data, 0);
+                    module.svp_apply_dft_to_dft_inplace(&mut pt_dft, 0, &sk_prepared.data, col_j - 1);
+                    module.vec_znx_idft_apply_tmpa(&mut pt_big, 0, &mut pt_dft, 0);
                     module.vec_znx_big_normalize(basek, &mut pt.data, 0, &pt_big, 0, scratch.borrow());
                 }
 

poulpy-core/src/noise/glwe_ct.rs

@@ -1,8 +1,8 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
-        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes,
-        VecZnxSubABInplace,
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDftInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
+        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume,
+        VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSubABInplace,
     },
     layouts::{Backend, DataRef, Module, ScratchOwned},
     oep::{ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeVecZnxBigImpl, TakeVecZnxDftImpl},
@@ -26,9 +26,9 @@ impl<D: DataRef> GLWECiphertext<D> {
         DataPt: DataRef,
         Module<B>: VecZnxDftAllocBytes
             + VecZnxBigAllocBytes
-            + DFT<B>
-            + SvpApplyInplace<B>
-            + IDFTConsume<B>
+            + VecZnxDftApply<B>
+            + SvpApplyDftToDftInplace<B>
+            + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddInplace<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>

poulpy-core/src/operations/glwe.rs

@@ -202,14 +202,14 @@ pub trait GLWEOperations: GLWECiphertextToMut + SetMetaData + Sized {
         self.set_k(set_k_unary(self, a))
     }
 
-    fn rotate_inplace<B: Backend>(&mut self, module: &Module<B>, k: i64)
+    fn rotate_inplace<B: Backend>(&mut self, module: &Module<B>, k: i64, scratch: &mut Scratch<B>)
     where
-        Module<B>: VecZnxRotateInplace,
+        Module<B>: VecZnxRotateInplace<B>,
     {
         let self_mut: &mut GLWECiphertext<&mut [u8]> = &mut self.to_mut();
 
         (0..self_mut.rank() + 1).for_each(|i| {
-            module.vec_znx_rotate_inplace(k, &mut self_mut.data, i);
+            module.vec_znx_rotate_inplace(k, &mut self_mut.data, i, scratch);
         });
     }
 
@@ -235,14 +235,14 @@ pub trait GLWEOperations: GLWECiphertextToMut + SetMetaData + Sized {
         self.set_k(set_k_unary(self, a))
     }
 
-    fn mul_xp_minus_one_inplace<B: Backend>(&mut self, module: &Module<B>, k: i64)
+    fn mul_xp_minus_one_inplace<B: Backend>(&mut self, module: &Module<B>, k: i64, scratch: &mut Scratch<B>)
     where
-        Module<B>: VecZnxMulXpMinusOneInplace,
+        Module<B>: VecZnxMulXpMinusOneInplace<B>,
     {
         let self_mut: &mut GLWECiphertext<&mut [u8]> = &mut self.to_mut();
 
         (0..self_mut.rank() + 1).for_each(|i| {
-            module.vec_znx_mul_xp_minus_one_inplace(k, &mut self_mut.data, i);
+            module.vec_znx_mul_xp_minus_one_inplace(k, &mut self_mut.data, i, scratch);
         });
     }
 
@@ -268,12 +268,14 @@ pub trait GLWEOperations: GLWECiphertextToMut + SetMetaData + Sized {
         self.set_basek(a.basek());
     }
 
-    fn rsh<B: Backend>(&mut self, module: &Module<B>, k: usize)
+    fn rsh<B: Backend>(&mut self, module: &Module<B>, k: usize, scratch: &mut Scratch<B>)
     where
-        Module<B>: VecZnxRshInplace,
+        Module<B>: VecZnxRshInplace<B>,
     {
         let basek: usize = self.basek();
-        module.vec_znx_rsh_inplace(basek, k, &mut self.to_mut().data);
+        (0..self.cols()).for_each(|i| {
+            module.vec_znx_rsh_inplace(basek, k, &mut self.to_mut().data, i, scratch);
+        })
     }
 
     fn normalize<A, B: Backend>(&mut self, module: &Module<B>, a: &A, scratch: &mut Scratch<B>)

poulpy-core/src/tests/generics/automorphism/gglwe_atk.rs

@@ -1,356 +0,0 @@
-use poulpy_hal::{
-    api::{
-        DFT, IDFTConsume, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
-        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism, VecZnxAutomorphismInplace,
-        VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
-        VecZnxCopy, VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes,
-        VecZnxSub, VecZnxSubABInplace, VecZnxSubScalarInplace, VecZnxSwithcDegree, VmpApplyDftToDft, VmpApplyDftToDftAdd,
-        VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPrepare,
-    },
-    layouts::{Backend, Module, ScratchOwned},
-    oep::{
-        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
-        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl,
-    },
-    source::Source,
-};
-
-use crate::{
-    encryption::SIGMA,
-    layouts::{
-        GGLWEAutomorphismKey, GLWEPlaintext, GLWESecret, Infos,
-        prepared::{GGLWEAutomorphismKeyPrepared, GLWESecretPrepared, Prepare, PrepareAlloc},
-    },
-    noise::log2_std_noise_gglwe_product,
-};
-
-#[allow(clippy::too_many_arguments)]
-pub fn test_gglwe_automorphism_key_automorphism<B>(
-    module: &Module<B>,
-    p0: i64,
-    p1: i64,
-    basek: usize,
-    digits: usize,
-    k_in: usize,
-    k_out: usize,
-    k_apply: usize,
-    rank: usize,
-) where
-    Module<B>: VecZnxDftAllocBytes
-        + VmpApplyDftToDftTmpBytes
-        + VecZnxBigNormalizeTmpBytes
-        + VmpApplyDftToDft<B>
-        + VmpApplyDftToDftAdd<B>
-        + DFT<B>
-        + IDFTConsume<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxBigNormalize<B>
-        + VecZnxAutomorphism
-        + VecZnxAutomorphismInplace
-        + SvpPPolAllocBytes
-        + VecZnxDftAllocBytes
-        + VecZnxNormalizeTmpBytes
-        + VmpPMatAlloc<B>
-        + VmpPrepare<B>
-        + SvpPrepare<B>
-        + SvpApplyInplace<B>
-        + VecZnxAddScalarInplace
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + VecZnxSwithcDegree
-        + SvpPPolAlloc<B>
-        + VecZnxBigAddInplace<B>
-        + VecZnxSubScalarInplace,
-    B: Backend
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxImpl<B>
-        + TakeSvpPPolImpl<B>
-        + TakeVecZnxBigImpl<B>,
-{
-    let n: usize = module.n();
-    let digits_in: usize = 1;
-
-    let rows_in: usize = k_in / (basek * digits);
-    let rows_apply: usize = k_in.div_ceil(basek * digits);
-
-    let mut auto_key_in: GGLWEAutomorphismKey<Vec<u8>> = GGLWEAutomorphismKey::alloc(n, basek, k_in, rows_in, digits_in, rank);
-    let mut auto_key_out: GGLWEAutomorphismKey<Vec<u8>> = GGLWEAutomorphismKey::alloc(n, basek, k_out, rows_in, digits_in, rank);
-    let mut auto_key_apply: GGLWEAutomorphismKey<Vec<u8>> =
-        GGLWEAutomorphismKey::alloc(n, basek, k_apply, rows_apply, digits, rank);
-
-    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]);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
-        GGLWEAutomorphismKey::encrypt_sk_scratch_space(module, basek, k_apply, rank)
-            | GGLWEAutomorphismKey::automorphism_scratch_space(module, basek, k_out, k_in, k_apply, digits, rank),
-    );
-
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk.fill_ternary_prob(0.5, &mut source_xs);
-
-    // gglwe_{s1}(s0) = s0 -> s1
-    auto_key_in.encrypt_sk(
-        module,
-        p0,
-        &sk,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    // gglwe_{s2}(s1) -> s1 -> s2
-    auto_key_apply.encrypt_sk(
-        module,
-        p1,
-        &sk,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let mut auto_key_apply_prepared: GGLWEAutomorphismKeyPrepared<Vec<u8>, B> =
-        GGLWEAutomorphismKeyPrepared::alloc(module, basek, k_apply, rows_apply, digits, rank);
-
-    auto_key_apply_prepared.prepare(module, &auto_key_apply, scratch.borrow());
-
-    // gglwe_{s1}(s0) (x) gglwe_{s2}(s1) = gglwe_{s2}(s0)
-    auto_key_out.automorphism(
-        module,
-        &auto_key_in,
-        &auto_key_apply_prepared,
-        scratch.borrow(),
-    );
-
-    let mut pt: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_out);
-
-    let mut sk_auto: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk_auto.fill_zero(); // Necessary to avoid panic of unfilled sk
-    (0..rank).for_each(|i| {
-        module.vec_znx_automorphism(
-            module.galois_element_inv(p0 * p1),
-            &mut sk_auto.data.as_vec_znx_mut(),
-            i,
-            &sk.data.as_vec_znx(),
-            i,
-        );
-    });
-
-    let sk_auto_dft: GLWESecretPrepared<Vec<u8>, B> = sk_auto.prepare_alloc(module, scratch.borrow());
-
-    (0..auto_key_out.rank_in()).for_each(|col_i| {
-        (0..auto_key_out.rows()).for_each(|row_i| {
-            auto_key_out
-                .at(row_i, col_i)
-                .decrypt(module, &mut pt, &sk_auto_dft, scratch.borrow());
-
-            module.vec_znx_sub_scalar_inplace(
-                &mut pt.data,
-                0,
-                (digits_in - 1) + row_i * digits_in,
-                &sk.data,
-                col_i,
-            );
-
-            let noise_have: f64 = pt.data.std(basek, 0).log2();
-            let noise_want: f64 = log2_std_noise_gglwe_product(
-                n as f64,
-                basek * digits,
-                0.5,
-                0.5,
-                0f64,
-                SIGMA * SIGMA,
-                0f64,
-                rank as f64,
-                k_out,
-                k_apply,
-            );
-
-            assert!(
-                noise_have < noise_want + 0.5,
-                "{} {}",
-                noise_have,
-                noise_want
-            );
-        });
-    });
-}
-
-#[allow(clippy::too_many_arguments)]
-pub fn test_gglwe_automorphism_key_automorphism_inplace<B>(
-    module: &Module<B>,
-    p0: i64,
-    p1: i64,
-    basek: usize,
-    digits: usize,
-    k_in: usize,
-    k_apply: usize,
-    rank: usize,
-) where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxDftAllocBytes
-        + VmpApplyDftToDftTmpBytes
-        + VecZnxBigNormalizeTmpBytes
-        + VmpApplyDftToDftTmpBytes
-        + VmpApplyDftToDft<B>
-        + VmpApplyDftToDftAdd<B>
-        + DFT<B>
-        + IDFTConsume<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxBigNormalize<B>
-        + VecZnxAutomorphism
-        + VecZnxSwithcDegree
-        + VecZnxAddScalarInplace
-        + VecZnxAutomorphism
-        + VecZnxAutomorphismInplace
-        + VecZnxDftAllocBytes
-        + VecZnxBigAllocBytes
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxBigAddInplace<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxBigNormalize<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxSubScalarInplace
-        + VecZnxCopy
-        + VmpPMatAlloc<B>
-        + VmpPrepare<B>,
-    B: Backend
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxImpl<B>
-        + TakeSvpPPolImpl<B>
-        + TakeVecZnxBigImpl<B>,
-{
-    let n: usize = module.n();
-    let digits_in: usize = 1;
-
-    let rows_in: usize = k_in / (basek * digits);
-    let rows_apply: usize = k_in.div_ceil(basek * digits);
-
-    let mut auto_key: GGLWEAutomorphismKey<Vec<u8>> = GGLWEAutomorphismKey::alloc(n, basek, k_in, rows_in, digits_in, rank);
-    let mut auto_key_apply: GGLWEAutomorphismKey<Vec<u8>> =
-        GGLWEAutomorphismKey::alloc(n, basek, k_apply, rows_apply, digits, rank);
-
-    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]);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
-        GGLWEAutomorphismKey::encrypt_sk_scratch_space(module, basek, k_apply, rank)
-            | GGLWEAutomorphismKey::automorphism_inplace_scratch_space(module, basek, k_in, k_apply, digits, rank),
-    );
-
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk.fill_ternary_prob(0.5, &mut source_xs);
-
-    // gglwe_{s1}(s0) = s0 -> s1
-    auto_key.encrypt_sk(
-        module,
-        p0,
-        &sk,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    // gglwe_{s2}(s1) -> s1 -> s2
-    auto_key_apply.encrypt_sk(
-        module,
-        p1,
-        &sk,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let mut auto_key_apply_prepared: GGLWEAutomorphismKeyPrepared<Vec<u8>, B> =
-        GGLWEAutomorphismKeyPrepared::alloc(module, basek, k_apply, rows_apply, digits, rank);
-
-    auto_key_apply_prepared.prepare(module, &auto_key_apply, scratch.borrow());
-
-    // gglwe_{s1}(s0) (x) gglwe_{s2}(s1) = gglwe_{s2}(s0)
-    auto_key.automorphism_inplace(module, &auto_key_apply_prepared, scratch.borrow());
-
-    let mut pt: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_in);
-
-    let mut sk_auto: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk_auto.fill_zero(); // Necessary to avoid panic of unfilled sk
-
-    (0..rank).for_each(|i| {
-        module.vec_znx_automorphism(
-            module.galois_element_inv(p0 * p1),
-            &mut sk_auto.data.as_vec_znx_mut(),
-            i,
-            &sk.data.as_vec_znx(),
-            i,
-        );
-    });
-
-    let sk_auto_dft: GLWESecretPrepared<Vec<u8>, B> = sk_auto.prepare_alloc(module, scratch.borrow());
-
-    (0..auto_key.rank_in()).for_each(|col_i| {
-        (0..auto_key.rows()).for_each(|row_i| {
-            auto_key
-                .at(row_i, col_i)
-                .decrypt(module, &mut pt, &sk_auto_dft, scratch.borrow());
-            module.vec_znx_sub_scalar_inplace(
-                &mut pt.data,
-                0,
-                (digits_in - 1) + row_i * digits_in,
-                &sk.data,
-                col_i,
-            );
-
-            let noise_have: f64 = pt.data.std(basek, 0).log2();
-            let noise_want: f64 = log2_std_noise_gglwe_product(
-                n as f64,
-                basek * digits,
-                0.5,
-                0.5,
-                0f64,
-                SIGMA * SIGMA,
-                0f64,
-                rank as f64,
-                k_in,
-                k_apply,
-            );
-
-            assert!(
-                noise_have < noise_want + 0.5,
-                "{} {}",
-                noise_have,
-                noise_want
-            );
-        });
-    });
-}

poulpy-core/src/tests/generics/automorphism/ggsw_ct.rs

@@ -1,326 +0,0 @@
-use poulpy_hal::{
-    api::{
-        DFT, IDFTConsume, IDFTTmpA, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApply, SvpApplyInplace, SvpPPolAlloc,
-        SvpPPolAllocBytes, SvpPrepare, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism,
-        VecZnxAutomorphismInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAlloc, VecZnxBigAllocBytes,
-        VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxCopy, VecZnxDftAddInplace, VecZnxDftAlloc, VecZnxDftAllocBytes,
-        VecZnxDftCopy, VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub,
-        VecZnxSubABInplace, VecZnxSwithcDegree, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes, VmpPMatAlloc,
-        VmpPrepare,
-    },
-    layouts::{Backend, Module, ScalarZnx, ScratchOwned},
-    oep::{
-        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
-        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl, VecZnxBigAllocBytesImpl, VecZnxDftAllocBytesImpl,
-    },
-    source::Source,
-};
-
-use crate::{
-    encryption::SIGMA,
-    layouts::{
-        GGLWEAutomorphismKey, GGLWETensorKey, GGSWCiphertext, GLWESecret,
-        prepared::{GGLWEAutomorphismKeyPrepared, GGLWETensorKeyPrepared, GLWESecretPrepared, Prepare, PrepareAlloc},
-    },
-    noise::noise_ggsw_keyswitch,
-};
-
-#[allow(clippy::too_many_arguments)]
-pub fn test_ggsw_automorphism<B>(
-    p: i64,
-    module: &Module<B>,
-    basek: usize,
-    k_out: usize,
-    k_in: usize,
-    k_ksk: usize,
-    k_tsk: usize,
-    digits: usize,
-    rank: usize,
-) where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigAllocBytes
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxBigAddInplace<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxBigNormalize<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxBigAlloc<B>
-        + VecZnxDftAlloc<B>
-        + VecZnxBigNormalizeTmpBytes
-        + IDFTTmpA<B>
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxAddScalarInplace
-        + VecZnxCopy
-        + VecZnxSubABInplace
-        + VmpPMatAlloc<B>
-        + VmpPrepare<B>
-        + VmpApplyDftToDftTmpBytes
-        + VmpApplyDftToDft<B>
-        + VmpApplyDftToDftAdd<B>
-        + VecZnxDftCopy<B>
-        + VecZnxDftAddInplace<B>
-        + VecZnxFillUniform
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpApply<B>
-        + VecZnxSwithcDegree
-        + VecZnxAutomorphismInplace
-        + VecZnxAutomorphism,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>
-        + VecZnxDftAllocBytesImpl<B>
-        + VecZnxBigAllocBytesImpl<B>
-        + TakeSvpPPolImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = k_in.div_ceil(basek * digits);
-    let rows_in: usize = k_in.div_euclid(basek * digits);
-
-    let digits_in: usize = 1;
-
-    let mut ct_in: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_in, rows_in, digits_in, rank);
-    let mut ct_out: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_out, rows_in, digits_in, rank);
-    let mut tensor_key: GGLWETensorKey<Vec<u8>> = GGLWETensorKey::alloc(n, basek, k_tsk, rows, digits, rank);
-    let mut auto_key: GGLWEAutomorphismKey<Vec<u8>> = GGLWEAutomorphismKey::alloc(n, basek, k_ksk, rows, digits, rank);
-    let mut pt_scalar: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
-
-    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]);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
-        GGSWCiphertext::encrypt_sk_scratch_space(module, basek, k_in, rank)
-            | GGLWEAutomorphismKey::encrypt_sk_scratch_space(module, basek, k_ksk, rank)
-            | GGLWETensorKey::encrypt_sk_scratch_space(module, basek, k_tsk, rank)
-            | GGSWCiphertext::automorphism_scratch_space(
-                module, basek, k_out, k_in, k_ksk, digits, k_tsk, digits, rank,
-            ),
-    );
-
-    let var_xs: f64 = 0.5;
-
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk.fill_ternary_prob(var_xs, &mut source_xs);
-    let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
-
-    auto_key.encrypt_sk(
-        module,
-        p,
-        &sk,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-    tensor_key.encrypt_sk(
-        module,
-        &sk,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    pt_scalar.fill_ternary_hw(0, n, &mut source_xs);
-
-    ct_in.encrypt_sk(
-        module,
-        &pt_scalar,
-        &sk_prepared,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let mut auto_key_prepared: GGLWEAutomorphismKeyPrepared<Vec<u8>, B> =
-        GGLWEAutomorphismKeyPrepared::alloc(module, basek, k_ksk, rows, digits, rank);
-    auto_key_prepared.prepare(module, &auto_key, scratch.borrow());
-
-    let mut tsk_prepared: GGLWETensorKeyPrepared<Vec<u8>, B> =
-        GGLWETensorKeyPrepared::alloc(module, basek, k_tsk, rows, digits, rank);
-    tsk_prepared.prepare(module, &tensor_key, scratch.borrow());
-
-    ct_out.automorphism(
-        module,
-        &ct_in,
-        &auto_key_prepared,
-        &tsk_prepared,
-        scratch.borrow(),
-    );
-
-    module.vec_znx_automorphism_inplace(p, &mut pt_scalar.as_vec_znx_mut(), 0);
-
-    let max_noise = |col_j: usize| -> f64 {
-        noise_ggsw_keyswitch(
-            n as f64,
-            basek * digits,
-            col_j,
-            var_xs,
-            0f64,
-            SIGMA * SIGMA,
-            0f64,
-            rank as f64,
-            k_in,
-            k_ksk,
-            k_tsk,
-        ) + 0.5
-    };
-
-    ct_out.assert_noise(module, &sk_prepared, &pt_scalar, max_noise);
-}
-
-#[allow(clippy::too_many_arguments)]
-pub fn test_ggsw_automorphism_inplace<B>(
-    p: i64,
-    module: &Module<B>,
-    basek: usize,
-    k_ct: usize,
-    k_ksk: usize,
-    k_tsk: usize,
-    digits: usize,
-    rank: usize,
-) where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigAllocBytes
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxBigAddInplace<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxBigNormalize<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxBigAlloc<B>
-        + VecZnxDftAlloc<B>
-        + VecZnxBigNormalizeTmpBytes
-        + IDFTTmpA<B>
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxAddScalarInplace
-        + VecZnxCopy
-        + VecZnxSubABInplace
-        + VmpPMatAlloc<B>
-        + VmpPrepare<B>
-        + VmpApplyDftToDftTmpBytes
-        + VmpApplyDftToDft<B>
-        + VmpApplyDftToDftAdd<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxDftCopy<B>
-        + VecZnxDftAddInplace<B>
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + VecZnxFillUniform
-        + SvpApply<B>
-        + VecZnxSwithcDegree
-        + VecZnxAutomorphismInplace
-        + VecZnxAutomorphism,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>
-        + VecZnxDftAllocBytesImpl<B>
-        + VecZnxBigAllocBytesImpl<B>
-        + TakeSvpPPolImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = k_ct.div_ceil(digits * basek);
-    let rows_in: usize = k_ct.div_euclid(basek * digits);
-    let digits_in: usize = 1;
-
-    let mut ct: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_ct, rows_in, digits_in, rank);
-    let mut tensor_key: GGLWETensorKey<Vec<u8>> = GGLWETensorKey::alloc(n, basek, k_tsk, rows, digits, rank);
-    let mut auto_key: GGLWEAutomorphismKey<Vec<u8>> = GGLWEAutomorphismKey::alloc(n, basek, k_ksk, rows, digits, rank);
-    let mut pt_scalar: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
-
-    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]);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
-        GGSWCiphertext::encrypt_sk_scratch_space(module, basek, k_ct, rank)
-            | GGLWEAutomorphismKey::encrypt_sk_scratch_space(module, basek, k_ksk, rank)
-            | GGLWETensorKey::encrypt_sk_scratch_space(module, basek, k_tsk, rank)
-            | GGSWCiphertext::automorphism_inplace_scratch_space(module, basek, k_ct, k_ksk, digits, k_tsk, digits, rank),
-    );
-
-    let var_xs: f64 = 0.5;
-
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk.fill_ternary_prob(var_xs, &mut source_xs);
-    let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
-
-    auto_key.encrypt_sk(
-        module,
-        p,
-        &sk,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-    tensor_key.encrypt_sk(
-        module,
-        &sk,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    pt_scalar.fill_ternary_hw(0, n, &mut source_xs);
-
-    ct.encrypt_sk(
-        module,
-        &pt_scalar,
-        &sk_prepared,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let mut auto_key_prepared: GGLWEAutomorphismKeyPrepared<Vec<u8>, B> =
-        GGLWEAutomorphismKeyPrepared::alloc(module, basek, k_ksk, rows, digits, rank);
-    auto_key_prepared.prepare(module, &auto_key, scratch.borrow());
-
-    let mut tsk_prepared: GGLWETensorKeyPrepared<Vec<u8>, B> =
-        GGLWETensorKeyPrepared::alloc(module, basek, k_tsk, rows, digits, rank);
-    tsk_prepared.prepare(module, &tensor_key, scratch.borrow());
-
-    ct.automorphism_inplace(module, &auto_key_prepared, &tsk_prepared, scratch.borrow());
-
-    module.vec_znx_automorphism_inplace(p, &mut pt_scalar.as_vec_znx_mut(), 0);
-
-    let max_noise = |col_j: usize| -> f64 {
-        noise_ggsw_keyswitch(
-            n as f64,
-            basek * digits,
-            col_j,
-            var_xs,
-            0f64,
-            SIGMA * SIGMA,
-            0f64,
-            rank as f64,
-            k_ct,
-            k_ksk,
-            k_tsk,
-        ) + 0.5
-    };
-
-    ct.assert_noise(module, &sk_prepared, &pt_scalar, max_noise);
-}

poulpy-core/src/tests/generics/automorphism/glwe_ct.rs

@@ -1,265 +0,0 @@
-use poulpy_hal::{
-    api::{
-        DFT, IDFTConsume, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
-        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism, VecZnxAutomorphismInplace,
-        VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
-        VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub,
-        VecZnxSubABInplace, VecZnxSwithcDegree, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes, VmpPMatAlloc,
-        VmpPrepare,
-    },
-    layouts::{Backend, Module, ScratchOwned},
-    oep::{
-        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
-        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl,
-    },
-    source::Source,
-};
-
-use crate::{
-    encryption::SIGMA,
-    layouts::{
-        GGLWEAutomorphismKey, GLWECiphertext, GLWEPlaintext, GLWESecret, Infos,
-        prepared::{GGLWEAutomorphismKeyPrepared, GLWESecretPrepared, Prepare, PrepareAlloc},
-    },
-    noise::log2_std_noise_gglwe_product,
-};
-
-#[allow(clippy::too_many_arguments)]
-pub fn test_glwe_automorphism<B>(
-    module: &Module<B>,
-    basek: usize,
-    p: i64,
-    k_out: usize,
-    k_in: usize,
-    k_ksk: usize,
-    digits: usize,
-    rank: usize,
-) where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VmpApplyDftToDftTmpBytes
-        + VecZnxBigNormalizeTmpBytes
-        + VmpApplyDftToDft<B>
-        + VmpApplyDftToDftAdd<B>
-        + VecZnxAutomorphism
-        + VecZnxSwithcDegree
-        + VecZnxAddScalarInplace
-        + VecZnxAutomorphismInplace
-        + VmpPMatAlloc<B>
-        + VmpPrepare<B>,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + TakeSvpPPolImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = k_in.div_ceil(basek * digits);
-
-    let mut autokey: GGLWEAutomorphismKey<Vec<u8>> = GGLWEAutomorphismKey::alloc(n, basek, k_ksk, rows, digits, rank);
-    let mut ct_in: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_in, rank);
-    let mut ct_out: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_out, rank);
-    let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_in);
-
-    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]);
-
-    module.vec_znx_fill_uniform(basek, &mut pt_want.data, 0, k_in, &mut source_xa);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
-        GGLWEAutomorphismKey::encrypt_sk_scratch_space(module, basek, autokey.k(), rank)
-            | GLWECiphertext::decrypt_scratch_space(module, basek, ct_out.k())
-            | GLWECiphertext::encrypt_sk_scratch_space(module, basek, ct_in.k())
-            | GLWECiphertext::automorphism_scratch_space(
-                module,
-                basek,
-                ct_out.k(),
-                ct_in.k(),
-                autokey.k(),
-                digits,
-                rank,
-            ),
-    );
-
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk.fill_ternary_prob(0.5, &mut source_xs);
-    let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
-
-    autokey.encrypt_sk(
-        module,
-        p,
-        &sk,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    ct_in.encrypt_sk(
-        module,
-        &pt_want,
-        &sk_prepared,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let mut autokey_prepared: GGLWEAutomorphismKeyPrepared<Vec<u8>, B> =
-        GGLWEAutomorphismKeyPrepared::alloc(module, basek, k_ksk, rows, digits, rank);
-    autokey_prepared.prepare(module, &autokey, scratch.borrow());
-
-    ct_out.automorphism(module, &ct_in, &autokey_prepared, scratch.borrow());
-
-    let max_noise: f64 = log2_std_noise_gglwe_product(
-        module.n() as f64,
-        basek * digits,
-        0.5,
-        0.5,
-        0f64,
-        SIGMA * SIGMA,
-        0f64,
-        rank as f64,
-        k_in,
-        k_ksk,
-    );
-
-    module.vec_znx_automorphism_inplace(p, &mut pt_want.data, 0);
-
-    ct_out.assert_noise(module, &sk_prepared, &pt_want, max_noise + 1.0);
-}
-
-#[allow(clippy::too_many_arguments)]
-pub fn test_glwe_automorphism_inplace<B>(
-    module: &Module<B>,
-    basek: usize,
-    p: i64,
-    k_ct: usize,
-    k_ksk: usize,
-    digits: usize,
-    rank: usize,
-) where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VmpApplyDftToDftTmpBytes
-        + VecZnxBigNormalizeTmpBytes
-        + VmpApplyDftToDft<B>
-        + VmpApplyDftToDftAdd<B>
-        + VecZnxAutomorphism
-        + VecZnxSwithcDegree
-        + VecZnxAddScalarInplace
-        + VecZnxAutomorphismInplace
-        + VmpPMatAlloc<B>
-        + VmpPrepare<B>,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + TakeSvpPPolImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = k_ct.div_ceil(basek * digits);
-
-    let mut autokey: GGLWEAutomorphismKey<Vec<u8>> = GGLWEAutomorphismKey::alloc(n, basek, k_ksk, rows, digits, rank);
-    let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_ct, rank);
-    let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, 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]);
-
-    module.vec_znx_fill_uniform(basek, &mut pt_want.data, 0, k_ct, &mut source_xa);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
-        GGLWEAutomorphismKey::encrypt_sk_scratch_space(module, basek, autokey.k(), rank)
-            | GLWECiphertext::decrypt_scratch_space(module, basek, ct.k())
-            | GLWECiphertext::encrypt_sk_scratch_space(module, basek, ct.k())
-            | GLWECiphertext::automorphism_inplace_scratch_space(module, basek, ct.k(), autokey.k(), digits, rank),
-    );
-
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk.fill_ternary_prob(0.5, &mut source_xs);
-    let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
-
-    autokey.encrypt_sk(
-        module,
-        p,
-        &sk,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    ct.encrypt_sk(
-        module,
-        &pt_want,
-        &sk_prepared,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let mut autokey_prepared: GGLWEAutomorphismKeyPrepared<Vec<u8>, B> =
-        GGLWEAutomorphismKeyPrepared::alloc(module, basek, k_ksk, rows, digits, rank);
-    autokey_prepared.prepare(module, &autokey, scratch.borrow());
-
-    ct.automorphism_inplace(module, &autokey_prepared, scratch.borrow());
-
-    let max_noise: f64 = log2_std_noise_gglwe_product(
-        module.n() as f64,
-        basek * digits,
-        0.5,
-        0.5,
-        0f64,
-        SIGMA * SIGMA,
-        0f64,
-        rank as f64,
-        k_ct,
-        k_ksk,
-    );
-
-    module.vec_znx_automorphism_inplace(p, &mut pt_want.data, 0);
-
-    ct.assert_noise(module, &sk_prepared, &pt_want, max_noise + 1.0);
-}

poulpy-core/src/tests/generics/encryption/gglwe_atk.rs

@@ -1,202 +0,0 @@
-use poulpy_hal::{
-    api::{
-        DFT, IDFTConsume, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
-        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism, VecZnxAutomorphismInplace,
-        VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
-        VecZnxCopy, VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes,
-        VecZnxSub, VecZnxSubABInplace, VecZnxSubScalarInplace, VecZnxSwithcDegree, VmpApplyDftToDft, VmpApplyDftToDftAdd,
-        VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPrepare,
-    },
-    layouts::{Backend, Module, ScratchOwned},
-    oep::{
-        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
-        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl,
-    },
-    source::Source,
-};
-
-use crate::{
-    encryption::SIGMA,
-    layouts::{
-        GGLWEAutomorphismKey, GLWESecret,
-        compressed::{Decompress, GGLWEAutomorphismKeyCompressed},
-        prepared::{GLWESecretPrepared, PrepareAlloc},
-    },
-};
-
-pub fn test_gglwe_automorphisk_key_encrypt_sk<B>(module: &Module<B>, basek: usize, k_ksk: usize, digits: usize, rank: usize)
-where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VmpApplyDftToDftTmpBytes
-        + VecZnxBigNormalizeTmpBytes
-        + VmpApplyDftToDft<B>
-        + VmpApplyDftToDftAdd<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxAutomorphism
-        + VecZnxSwithcDegree
-        + VecZnxAddScalarInplace
-        + VecZnxAutomorphismInplace
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxSubScalarInplace
-        + VecZnxCopy
-        + VmpPMatAlloc<B>
-        + VmpPrepare<B>,
-    B: Backend
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxImpl<B>
-        + TakeSvpPPolImpl<B>
-        + TakeVecZnxBigImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = (k_ksk - digits * basek) / (digits * basek);
-
-    let mut atk: GGLWEAutomorphismKey<Vec<u8>> = GGLWEAutomorphismKey::alloc(n, basek, k_ksk, rows, digits, rank);
-
-    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]);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(GGLWEAutomorphismKey::encrypt_sk_scratch_space(
-        module, basek, k_ksk, rank,
-    ));
-
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk.fill_ternary_prob(0.5, &mut source_xs);
-
-    let p = -5;
-
-    atk.encrypt_sk(
-        module,
-        p,
-        &sk,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let mut sk_out: GLWESecret<Vec<u8>> = sk.clone();
-    (0..atk.rank()).for_each(|i| {
-        module.vec_znx_automorphism(
-            module.galois_element_inv(p),
-            &mut sk_out.data.as_vec_znx_mut(),
-            i,
-            &sk.data.as_vec_znx(),
-            i,
-        );
-    });
-    let sk_out_prepared: GLWESecretPrepared<Vec<u8>, B> = sk_out.prepare_alloc(module, scratch.borrow());
-
-    atk.key
-        .key
-        .assert_noise(module, &sk_out_prepared, &sk.data, SIGMA);
-}
-
-pub fn test_gglwe_automorphisk_key_compressed_encrypt_sk<B>(
-    module: &Module<B>,
-    basek: usize,
-    k_ksk: usize,
-    digits: usize,
-    rank: usize,
-) where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VmpApplyDftToDftTmpBytes
-        + VecZnxBigNormalizeTmpBytes
-        + VmpApplyDftToDft<B>
-        + VmpApplyDftToDftAdd<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxAutomorphism
-        + VecZnxSwithcDegree
-        + VecZnxAddScalarInplace
-        + VecZnxAutomorphismInplace
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxSubScalarInplace
-        + VecZnxCopy
-        + VmpPMatAlloc<B>
-        + VmpPrepare<B>,
-    B: Backend
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxImpl<B>
-        + TakeSvpPPolImpl<B>
-        + TakeVecZnxBigImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = (k_ksk - digits * basek) / (digits * basek);
-
-    let mut atk_compressed: GGLWEAutomorphismKeyCompressed<Vec<u8>> =
-        GGLWEAutomorphismKeyCompressed::alloc(n, basek, k_ksk, rows, digits, rank);
-
-    let mut source_xs: Source = Source::new([0u8; 32]);
-    let mut source_xe: Source = Source::new([0u8; 32]);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(GGLWEAutomorphismKey::encrypt_sk_scratch_space(
-        module, basek, k_ksk, rank,
-    ));
-
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk.fill_ternary_prob(0.5, &mut source_xs);
-
-    let p = -5;
-
-    let seed_xa: [u8; 32] = [1u8; 32];
-
-    atk_compressed.encrypt_sk(module, p, &sk, seed_xa, &mut source_xe, scratch.borrow());
-
-    let mut sk_out: GLWESecret<Vec<u8>> = sk.clone();
-    (0..atk_compressed.rank()).for_each(|i| {
-        module.vec_znx_automorphism(
-            module.galois_element_inv(p),
-            &mut sk_out.data.as_vec_znx_mut(),
-            i,
-            &sk.data.as_vec_znx(),
-            i,
-        );
-    });
-    let sk_out_prepared = sk_out.prepare_alloc(module, scratch.borrow());
-
-    let mut atk: GGLWEAutomorphismKey<Vec<u8>> = GGLWEAutomorphismKey::alloc(n, basek, k_ksk, rows, digits, rank);
-    atk.decompress(module, &atk_compressed);
-
-    atk.key
-        .key
-        .assert_noise(module, &sk_out_prepared, &sk.data, SIGMA);
-}

poulpy-core/src/tests/generics/encryption/gglwe_ct.rs

@@ -1,185 +0,0 @@
-use poulpy_hal::{
-    api::{
-        DFT, IDFTConsume, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
-        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
-        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxCopy, VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize,
-        VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VecZnxSubScalarInplace,
-        VecZnxSwithcDegree, VmpPMatAlloc, VmpPrepare,
-    },
-    layouts::{Backend, Module, ScratchOwned},
-    oep::{
-        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
-        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl, VecZnxBigAllocBytesImpl, VecZnxDftAllocBytesImpl,
-    },
-    source::Source,
-};
-
-use crate::{
-    encryption::SIGMA,
-    layouts::{
-        GGLWESwitchingKey, GLWESecret,
-        compressed::{Decompress, GGLWESwitchingKeyCompressed},
-        prepared::{GLWESecretPrepared, PrepareAlloc},
-    },
-};
-
-pub fn test_gglwe_switching_key_encrypt_sk<B>(
-    module: &Module<B>,
-    basek: usize,
-    k_ksk: usize,
-    digits: usize,
-    rank_in: usize,
-    rank_out: usize,
-) where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxSwithcDegree
-        + VecZnxAddScalarInplace
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxSubScalarInplace
-        + VecZnxCopy
-        + VmpPMatAlloc<B>
-        + VmpPrepare<B>,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>
-        + VecZnxDftAllocBytesImpl<B>
-        + VecZnxBigAllocBytesImpl<B>
-        + TakeSvpPPolImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = (k_ksk - digits * basek) / (digits * basek);
-
-    let mut ksk: GGLWESwitchingKey<Vec<u8>> = GGLWESwitchingKey::alloc(n, basek, k_ksk, rows, digits, rank_in, rank_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]);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(GGLWESwitchingKey::encrypt_sk_scratch_space(
-        module, basek, k_ksk, rank_in, rank_out,
-    ));
-
-    let mut sk_in: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_in);
-    sk_in.fill_ternary_prob(0.5, &mut source_xs);
-
-    let mut sk_out: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_out);
-    sk_out.fill_ternary_prob(0.5, &mut source_xs);
-    let sk_out_prepared: GLWESecretPrepared<Vec<u8>, B> = sk_out.prepare_alloc(module, scratch.borrow());
-
-    ksk.encrypt_sk(
-        module,
-        &sk_in,
-        &sk_out,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    ksk.key
-        .assert_noise(module, &sk_out_prepared, &sk_in.data, SIGMA);
-}
-
-pub fn test_gglwe_switching_key_compressed_encrypt_sk<B>(
-    module: &Module<B>,
-    basek: usize,
-    k_ksk: usize,
-    digits: usize,
-    rank_in: usize,
-    rank_out: usize,
-) where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxSwithcDegree
-        + VecZnxAddScalarInplace
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxSubScalarInplace
-        + VecZnxCopy
-        + VmpPMatAlloc<B>
-        + VmpPrepare<B>,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>
-        + VecZnxDftAllocBytesImpl<B>
-        + VecZnxBigAllocBytesImpl<B>
-        + TakeSvpPPolImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = (k_ksk - digits * basek) / (digits * basek);
-
-    let mut ksk_compressed: GGLWESwitchingKeyCompressed<Vec<u8>> =
-        GGLWESwitchingKeyCompressed::alloc(n, basek, k_ksk, rows, digits, rank_in, rank_out);
-
-    let mut source_xs: Source = Source::new([0u8; 32]);
-    let mut source_xe: Source = Source::new([0u8; 32]);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(GGLWESwitchingKeyCompressed::encrypt_sk_scratch_space(
-        module, basek, k_ksk, rank_in, rank_out,
-    ));
-
-    let mut sk_in: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_in);
-    sk_in.fill_ternary_prob(0.5, &mut source_xs);
-
-    let mut sk_out: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_out);
-    sk_out.fill_ternary_prob(0.5, &mut source_xs);
-    let sk_out_prepared: GLWESecretPrepared<Vec<u8>, B> = sk_out.prepare_alloc(module, scratch.borrow());
-
-    let seed_xa = [1u8; 32];
-
-    ksk_compressed.encrypt_sk(
-        module,
-        &sk_in,
-        &sk_out,
-        seed_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let mut ksk: GGLWESwitchingKey<Vec<u8>> = GGLWESwitchingKey::alloc(n, basek, k_ksk, rows, digits, rank_in, rank_out);
-    ksk.decompress(module, &ksk_compressed);
-
-    ksk.key
-        .assert_noise(module, &sk_out_prepared, &sk_in.data, SIGMA);
-}

poulpy-core/src/tests/generics/encryption/ggsw_ct.rs

@@ -1,181 +0,0 @@
-use poulpy_hal::{
-    api::{
-        DFT, IDFTConsume, IDFTTmpA, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyInplace, SvpPPolAlloc, SvpPPolAllocBytes,
-        SvpPrepare, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
-        VecZnxBigAlloc, VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxCopy, VecZnxDftAlloc,
-        VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub,
-        VecZnxSubABInplace, VmpPMatAlloc, VmpPrepare,
-    },
-    layouts::{Backend, Module, ScalarZnx, ScratchOwned},
-    oep::{
-        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
-        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl, VecZnxBigAllocBytesImpl, VecZnxDftAllocBytesImpl,
-    },
-    source::Source,
-};
-
-use crate::{
-    encryption::SIGMA,
-    layouts::{
-        GGSWCiphertext, GLWESecret,
-        compressed::{Decompress, GGSWCiphertextCompressed},
-        prepared::{GLWESecretPrepared, PrepareAlloc},
-    },
-};
-
-pub fn test_ggsw_encrypt_sk<B>(module: &Module<B>, basek: usize, k: usize, digits: usize, rank: usize)
-where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxAddScalarInplace
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxCopy
-        + VmpPMatAlloc<B>
-        + VmpPrepare<B>
-        + VecZnxBigAlloc<B>
-        + VecZnxDftAlloc<B>
-        + VecZnxBigNormalizeTmpBytes
-        + IDFTTmpA<B>,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + TakeSvpPPolImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>
-        + VecZnxDftAllocBytesImpl<B>
-        + VecZnxBigAllocBytesImpl<B>
-        + TakeSvpPPolImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = (k - digits * basek) / (digits * basek);
-
-    let mut ct: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k, rows, digits, rank);
-
-    let mut pt_scalar: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
-
-    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]);
-
-    pt_scalar.fill_ternary_hw(0, n, &mut source_xs);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(GGSWCiphertext::encrypt_sk_scratch_space(
-        module, basek, k, rank,
-    ));
-
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk.fill_ternary_prob(0.5, &mut source_xs);
-    let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
-
-    ct.encrypt_sk(
-        module,
-        &pt_scalar,
-        &sk_prepared,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let noise_f = |_col_i: usize| -(k as f64) + SIGMA.log2() + 0.5;
-
-    ct.assert_noise(module, &sk_prepared, &pt_scalar, noise_f);
-}
-
-pub fn test_ggsw_compressed_encrypt_sk<B>(module: &Module<B>, basek: usize, k: usize, digits: usize, rank: usize)
-where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxAddScalarInplace
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxCopy
-        + VmpPMatAlloc<B>
-        + VmpPrepare<B>
-        + VecZnxBigAlloc<B>
-        + VecZnxDftAlloc<B>
-        + VecZnxBigNormalizeTmpBytes
-        + IDFTTmpA<B>,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>
-        + VecZnxDftAllocBytesImpl<B>
-        + VecZnxBigAllocBytesImpl<B>
-        + TakeSvpPPolImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = (k - digits * basek) / (digits * basek);
-
-    let mut ct_compressed: GGSWCiphertextCompressed<Vec<u8>> = GGSWCiphertextCompressed::alloc(n, basek, k, rows, digits, rank);
-
-    let mut pt_scalar: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
-
-    let mut source_xs: Source = Source::new([0u8; 32]);
-    let mut source_xe: Source = Source::new([0u8; 32]);
-
-    pt_scalar.fill_ternary_hw(0, n, &mut source_xs);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(GGSWCiphertextCompressed::encrypt_sk_scratch_space(
-        module, basek, k, rank,
-    ));
-
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk.fill_ternary_prob(0.5, &mut source_xs);
-    let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
-
-    let seed_xa: [u8; 32] = [1u8; 32];
-
-    ct_compressed.encrypt_sk(
-        module,
-        &pt_scalar,
-        &sk_prepared,
-        seed_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let noise_f = |_col_i: usize| -(k as f64) + SIGMA.log2() + 0.5;
-
-    let mut ct: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k, rows, digits, rank);
-    ct.decompress(module, &ct_compressed);
-
-    ct.assert_noise(module, &sk_prepared, &pt_scalar, noise_f);
-}

poulpy-core/src/tests/generics/encryption/glwe_ct.rs

@@ -1,371 +0,0 @@
-use poulpy_hal::{
-    api::{
-        DFT, IDFTConsume, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApply, SvpApplyInplace, SvpPPolAlloc, SvpPPolAllocBytes,
-        SvpPrepare, VecZnxAddInplace, VecZnxAddNormal, VecZnxBigAddInplace, VecZnxBigAddNormal, VecZnxBigAddSmallInplace,
-        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxCopy, VecZnxDftAlloc, VecZnxDftAllocBytes, VecZnxFillUniform,
-        VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
-    },
-    layouts::{Backend, Module, ScratchOwned},
-    oep::{
-        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
-        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl,
-    },
-    source::Source,
-};
-
-use crate::{
-    encryption::SIGMA,
-    layouts::{
-        GLWECiphertext, GLWEPlaintext, GLWEPublicKey, GLWESecret, Infos,
-        compressed::{Decompress, GLWECiphertextCompressed},
-        prepared::{GLWEPublicKeyPrepared, GLWESecretPrepared, PrepareAlloc},
-    },
-    operations::GLWEOperations,
-};
-
-pub fn test_glwe_encrypt_sk<B>(module: &Module<B>, basek: usize, k_ct: usize, k_pt: usize, rank: usize)
-where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigAllocBytes
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxBigAddInplace<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxBigNormalize<B>
-        + VecZnxNormalizeTmpBytes
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxDftAllocBytes
-        + VecZnxBigAllocBytes
-        + SvpPPolAllocBytes
-        + SvpPrepare<B>
-        + SvpApply<B>
-        + IDFTConsume<B>
-        + VecZnxBigAddNormal<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxBigNormalize<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + TakeSvpPPolImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>,
-{
-    let n = module.n();
-    let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_ct, rank);
-    let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_pt);
-    let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_pt);
-
-    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]);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
-        GLWECiphertext::encrypt_sk_scratch_space(module, basek, ct.k())
-            | GLWECiphertext::decrypt_scratch_space(module, basek, ct.k()),
-    );
-
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk.fill_ternary_prob(0.5, &mut source_xs);
-    let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
-
-    module.vec_znx_fill_uniform(basek, &mut pt_want.data, 0, k_pt, &mut source_xa);
-
-    ct.encrypt_sk(
-        module,
-        &pt_want,
-        &sk_prepared,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    ct.decrypt(module, &mut pt_have, &sk_prepared, scratch.borrow());
-
-    pt_want.sub_inplace_ab(module, &pt_have);
-
-    let noise_have: f64 = pt_want.data.std(basek, 0) * (ct.k() as f64).exp2();
-    let noise_want: f64 = SIGMA;
-
-    assert!(noise_have <= noise_want + 0.2);
-}
-
-pub fn test_glwe_compressed_encrypt_sk<B>(module: &Module<B>, basek: usize, k_ct: usize, k_pt: usize, rank: usize)
-where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigAllocBytes
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxBigAddInplace<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxBigNormalize<B>
-        + VecZnxNormalizeTmpBytes
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxDftAllocBytes
-        + VecZnxBigAllocBytes
-        + SvpPPolAllocBytes
-        + SvpPrepare<B>
-        + SvpApply<B>
-        + IDFTConsume<B>
-        + VecZnxBigAddNormal<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxBigNormalize<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + VecZnxCopy,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + TakeSvpPPolImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>,
-{
-    let n = module.n();
-    let mut ct_compressed: GLWECiphertextCompressed<Vec<u8>> = GLWECiphertextCompressed::alloc(n, basek, k_ct, rank);
-
-    let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_pt);
-    let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_pt);
-
-    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]);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
-        GLWECiphertextCompressed::encrypt_sk_scratch_space(module, basek, k_ct)
-            | GLWECiphertext::decrypt_scratch_space(module, basek, k_ct),
-    );
-
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk.fill_ternary_prob(0.5, &mut source_xs);
-    let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
-
-    module.vec_znx_fill_uniform(basek, &mut pt_want.data, 0, k_pt, &mut source_xa);
-
-    let seed_xa: [u8; 32] = [1u8; 32];
-
-    ct_compressed.encrypt_sk(
-        module,
-        &pt_want,
-        &sk_prepared,
-        seed_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_ct, rank);
-    ct.decompress(module, &ct_compressed);
-
-    ct.decrypt(module, &mut pt_have, &sk_prepared, scratch.borrow());
-
-    pt_want.sub_inplace_ab(module, &pt_have);
-
-    let noise_have: f64 = pt_want.data.std(basek, 0) * (ct.k() as f64).exp2();
-    let noise_want: f64 = SIGMA;
-
-    assert!(
-        noise_have <= noise_want + 0.2,
-        "{} <= {}",
-        noise_have,
-        noise_want + 0.2
-    );
-}
-
-pub fn test_glwe_encrypt_zero_sk<B>(module: &Module<B>, basek: usize, k_ct: usize, rank: usize)
-where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigAllocBytes
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxBigAddInplace<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxBigNormalize<B>
-        + VecZnxNormalizeTmpBytes
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxDftAllocBytes
-        + VecZnxBigAllocBytes
-        + SvpPPolAllocBytes
-        + SvpPrepare<B>
-        + SvpApply<B>
-        + IDFTConsume<B>
-        + VecZnxBigAddNormal<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxBigNormalize<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + TakeSvpPPolImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>,
-{
-    let n = module.n();
-    let mut pt: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_ct);
-
-    let mut source_xs: Source = Source::new([0u8; 32]);
-    let mut source_xe: Source = Source::new([1u8; 32]);
-    let mut source_xa: Source = Source::new([0u8; 32]);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
-        GLWECiphertext::decrypt_scratch_space(module, basek, k_ct)
-            | GLWECiphertext::encrypt_sk_scratch_space(module, basek, k_ct),
-    );
-
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk.fill_ternary_prob(0.5, &mut source_xs);
-    let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
-
-    let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_ct, rank);
-
-    ct.encrypt_zero_sk(
-        module,
-        &sk_prepared,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-    ct.decrypt(module, &mut pt, &sk_prepared, scratch.borrow());
-
-    assert!((SIGMA - pt.data.std(basek, 0) * (k_ct as f64).exp2()) <= 0.2);
-}
-
-pub fn test_glwe_encrypt_pk<B>(module: &Module<B>, basek: usize, k_ct: usize, k_pk: usize, rank: usize)
-where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxCopy
-        + VecZnxDftAlloc<B>
-        + SvpApply<B>
-        + VecZnxBigAddNormal<B>,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + TakeSvpPPolImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>,
-{
-    let n: usize = module.n();
-    let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_ct, rank);
-    let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_ct);
-    let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, 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]);
-    let mut source_xu: Source = Source::new([0u8; 32]);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
-        GLWECiphertext::encrypt_sk_scratch_space(module, basek, ct.k())
-            | GLWECiphertext::decrypt_scratch_space(module, basek, ct.k())
-            | GLWECiphertext::encrypt_pk_scratch_space(module, basek, k_pk),
-    );
-
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk.fill_ternary_prob(0.5, &mut source_xs);
-    let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
-
-    let mut pk: GLWEPublicKey<Vec<u8>> = GLWEPublicKey::alloc(n, basek, k_pk, rank);
-    pk.generate_from_sk(module, &sk_prepared, &mut source_xa, &mut source_xe);
-
-    module.vec_znx_fill_uniform(basek, &mut pt_want.data, 0, k_ct, &mut source_xa);
-
-    let pk_prepared: GLWEPublicKeyPrepared<Vec<u8>, B> = pk.prepare_alloc(module, scratch.borrow());
-
-    ct.encrypt_pk(
-        module,
-        &pt_want,
-        &pk_prepared,
-        &mut source_xu,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    ct.decrypt(module, &mut pt_have, &sk_prepared, scratch.borrow());
-
-    pt_want.sub_inplace_ab(module, &pt_have);
-
-    let noise_have: f64 = pt_want.data.std(basek, 0).log2();
-    let noise_want: f64 = ((((rank as f64) + 1.0) * n as f64 * 0.5 * SIGMA * SIGMA).sqrt()).log2() - (k_ct as f64);
-
-    assert!(
-        noise_have <= noise_want + 0.2,
-        "{} {}",
-        noise_have,
-        noise_want
-    );
-}

poulpy-core/src/tests/generics/encryption/glwe_tsk.rs

@@ -1,241 +0,0 @@
-use poulpy_hal::{
-    api::{
-        DFT, IDFTConsume, IDFTTmpA, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApply, SvpApplyInplace, SvpPPolAlloc,
-        SvpPPolAllocBytes, SvpPrepare, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAddInplace,
-        VecZnxBigAddSmallInplace, VecZnxBigAlloc, VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxCopy, VecZnxDftAlloc,
-        VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub,
-        VecZnxSubABInplace, VecZnxSubScalarInplace, VecZnxSwithcDegree,
-    },
-    layouts::{Backend, Module, ScratchOwned, VecZnxDft},
-    oep::{
-        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
-        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl, VecZnxBigAllocBytesImpl, VecZnxDftAllocBytesImpl,
-    },
-    source::Source,
-};
-
-use crate::{
-    encryption::SIGMA,
-    layouts::{
-        GGLWETensorKey, GLWEPlaintext, GLWESecret, Infos,
-        compressed::{Decompress, GGLWETensorKeyCompressed},
-        prepared::{GLWESecretPrepared, PrepareAlloc},
-    },
-};
-
-pub fn test_glwe_tensor_key_encrypt_sk<B>(module: &Module<B>, basek: usize, k: usize, rank: usize)
-where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxCopy
-        + VecZnxDftAlloc<B>
-        + SvpApply<B>
-        + VecZnxBigAlloc<B>
-        + IDFTTmpA<B>
-        + VecZnxAddScalarInplace
-        + VecZnxSwithcDegree
-        + VecZnxSubScalarInplace,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>
-        + VecZnxDftAllocBytesImpl<B>
-        + VecZnxBigAllocBytesImpl<B>
-        + TakeSvpPPolImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = k / basek;
-
-    let mut tensor_key: GGLWETensorKey<Vec<u8>> = GGLWETensorKey::alloc(n, basek, k, rows, 1, rank);
-
-    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]);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(GGLWETensorKey::encrypt_sk_scratch_space(
-        module,
-        basek,
-        tensor_key.k(),
-        rank,
-    ));
-
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk.fill_ternary_prob(0.5, &mut source_xs);
-    let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
-
-    tensor_key.encrypt_sk(
-        module,
-        &sk,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let mut pt: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k);
-
-    let mut sk_ij_dft = module.vec_znx_dft_alloc(1, 1);
-    let mut sk_ij_big = module.vec_znx_big_alloc(1, 1);
-    let mut sk_ij: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, 1);
-    let mut sk_dft: VecZnxDft<Vec<u8>, B> = module.vec_znx_dft_alloc(rank, 1);
-
-    (0..rank).for_each(|i| {
-        module.dft(1, 0, &mut sk_dft, i, &sk.data.as_vec_znx(), i);
-    });
-
-    (0..rank).for_each(|i| {
-        (0..rank).for_each(|j| {
-            module.svp_apply(&mut sk_ij_dft, 0, &sk_prepared.data, j, &sk_dft, i);
-            module.idft_tmp_a(&mut sk_ij_big, 0, &mut sk_ij_dft, 0);
-            module.vec_znx_big_normalize(
-                basek,
-                &mut sk_ij.data.as_vec_znx_mut(),
-                0,
-                &sk_ij_big,
-                0,
-                scratch.borrow(),
-            );
-            (0..tensor_key.rank_in()).for_each(|col_i| {
-                (0..tensor_key.rows()).for_each(|row_i| {
-                    tensor_key
-                        .at(i, j)
-                        .at(row_i, col_i)
-                        .decrypt(module, &mut pt, &sk_prepared, scratch.borrow());
-
-                    module.vec_znx_sub_scalar_inplace(&mut pt.data, 0, row_i, &sk_ij.data, col_i);
-
-                    let std_pt: f64 = pt.data.std(basek, 0) * (k as f64).exp2();
-                    assert!((SIGMA - std_pt).abs() <= 0.5, "{} {}", SIGMA, std_pt);
-                });
-            });
-        })
-    })
-}
-
-pub fn test_glwe_tensor_key_compressed_encrypt_sk<B>(module: &Module<B>, basek: usize, k: usize, rank: usize)
-where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxCopy
-        + VecZnxDftAlloc<B>
-        + SvpApply<B>
-        + VecZnxBigAlloc<B>
-        + IDFTTmpA<B>
-        + VecZnxAddScalarInplace
-        + VecZnxSwithcDegree
-        + VecZnxSubScalarInplace,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>
-        + VecZnxDftAllocBytesImpl<B>
-        + VecZnxBigAllocBytesImpl<B>
-        + TakeSvpPPolImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = k / basek;
-
-    let mut tensor_key_compressed: GGLWETensorKeyCompressed<Vec<u8>> =
-        GGLWETensorKeyCompressed::alloc(n, basek, k, rows, 1, rank);
-
-    let mut source_xs: Source = Source::new([0u8; 32]);
-    let mut source_xe: Source = Source::new([0u8; 32]);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(GGLWETensorKeyCompressed::encrypt_sk_scratch_space(
-        module,
-        basek,
-        tensor_key_compressed.k(),
-        rank,
-    ));
-
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk.fill_ternary_prob(0.5, &mut source_xs);
-    let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
-
-    let seed_xa: [u8; 32] = [1u8; 32];
-
-    tensor_key_compressed.encrypt_sk(module, &sk, seed_xa, &mut source_xe, scratch.borrow());
-
-    let mut tensor_key: GGLWETensorKey<Vec<u8>> = GGLWETensorKey::alloc(n, basek, k, rows, 1, rank);
-    tensor_key.decompress(module, &tensor_key_compressed);
-
-    let mut pt: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k);
-
-    let mut sk_ij_dft = module.vec_znx_dft_alloc(1, 1);
-    let mut sk_ij_big = module.vec_znx_big_alloc(1, 1);
-    let mut sk_ij: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, 1);
-    let mut sk_dft: VecZnxDft<Vec<u8>, B> = module.vec_znx_dft_alloc(rank, 1);
-
-    (0..rank).for_each(|i| {
-        module.dft(1, 0, &mut sk_dft, i, &sk.data.as_vec_znx(), i);
-    });
-
-    (0..rank).for_each(|i| {
-        (0..rank).for_each(|j| {
-            module.svp_apply(&mut sk_ij_dft, 0, &sk_prepared.data, j, &sk_dft, i);
-            module.idft_tmp_a(&mut sk_ij_big, 0, &mut sk_ij_dft, 0);
-            module.vec_znx_big_normalize(
-                basek,
-                &mut sk_ij.data.as_vec_znx_mut(),
-                0,
-                &sk_ij_big,
-                0,
-                scratch.borrow(),
-            );
-            (0..tensor_key.rank_in()).for_each(|col_i| {
-                (0..tensor_key.rows()).for_each(|row_i| {
-                    tensor_key
-                        .at(i, j)
-                        .at(row_i, col_i)
-                        .decrypt(module, &mut pt, &sk_prepared, scratch.borrow());
-
-                    module.vec_znx_sub_scalar_inplace(&mut pt.data, 0, row_i, &sk_ij.data, col_i);
-
-                    let std_pt: f64 = pt.data.std(basek, 0) * (k as f64).exp2();
-                    assert!((SIGMA - std_pt).abs() <= 0.5, "{} {}", SIGMA, std_pt);
-                });
-            });
-        })
-    })
-}

poulpy-core/src/tests/generics/external_product/gglwe_ksk.rs

@@ -1,304 +0,0 @@
-use poulpy_hal::{
-    api::{
-        DFT, IDFTConsume, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
-        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
-        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxCopy, VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize,
-        VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxRotateInplace, VecZnxSub, VecZnxSubABInplace,
-        VecZnxSubScalarInplace, VecZnxSwithcDegree, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
-        VmpPMatAlloc, VmpPrepare,
-    },
-    layouts::{Backend, Module, ScalarZnx, ScalarZnxToMut, ScratchOwned, ZnxViewMut},
-    oep::{
-        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
-        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl, VecZnxBigAllocBytesImpl, VecZnxDftAllocBytesImpl,
-    },
-    source::Source,
-};
-
-use crate::{
-    encryption::SIGMA,
-    layouts::{
-        GGLWESwitchingKey, GGSWCiphertext, GLWESecret,
-        prepared::{GGSWCiphertextPrepared, GLWESecretPrepared, PrepareAlloc},
-    },
-    noise::noise_ggsw_product,
-};
-
-#[allow(clippy::too_many_arguments)]
-pub fn test_gglwe_switching_key_external_product<B>(
-    module: &Module<B>,
-    basek: usize,
-    k_out: usize,
-    k_in: usize,
-    k_ggsw: usize,
-    digits: usize,
-    rank_in: usize,
-    rank_out: usize,
-) where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxSwithcDegree
-        + VecZnxAddScalarInplace
-        + VecZnxSubScalarInplace
-        + VecZnxCopy
-        + VmpPMatAlloc<B>
-        + VecZnxRotateInplace
-        + VmpApplyDftToDftTmpBytes
-        + VmpApplyDftToDft<B>
-        + VmpApplyDftToDftAdd<B>
-        + VmpPrepare<B>,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>
-        + VecZnxDftAllocBytesImpl<B>
-        + VecZnxBigAllocBytesImpl<B>
-        + TakeSvpPPolImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = k_in.div_ceil(basek * digits);
-    let digits_in: usize = 1;
-
-    let mut ct_gglwe_in: GGLWESwitchingKey<Vec<u8>> =
-        GGLWESwitchingKey::alloc(n, basek, k_in, rows, digits_in, rank_in, rank_out);
-    let mut ct_gglwe_out: GGLWESwitchingKey<Vec<u8>> =
-        GGLWESwitchingKey::alloc(n, basek, k_out, rows, digits_in, rank_in, rank_out);
-    let mut ct_rgsw: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_ggsw, rows, digits, rank_out);
-
-    let mut pt_rgsw: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
-
-    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]);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
-        GGLWESwitchingKey::encrypt_sk_scratch_space(module, basek, k_in, rank_in, rank_out)
-            | GGLWESwitchingKey::external_product_scratch_space(module, basek, k_out, k_in, k_ggsw, digits, rank_out)
-            | GGSWCiphertext::encrypt_sk_scratch_space(module, basek, k_ggsw, rank_out),
-    );
-
-    let r: usize = 1;
-
-    pt_rgsw.to_mut().raw_mut()[r] = 1; // X^{r}
-
-    let var_xs: f64 = 0.5;
-
-    let mut sk_in: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_in);
-    sk_in.fill_ternary_prob(var_xs, &mut source_xs);
-
-    let mut sk_out: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_out);
-    sk_out.fill_ternary_prob(var_xs, &mut source_xs);
-    let sk_out_prepared: GLWESecretPrepared<Vec<u8>, B> = sk_out.prepare_alloc(module, scratch.borrow());
-
-    // gglwe_{s1}(s0) = s0 -> s1
-    ct_gglwe_in.encrypt_sk(
-        module,
-        &sk_in,
-        &sk_out,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    ct_rgsw.encrypt_sk(
-        module,
-        &pt_rgsw,
-        &sk_out_prepared,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let ct_rgsw_prepared: GGSWCiphertextPrepared<Vec<u8>, B> = ct_rgsw.prepare_alloc(module, scratch.borrow());
-
-    // gglwe_(m) (x) RGSW_(X^k) = gglwe_(m * X^k)
-    ct_gglwe_out.external_product(module, &ct_gglwe_in, &ct_rgsw_prepared, scratch.borrow());
-
-    (0..rank_in).for_each(|i| {
-        module.vec_znx_rotate_inplace(r as i64, &mut sk_in.data.as_vec_znx_mut(), i); // * X^{r}
-    });
-
-    let var_gct_err_lhs: f64 = SIGMA * SIGMA;
-    let var_gct_err_rhs: f64 = 0f64;
-
-    let var_msg: f64 = 1f64 / n as f64; // X^{k}
-    let var_a0_err: f64 = SIGMA * SIGMA;
-    let var_a1_err: f64 = 1f64 / 12f64;
-
-    let max_noise: f64 = noise_ggsw_product(
-        n as f64,
-        basek * digits,
-        var_xs,
-        var_msg,
-        var_a0_err,
-        var_a1_err,
-        var_gct_err_lhs,
-        var_gct_err_rhs,
-        rank_out as f64,
-        k_in,
-        k_ggsw,
-    );
-
-    ct_gglwe_out
-        .key
-        .assert_noise(module, &sk_out_prepared, &sk_in.data, max_noise + 0.5);
-}
-
-#[allow(clippy::too_many_arguments)]
-pub fn test_gglwe_switching_key_external_product_inplace<B>(
-    module: &Module<B>,
-    basek: usize,
-    k_ct: usize,
-    k_ggsw: usize,
-    digits: usize,
-    rank_in: usize,
-    rank_out: usize,
-) where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxSwithcDegree
-        + VecZnxAddScalarInplace
-        + VecZnxSubScalarInplace
-        + VecZnxCopy
-        + VmpPMatAlloc<B>
-        + VecZnxRotateInplace
-        + VmpApplyDftToDftTmpBytes
-        + VmpApplyDftToDft<B>
-        + VmpApplyDftToDftAdd<B>
-        + VmpPrepare<B>,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>
-        + VecZnxDftAllocBytesImpl<B>
-        + VecZnxBigAllocBytesImpl<B>
-        + TakeSvpPPolImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = k_ct.div_ceil(basek * digits);
-
-    let digits_in: usize = 1;
-
-    let mut ct_gglwe: GGLWESwitchingKey<Vec<u8>> = GGLWESwitchingKey::alloc(n, basek, k_ct, rows, digits_in, rank_in, rank_out);
-    let mut ct_rgsw: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_ggsw, rows, digits, rank_out);
-
-    let mut pt_rgsw: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
-
-    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]);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
-        GGLWESwitchingKey::encrypt_sk_scratch_space(module, basek, k_ct, rank_in, rank_out)
-            | GGLWESwitchingKey::external_product_inplace_scratch_space(module, basek, k_ct, k_ggsw, digits, rank_out)
-            | GGSWCiphertext::encrypt_sk_scratch_space(module, basek, k_ggsw, rank_out),
-    );
-
-    let r: usize = 1;
-
-    pt_rgsw.to_mut().raw_mut()[r] = 1; // X^{r}
-
-    let var_xs: f64 = 0.5;
-
-    let mut sk_in: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_in);
-    sk_in.fill_ternary_prob(var_xs, &mut source_xs);
-
-    let mut sk_out: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_out);
-    sk_out.fill_ternary_prob(var_xs, &mut source_xs);
-    let sk_out_prepared: GLWESecretPrepared<Vec<u8>, B> = sk_out.prepare_alloc(module, scratch.borrow());
-
-    // gglwe_{s1}(s0) = s0 -> s1
-    ct_gglwe.encrypt_sk(
-        module,
-        &sk_in,
-        &sk_out,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    ct_rgsw.encrypt_sk(
-        module,
-        &pt_rgsw,
-        &sk_out_prepared,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let ct_rgsw_prepared: GGSWCiphertextPrepared<Vec<u8>, B> = ct_rgsw.prepare_alloc(module, scratch.borrow());
-
-    // gglwe_(m) (x) RGSW_(X^k) = gglwe_(m * X^k)
-    ct_gglwe.external_product_inplace(module, &ct_rgsw_prepared, scratch.borrow());
-
-    (0..rank_in).for_each(|i| {
-        module.vec_znx_rotate_inplace(r as i64, &mut sk_in.data.as_vec_znx_mut(), i); // * X^{r}
-    });
-
-    let var_gct_err_lhs: f64 = SIGMA * SIGMA;
-    let var_gct_err_rhs: f64 = 0f64;
-
-    let var_msg: f64 = 1f64 / n as f64; // X^{k}
-    let var_a0_err: f64 = SIGMA * SIGMA;
-    let var_a1_err: f64 = 1f64 / 12f64;
-
-    let max_noise: f64 = noise_ggsw_product(
-        n as f64,
-        basek * digits,
-        var_xs,
-        var_msg,
-        var_a0_err,
-        var_a1_err,
-        var_gct_err_lhs,
-        var_gct_err_rhs,
-        rank_out as f64,
-        k_ct,
-        k_ggsw,
-    );
-
-    ct_gglwe
-        .key
-        .assert_noise(module, &sk_out_prepared, &sk_in.data, max_noise + 0.5);
-}

poulpy-core/src/tests/generics/external_product/ggsw_ct.rs

@@ -1,290 +0,0 @@
-use poulpy_hal::{
-    api::{
-        DFT, IDFTConsume, IDFTTmpA, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyInplace, SvpPPolAlloc, SvpPPolAllocBytes,
-        SvpPrepare, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
-        VecZnxBigAlloc, VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxCopy, VecZnxDftAlloc,
-        VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes,
-        VecZnxRotateInplace, VecZnxSub, VecZnxSubABInplace, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
-        VmpPMatAlloc, VmpPrepare,
-    },
-    layouts::{Backend, Module, ScalarZnx, ScalarZnxToMut, ScratchOwned, ZnxViewMut},
-    oep::{
-        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
-        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl, VecZnxBigAllocBytesImpl, VecZnxDftAllocBytesImpl,
-    },
-    source::Source,
-};
-
-use crate::{
-    encryption::SIGMA,
-    layouts::{
-        GGSWCiphertext, GLWESecret,
-        prepared::{GGSWCiphertextPrepared, GLWESecretPrepared, PrepareAlloc},
-    },
-    noise::noise_ggsw_product,
-};
-
-#[allow(clippy::too_many_arguments)]
-pub fn test_ggsw_external_product<B>(
-    module: &Module<B>,
-    basek: usize,
-    k_in: usize,
-    k_out: usize,
-    k_ggsw: usize,
-    digits: usize,
-    rank: usize,
-) where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxAddScalarInplace
-        + VecZnxCopy
-        + VmpPMatAlloc<B>
-        + VecZnxRotateInplace
-        + VmpApplyDftToDftTmpBytes
-        + VmpApplyDftToDft<B>
-        + VmpApplyDftToDftAdd<B>
-        + VmpPrepare<B>
-        + VecZnxBigAlloc<B>
-        + VecZnxDftAlloc<B>
-        + VecZnxBigNormalizeTmpBytes
-        + IDFTTmpA<B>,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>
-        + VecZnxDftAllocBytesImpl<B>
-        + VecZnxBigAllocBytesImpl<B>
-        + TakeSvpPPolImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = k_in.div_ceil(basek * digits);
-    let rows_in: usize = k_in.div_euclid(basek * digits);
-    let digits_in: usize = 1;
-
-    let mut ct_ggsw_lhs_in: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_in, rows_in, digits_in, rank);
-    let mut ct_ggsw_lhs_out: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_out, rows_in, digits_in, rank);
-    let mut ct_ggsw_rhs: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_ggsw, rows, digits, rank);
-    let mut pt_ggsw_lhs: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
-    let mut pt_ggsw_rhs: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
-
-    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]);
-
-    pt_ggsw_lhs.fill_ternary_prob(0, 0.5, &mut source_xs);
-
-    let k: usize = 1;
-
-    pt_ggsw_rhs.to_mut().raw_mut()[k] = 1; //X^{k}
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
-        GGSWCiphertext::encrypt_sk_scratch_space(module, basek, k_ggsw, rank)
-            | GGSWCiphertext::external_product_scratch_space(module, basek, k_out, k_in, k_ggsw, digits, rank),
-    );
-
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk.fill_ternary_prob(0.5, &mut source_xs);
-    let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
-
-    ct_ggsw_rhs.encrypt_sk(
-        module,
-        &pt_ggsw_rhs,
-        &sk_prepared,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    ct_ggsw_lhs_in.encrypt_sk(
-        module,
-        &pt_ggsw_lhs,
-        &sk_prepared,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let ct_rhs_prepared: GGSWCiphertextPrepared<Vec<u8>, B> = ct_ggsw_rhs.prepare_alloc(module, scratch.borrow());
-
-    ct_ggsw_lhs_out.external_product(module, &ct_ggsw_lhs_in, &ct_rhs_prepared, scratch.borrow());
-
-    module.vec_znx_rotate_inplace(k as i64, &mut pt_ggsw_lhs.as_vec_znx_mut(), 0);
-
-    let var_gct_err_lhs: f64 = SIGMA * SIGMA;
-    let var_gct_err_rhs: f64 = 0f64;
-
-    let var_msg: f64 = 1f64 / n as f64; // X^{k}
-    let var_a0_err: f64 = SIGMA * SIGMA;
-    let var_a1_err: f64 = 1f64 / 12f64;
-
-    let max_noise = |_col_j: usize| -> f64 {
-        noise_ggsw_product(
-            n as f64,
-            basek * digits,
-            0.5,
-            var_msg,
-            var_a0_err,
-            var_a1_err,
-            var_gct_err_lhs,
-            var_gct_err_rhs,
-            rank as f64,
-            k_in,
-            k_ggsw,
-        ) + 0.5
-    };
-
-    ct_ggsw_lhs_out.assert_noise(module, &sk_prepared, &pt_ggsw_lhs, max_noise);
-}
-
-#[allow(clippy::too_many_arguments)]
-pub fn test_ggsw_external_product_inplace<B>(
-    module: &Module<B>,
-    basek: usize,
-    k_ct: usize,
-    k_ggsw: usize,
-    digits: usize,
-    rank: usize,
-) where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxAddScalarInplace
-        + VecZnxCopy
-        + VmpPMatAlloc<B>
-        + VecZnxRotateInplace
-        + VmpApplyDftToDftTmpBytes
-        + VmpApplyDftToDft<B>
-        + VmpApplyDftToDftAdd<B>
-        + VmpPrepare<B>
-        + VecZnxBigAlloc<B>
-        + VecZnxDftAlloc<B>
-        + VecZnxBigNormalizeTmpBytes
-        + IDFTTmpA<B>,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>
-        + VecZnxDftAllocBytesImpl<B>
-        + VecZnxBigAllocBytesImpl<B>
-        + TakeSvpPPolImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = k_ct.div_ceil(digits * basek);
-    let rows_in: usize = k_ct.div_euclid(basek * digits);
-    let digits_in: usize = 1;
-
-    let mut ct_ggsw_lhs: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_ct, rows_in, digits_in, rank);
-    let mut ct_ggsw_rhs: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_ggsw, rows, digits, rank);
-
-    let mut pt_ggsw_lhs: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
-    let mut pt_ggsw_rhs: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
-
-    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]);
-
-    pt_ggsw_lhs.fill_ternary_prob(0, 0.5, &mut source_xs);
-
-    let k: usize = 1;
-
-    pt_ggsw_rhs.to_mut().raw_mut()[k] = 1; //X^{k}
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
-        GGSWCiphertext::encrypt_sk_scratch_space(module, basek, k_ggsw, rank)
-            | GGSWCiphertext::external_product_inplace_scratch_space(module, basek, k_ct, k_ggsw, digits, rank),
-    );
-
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk.fill_ternary_prob(0.5, &mut source_xs);
-    let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
-
-    ct_ggsw_rhs.encrypt_sk(
-        module,
-        &pt_ggsw_rhs,
-        &sk_prepared,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    ct_ggsw_lhs.encrypt_sk(
-        module,
-        &pt_ggsw_lhs,
-        &sk_prepared,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let ct_rhs_prepared: GGSWCiphertextPrepared<Vec<u8>, B> = ct_ggsw_rhs.prepare_alloc(module, scratch.borrow());
-
-    ct_ggsw_lhs.external_product_inplace(module, &ct_rhs_prepared, scratch.borrow());
-
-    module.vec_znx_rotate_inplace(k as i64, &mut pt_ggsw_lhs.as_vec_znx_mut(), 0);
-
-    let var_gct_err_lhs: f64 = SIGMA * SIGMA;
-    let var_gct_err_rhs: f64 = 0f64;
-
-    let var_msg: f64 = 1f64 / n as f64; // X^{k}
-    let var_a0_err: f64 = SIGMA * SIGMA;
-    let var_a1_err: f64 = 1f64 / 12f64;
-
-    let max_noise = |_col_j: usize| -> f64 {
-        noise_ggsw_product(
-            n as f64,
-            basek * digits,
-            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,
-        ) + 0.5
-    };
-
-    ct_ggsw_lhs.assert_noise(module, &sk_prepared, &pt_ggsw_lhs, max_noise);
-}

poulpy-core/src/tests/generics/external_product/glwe_ct.rs

@@ -1,282 +0,0 @@
-use poulpy_hal::{
-    api::{
-        DFT, IDFTConsume, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
-        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
-        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace,
-        VecZnxNormalizeTmpBytes, VecZnxRotateInplace, VecZnxSub, VecZnxSubABInplace, VmpApplyDftToDft, VmpApplyDftToDftAdd,
-        VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPrepare,
-    },
-    layouts::{Backend, Module, ScalarZnx, ScratchOwned, ZnxViewMut},
-    oep::{
-        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
-        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl,
-    },
-    source::Source,
-};
-
-use crate::{
-    encryption::SIGMA,
-    layouts::{
-        GGSWCiphertext, GLWECiphertext, GLWEPlaintext, GLWESecret, Infos,
-        prepared::{GGSWCiphertextPrepared, GLWESecretPrepared, PrepareAlloc},
-    },
-    noise::noise_ggsw_product,
-};
-
-#[allow(clippy::too_many_arguments)]
-pub fn test_glwe_external_product<B>(
-    module: &Module<B>,
-    basek: usize,
-    k_out: usize,
-    k_in: usize,
-    k_ggsw: usize,
-    digits: usize,
-    rank: usize,
-) where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxAddScalarInplace
-        + VecZnxRotateInplace
-        + VmpPMatAlloc<B>
-        + VmpPrepare<B>
-        + VmpApplyDftToDftTmpBytes
-        + VmpApplyDftToDft<B>
-        + VmpApplyDftToDftAdd<B>,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + TakeSvpPPolImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = k_in.div_ceil(basek * digits);
-
-    let mut ct_ggsw: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_ggsw, rows, digits, rank);
-    let mut ct_glwe_in: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_in, rank);
-    let mut ct_glwe_out: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_out, rank);
-    let mut pt_rgsw: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
-    let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_in);
-
-    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
-    module.vec_znx_fill_uniform(basek, &mut pt_want.data, 0, k_in, &mut source_xa);
-
-    pt_want.data.at_mut(0, 0)[1] = 1;
-
-    let k: usize = 1;
-
-    pt_rgsw.raw_mut()[k] = 1; // X^{k}
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
-        GGSWCiphertext::encrypt_sk_scratch_space(module, basek, ct_ggsw.k(), rank)
-            | GLWECiphertext::encrypt_sk_scratch_space(module, basek, ct_glwe_in.k())
-            | GLWECiphertext::external_product_scratch_space(
-                module,
-                basek,
-                ct_glwe_out.k(),
-                ct_glwe_in.k(),
-                ct_ggsw.k(),
-                digits,
-                rank,
-            ),
-    );
-
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk.fill_ternary_prob(0.5, &mut source_xs);
-    let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
-
-    ct_ggsw.encrypt_sk(
-        module,
-        &pt_rgsw,
-        &sk_prepared,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    ct_glwe_in.encrypt_sk(
-        module,
-        &pt_want,
-        &sk_prepared,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let ct_ggsw_prepared: GGSWCiphertextPrepared<Vec<u8>, B> = ct_ggsw.prepare_alloc(module, scratch.borrow());
-
-    ct_glwe_out.external_product(module, &ct_glwe_in, &ct_ggsw_prepared, scratch.borrow());
-
-    module.vec_znx_rotate_inplace(k as i64, &mut pt_want.data, 0);
-
-    let var_gct_err_lhs: f64 = SIGMA * SIGMA;
-    let var_gct_err_rhs: f64 = 0f64;
-
-    let var_msg: f64 = 1f64 / n as f64; // X^{k}
-    let var_a0_err: f64 = SIGMA * SIGMA;
-    let var_a1_err: f64 = 1f64 / 12f64;
-
-    let max_noise: f64 = noise_ggsw_product(
-        n as f64,
-        basek * digits,
-        0.5,
-        var_msg,
-        var_a0_err,
-        var_a1_err,
-        var_gct_err_lhs,
-        var_gct_err_rhs,
-        rank as f64,
-        k_in,
-        k_ggsw,
-    );
-
-    ct_glwe_out.assert_noise(module, &sk_prepared, &pt_want, max_noise + 0.5);
-}
-
-#[allow(clippy::too_many_arguments)]
-pub fn test_glwe_external_product_inplace<B>(
-    module: &Module<B>,
-    basek: usize,
-    k_ct: usize,
-    k_ggsw: usize,
-    digits: usize,
-    rank: usize,
-) where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxAddScalarInplace
-        + VecZnxRotateInplace
-        + VmpPMatAlloc<B>
-        + VmpPrepare<B>
-        + VmpApplyDftToDftTmpBytes
-        + VmpApplyDftToDft<B>
-        + VmpApplyDftToDftAdd<B>,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + TakeSvpPPolImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = k_ct.div_ceil(basek * digits);
-
-    let mut ct_ggsw: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_ggsw, rows, digits, rank);
-    let mut ct_glwe: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_ct, rank);
-    let mut pt_rgsw: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
-    let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, 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
-    module.vec_znx_fill_uniform(basek, &mut pt_want.data, 0, k_ct, &mut source_xa);
-
-    pt_want.data.at_mut(0, 0)[1] = 1;
-
-    let k: usize = 1;
-
-    pt_rgsw.raw_mut()[k] = 1; // X^{k}
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
-        GGSWCiphertext::encrypt_sk_scratch_space(module, basek, ct_ggsw.k(), rank)
-            | GLWECiphertext::encrypt_sk_scratch_space(module, basek, ct_glwe.k())
-            | GLWECiphertext::external_product_inplace_scratch_space(module, basek, ct_glwe.k(), ct_ggsw.k(), digits, rank),
-    );
-
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk.fill_ternary_prob(0.5, &mut source_xs);
-    let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
-
-    ct_ggsw.encrypt_sk(
-        module,
-        &pt_rgsw,
-        &sk_prepared,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    ct_glwe.encrypt_sk(
-        module,
-        &pt_want,
-        &sk_prepared,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let ct_ggsw_prepared: GGSWCiphertextPrepared<Vec<u8>, B> = ct_ggsw.prepare_alloc(module, scratch.borrow());
-
-    ct_glwe.external_product_inplace(module, &ct_ggsw_prepared, scratch.borrow());
-
-    module.vec_znx_rotate_inplace(k as i64, &mut pt_want.data, 0);
-
-    let var_gct_err_lhs: f64 = SIGMA * SIGMA;
-    let var_gct_err_rhs: f64 = 0f64;
-
-    let var_msg: f64 = 1f64 / n as f64; // X^{k}
-    let var_a0_err: f64 = SIGMA * SIGMA;
-    let var_a1_err: f64 = 1f64 / 12f64;
-
-    let max_noise: f64 = noise_ggsw_product(
-        n as f64,
-        basek * digits,
-        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,
-    );
-
-    ct_glwe.assert_noise(module, &sk_prepared, &pt_want, max_noise + 0.5);
-}

poulpy-core/src/tests/generics/keyswitch/gglwe_ct.rs

@@ -1,303 +0,0 @@
-use poulpy_hal::{
-    api::{
-        DFT, IDFTConsume, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
-        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
-        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxDftAllocBytes, VecZnxFillUniform,
-        VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VecZnxSubScalarInplace,
-        VecZnxSwithcDegree, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPrepare,
-    },
-    layouts::{Backend, Module, ScratchOwned},
-    oep::{
-        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
-        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl,
-    },
-    source::Source,
-};
-
-use crate::{
-    encryption::SIGMA,
-    layouts::{
-        GGLWESwitchingKey, GLWESecret,
-        prepared::{GGLWESwitchingKeyPrepared, GLWESecretPrepared, PrepareAlloc},
-    },
-    noise::log2_std_noise_gglwe_product,
-};
-
-#[allow(clippy::too_many_arguments)]
-pub fn test_gglwe_switching_key_keyswitch<B>(
-    module: &Module<B>,
-    basek: usize,
-    k_out: usize,
-    k_in: usize,
-    k_ksk: usize,
-    digits: usize,
-    rank_in_s0s1: usize,
-    rank_out_s0s1: usize,
-    rank_out_s1s2: usize,
-) where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxAddScalarInplace
-        + VmpPMatAlloc<B>
-        + VmpPrepare<B>
-        + VmpApplyDftToDftTmpBytes
-        + VmpApplyDftToDft<B>
-        + VmpApplyDftToDftAdd<B>
-        + VecZnxBigNormalizeTmpBytes
-        + VecZnxSwithcDegree
-        + VecZnxSubScalarInplace,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + TakeSvpPPolImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = k_in.div_ceil(basek * digits);
-    let digits_in: usize = 1;
-
-    let mut ct_gglwe_s0s1: GGLWESwitchingKey<Vec<u8>> =
-        GGLWESwitchingKey::alloc(n, basek, k_in, rows, digits_in, rank_in_s0s1, rank_out_s0s1);
-    let mut ct_gglwe_s1s2: GGLWESwitchingKey<Vec<u8>> =
-        GGLWESwitchingKey::alloc(n, basek, k_ksk, rows, digits, rank_out_s0s1, rank_out_s1s2);
-    let mut ct_gglwe_s0s2: GGLWESwitchingKey<Vec<u8>> = GGLWESwitchingKey::alloc(
-        n,
-        basek,
-        k_out,
-        rows,
-        digits_in,
-        rank_in_s0s1,
-        rank_out_s1s2,
-    );
-
-    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]);
-
-    let mut scratch_enc: ScratchOwned<B> = ScratchOwned::alloc(GGLWESwitchingKey::encrypt_sk_scratch_space(
-        module,
-        basek,
-        k_ksk,
-        rank_in_s0s1 | rank_out_s0s1,
-        rank_out_s0s1 | rank_out_s1s2,
-    ));
-    let mut scratch_apply: ScratchOwned<B> = ScratchOwned::alloc(GGLWESwitchingKey::keyswitch_scratch_space(
-        module,
-        basek,
-        k_out,
-        k_in,
-        k_ksk,
-        digits,
-        ct_gglwe_s1s2.rank_in(),
-        ct_gglwe_s1s2.rank_out(),
-    ));
-
-    let mut sk0: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_in_s0s1);
-    sk0.fill_ternary_prob(0.5, &mut source_xs);
-
-    let mut sk1: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_out_s0s1);
-    sk1.fill_ternary_prob(0.5, &mut source_xs);
-
-    let mut sk2: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_out_s1s2);
-    sk2.fill_ternary_prob(0.5, &mut source_xs);
-    let sk2_prepared: GLWESecretPrepared<Vec<u8>, B> = sk2.prepare_alloc(module, scratch_apply.borrow());
-
-    // gglwe_{s1}(s0) = s0 -> s1
-    ct_gglwe_s0s1.encrypt_sk(
-        module,
-        &sk0,
-        &sk1,
-        &mut source_xa,
-        &mut source_xe,
-        scratch_enc.borrow(),
-    );
-
-    // gglwe_{s2}(s1) -> s1 -> s2
-    ct_gglwe_s1s2.encrypt_sk(
-        module,
-        &sk1,
-        &sk2,
-        &mut source_xa,
-        &mut source_xe,
-        scratch_enc.borrow(),
-    );
-
-    let ct_gglwe_s1s2_prepared: GGLWESwitchingKeyPrepared<Vec<u8>, B> =
-        ct_gglwe_s1s2.prepare_alloc(module, scratch_apply.borrow());
-
-    // gglwe_{s1}(s0) (x) gglwe_{s2}(s1) = gglwe_{s2}(s0)
-    ct_gglwe_s0s2.keyswitch(
-        module,
-        &ct_gglwe_s0s1,
-        &ct_gglwe_s1s2_prepared,
-        scratch_apply.borrow(),
-    );
-
-    let max_noise: f64 = log2_std_noise_gglwe_product(
-        n as f64,
-        basek * digits,
-        0.5,
-        0.5,
-        0f64,
-        SIGMA * SIGMA,
-        0f64,
-        rank_out_s0s1 as f64,
-        k_in,
-        k_ksk,
-    );
-
-    ct_gglwe_s0s2
-        .key
-        .assert_noise(module, &sk2_prepared, &sk0.data, max_noise + 0.5);
-}
-
-#[allow(clippy::too_many_arguments)]
-pub fn test_gglwe_switching_key_keyswitch_inplace<B>(
-    module: &Module<B>,
-    basek: usize,
-    k_ct: usize,
-    k_ksk: usize,
-    digits: usize,
-    rank_in: usize,
-    rank_out: usize,
-) where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxAddScalarInplace
-        + VmpPMatAlloc<B>
-        + VmpPrepare<B>
-        + VmpApplyDftToDftTmpBytes
-        + VmpApplyDftToDft<B>
-        + VmpApplyDftToDftAdd<B>
-        + VecZnxBigNormalizeTmpBytes
-        + VecZnxSwithcDegree
-        + VecZnxSubScalarInplace,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + TakeSvpPPolImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = k_ct.div_ceil(basek * digits);
-    let digits_in: usize = 1;
-
-    let mut ct_gglwe_s0s1: GGLWESwitchingKey<Vec<u8>> =
-        GGLWESwitchingKey::alloc(n, basek, k_ct, rows, digits_in, rank_in, rank_out);
-    let mut ct_gglwe_s1s2: GGLWESwitchingKey<Vec<u8>> =
-        GGLWESwitchingKey::alloc(n, basek, k_ksk, rows, digits, rank_out, rank_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]);
-
-    let mut scratch_enc: ScratchOwned<B> = ScratchOwned::alloc(GGLWESwitchingKey::encrypt_sk_scratch_space(
-        module,
-        basek,
-        k_ksk,
-        rank_in | rank_out,
-        rank_out,
-    ));
-    let mut scratch_apply: ScratchOwned<B> = ScratchOwned::alloc(GGLWESwitchingKey::keyswitch_inplace_scratch_space(
-        module, basek, k_ct, k_ksk, digits, rank_out,
-    ));
-
-    let var_xs: f64 = 0.5;
-
-    let mut sk0: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_in);
-    sk0.fill_ternary_prob(var_xs, &mut source_xs);
-
-    let mut sk1: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_out);
-    sk1.fill_ternary_prob(var_xs, &mut source_xs);
-
-    let mut sk2: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_out);
-    sk2.fill_ternary_prob(var_xs, &mut source_xs);
-    let sk2_prepared: GLWESecretPrepared<Vec<u8>, B> = sk2.prepare_alloc(module, scratch_apply.borrow());
-
-    // gglwe_{s1}(s0) = s0 -> s1
-    ct_gglwe_s0s1.encrypt_sk(
-        module,
-        &sk0,
-        &sk1,
-        &mut source_xa,
-        &mut source_xe,
-        scratch_enc.borrow(),
-    );
-
-    // gglwe_{s2}(s1) -> s1 -> s2
-    ct_gglwe_s1s2.encrypt_sk(
-        module,
-        &sk1,
-        &sk2,
-        &mut source_xa,
-        &mut source_xe,
-        scratch_enc.borrow(),
-    );
-
-    let ct_gglwe_s1s2_prepared: GGLWESwitchingKeyPrepared<Vec<u8>, B> =
-        ct_gglwe_s1s2.prepare_alloc(module, scratch_apply.borrow());
-
-    // gglwe_{s1}(s0) (x) gglwe_{s2}(s1) = gglwe_{s2}(s0)
-    ct_gglwe_s0s1.keyswitch_inplace(module, &ct_gglwe_s1s2_prepared, scratch_apply.borrow());
-
-    let ct_gglwe_s0s2: GGLWESwitchingKey<Vec<u8>> = ct_gglwe_s0s1;
-
-    let max_noise: f64 = log2_std_noise_gglwe_product(
-        n as f64,
-        basek * digits,
-        var_xs,
-        var_xs,
-        0f64,
-        SIGMA * SIGMA,
-        0f64,
-        rank_out as f64,
-        k_ct,
-        k_ksk,
-    );
-
-    ct_gglwe_s0s2
-        .key
-        .assert_noise(module, &sk2_prepared, &sk0.data, max_noise + 0.5);
-}

poulpy-core/src/tests/generics/keyswitch/ggsw_ct.rs

@@ -1,305 +0,0 @@
-use poulpy_hal::{
-    api::{
-        DFT, IDFTConsume, IDFTTmpA, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApply, SvpApplyInplace, SvpPPolAlloc,
-        SvpPPolAllocBytes, SvpPrepare, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAddInplace,
-        VecZnxBigAddSmallInplace, VecZnxBigAlloc, VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
-        VecZnxDftAddInplace, VecZnxDftAlloc, VecZnxDftAllocBytes, VecZnxDftCopy, VecZnxFillUniform, VecZnxNormalize,
-        VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VecZnxSwithcDegree, VmpApplyDftToDft,
-        VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPrepare,
-    },
-    layouts::{Backend, Module, ScalarZnx, ScratchOwned},
-    oep::{
-        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
-        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl,
-    },
-    source::Source,
-};
-
-use crate::{
-    encryption::SIGMA,
-    layouts::{
-        GGLWESwitchingKey, GGLWETensorKey, GGSWCiphertext, GLWESecret,
-        prepared::{GGLWESwitchingKeyPrepared, GGLWETensorKeyPrepared, GLWESecretPrepared, PrepareAlloc},
-    },
-    noise::noise_ggsw_keyswitch,
-};
-
-#[allow(clippy::too_many_arguments)]
-pub fn test_ggsw_keyswitch<B>(
-    module: &Module<B>,
-    basek: usize,
-    k_out: usize,
-    k_in: usize,
-    k_ksk: usize,
-    k_tsk: usize,
-    digits: usize,
-    rank: usize,
-) where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxAddScalarInplace
-        + VmpPMatAlloc<B>
-        + VmpPrepare<B>
-        + VmpApplyDftToDftTmpBytes
-        + VmpApplyDftToDft<B>
-        + VmpApplyDftToDftAdd<B>
-        + VecZnxBigNormalizeTmpBytes
-        + VecZnxSwithcDegree
-        + SvpApply<B>
-        + IDFTTmpA<B>
-        + VecZnxDftCopy<B>
-        + VecZnxDftAddInplace<B>
-        + VecZnxBigAlloc<B>
-        + VecZnxDftAlloc<B>,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + TakeSvpPPolImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = k_in.div_ceil(digits * basek);
-
-    let digits_in: usize = 1;
-
-    let mut ct_in: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_in, rows, digits_in, rank);
-    let mut ct_out: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_out, rows, digits_in, rank);
-    let mut tsk: GGLWETensorKey<Vec<u8>> = GGLWETensorKey::alloc(n, basek, k_ksk, rows, digits, rank);
-    let mut ksk: GGLWESwitchingKey<Vec<u8>> = GGLWESwitchingKey::alloc(n, basek, k_ksk, rows, digits, rank, rank);
-    let mut pt_scalar: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
-
-    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]);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
-        GGSWCiphertext::encrypt_sk_scratch_space(module, basek, k_in, rank)
-            | GGLWESwitchingKey::encrypt_sk_scratch_space(module, basek, k_ksk, rank, rank)
-            | GGLWETensorKey::encrypt_sk_scratch_space(module, basek, k_tsk, rank)
-            | GGSWCiphertext::keyswitch_scratch_space(
-                module, basek, k_out, k_in, k_ksk, digits, k_tsk, digits, rank,
-            ),
-    );
-
-    let var_xs: f64 = 0.5;
-
-    let mut sk_in: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk_in.fill_ternary_prob(var_xs, &mut source_xs);
-    let sk_in_dft: GLWESecretPrepared<Vec<u8>, B> = sk_in.prepare_alloc(module, scratch.borrow());
-
-    let mut sk_out: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk_out.fill_ternary_prob(var_xs, &mut source_xs);
-    let sk_out_prepared: GLWESecretPrepared<Vec<u8>, B> = sk_out.prepare_alloc(module, scratch.borrow());
-
-    ksk.encrypt_sk(
-        module,
-        &sk_in,
-        &sk_out,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-    tsk.encrypt_sk(
-        module,
-        &sk_out,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    pt_scalar.fill_ternary_hw(0, n, &mut source_xs);
-
-    ct_in.encrypt_sk(
-        module,
-        &pt_scalar,
-        &sk_in_dft,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let ksk_prepared: GGLWESwitchingKeyPrepared<Vec<u8>, B> = ksk.prepare_alloc(module, scratch.borrow());
-    let tsk_prepared: GGLWETensorKeyPrepared<Vec<u8>, B> = tsk.prepare_alloc(module, scratch.borrow());
-
-    ct_out.keyswitch(
-        module,
-        &ct_in,
-        &ksk_prepared,
-        &tsk_prepared,
-        scratch.borrow(),
-    );
-
-    let max_noise = |col_j: usize| -> f64 {
-        noise_ggsw_keyswitch(
-            n as f64,
-            basek * digits,
-            col_j,
-            var_xs,
-            0f64,
-            SIGMA * SIGMA,
-            0f64,
-            rank as f64,
-            k_in,
-            k_ksk,
-            k_tsk,
-        ) + 0.5
-    };
-
-    ct_out.assert_noise(module, &sk_out_prepared, &pt_scalar, max_noise);
-}
-
-#[allow(clippy::too_many_arguments)]
-pub fn test_ggsw_keyswitch_inplace<B>(
-    module: &Module<B>,
-    basek: usize,
-    k_ct: usize,
-    k_ksk: usize,
-    k_tsk: usize,
-    digits: usize,
-    rank: usize,
-) where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxAddScalarInplace
-        + VmpPMatAlloc<B>
-        + VmpPrepare<B>
-        + VmpApplyDftToDftTmpBytes
-        + VmpApplyDftToDft<B>
-        + VmpApplyDftToDftAdd<B>
-        + VecZnxBigNormalizeTmpBytes
-        + VecZnxSwithcDegree
-        + SvpApply<B>
-        + IDFTTmpA<B>
-        + VecZnxDftCopy<B>
-        + VecZnxDftAddInplace<B>
-        + VecZnxBigAlloc<B>
-        + VecZnxDftAlloc<B>,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + TakeSvpPPolImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = k_ct.div_ceil(digits * basek);
-
-    let digits_in: usize = 1;
-
-    let mut ct: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_ct, rows, digits_in, rank);
-    let mut tsk: GGLWETensorKey<Vec<u8>> = GGLWETensorKey::alloc(n, basek, k_tsk, rows, digits, rank);
-    let mut ksk: GGLWESwitchingKey<Vec<u8>> = GGLWESwitchingKey::alloc(n, basek, k_ksk, rows, digits, rank, rank);
-    let mut pt_scalar: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
-
-    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]);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
-        GGSWCiphertext::encrypt_sk_scratch_space(module, basek, k_ct, rank)
-            | GGLWESwitchingKey::encrypt_sk_scratch_space(module, basek, k_ksk, rank, rank)
-            | GGLWETensorKey::encrypt_sk_scratch_space(module, basek, k_tsk, rank)
-            | GGSWCiphertext::keyswitch_inplace_scratch_space(module, basek, k_ct, k_ksk, digits, k_tsk, digits, rank),
-    );
-
-    let var_xs: f64 = 0.5;
-
-    let mut sk_in: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk_in.fill_ternary_prob(var_xs, &mut source_xs);
-    let sk_in_dft: GLWESecretPrepared<Vec<u8>, B> = sk_in.prepare_alloc(module, scratch.borrow());
-
-    let mut sk_out: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk_out.fill_ternary_prob(var_xs, &mut source_xs);
-    let sk_out_prepared: GLWESecretPrepared<Vec<u8>, B> = sk_out.prepare_alloc(module, scratch.borrow());
-
-    ksk.encrypt_sk(
-        module,
-        &sk_in,
-        &sk_out,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-    tsk.encrypt_sk(
-        module,
-        &sk_out,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    pt_scalar.fill_ternary_hw(0, n, &mut source_xs);
-
-    ct.encrypt_sk(
-        module,
-        &pt_scalar,
-        &sk_in_dft,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let ksk_prepared: GGLWESwitchingKeyPrepared<Vec<u8>, B> = ksk.prepare_alloc(module, scratch.borrow());
-    let tsk_prepared: GGLWETensorKeyPrepared<Vec<u8>, B> = tsk.prepare_alloc(module, scratch.borrow());
-
-    ct.keyswitch_inplace(module, &ksk_prepared, &tsk_prepared, scratch.borrow());
-
-    let max_noise = |col_j: usize| -> f64 {
-        noise_ggsw_keyswitch(
-            n as f64,
-            basek * digits,
-            col_j,
-            var_xs,
-            0f64,
-            SIGMA * SIGMA,
-            0f64,
-            rank as f64,
-            k_ct,
-            k_ksk,
-            k_tsk,
-        ) + 0.5
-    };
-
-    ct.assert_noise(module, &sk_out_prepared, &pt_scalar, max_noise);
-}

poulpy-core/src/tests/generics/keyswitch/glwe_ct.rs

@@ -1,251 +0,0 @@
-use poulpy_hal::{
-    api::{
-        DFT, IDFTConsume, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
-        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
-        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxDftAllocBytes, VecZnxFillUniform,
-        VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VecZnxSwithcDegree,
-        VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPrepare,
-    },
-    layouts::{Backend, Module, ScratchOwned},
-    oep::{
-        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
-        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl,
-    },
-    source::Source,
-};
-
-use crate::{
-    encryption::SIGMA,
-    layouts::{
-        GGLWESwitchingKey, GLWECiphertext, GLWEPlaintext, GLWESecret, Infos,
-        prepared::{GGLWESwitchingKeyPrepared, GLWESecretPrepared, PrepareAlloc},
-    },
-    noise::log2_std_noise_gglwe_product,
-};
-
-#[allow(clippy::too_many_arguments)]
-pub fn test_glwe_keyswitch<B>(
-    module: &Module<B>,
-    basek: usize,
-    k_out: usize,
-    k_in: usize,
-    k_ksk: usize,
-    digits: usize,
-    rank_in: usize,
-    rank_out: usize,
-) where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxAddScalarInplace
-        + VmpPMatAlloc<B>
-        + VmpPrepare<B>
-        + VmpApplyDftToDftTmpBytes
-        + VmpApplyDftToDft<B>
-        + VmpApplyDftToDftAdd<B>
-        + VecZnxBigNormalizeTmpBytes
-        + VecZnxSwithcDegree,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + TakeSvpPPolImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>,
-{
-    let n = module.n();
-    let rows: usize = k_in.div_ceil(basek * digits);
-
-    let mut ksk: GGLWESwitchingKey<Vec<u8>> = GGLWESwitchingKey::alloc(n, basek, k_ksk, rows, digits, rank_in, rank_out);
-    let mut ct_in: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_in, rank_in);
-    let mut ct_out: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_out, rank_out);
-    let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_in);
-
-    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]);
-
-    module.vec_znx_fill_uniform(basek, &mut pt_want.data, 0, k_in, &mut source_xa);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
-        GGLWESwitchingKey::encrypt_sk_scratch_space(module, basek, ksk.k(), rank_in, rank_out)
-            | GLWECiphertext::encrypt_sk_scratch_space(module, basek, ct_in.k())
-            | GLWECiphertext::keyswitch_scratch_space(
-                module,
-                basek,
-                ct_out.k(),
-                ct_in.k(),
-                ksk.k(),
-                digits,
-                rank_in,
-                rank_out,
-            ),
-    );
-
-    let mut sk_in: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_in);
-    sk_in.fill_ternary_prob(0.5, &mut source_xs);
-    let sk_in_prepared: GLWESecretPrepared<Vec<u8>, B> = sk_in.prepare_alloc(module, scratch.borrow());
-
-    let mut sk_out: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_out);
-    sk_out.fill_ternary_prob(0.5, &mut source_xs);
-    let sk_out_prepared: GLWESecretPrepared<Vec<u8>, B> = sk_out.prepare_alloc(module, scratch.borrow());
-
-    ksk.encrypt_sk(
-        module,
-        &sk_in,
-        &sk_out,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    ct_in.encrypt_sk(
-        module,
-        &pt_want,
-        &sk_in_prepared,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let ksk_prepared: GGLWESwitchingKeyPrepared<Vec<u8>, B> = ksk.prepare_alloc(module, scratch.borrow());
-
-    ct_out.keyswitch(module, &ct_in, &ksk_prepared, scratch.borrow());
-
-    let max_noise: f64 = log2_std_noise_gglwe_product(
-        module.n() as f64,
-        basek * digits,
-        0.5,
-        0.5,
-        0f64,
-        SIGMA * SIGMA,
-        0f64,
-        rank_in as f64,
-        k_in,
-        k_ksk,
-    );
-
-    ct_out.assert_noise(module, &sk_out_prepared, &pt_want, max_noise + 0.5);
-}
-
-pub fn test_glwe_keyswitch_inplace<B>(module: &Module<B>, basek: usize, k_ct: usize, k_ksk: usize, digits: usize, rank: usize)
-where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxAddScalarInplace
-        + VmpPMatAlloc<B>
-        + VmpPrepare<B>
-        + VmpApplyDftToDftTmpBytes
-        + VmpApplyDftToDft<B>
-        + VmpApplyDftToDftAdd<B>
-        + VecZnxBigNormalizeTmpBytes
-        + VecZnxSwithcDegree,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + TakeSvpPPolImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>,
-{
-    let n: usize = module.n();
-    let rows: usize = k_ct.div_ceil(basek * digits);
-
-    let mut ksk: GGLWESwitchingKey<Vec<u8>> = GGLWESwitchingKey::alloc(n, basek, k_ksk, rows, digits, rank, rank);
-    let mut ct_glwe: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_ct, rank);
-    let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, 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]);
-
-    module.vec_znx_fill_uniform(basek, &mut pt_want.data, 0, k_ct, &mut source_xa);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
-        GGLWESwitchingKey::encrypt_sk_scratch_space(module, basek, ksk.k(), rank, rank)
-            | GLWECiphertext::encrypt_sk_scratch_space(module, basek, ct_glwe.k())
-            | GLWECiphertext::keyswitch_inplace_scratch_space(module, basek, ct_glwe.k(), ksk.k(), digits, rank),
-    );
-
-    let mut sk_in: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk_in.fill_ternary_prob(0.5, &mut source_xs);
-    let sk_in_prepared: GLWESecretPrepared<Vec<u8>, B> = sk_in.prepare_alloc(module, scratch.borrow());
-
-    let mut sk_out: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk_out.fill_ternary_prob(0.5, &mut source_xs);
-    let sk_out_prepared: GLWESecretPrepared<Vec<u8>, B> = sk_out.prepare_alloc(module, scratch.borrow());
-
-    ksk.encrypt_sk(
-        module,
-        &sk_in,
-        &sk_out,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    ct_glwe.encrypt_sk(
-        module,
-        &pt_want,
-        &sk_in_prepared,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let ksk_prepared: GGLWESwitchingKeyPrepared<Vec<u8>, B> = ksk.prepare_alloc(module, scratch.borrow());
-
-    ct_glwe.keyswitch_inplace(module, &ksk_prepared, scratch.borrow());
-
-    let max_noise: f64 = log2_std_noise_gglwe_product(
-        module.n() as f64,
-        basek * digits,
-        0.5,
-        0.5,
-        0f64,
-        SIGMA * SIGMA,
-        0f64,
-        rank as f64,
-        k_ct,
-        k_ksk,
-    );
-
-    ct_glwe.assert_noise(module, &sk_out_prepared, &pt_want, max_noise + 0.5);
-}

poulpy-core/src/tests/generics/trace.rs

@@ -1,167 +0,0 @@
-use std::collections::HashMap;
-
-use poulpy_hal::{
-    api::{
-        DFT, IDFTConsume, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
-        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism, VecZnxBigAddInplace,
-        VecZnxBigAddSmallInplace, VecZnxBigAllocBytes, VecZnxBigAutomorphismInplace, VecZnxBigNormalize,
-        VecZnxBigNormalizeTmpBytes, VecZnxBigSubSmallBInplace, VecZnxCopy, VecZnxDftAllocBytes, VecZnxFillUniform,
-        VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxRotateInplace, VecZnxRshInplace, VecZnxSub,
-        VecZnxSubABInplace, VecZnxSwithcDegree, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes, VmpPMatAlloc,
-        VmpPrepare,
-    },
-    layouts::{Backend, Module, ScratchOwned, ZnxView, ZnxViewMut},
-    oep::{
-        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
-        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl,
-    },
-    source::Source,
-};
-
-use crate::{
-    encryption::SIGMA,
-    layouts::{
-        GGLWEAutomorphismKey, GLWECiphertext, GLWEPlaintext, GLWESecret, Infos,
-        prepared::{GGLWEAutomorphismKeyPrepared, GLWESecretPrepared, PrepareAlloc},
-    },
-    noise::var_noise_gglwe_product,
-};
-
-pub fn test_glwe_trace_inplace<B>(module: &Module<B>, basek: usize, k: usize, rank: usize)
-where
-    Module<B>: VecZnxDftAllocBytes
-        + VecZnxAutomorphism
-        + VecZnxBigAutomorphismInplace<B>
-        + VecZnxBigSubSmallBInplace<B>
-        + VecZnxRshInplace
-        + VecZnxRotateInplace
-        + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
-        + VecZnxFillUniform
-        + VecZnxSubABInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub
-        + SvpPrepare<B>
-        + SvpPPolAllocBytes
-        + SvpPPolAlloc<B>
-        + VecZnxBigAllocBytes
-        + VecZnxBigAddInplace<B>
-        + VecZnxBigAddSmallInplace<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxAddScalarInplace
-        + VmpPMatAlloc<B>
-        + VmpPrepare<B>
-        + VmpApplyDftToDftTmpBytes
-        + VmpApplyDftToDft<B>
-        + VmpApplyDftToDftAdd<B>
-        + VecZnxBigNormalizeTmpBytes
-        + VecZnxSwithcDegree
-        + VecZnxCopy,
-    B: Backend
-        + TakeVecZnxDftImpl<B>
-        + TakeVecZnxBigImpl<B>
-        + TakeSvpPPolImpl<B>
-        + ScratchOwnedAllocImpl<B>
-        + ScratchOwnedBorrowImpl<B>
-        + ScratchAvailableImpl<B>
-        + TakeScalarZnxImpl<B>
-        + TakeVecZnxImpl<B>,
-{
-    let n: usize = module.n();
-    let k_autokey: usize = k + basek;
-
-    let digits: usize = 1;
-    let rows: usize = k.div_ceil(basek * digits);
-
-    let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k, rank);
-    let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k);
-    let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k);
-
-    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]);
-
-    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
-        GLWECiphertext::encrypt_sk_scratch_space(module, basek, ct.k())
-            | GLWECiphertext::decrypt_scratch_space(module, basek, ct.k())
-            | GGLWEAutomorphismKey::encrypt_sk_scratch_space(module, basek, k_autokey, rank)
-            | GLWECiphertext::trace_inplace_scratch_space(module, basek, ct.k(), k_autokey, digits, rank),
-    );
-
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
-    sk.fill_ternary_prob(0.5, &mut source_xs);
-    let sk_dft: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
-
-    let mut data_want: Vec<i64> = vec![0i64; n];
-
-    data_want
-        .iter_mut()
-        .for_each(|x| *x = source_xa.next_i64() & 0xFF);
-
-    module.vec_znx_fill_uniform(basek, &mut pt_have.data, 0, k, &mut source_xa);
-
-    ct.encrypt_sk(
-        module,
-        &pt_have,
-        &sk_dft,
-        &mut source_xa,
-        &mut source_xe,
-        scratch.borrow(),
-    );
-
-    let mut auto_keys: HashMap<i64, GGLWEAutomorphismKeyPrepared<Vec<u8>, B>> = HashMap::new();
-    let gal_els: Vec<i64> = GLWECiphertext::trace_galois_elements(module);
-    let mut tmp: GGLWEAutomorphismKey<Vec<u8>> = GGLWEAutomorphismKey::alloc(n, basek, k_autokey, rows, digits, rank);
-    gal_els.iter().for_each(|gal_el| {
-        tmp.encrypt_sk(
-            module,
-            *gal_el,
-            &sk,
-            &mut source_xa,
-            &mut source_xe,
-            scratch.borrow(),
-        );
-        let atk_prepared: GGLWEAutomorphismKeyPrepared<Vec<u8>, B> = tmp.prepare_alloc(module, scratch.borrow());
-        auto_keys.insert(*gal_el, atk_prepared);
-    });
-
-    ct.trace_inplace(module, 0, 5, &auto_keys, scratch.borrow());
-    ct.trace_inplace(module, 5, module.log_n(), &auto_keys, scratch.borrow());
-
-    (0..pt_want.size()).for_each(|i| pt_want.data.at_mut(0, i)[0] = pt_have.data.at(0, i)[0]);
-
-    ct.decrypt(module, &mut pt_have, &sk_dft, scratch.borrow());
-
-    module.vec_znx_sub_ab_inplace(&mut pt_want.data, 0, &pt_have.data, 0);
-    module.vec_znx_normalize_inplace(basek, &mut pt_want.data, 0, scratch.borrow());
-
-    let noise_have: f64 = pt_want.std().log2();
-
-    let mut noise_want: f64 = var_noise_gglwe_product(
-        n as f64,
-        basek,
-        0.5,
-        0.5,
-        1.0 / 12.0,
-        SIGMA * SIGMA,
-        0.0,
-        rank as f64,
-        k,
-        k_autokey,
-    );
-    noise_want += SIGMA * SIGMA * (-2.0 * (k) as f64).exp2();
-    noise_want += n as f64 * 1.0 / 12.0 * 0.5 * rank as f64 * (-2.0 * (k) as f64).exp2();
-    noise_want = noise_want.sqrt().log2();
-
-    assert!(
-        (noise_have - noise_want).abs() < 1.0,
-        "{} > {}",
-        noise_have,
-        noise_want
-    );
-}

poulpy-core/src/tests/implementation/cpu_spqlios/fft64/gglwe.rs

@@ -1,246 +0,0 @@
-use poulpy_backend::cpu_spqlios::FFT64;
-use poulpy_hal::{api::ModuleNew, layouts::Module};
-
-use crate::tests::generics::{
-    automorphism::{test_gglwe_automorphism_key_automorphism, test_gglwe_automorphism_key_automorphism_inplace},
-    encryption::{
-        test_gglwe_automorphisk_key_compressed_encrypt_sk, test_gglwe_automorphisk_key_encrypt_sk,
-        test_gglwe_switching_key_compressed_encrypt_sk, test_gglwe_switching_key_encrypt_sk,
-        test_glwe_tensor_key_compressed_encrypt_sk, test_glwe_tensor_key_encrypt_sk,
-    },
-    external_product::{test_gglwe_switching_key_external_product, test_gglwe_switching_key_external_product_inplace},
-    keyswitch::{test_gglwe_switching_key_keyswitch, test_gglwe_switching_key_keyswitch_inplace},
-};
-
-#[test]
-fn gglwe_switching_key_encrypt_sk() {
-    let log_n: usize = 8;
-    let module = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_ksk: usize = 54;
-    let digits: usize = k_ksk / basek;
-    (1..4).for_each(|rank_in| {
-        (1..4).for_each(|rank_out| {
-            (1..digits + 1).for_each(|di| {
-                println!(
-                    "test_gglwe_switching_key_encrypt_sk digits: {} ranks: ({} {})",
-                    di, rank_in, rank_out
-                );
-                test_gglwe_switching_key_encrypt_sk(&module, basek, k_ksk, di, rank_in, rank_out);
-            });
-        });
-    });
-}
-
-#[test]
-fn gglwe_switching_key_compressed_encrypt_sk() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_ksk: usize = 54;
-    let digits: usize = k_ksk / basek;
-    (1..4).for_each(|rank_in| {
-        (1..4).for_each(|rank_out| {
-            (1..digits + 1).for_each(|di| {
-                println!(
-                    "test_gglwe_switching_key_compressed_encrypt_sk digits: {} ranks: ({} {})",
-                    di, rank_in, rank_out
-                );
-                test_gglwe_switching_key_compressed_encrypt_sk(&module, basek, k_ksk, di, rank_in, rank_out);
-            });
-        });
-    });
-}
-
-#[test]
-fn gglwe_switching_key_keyswitch() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_in: usize = 60;
-    let digits: usize = k_in.div_ceil(basek);
-    (1..4).for_each(|rank_in_s0s1| {
-        (1..4).for_each(|rank_out_s0s1| {
-            (1..4).for_each(|rank_out_s1s2| {
-                (1..digits + 1).for_each(|di| {
-                    let k_ksk: usize = k_in + basek * di;
-                    println!(
-                        "test_gglwe_switching_key_keyswitch digits: {} ranks: ({},{},{})",
-                        di, rank_in_s0s1, rank_out_s0s1, rank_out_s1s2
-                    );
-                    let k_out: usize = k_ksk; // Better capture noise.
-                    test_gglwe_switching_key_keyswitch(
-                        &module,
-                        basek,
-                        k_out,
-                        k_in,
-                        k_ksk,
-                        di,
-                        rank_in_s0s1,
-                        rank_out_s0s1,
-                        rank_out_s1s2,
-                    );
-                })
-            })
-        });
-    });
-}
-
-#[test]
-fn gglwe_switching_key_keyswitch_inplace() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_ct: usize = 60;
-    let digits: usize = k_ct.div_ceil(basek);
-    (1..4).for_each(|rank_in_s0s1| {
-        (1..4).for_each(|rank_out_s0s1| {
-            (1..digits + 1).for_each(|di| {
-                let k_ksk: usize = k_ct + basek * di;
-                println!(
-                    "test_gglwe_switching_key_keyswitch_inplace digits: {} ranks: ({},{})",
-                    di, rank_in_s0s1, rank_out_s0s1
-                );
-                test_gglwe_switching_key_keyswitch_inplace(&module, basek, k_ct, k_ksk, di, rank_in_s0s1, rank_out_s0s1);
-            });
-        });
-    });
-}
-
-#[test]
-fn gglwe_switching_key_external_product() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_in: usize = 60;
-    let digits: usize = k_in.div_ceil(basek);
-    (1..4).for_each(|rank_in| {
-        (1..4).for_each(|rank_out| {
-            (1..digits + 1).for_each(|di| {
-                let k_ggsw: usize = k_in + basek * di;
-                println!(
-                    "test_gglwe_switching_key_external_product digits: {} ranks: ({} {})",
-                    di, rank_in, rank_out
-                );
-                let k_out: usize = k_in; // Better capture noise.
-                test_gglwe_switching_key_external_product(&module, basek, k_out, k_in, k_ggsw, di, rank_in, rank_out);
-            });
-        });
-    });
-}
-
-#[test]
-fn gglwe_switching_key_external_product_inplace() {
-    let log_n: usize = 5;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_ct: usize = 60;
-    let digits: usize = k_ct.div_ceil(basek);
-    (1..4).for_each(|rank_in| {
-        (1..4).for_each(|rank_out| {
-            (1..digits).for_each(|di| {
-                let k_ggsw: usize = k_ct + basek * di;
-                println!(
-                    "test_gglwe_switching_key_external_product_inplace digits: {} ranks: ({} {})",
-                    di, rank_in, rank_out
-                );
-                test_gglwe_switching_key_external_product_inplace(&module, basek, k_ct, k_ggsw, di, rank_in, rank_out);
-            });
-        });
-    });
-}
-
-#[test]
-fn gglwe_automorphisk_key_encrypt_sk() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k: usize = 60;
-    let digits: usize = k.div_ceil(basek) - 1;
-    (1..4).for_each(|rank| {
-        (2..digits + 1).for_each(|di| {
-            println!(
-                "test_gglwe_automorphisk_key_encrypt_sk digits: {} rank: {}",
-                di, rank
-            );
-            test_gglwe_automorphisk_key_encrypt_sk(&module, basek, k, di, rank);
-        });
-    });
-}
-
-#[test]
-fn gglwe_automorphisk_key_compressed_encrypt_sk() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k: usize = 60;
-    let digits: usize = k.div_ceil(basek) - 1;
-    (1..4).for_each(|rank| {
-        (2..digits + 1).for_each(|di| {
-            println!(
-                "test_gglwe_automorphisk_key_compressed_encrypt_sk digits: {} rank: {}",
-                di, rank
-            );
-            test_gglwe_automorphisk_key_compressed_encrypt_sk(&module, basek, k, di, rank);
-        });
-    });
-}
-
-#[test]
-fn gglwe_automorphism_key_automorphism() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_in: usize = 60;
-    let k_out: usize = 40;
-    let digits: usize = k_in.div_ceil(basek);
-    (1..4).for_each(|rank| {
-        (2..digits + 1).for_each(|di| {
-            println!(
-                "test_gglwe_automorphism_key_automorphism: {} rank: {}",
-                di, rank
-            );
-            let k_apply: usize = (digits + di) * basek;
-            test_gglwe_automorphism_key_automorphism(&module, -1, 5, basek, di, k_in, k_out, k_apply, rank);
-        });
-    });
-}
-
-#[test]
-fn gglwe_automorphism_key_automorphism_inplace() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_in: usize = 60;
-    let digits: usize = k_in.div_ceil(basek);
-    (1..4).for_each(|rank| {
-        (2..digits + 1).for_each(|di| {
-            println!(
-                "test_gglwe_automorphism_key_automorphism_inplace: {} rank: {}",
-                di, rank
-            );
-            let k_apply: usize = (digits + di) * basek;
-            test_gglwe_automorphism_key_automorphism_inplace(&module, -1, 5, basek, di, k_in, k_apply, rank);
-        });
-    });
-}
-
-#[test]
-fn glwe_tensor_key_encrypt_sk() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    (1..4).for_each(|rank| {
-        println!("test_glwe_tensor_key_encrypt_sk rank: {}", rank);
-        test_glwe_tensor_key_encrypt_sk(&module, 16, 54, rank);
-    });
-}
-
-#[test]
-fn glwe_tensor_key_compressed_encrypt_sk() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    (1..4).for_each(|rank| {
-        println!("test_glwe_tensor_key_compressed_encrypt_sk rank: {}", rank);
-        test_glwe_tensor_key_compressed_encrypt_sk(&module, 16, 54, rank);
-    });
-}

poulpy-core/src/tests/implementation/cpu_spqlios/fft64/ggws.rs

@@ -1,148 +0,0 @@
-use poulpy_backend::cpu_spqlios::FFT64;
-use poulpy_hal::{api::ModuleNew, layouts::Module};
-
-use crate::tests::generics::{
-    automorphism::{test_ggsw_automorphism, test_ggsw_automorphism_inplace},
-    encryption::{test_ggsw_compressed_encrypt_sk, test_ggsw_encrypt_sk},
-    external_product::{test_ggsw_external_product, test_ggsw_external_product_inplace},
-    keyswitch::{test_ggsw_keyswitch, test_ggsw_keyswitch_inplace},
-};
-
-#[test]
-fn ggsw_encrypt_sk() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_ct: usize = 54;
-    let digits: usize = k_ct / basek;
-    (1..4).for_each(|rank| {
-        (1..digits + 1).for_each(|di| {
-            println!("test_ggsw_encrypt_sk digits: {} rank: {}", di, rank);
-            test_ggsw_encrypt_sk(&module, basek, k_ct, di, rank);
-        });
-    });
-}
-
-#[test]
-fn ggsw_compressed_encrypt_sk() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_ct: usize = 54;
-    let digits: usize = k_ct / basek;
-    (1..4).for_each(|rank| {
-        (1..digits + 1).for_each(|di| {
-            println!(
-                "test_ggsw_compressed_encrypt_sk digits: {} rank: {}",
-                di, rank
-            );
-            test_ggsw_compressed_encrypt_sk(&module, basek, k_ct, di, rank);
-        });
-    });
-}
-
-#[test]
-fn ggsw_keyswitch() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_in: usize = 54;
-    let digits: usize = k_in.div_ceil(basek);
-    (1..4).for_each(|rank| {
-        (1..digits + 1).for_each(|di| {
-            let k_ksk: usize = k_in + basek * di;
-            let k_tsk: usize = k_ksk;
-            println!("test_ggsw_keyswitch digits: {} rank: {}", di, rank);
-            let k_out: usize = k_ksk; // Better capture noise.
-            test_ggsw_keyswitch(&module, basek, k_out, k_in, k_ksk, k_tsk, di, rank);
-        });
-    });
-}
-
-#[test]
-fn ggsw_keyswitch_inplace() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_ct: usize = 54;
-    let digits: usize = k_ct.div_ceil(basek);
-    (1..4).for_each(|rank| {
-        (1..digits + 1).for_each(|di| {
-            let k_ksk: usize = k_ct + basek * di;
-            let k_tsk: usize = k_ksk;
-            println!("test_ggsw_keyswitch_inplace digits: {} rank: {}", di, rank);
-            test_ggsw_keyswitch_inplace(&module, basek, k_ct, k_ksk, k_tsk, di, rank);
-        });
-    });
-}
-
-#[test]
-fn ggsw_automorphism() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_in: usize = 54;
-    let digits: usize = k_in.div_ceil(basek);
-    (1..4).for_each(|rank| {
-        (1..digits + 1).for_each(|di| {
-            let k_ksk: usize = k_in + basek * di;
-            let k_tsk: usize = k_ksk;
-            println!("test_ggsw_automorphism rank: {}", rank);
-            let k_out: usize = k_ksk; // Better capture noise.
-            test_ggsw_automorphism(-5, &module, basek, k_out, k_in, k_ksk, k_tsk, di, rank);
-        });
-    });
-}
-
-#[test]
-fn ggsw_automorphism_inplace() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_ct: usize = 54;
-    let digits: usize = k_ct.div_ceil(basek);
-    (1..4).for_each(|rank| {
-        (1..digits + 1).for_each(|di| {
-            let k_ksk: usize = k_ct + basek * di;
-            let k_tsk: usize = k_ksk;
-            println!("test_ggsw_automorphism_inplace rank: {}", rank);
-            test_ggsw_automorphism_inplace(-5, &module, basek, k_ct, k_ksk, k_tsk, di, rank);
-        });
-    });
-}
-
-#[test]
-fn ggsw_external_product() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_in: usize = 60;
-    let digits: usize = k_in.div_ceil(basek);
-    (1..4).for_each(|rank| {
-        (1..digits + 1).for_each(|di| {
-            let k_ggsw: usize = k_in + basek * di;
-            println!("test external_product digits: {} ranks: {}", di, rank);
-            let k_out: usize = k_in; // Better capture noise.
-            test_ggsw_external_product(&module, basek, k_in, k_out, k_ggsw, di, rank);
-        });
-    });
-}
-
-#[test]
-fn ggsw_external_product_inplace() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_ct: usize = 60;
-    let digits: usize = k_ct.div_ceil(basek);
-    (1..4).for_each(|rank| {
-        (1..digits).for_each(|di| {
-            let k_ggsw: usize = k_ct + basek * di;
-            println!(
-                "test_ggsw_external_product_inplace digits: {} rank: {}",
-                di, rank
-            );
-            test_ggsw_external_product_inplace(&module, basek, k_ct, k_ggsw, di, rank);
-        });
-    });
-}

poulpy-core/src/tests/implementation/cpu_spqlios/fft64/glwe.rs

@@ -1,177 +0,0 @@
-use poulpy_backend::cpu_spqlios::FFT64;
-use poulpy_hal::{api::ModuleNew, layouts::Module};
-
-use crate::tests::generics::{
-    automorphism::{test_glwe_automorphism, test_glwe_automorphism_inplace},
-    encryption::{test_glwe_compressed_encrypt_sk, test_glwe_encrypt_pk, test_glwe_encrypt_sk, test_glwe_encrypt_zero_sk},
-    external_product::{test_glwe_external_product, test_glwe_external_product_inplace},
-    keyswitch::{test_glwe_keyswitch, test_glwe_keyswitch_inplace},
-    test_glwe_packing, test_glwe_trace_inplace,
-};
-
-#[test]
-fn glwe_encrypt_sk() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    (1..4).for_each(|rank| {
-        println!("test_glwe_encrypt_sk rank: {}", rank);
-        test_glwe_encrypt_sk(&module, 8, 54, 30, rank);
-    });
-}
-
-#[test]
-fn glwe_compressed_encrypt_sk() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    (1..4).for_each(|rank| {
-        println!("test_glwe_compressed_encrypt_sk rank: {}", rank);
-        test_glwe_compressed_encrypt_sk(&module, 8, 54, 30, rank);
-    });
-}
-
-#[test]
-fn glwe_encrypt_zero_sk() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    (1..4).for_each(|rank| {
-        println!("test_glwe_encrypt_zero_sk rank: {}", rank);
-        test_glwe_encrypt_zero_sk(&module, 8, 64, rank);
-    });
-}
-
-#[test]
-fn glwe_encrypt_pk() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    (1..4).for_each(|rank| {
-        println!("test_glwe_encrypt_pk rank: {}", rank);
-        test_glwe_encrypt_pk(&module, 8, 64, 64, rank)
-    });
-}
-
-#[test]
-fn glwe_keyswitch() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_in: usize = 45;
-    let digits: usize = k_in.div_ceil(basek);
-    (1..4).for_each(|rank_in| {
-        (1..4).for_each(|rank_out| {
-            (1..digits + 1).for_each(|di| {
-                let k_ksk: usize = k_in + basek * di;
-                let k_out: usize = k_ksk; // better capture noise
-                println!(
-                    "test_glwe_keyswitch digits: {} rank_in: {} rank_out: {}",
-                    di, rank_in, rank_out
-                );
-                test_glwe_keyswitch(&module, basek, k_out, k_in, k_ksk, di, rank_in, rank_out);
-            })
-        });
-    });
-}
-
-#[test]
-fn glwe_keyswitch_inplace() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_ct: usize = 45;
-    let digits: usize = k_ct.div_ceil(basek);
-    (1..4).for_each(|rank| {
-        (1..digits + 1).for_each(|di| {
-            let k_ksk: usize = k_ct + basek * di;
-            println!("test_glwe_keyswitch_inplace digits: {} rank: {}", di, rank);
-            test_glwe_keyswitch_inplace(&module, basek, k_ct, k_ksk, di, rank);
-        });
-    });
-}
-
-#[test]
-fn glwe_automorphism() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_in: usize = 60;
-    let digits: usize = k_in.div_ceil(basek);
-    (1..4).for_each(|rank| {
-        (1..digits + 1).for_each(|di| {
-            let k_ksk: usize = k_in + basek * di;
-            let k_out: usize = k_ksk; // Better capture noise.
-            println!("test_glwe_automorphism digits: {} rank: {}", di, rank);
-            test_glwe_automorphism(&module, basek, -5, k_out, k_in, k_ksk, di, rank);
-        })
-    });
-}
-
-#[test]
-fn glwe_automorphism_inplace() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_ct: usize = 60;
-    let digits: usize = k_ct.div_ceil(basek);
-    (1..4).for_each(|rank| {
-        (1..digits + 1).for_each(|di| {
-            let k_ksk: usize = k_ct + basek * di;
-            println!(
-                "test_glwe_automorphism_inplace digits: {} rank: {}",
-                di, rank
-            );
-            test_glwe_automorphism_inplace(&module, basek, -5, k_ct, k_ksk, di, rank);
-        });
-    });
-}
-
-#[test]
-fn glwe_external_product() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_in: usize = 45;
-    let digits: usize = k_in.div_ceil(basek);
-    (1..4).for_each(|rank| {
-        (1..digits + 1).for_each(|di| {
-            let k_ggsw: usize = k_in + basek * di;
-            let k_out: usize = k_ggsw; // Better capture noise
-            println!("test_glwe_external_product digits: {} rank: {}", di, rank);
-            test_glwe_external_product(&module, basek, k_out, k_in, k_ggsw, di, rank);
-        });
-    });
-}
-
-#[test]
-fn glwe_external_product_inplace() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    let basek: usize = 12;
-    let k_ct: usize = 60;
-    let digits: usize = k_ct.div_ceil(basek);
-    (1..4).for_each(|rank| {
-        (1..digits + 1).for_each(|di| {
-            let k_ggsw: usize = k_ct + basek * di;
-            println!(
-                "test_glwe_external_product_inplace digits: {} rank: {}",
-                di, rank
-            );
-            test_glwe_external_product_inplace(&module, basek, k_ct, k_ggsw, di, rank);
-        });
-    });
-}
-
-#[test]
-fn glwe_trace_inplace() {
-    let log_n: usize = 8;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    (1..4).for_each(|rank| {
-        println!("test_glwe_trace_inplace rank: {}", rank);
-        test_glwe_trace_inplace(&module, 8, 54, rank);
-    });
-}
-
-#[test]
-fn glwe_packing() {
-    let log_n: usize = 5;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    test_glwe_packing(&module);
-}

poulpy-core/src/tests/implementation/cpu_spqlios/fft64/lwe.rs

@@ -1,24 +0,0 @@
-use crate::tests::generics::{keyswitch::test_lwe_keyswitch, test_glwe_to_lwe, test_lwe_to_glwe};
-use poulpy_backend::cpu_spqlios::FFT64;
-use poulpy_hal::{api::ModuleNew, layouts::Module};
-
-#[test]
-fn lwe_to_glwe() {
-    let log_n: usize = 5;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    test_lwe_to_glwe(&module)
-}
-
-#[test]
-fn glwe_to_lwe() {
-    let log_n: usize = 5;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    test_glwe_to_lwe(&module)
-}
-
-#[test]
-fn lwe_keyswitch() {
-    let log_n: usize = 5;
-    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
-    test_lwe_keyswitch(&module)
-}

poulpy-core/src/tests/implementation/cpu_spqlios/fft64/mod.rs

@@ -1,4 +0,0 @@
-mod gglwe;
-mod ggws;
-mod glwe;
-mod lwe;

poulpy-core/src/tests/implementation/cpu_spqlios/mod.rs

@@ -1 +0,0 @@
-mod fft64;

poulpy-core/src/tests/implementation/mod.rs

@@ -1 +0,0 @@
-mod cpu_spqlios;

poulpy-core/src/tests/mod.rs

@@ -1,7 +1,181 @@
-pub mod generics;
-
-#[cfg(test)]
-mod implementation;
+pub mod test_suite;
 
 #[cfg(test)]
 mod serialization;
+
+#[allow(unused_imports)]
+use poulpy_hal::backend_test_suite;
+
+#[cfg(test)]
+backend_test_suite!(
+    mod cpu_spqlios,
+    backend = poulpy_backend::cpu_spqlios::FFT64Spqlios,
+    size = 1<<8,
+    tests = {
+        // GLWE Encryption
+        glwe_encrypt_sk => crate::tests::test_suite::encryption::test_glwe_encrypt_sk,
+        glwe_compressed_encrypt_sk => crate::tests::test_suite::encryption::test_glwe_compressed_encrypt_sk,
+        glwe_encrypt_zero_sk => crate::tests::test_suite::encryption::test_glwe_encrypt_zero_sk,
+        glwe_encrypt_pk => crate::tests::test_suite::encryption::test_glwe_encrypt_pk,
+        // GLWE Keyswitch
+        glwe_keyswitch => crate::tests::test_suite::keyswitch::test_glwe_keyswitch,
+        glwe_keyswitch_inplace => crate::tests::test_suite::keyswitch::test_glwe_keyswitch_inplace,
+        // GLWE Automorphism
+        glwe_automorphism => crate::tests::test_suite::automorphism::test_glwe_automorphism,
+        glwe_automorphism_inplace => crate::tests::test_suite::automorphism::test_glwe_automorphism_inplace,
+        // GLWE External Product
+        glwe_external_product => crate::tests::test_suite::external_product::test_glwe_external_product,
+        glwe_external_product_inplace => crate::tests::test_suite::external_product::test_glwe_external_product_inplace,
+        // GLWE Trace
+        glwe_trace_inplace => crate::tests::test_suite::test_glwe_trace_inplace,
+        glwe_packing => crate::tests::test_suite::test_glwe_packing,
+        // GGLWE Encryption
+        gglwe_switching_key_encrypt_sk => crate::tests::test_suite::encryption::test_gglwe_switching_key_encrypt_sk,
+        gglwe_switching_key_compressed_encrypt_sk => crate::tests::test_suite::encryption::test_gglwe_switching_key_compressed_encrypt_sk,
+        gglwe_automorphisk_key_encrypt_sk => crate::tests::test_suite::encryption::test_gglwe_automorphisk_key_encrypt_sk,
+        gglwe_automorphisk_key_compressed_encrypt_sk => crate::tests::test_suite::encryption::test_gglwe_automorphisk_key_compressed_encrypt_sk,
+        gglwe_tensor_key_encrypt_sk => crate::tests::test_suite::encryption::test_gglwe_tensor_key_encrypt_sk,
+        gglwe_tensor_key_compressed_encrypt_sk => crate::tests::test_suite::encryption::test_gglwe_tensor_key_compressed_encrypt_sk,
+        // GGLWE Keyswitching
+        gglwe_switching_key_keyswitch => crate::tests::test_suite::keyswitch::test_gglwe_switching_key_keyswitch,
+        gglwe_switching_key_keyswitch_inplace => crate::tests::test_suite::keyswitch::test_gglwe_switching_key_keyswitch_inplace,
+        // GGLWE External Product
+        gglwe_switching_key_external_product => crate::tests::test_suite::external_product::test_gglwe_switching_key_external_product,
+        gglwe_switching_key_external_product_inplace => crate::tests::test_suite::external_product::test_gglwe_switching_key_external_product_inplace,
+        // GGLWE Automorphism
+        gglwe_automorphism_key_automorphism => crate::tests::test_suite::automorphism::test_gglwe_automorphism_key_automorphism,
+        gglwe_automorphism_key_automorphism_inplace => crate::tests::test_suite::automorphism::test_gglwe_automorphism_key_automorphism_inplace,
+        // GGSW Encryption
+        ggsw_encrypt_sk => crate::tests::test_suite::encryption::test_ggsw_encrypt_sk,
+        ggsw_compressed_encrypt_sk => crate::tests::test_suite::encryption::test_ggsw_compressed_encrypt_sk,
+        // GGSW Keyswitching
+        ggsw_keyswitch => crate::tests::test_suite::keyswitch::test_ggsw_keyswitch,
+        ggsw_keyswitch_inplace => crate::tests::test_suite::keyswitch::test_ggsw_keyswitch_inplace,
+        // GGSW External Product
+        ggsw_external_product => crate::tests::test_suite::external_product::test_ggsw_external_product,
+        ggsw_external_product_inplace => crate::tests::test_suite::external_product::test_ggsw_external_product_inplace,
+        // GGSW Automorphism
+        ggsw_automorphism => crate::tests::test_suite::automorphism::test_ggsw_automorphism,
+        ggsw_automorphism_inplace => crate::tests::test_suite::automorphism::test_ggsw_automorphism_inplace,
+        // LWE
+        lwe_keyswitch => crate::tests::test_suite::keyswitch::test_lwe_keyswitch,
+        glwe_to_lwe => crate::tests::test_suite::test_glwe_to_lwe,
+        lwe_to_glwe => crate::tests::test_suite::test_lwe_to_glwe,
+    }
+);
+
+#[cfg(test)]
+backend_test_suite!(
+    mod cpu_ref,
+    backend = poulpy_backend::cpu_fft64_ref::FFT64Ref,
+    size = 1<<8,
+    tests = {
+        // GLWE Encryption
+        glwe_encrypt_sk => crate::tests::test_suite::encryption::test_glwe_encrypt_sk,
+        glwe_compressed_encrypt_sk => crate::tests::test_suite::encryption::test_glwe_compressed_encrypt_sk,
+        glwe_encrypt_zero_sk => crate::tests::test_suite::encryption::test_glwe_encrypt_zero_sk,
+        glwe_encrypt_pk => crate::tests::test_suite::encryption::test_glwe_encrypt_pk,
+        // GLWE Keyswitch
+        glwe_keyswitch => crate::tests::test_suite::keyswitch::test_glwe_keyswitch,
+        glwe_keyswitch_inplace => crate::tests::test_suite::keyswitch::test_glwe_keyswitch_inplace,
+        // GLWE Automorphism
+        glwe_automorphism => crate::tests::test_suite::automorphism::test_glwe_automorphism,
+        glwe_automorphism_inplace => crate::tests::test_suite::automorphism::test_glwe_automorphism_inplace,
+        // GLWE External Product
+        glwe_external_product => crate::tests::test_suite::external_product::test_glwe_external_product,
+        glwe_external_product_inplace => crate::tests::test_suite::external_product::test_glwe_external_product_inplace,
+        // GLWE Trace
+        glwe_trace_inplace => crate::tests::test_suite::test_glwe_trace_inplace,
+        glwe_packing => crate::tests::test_suite::test_glwe_packing,
+        // GGLWE Encryption
+        gglwe_switching_key_encrypt_sk => crate::tests::test_suite::encryption::test_gglwe_switching_key_encrypt_sk,
+        gglwe_switching_key_compressed_encrypt_sk => crate::tests::test_suite::encryption::test_gglwe_switching_key_compressed_encrypt_sk,
+        gglwe_automorphisk_key_encrypt_sk => crate::tests::test_suite::encryption::test_gglwe_automorphisk_key_encrypt_sk,
+        gglwe_automorphisk_key_compressed_encrypt_sk => crate::tests::test_suite::encryption::test_gglwe_automorphisk_key_compressed_encrypt_sk,
+        gglwe_tensor_key_encrypt_sk => crate::tests::test_suite::encryption::test_gglwe_tensor_key_encrypt_sk,
+        gglwe_tensor_key_compressed_encrypt_sk => crate::tests::test_suite::encryption::test_gglwe_tensor_key_compressed_encrypt_sk,
+        // GGLWE Keyswitching
+        gglwe_switching_key_keyswitch => crate::tests::test_suite::keyswitch::test_gglwe_switching_key_keyswitch,
+        gglwe_switching_key_keyswitch_inplace => crate::tests::test_suite::keyswitch::test_gglwe_switching_key_keyswitch_inplace,
+        // GGLWE External Product
+        gglwe_switching_key_external_product => crate::tests::test_suite::external_product::test_gglwe_switching_key_external_product,
+        gglwe_switching_key_external_product_inplace => crate::tests::test_suite::external_product::test_gglwe_switching_key_external_product_inplace,
+        // GGLWE Automorphism
+        gglwe_automorphism_key_automorphism => crate::tests::test_suite::automorphism::test_gglwe_automorphism_key_automorphism,
+        gglwe_automorphism_key_automorphism_inplace => crate::tests::test_suite::automorphism::test_gglwe_automorphism_key_automorphism_inplace,
+        // GGSW Encryption
+        ggsw_encrypt_sk => crate::tests::test_suite::encryption::test_ggsw_encrypt_sk,
+        ggsw_compressed_encrypt_sk => crate::tests::test_suite::encryption::test_ggsw_compressed_encrypt_sk,
+        // GGSW Keyswitching
+        ggsw_keyswitch => crate::tests::test_suite::keyswitch::test_ggsw_keyswitch,
+        ggsw_keyswitch_inplace => crate::tests::test_suite::keyswitch::test_ggsw_keyswitch_inplace,
+        // GGSW External Product
+        ggsw_external_product => crate::tests::test_suite::external_product::test_ggsw_external_product,
+        ggsw_external_product_inplace => crate::tests::test_suite::external_product::test_ggsw_external_product_inplace,
+        // GGSW Automorphism
+        ggsw_automorphism => crate::tests::test_suite::automorphism::test_ggsw_automorphism,
+        ggsw_automorphism_inplace => crate::tests::test_suite::automorphism::test_ggsw_automorphism_inplace,
+        // LWE
+        lwe_keyswitch => crate::tests::test_suite::keyswitch::test_lwe_keyswitch,
+        glwe_to_lwe => crate::tests::test_suite::test_glwe_to_lwe,
+        lwe_to_glwe => crate::tests::test_suite::test_lwe_to_glwe,
+    }
+);
+
+#[cfg(test)]
+backend_test_suite!(
+    mod cpu_avx,
+    backend = poulpy_backend::cpu_fft64_avx::FFT64Avx,
+    size = 1<<8,
+    tests = {
+        // GLWE Encryption
+        glwe_encrypt_sk => crate::tests::test_suite::encryption::test_glwe_encrypt_sk,
+        glwe_compressed_encrypt_sk => crate::tests::test_suite::encryption::test_glwe_compressed_encrypt_sk,
+        glwe_encrypt_zero_sk => crate::tests::test_suite::encryption::test_glwe_encrypt_zero_sk,
+        glwe_encrypt_pk => crate::tests::test_suite::encryption::test_glwe_encrypt_pk,
+        // GLWE Keyswitch
+        glwe_keyswitch => crate::tests::test_suite::keyswitch::test_glwe_keyswitch,
+        glwe_keyswitch_inplace => crate::tests::test_suite::keyswitch::test_glwe_keyswitch_inplace,
+        // GLWE Automorphism
+        glwe_automorphism => crate::tests::test_suite::automorphism::test_glwe_automorphism,
+        glwe_automorphism_inplace => crate::tests::test_suite::automorphism::test_glwe_automorphism_inplace,
+        // GLWE External Product
+        glwe_external_product => crate::tests::test_suite::external_product::test_glwe_external_product,
+        glwe_external_product_inplace => crate::tests::test_suite::external_product::test_glwe_external_product_inplace,
+        // GLWE Trace
+        glwe_trace_inplace => crate::tests::test_suite::test_glwe_trace_inplace,
+        glwe_packing => crate::tests::test_suite::test_glwe_packing,
+        // GGLWE Encryption
+        gglwe_switching_key_encrypt_sk => crate::tests::test_suite::encryption::test_gglwe_switching_key_encrypt_sk,
+        gglwe_switching_key_compressed_encrypt_sk => crate::tests::test_suite::encryption::test_gglwe_switching_key_compressed_encrypt_sk,
+        gglwe_automorphisk_key_encrypt_sk => crate::tests::test_suite::encryption::test_gglwe_automorphisk_key_encrypt_sk,
+        gglwe_automorphisk_key_compressed_encrypt_sk => crate::tests::test_suite::encryption::test_gglwe_automorphisk_key_compressed_encrypt_sk,
+        gglwe_tensor_key_encrypt_sk => crate::tests::test_suite::encryption::test_gglwe_tensor_key_encrypt_sk,
+        gglwe_tensor_key_compressed_encrypt_sk => crate::tests::test_suite::encryption::test_gglwe_tensor_key_compressed_encrypt_sk,
+        // GGLWE Keyswitching
+        gglwe_switching_key_keyswitch => crate::tests::test_suite::keyswitch::test_gglwe_switching_key_keyswitch,
+        gglwe_switching_key_keyswitch_inplace => crate::tests::test_suite::keyswitch::test_gglwe_switching_key_keyswitch_inplace,
+        // GGLWE External Product
+        gglwe_switching_key_external_product => crate::tests::test_suite::external_product::test_gglwe_switching_key_external_product,
+        gglwe_switching_key_external_product_inplace => crate::tests::test_suite::external_product::test_gglwe_switching_key_external_product_inplace,
+        // GGLWE Automorphism
+        gglwe_automorphism_key_automorphism => crate::tests::test_suite::automorphism::test_gglwe_automorphism_key_automorphism,
+        gglwe_automorphism_key_automorphism_inplace => crate::tests::test_suite::automorphism::test_gglwe_automorphism_key_automorphism_inplace,
+        // GGSW Encryption
+        ggsw_encrypt_sk => crate::tests::test_suite::encryption::test_ggsw_encrypt_sk,
+        ggsw_compressed_encrypt_sk => crate::tests::test_suite::encryption::test_ggsw_compressed_encrypt_sk,
+        // GGSW Keyswitching
+        ggsw_keyswitch => crate::tests::test_suite::keyswitch::test_ggsw_keyswitch,
+        ggsw_keyswitch_inplace => crate::tests::test_suite::keyswitch::test_ggsw_keyswitch_inplace,
+        // GGSW External Product
+        ggsw_external_product => crate::tests::test_suite::external_product::test_ggsw_external_product,
+        ggsw_external_product_inplace => crate::tests::test_suite::external_product::test_ggsw_external_product_inplace,
+        // GGSW Automorphism
+        ggsw_automorphism => crate::tests::test_suite::automorphism::test_ggsw_automorphism,
+        ggsw_automorphism_inplace => crate::tests::test_suite::automorphism::test_ggsw_automorphism_inplace,
+        // LWE
+        lwe_keyswitch => crate::tests::test_suite::keyswitch::test_lwe_keyswitch,
+        glwe_to_lwe => crate::tests::test_suite::test_glwe_to_lwe,
+        lwe_to_glwe => crate::tests::test_suite::test_lwe_to_glwe,
+    }
+);

poulpy-core/src/tests/serialization.rs

@@ -1,4 +1,4 @@
-use poulpy_hal::tests::serialization::test_reader_writer_interface;
+use poulpy_hal::test_suite::serialization::test_reader_writer_interface;
 
 use crate::layouts::{
     GGLWEAutomorphismKey, GGLWECiphertext, GGLWESwitchingKey, GGLWETensorKey, GGSWCiphertext, GLWECiphertext,
@@ -21,7 +21,7 @@ const DIGITS: usize = 1;
 #[test]
 fn glwe_serialization() {
     let original: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(N_GLWE, BASEK, K, RANK);
-    poulpy_hal::tests::serialization::test_reader_writer_interface(original);
+    poulpy_hal::test_suite::serialization::test_reader_writer_interface(original);
 }
 
 #[test]

poulpy-core/src/tests/test_suite/automorphism/gglwe_atk.rs

@@ -0,0 +1,370 @@
+use poulpy_hal::{
+    api::{
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism, VecZnxAutomorphismInplace,
+        VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
+        VecZnxCopy, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize,
+        VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VecZnxSubScalarInplace, VecZnxSwitchRing,
+        VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPrepare,
+    },
+    layouts::{Backend, Module, ScratchOwned},
+    oep::{
+        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
+        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl,
+    },
+    source::Source,
+};
+
+use crate::{
+    encryption::SIGMA,
+    layouts::{
+        GGLWEAutomorphismKey, GLWEPlaintext, GLWESecret, Infos,
+        prepared::{GGLWEAutomorphismKeyPrepared, GLWESecretPrepared, Prepare, PrepareAlloc},
+    },
+    noise::log2_std_noise_gglwe_product,
+};
+
+#[allow(clippy::too_many_arguments)]
+pub fn test_gglwe_automorphism_key_automorphism<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VmpApplyDftToDftTmpBytes
+        + VecZnxBigNormalizeTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VecZnxDftApply<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigNormalize<B>
+        + VecZnxAutomorphism
+        + VecZnxAutomorphismInplace<B>
+        + SvpPPolAllocBytes
+        + VecZnxDftAllocBytes
+        + VecZnxNormalizeTmpBytes
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>
+        + SvpPrepare<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxAddScalarInplace
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + VecZnxSwitchRing
+        + SvpPPolAlloc<B>
+        + VecZnxBigAddInplace<B>
+        + VecZnxSubScalarInplace,
+    B: Backend
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxImpl<B>
+        + TakeSvpPPolImpl<B>
+        + TakeVecZnxBigImpl<B>,
+{
+    let basek: usize = 12;
+    let k_in: usize = 60;
+    let k_out: usize = 40;
+    let digits: usize = k_in.div_ceil(basek);
+    let p0 = -1;
+    let p1 = -5;
+    (1..3).for_each(|rank| {
+        (1..digits + 1).for_each(|di| {
+            let k_apply: usize = (digits + di) * basek;
+
+            let n: usize = module.n();
+            let digits_in: usize = 1;
+
+            let rows_in: usize = k_in / (basek * di);
+            let rows_out: usize = k_out / (basek * di);
+            let rows_apply: usize = k_in.div_ceil(basek * di);
+
+            let mut auto_key_in: GGLWEAutomorphismKey<Vec<u8>> =
+                GGLWEAutomorphismKey::alloc(n, basek, k_in, rows_in, digits_in, rank);
+            let mut auto_key_out: GGLWEAutomorphismKey<Vec<u8>> =
+                GGLWEAutomorphismKey::alloc(n, basek, k_out, rows_out, digits_in, rank);
+            let mut auto_key_apply: GGLWEAutomorphismKey<Vec<u8>> =
+                GGLWEAutomorphismKey::alloc(n, basek, k_apply, rows_apply, di, rank);
+
+            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]);
+
+            let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+                GGLWEAutomorphismKey::encrypt_sk_scratch_space(module, basek, k_apply, rank)
+                    | GGLWEAutomorphismKey::automorphism_scratch_space(module, basek, k_out, k_in, k_apply, di, rank),
+            );
+
+            let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+            sk.fill_ternary_prob(0.5, &mut source_xs);
+
+            // gglwe_{s1}(s0) = s0 -> s1
+            auto_key_in.encrypt_sk(
+                module,
+                p0,
+                &sk,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            // gglwe_{s2}(s1) -> s1 -> s2
+            auto_key_apply.encrypt_sk(
+                module,
+                p1,
+                &sk,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            let mut auto_key_apply_prepared: GGLWEAutomorphismKeyPrepared<Vec<u8>, B> =
+                GGLWEAutomorphismKeyPrepared::alloc(module, basek, k_apply, rows_apply, di, rank);
+
+            auto_key_apply_prepared.prepare(module, &auto_key_apply, scratch.borrow());
+
+            // gglwe_{s1}(s0) (x) gglwe_{s2}(s1) = gglwe_{s2}(s0)
+            auto_key_out.automorphism(
+                module,
+                &auto_key_in,
+                &auto_key_apply_prepared,
+                scratch.borrow(),
+            );
+
+            let mut pt: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_out);
+
+            let mut sk_auto: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+            sk_auto.fill_zero(); // Necessary to avoid panic of unfilled sk
+            (0..rank).for_each(|i| {
+                module.vec_znx_automorphism(
+                    module.galois_element_inv(p0 * p1),
+                    &mut sk_auto.data.as_vec_znx_mut(),
+                    i,
+                    &sk.data.as_vec_znx(),
+                    i,
+                );
+            });
+
+            let sk_auto_dft: GLWESecretPrepared<Vec<u8>, B> = sk_auto.prepare_alloc(module, scratch.borrow());
+
+            (0..auto_key_out.rank_in()).for_each(|col_i| {
+                (0..auto_key_out.rows()).for_each(|row_i| {
+                    auto_key_out
+                        .at(row_i, col_i)
+                        .decrypt(module, &mut pt, &sk_auto_dft, scratch.borrow());
+
+                    module.vec_znx_sub_scalar_inplace(
+                        &mut pt.data,
+                        0,
+                        (digits_in - 1) + row_i * digits_in,
+                        &sk.data,
+                        col_i,
+                    );
+
+                    let noise_have: f64 = pt.data.std(basek, 0).log2();
+                    let noise_want: f64 = log2_std_noise_gglwe_product(
+                        n as f64,
+                        basek * di,
+                        0.5,
+                        0.5,
+                        0f64,
+                        SIGMA * SIGMA,
+                        0f64,
+                        rank as f64,
+                        k_out,
+                        k_apply,
+                    );
+
+                    assert!(
+                        noise_have < noise_want + 0.5,
+                        "{} {}",
+                        noise_have,
+                        noise_want
+                    );
+                });
+            });
+        });
+    });
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn test_gglwe_automorphism_key_automorphism_inplace<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxDftAllocBytes
+        + VmpApplyDftToDftTmpBytes
+        + VecZnxBigNormalizeTmpBytes
+        + VmpApplyDftToDftTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VecZnxDftApply<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigNormalize<B>
+        + VecZnxAutomorphism
+        + VecZnxSwitchRing
+        + VecZnxAddScalarInplace
+        + VecZnxAutomorphism
+        + VecZnxAutomorphismInplace<B>
+        + VecZnxDftAllocBytes
+        + VecZnxBigAllocBytes
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxBigAddInplace<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigNormalize<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxSubScalarInplace
+        + VecZnxCopy
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>,
+    B: Backend
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxImpl<B>
+        + TakeSvpPPolImpl<B>
+        + TakeVecZnxBigImpl<B>,
+{
+    let basek: usize = 12;
+    let k_in: usize = 60;
+    let digits: usize = k_in.div_ceil(basek);
+    let p0: i64 = -1;
+    let p1: i64 = -5;
+    (1..3).for_each(|rank| {
+        (1..digits + 1).for_each(|di| {
+            println!(
+                "test_gglwe_automorphism_key_automorphism_inplace: {} rank: {}",
+                di, rank
+            );
+            let k_apply: usize = (digits + di) * basek;
+
+            let n: usize = module.n();
+            let digits_in: usize = 1;
+
+            let rows_in: usize = k_in / (basek * di);
+            let rows_apply: usize = k_in.div_ceil(basek * di);
+
+            let mut auto_key: GGLWEAutomorphismKey<Vec<u8>> =
+                GGLWEAutomorphismKey::alloc(n, basek, k_in, rows_in, digits_in, rank);
+            let mut auto_key_apply: GGLWEAutomorphismKey<Vec<u8>> =
+                GGLWEAutomorphismKey::alloc(n, basek, k_apply, rows_apply, di, rank);
+
+            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]);
+
+            let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+                GGLWEAutomorphismKey::encrypt_sk_scratch_space(module, basek, k_apply, rank)
+                    | GGLWEAutomorphismKey::automorphism_inplace_scratch_space(module, basek, k_in, k_apply, di, rank),
+            );
+
+            let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+            sk.fill_ternary_prob(0.5, &mut source_xs);
+
+            // gglwe_{s1}(s0) = s0 -> s1
+            auto_key.encrypt_sk(
+                module,
+                p0,
+                &sk,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            // gglwe_{s2}(s1) -> s1 -> s2
+            auto_key_apply.encrypt_sk(
+                module,
+                p1,
+                &sk,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            let mut auto_key_apply_prepared: GGLWEAutomorphismKeyPrepared<Vec<u8>, B> =
+                GGLWEAutomorphismKeyPrepared::alloc(module, basek, k_apply, rows_apply, di, rank);
+
+            auto_key_apply_prepared.prepare(module, &auto_key_apply, scratch.borrow());
+
+            // gglwe_{s1}(s0) (x) gglwe_{s2}(s1) = gglwe_{s2}(s0)
+            auto_key.automorphism_inplace(module, &auto_key_apply_prepared, scratch.borrow());
+
+            let mut pt: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_in);
+
+            let mut sk_auto: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+            sk_auto.fill_zero(); // Necessary to avoid panic of unfilled sk
+
+            (0..rank).for_each(|i| {
+                module.vec_znx_automorphism(
+                    module.galois_element_inv(p0 * p1),
+                    &mut sk_auto.data.as_vec_znx_mut(),
+                    i,
+                    &sk.data.as_vec_znx(),
+                    i,
+                );
+            });
+
+            let sk_auto_dft: GLWESecretPrepared<Vec<u8>, B> = sk_auto.prepare_alloc(module, scratch.borrow());
+
+            (0..auto_key.rank_in()).for_each(|col_i| {
+                (0..auto_key.rows()).for_each(|row_i| {
+                    auto_key
+                        .at(row_i, col_i)
+                        .decrypt(module, &mut pt, &sk_auto_dft, scratch.borrow());
+                    module.vec_znx_sub_scalar_inplace(
+                        &mut pt.data,
+                        0,
+                        (digits_in - 1) + row_i * digits_in,
+                        &sk.data,
+                        col_i,
+                    );
+
+                    let noise_have: f64 = pt.data.std(basek, 0).log2();
+                    let noise_want: f64 = log2_std_noise_gglwe_product(
+                        n as f64,
+                        basek * di,
+                        0.5,
+                        0.5,
+                        0f64,
+                        SIGMA * SIGMA,
+                        0f64,
+                        rank as f64,
+                        k_in,
+                        k_apply,
+                    );
+
+                    assert!(
+                        noise_have < noise_want + 0.5,
+                        "{} {}",
+                        noise_have,
+                        noise_want
+                    );
+                });
+            });
+        });
+    });
+}

poulpy-core/src/tests/test_suite/automorphism/ggsw_ct.rs

@@ -0,0 +1,330 @@
+use poulpy_hal::{
+    api::{
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes,
+        SvpPrepare, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism, VecZnxAutomorphismInplace,
+        VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAlloc, VecZnxBigAllocBytes, VecZnxBigNormalize,
+        VecZnxBigNormalizeTmpBytes, VecZnxCopy, VecZnxDftAddInplace, VecZnxDftAlloc, VecZnxDftAllocBytes, VecZnxDftApply,
+        VecZnxDftCopy, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA, VecZnxNormalize, VecZnxNormalizeInplace,
+        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VecZnxSwitchRing, VmpApplyDftToDft, VmpApplyDftToDftAdd,
+        VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPrepare,
+    },
+    layouts::{Backend, Module, ScalarZnx, ScratchOwned},
+    oep::{
+        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
+        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl, VecZnxBigAllocBytesImpl, VecZnxDftAllocBytesImpl,
+    },
+    source::Source,
+};
+
+use crate::{
+    encryption::SIGMA,
+    layouts::{
+        GGLWEAutomorphismKey, GGLWETensorKey, GGSWCiphertext, GLWESecret,
+        prepared::{GGLWEAutomorphismKeyPrepared, GGLWETensorKeyPrepared, GLWESecretPrepared, Prepare, PrepareAlloc},
+    },
+    noise::noise_ggsw_keyswitch,
+};
+
+#[allow(clippy::too_many_arguments)]
+pub fn test_ggsw_automorphism<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigAllocBytes
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxBigAddInplace<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigNormalize<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxBigAlloc<B>
+        + VecZnxDftAlloc<B>
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxIdftApplyTmpA<B>
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxAddScalarInplace
+        + VecZnxCopy
+        + VecZnxSubABInplace
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>
+        + VmpApplyDftToDftTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VecZnxDftCopy<B>
+        + VecZnxDftAddInplace<B>
+        + VecZnxFillUniform
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + SvpApplyDftToDft<B>
+        + VecZnxSwitchRing
+        + VecZnxAutomorphismInplace<B>
+        + VecZnxAutomorphism,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>
+        + VecZnxDftAllocBytesImpl<B>
+        + VecZnxBigAllocBytesImpl<B>
+        + TakeSvpPPolImpl<B>,
+{
+    let basek: usize = 12;
+    let k_in: usize = 54;
+    let digits: usize = k_in.div_ceil(basek);
+    let p: i64 = -5;
+    (1..3).for_each(|rank| {
+        (1..digits + 1).for_each(|di| {
+            let k_ksk: usize = k_in + basek * di;
+            let k_tsk: usize = k_ksk;
+            let k_out: usize = k_ksk; // Better capture noise.
+
+            let n: usize = module.n();
+            let rows: usize = k_in.div_ceil(basek * di);
+            let rows_in: usize = k_in.div_euclid(basek * di);
+
+            let digits_in: usize = 1;
+
+            let mut ct_in: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_in, rows_in, digits_in, rank);
+            let mut ct_out: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_out, rows_in, digits_in, rank);
+            let mut tensor_key: GGLWETensorKey<Vec<u8>> = GGLWETensorKey::alloc(n, basek, k_tsk, rows, di, rank);
+            let mut auto_key: GGLWEAutomorphismKey<Vec<u8>> = GGLWEAutomorphismKey::alloc(n, basek, k_ksk, rows, di, rank);
+            let mut pt_scalar: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
+
+            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]);
+
+            let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+                GGSWCiphertext::encrypt_sk_scratch_space(module, basek, k_in, rank)
+                    | GGLWEAutomorphismKey::encrypt_sk_scratch_space(module, basek, k_ksk, rank)
+                    | GGLWETensorKey::encrypt_sk_scratch_space(module, basek, k_tsk, rank)
+                    | GGSWCiphertext::automorphism_scratch_space(module, basek, k_out, k_in, k_ksk, di, k_tsk, di, rank),
+            );
+
+            let var_xs: f64 = 0.5;
+
+            let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+            sk.fill_ternary_prob(var_xs, &mut source_xs);
+            let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
+
+            auto_key.encrypt_sk(
+                module,
+                p,
+                &sk,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+            tensor_key.encrypt_sk(
+                module,
+                &sk,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            pt_scalar.fill_ternary_hw(0, n, &mut source_xs);
+
+            ct_in.encrypt_sk(
+                module,
+                &pt_scalar,
+                &sk_prepared,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            let mut auto_key_prepared: GGLWEAutomorphismKeyPrepared<Vec<u8>, B> =
+                GGLWEAutomorphismKeyPrepared::alloc(module, basek, k_ksk, rows, di, rank);
+            auto_key_prepared.prepare(module, &auto_key, scratch.borrow());
+
+            let mut tsk_prepared: GGLWETensorKeyPrepared<Vec<u8>, B> =
+                GGLWETensorKeyPrepared::alloc(module, basek, k_tsk, rows, di, rank);
+            tsk_prepared.prepare(module, &tensor_key, scratch.borrow());
+
+            ct_out.automorphism(
+                module,
+                &ct_in,
+                &auto_key_prepared,
+                &tsk_prepared,
+                scratch.borrow(),
+            );
+
+            module.vec_znx_automorphism_inplace(p, &mut pt_scalar.as_vec_znx_mut(), 0, scratch.borrow());
+
+            let max_noise = |col_j: usize| -> f64 {
+                noise_ggsw_keyswitch(
+                    n as f64,
+                    basek * di,
+                    col_j,
+                    var_xs,
+                    0f64,
+                    SIGMA * SIGMA,
+                    0f64,
+                    rank as f64,
+                    k_in,
+                    k_ksk,
+                    k_tsk,
+                ) + 0.5
+            };
+
+            ct_out.assert_noise(module, &sk_prepared, &pt_scalar, max_noise);
+        });
+    });
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn test_ggsw_automorphism_inplace<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigAllocBytes
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxBigAddInplace<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigNormalize<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxBigAlloc<B>
+        + VecZnxDftAlloc<B>
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxIdftApplyTmpA<B>
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxAddScalarInplace
+        + VecZnxCopy
+        + VecZnxSubABInplace
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>
+        + VmpApplyDftToDftTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxDftCopy<B>
+        + VecZnxDftAddInplace<B>
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + VecZnxFillUniform
+        + SvpApplyDftToDft<B>
+        + VecZnxSwitchRing
+        + VecZnxAutomorphismInplace<B>
+        + VecZnxAutomorphism,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>
+        + VecZnxDftAllocBytesImpl<B>
+        + VecZnxBigAllocBytesImpl<B>
+        + TakeSvpPPolImpl<B>,
+{
+    let basek: usize = 12;
+    let k_ct: usize = 54;
+    let digits: usize = k_ct.div_ceil(basek);
+    let p = -1;
+    (1..3).for_each(|rank| {
+        (1..digits + 1).for_each(|di| {
+            let k_ksk: usize = k_ct + basek * di;
+            let k_tsk: usize = k_ksk;
+
+            let n: usize = module.n();
+            let rows: usize = k_ct.div_ceil(di * basek);
+            let rows_in: usize = k_ct.div_euclid(basek * di);
+            let digits_in: usize = 1;
+
+            let mut ct: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_ct, rows_in, digits_in, rank);
+            let mut tensor_key: GGLWETensorKey<Vec<u8>> = GGLWETensorKey::alloc(n, basek, k_tsk, rows, di, rank);
+            let mut auto_key: GGLWEAutomorphismKey<Vec<u8>> = GGLWEAutomorphismKey::alloc(n, basek, k_ksk, rows, di, rank);
+            let mut pt_scalar: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
+
+            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]);
+
+            let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+                GGSWCiphertext::encrypt_sk_scratch_space(module, basek, k_ct, rank)
+                    | GGLWEAutomorphismKey::encrypt_sk_scratch_space(module, basek, k_ksk, rank)
+                    | GGLWETensorKey::encrypt_sk_scratch_space(module, basek, k_tsk, rank)
+                    | GGSWCiphertext::automorphism_inplace_scratch_space(module, basek, k_ct, k_ksk, di, k_tsk, di, rank),
+            );
+
+            let var_xs: f64 = 0.5;
+
+            let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+            sk.fill_ternary_prob(var_xs, &mut source_xs);
+            let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
+
+            auto_key.encrypt_sk(
+                module,
+                p,
+                &sk,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+            tensor_key.encrypt_sk(
+                module,
+                &sk,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            pt_scalar.fill_ternary_hw(0, n, &mut source_xs);
+
+            ct.encrypt_sk(
+                module,
+                &pt_scalar,
+                &sk_prepared,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            let mut auto_key_prepared: GGLWEAutomorphismKeyPrepared<Vec<u8>, B> =
+                GGLWEAutomorphismKeyPrepared::alloc(module, basek, k_ksk, rows, di, rank);
+            auto_key_prepared.prepare(module, &auto_key, scratch.borrow());
+
+            let mut tsk_prepared: GGLWETensorKeyPrepared<Vec<u8>, B> =
+                GGLWETensorKeyPrepared::alloc(module, basek, k_tsk, rows, di, rank);
+            tsk_prepared.prepare(module, &tensor_key, scratch.borrow());
+
+            ct.automorphism_inplace(module, &auto_key_prepared, &tsk_prepared, scratch.borrow());
+
+            module.vec_znx_automorphism_inplace(p, &mut pt_scalar.as_vec_znx_mut(), 0, scratch.borrow());
+
+            let max_noise = |col_j: usize| -> f64 {
+                noise_ggsw_keyswitch(
+                    n as f64,
+                    basek * di,
+                    col_j,
+                    var_xs,
+                    0f64,
+                    SIGMA * SIGMA,
+                    0f64,
+                    rank as f64,
+                    k_ct,
+                    k_ksk,
+                    k_tsk,
+                ) + 0.5
+            };
+
+            ct.assert_noise(module, &sk_prepared, &pt_scalar, max_noise);
+        });
+    });
+}

poulpy-core/src/tests/test_suite/automorphism/glwe_ct.rs

@@ -0,0 +1,275 @@
+use poulpy_hal::{
+    api::{
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism, VecZnxAutomorphismInplace,
+        VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
+        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace,
+        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VecZnxSwitchRing, VmpApplyDftToDft, VmpApplyDftToDftAdd,
+        VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPrepare,
+    },
+    layouts::{Backend, Module, ScratchOwned},
+    oep::{
+        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
+        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl,
+    },
+    source::Source,
+};
+
+use crate::{
+    encryption::SIGMA,
+    layouts::{
+        GGLWEAutomorphismKey, GLWECiphertext, GLWEPlaintext, GLWESecret, Infos,
+        prepared::{GGLWEAutomorphismKeyPrepared, GLWESecretPrepared, Prepare, PrepareAlloc},
+    },
+    noise::log2_std_noise_gglwe_product,
+};
+
+#[allow(clippy::too_many_arguments)]
+pub fn test_glwe_automorphism<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxBigAllocBytes
+        + VecZnxBigAddInplace<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VmpApplyDftToDftTmpBytes
+        + VecZnxBigNormalizeTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VecZnxAutomorphism
+        + VecZnxSwitchRing
+        + VecZnxAddScalarInplace
+        + VecZnxAutomorphismInplace<B>
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + TakeSvpPPolImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>,
+{
+    let basek: usize = 12;
+    let k_in: usize = 60;
+    let digits: usize = k_in.div_ceil(basek);
+    let p: i64 = -5;
+    (1..4).for_each(|rank| {
+        (1..digits + 1).for_each(|di| {
+            let k_ksk: usize = k_in + basek * di;
+            let k_out: usize = k_ksk; // Better capture noise.
+
+            let n: usize = module.n();
+            let rows: usize = k_in.div_ceil(basek * digits);
+
+            let mut autokey: GGLWEAutomorphismKey<Vec<u8>> = GGLWEAutomorphismKey::alloc(n, basek, k_ksk, rows, digits, rank);
+            let mut ct_in: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_in, rank);
+            let mut ct_out: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_out, rank);
+            let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_in);
+
+            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]);
+
+            module.vec_znx_fill_uniform(basek, &mut pt_want.data, 0, &mut source_xa);
+
+            let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+                GGLWEAutomorphismKey::encrypt_sk_scratch_space(module, basek, autokey.k(), rank)
+                    | GLWECiphertext::decrypt_scratch_space(module, basek, ct_out.k())
+                    | GLWECiphertext::encrypt_sk_scratch_space(module, basek, ct_in.k())
+                    | GLWECiphertext::automorphism_scratch_space(
+                        module,
+                        basek,
+                        ct_out.k(),
+                        ct_in.k(),
+                        autokey.k(),
+                        digits,
+                        rank,
+                    ),
+            );
+
+            let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+            sk.fill_ternary_prob(0.5, &mut source_xs);
+            let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
+
+            autokey.encrypt_sk(
+                module,
+                p,
+                &sk,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            ct_in.encrypt_sk(
+                module,
+                &pt_want,
+                &sk_prepared,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            let mut autokey_prepared: GGLWEAutomorphismKeyPrepared<Vec<u8>, B> =
+                GGLWEAutomorphismKeyPrepared::alloc(module, basek, k_ksk, rows, digits, rank);
+            autokey_prepared.prepare(module, &autokey, scratch.borrow());
+
+            ct_out.automorphism(module, &ct_in, &autokey_prepared, scratch.borrow());
+
+            let max_noise: f64 = log2_std_noise_gglwe_product(
+                module.n() as f64,
+                basek * digits,
+                0.5,
+                0.5,
+                0f64,
+                SIGMA * SIGMA,
+                0f64,
+                rank as f64,
+                k_in,
+                k_ksk,
+            );
+
+            module.vec_znx_automorphism_inplace(p, &mut pt_want.data, 0, scratch.borrow());
+
+            ct_out.assert_noise(module, &sk_prepared, &pt_want, max_noise + 1.0);
+        })
+    });
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn test_glwe_automorphism_inplace<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxBigAllocBytes
+        + VecZnxBigAddInplace<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VmpApplyDftToDftTmpBytes
+        + VecZnxBigNormalizeTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VecZnxAutomorphism
+        + VecZnxSwitchRing
+        + VecZnxAddScalarInplace
+        + VecZnxAutomorphismInplace<B>
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + TakeSvpPPolImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>,
+{
+    let basek: usize = 12;
+    let k_ct: usize = 60;
+    let digits: usize = k_ct.div_ceil(basek);
+    let p = -5;
+    (1..4).for_each(|rank| {
+        (1..digits + 1).for_each(|di| {
+            let k_ksk: usize = k_ct + basek * di;
+            println!(
+                "test_glwe_automorphism_inplace digits: {} rank: {}",
+                di, rank
+            );
+
+            let n: usize = module.n();
+            let rows: usize = k_ct.div_ceil(basek * digits);
+
+            let mut autokey: GGLWEAutomorphismKey<Vec<u8>> = GGLWEAutomorphismKey::alloc(n, basek, k_ksk, rows, digits, rank);
+            let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_ct, rank);
+            let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, 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]);
+
+            module.vec_znx_fill_uniform(basek, &mut pt_want.data, 0, &mut source_xa);
+
+            let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+                GGLWEAutomorphismKey::encrypt_sk_scratch_space(module, basek, autokey.k(), rank)
+                    | GLWECiphertext::decrypt_scratch_space(module, basek, ct.k())
+                    | GLWECiphertext::encrypt_sk_scratch_space(module, basek, ct.k())
+                    | GLWECiphertext::automorphism_inplace_scratch_space(module, basek, ct.k(), autokey.k(), digits, rank),
+            );
+
+            let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+            sk.fill_ternary_prob(0.5, &mut source_xs);
+            let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
+
+            autokey.encrypt_sk(
+                module,
+                p,
+                &sk,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            ct.encrypt_sk(
+                module,
+                &pt_want,
+                &sk_prepared,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            let mut autokey_prepared: GGLWEAutomorphismKeyPrepared<Vec<u8>, B> =
+                GGLWEAutomorphismKeyPrepared::alloc(module, basek, k_ksk, rows, digits, rank);
+            autokey_prepared.prepare(module, &autokey, scratch.borrow());
+
+            ct.automorphism_inplace(module, &autokey_prepared, scratch.borrow());
+
+            let max_noise: f64 = log2_std_noise_gglwe_product(
+                module.n() as f64,
+                basek * digits,
+                0.5,
+                0.5,
+                0f64,
+                SIGMA * SIGMA,
+                0f64,
+                rank as f64,
+                k_ct,
+                k_ksk,
+            );
+
+            module.vec_znx_automorphism_inplace(p, &mut pt_want.data, 0, scratch.borrow());
+
+            ct.assert_noise(module, &sk_prepared, &pt_want, max_noise + 1.0);
+        });
+    });
+}

poulpy-core/src/tests/test_suite/conversion.rs

@@ -1,11 +1,11 @@
 use poulpy_hal::{
     api::{
-        DFT, IDFTConsume, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
         VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphismInplace, VecZnxBigAddInplace,
         VecZnxBigAddSmallInplace, VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxDftAllocBytes,
-        VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
-        VecZnxSwithcDegree, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPrepare,
-        ZnAddNormal, ZnFillUniform, ZnNormalizeInplace,
+        VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace,
+        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VecZnxSwitchRing, VmpApplyDftToDft, VmpApplyDftToDftAdd,
+        VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPrepare, ZnAddNormal, ZnFillUniform, ZnNormalizeInplace,
     },
     layouts::{Backend, Module, ScratchOwned, ZnxView},
     oep::{
@@ -25,9 +25,9 @@ pub fn test_lwe_to_glwe<B>(module: &Module<B>)
 where
     Module<B>: VecZnxDftAllocBytes
         + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
         + VecZnxFillUniform
         + VecZnxSubABInplace
         + VecZnxAddInplace
@@ -49,8 +49,8 @@ where
         + VmpApplyDftToDft<B>
         + VmpApplyDftToDftAdd<B>
         + VecZnxBigNormalizeTmpBytes
-        + VecZnxSwithcDegree
-        + VecZnxAutomorphismInplace
+        + VecZnxSwitchRing
+        + VecZnxAutomorphismInplace<B>
         + ZnNormalizeInplace<B>
         + ZnFillUniform
         + ZnAddNormal,
@@ -130,9 +130,9 @@ pub fn test_glwe_to_lwe<B>(module: &Module<B>)
 where
     Module<B>: VecZnxDftAllocBytes
         + VecZnxBigNormalize<B>
-        + DFT<B>
-        + SvpApplyInplace<B>
-        + IDFTConsume<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
         + VecZnxFillUniform
         + VecZnxSubABInplace
         + VecZnxAddInplace
@@ -154,8 +154,8 @@ where
         + VmpApplyDftToDft<B>
         + VmpApplyDftToDftAdd<B>
         + VecZnxBigNormalizeTmpBytes
-        + VecZnxSwithcDegree
-        + VecZnxAutomorphismInplace
+        + VecZnxSwitchRing
+        + VecZnxAutomorphismInplace<B>
         + ZnNormalizeInplace<B>,
     B: Backend
         + TakeVecZnxDftImpl<B>

poulpy-core/src/tests/test_suite/encryption/gglwe_atk.rs

@@ -0,0 +1,211 @@
+use poulpy_hal::{
+    api::{
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism, VecZnxAutomorphismInplace,
+        VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
+        VecZnxCopy, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize,
+        VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VecZnxSubScalarInplace, VecZnxSwitchRing,
+        VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPrepare,
+    },
+    layouts::{Backend, Module, ScratchOwned},
+    oep::{
+        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
+        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl,
+    },
+    source::Source,
+};
+
+use crate::{
+    encryption::SIGMA,
+    layouts::{
+        GGLWEAutomorphismKey, GLWESecret,
+        compressed::{Decompress, GGLWEAutomorphismKeyCompressed},
+        prepared::{GLWESecretPrepared, PrepareAlloc},
+    },
+};
+
+pub fn test_gglwe_automorphisk_key_encrypt_sk<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VmpApplyDftToDftTmpBytes
+        + VecZnxBigNormalizeTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxAutomorphism
+        + VecZnxSwitchRing
+        + VecZnxAddScalarInplace
+        + VecZnxAutomorphismInplace<B>
+        + VecZnxBigAllocBytes
+        + VecZnxBigAddInplace<B>
+        + VecZnxSubScalarInplace
+        + VecZnxCopy
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>,
+    B: Backend
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxImpl<B>
+        + TakeSvpPPolImpl<B>
+        + TakeVecZnxBigImpl<B>,
+{
+    let basek: usize = 12;
+    let k_ksk: usize = 60;
+    let digits: usize = k_ksk.div_ceil(basek) - 1;
+    (1..3).for_each(|rank| {
+        (1..digits + 1).for_each(|di| {
+            let n: usize = module.n();
+            let rows: usize = (k_ksk - di * basek) / (di * basek);
+
+            let mut atk: GGLWEAutomorphismKey<Vec<u8>> = GGLWEAutomorphismKey::alloc(n, basek, k_ksk, rows, di, rank);
+
+            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]);
+
+            let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(GGLWEAutomorphismKey::encrypt_sk_scratch_space(
+                module, basek, k_ksk, rank,
+            ));
+
+            let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+            sk.fill_ternary_prob(0.5, &mut source_xs);
+
+            let p = -5;
+
+            atk.encrypt_sk(
+                module,
+                p,
+                &sk,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            let mut sk_out: GLWESecret<Vec<u8>> = sk.clone();
+            (0..atk.rank()).for_each(|i| {
+                module.vec_znx_automorphism(
+                    module.galois_element_inv(p),
+                    &mut sk_out.data.as_vec_znx_mut(),
+                    i,
+                    &sk.data.as_vec_znx(),
+                    i,
+                );
+            });
+            let sk_out_prepared: GLWESecretPrepared<Vec<u8>, B> = sk_out.prepare_alloc(module, scratch.borrow());
+
+            atk.key
+                .key
+                .assert_noise(module, &sk_out_prepared, &sk.data, SIGMA);
+        });
+    });
+}
+
+pub fn test_gglwe_automorphisk_key_compressed_encrypt_sk<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VmpApplyDftToDftTmpBytes
+        + VecZnxBigNormalizeTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxAutomorphism
+        + VecZnxSwitchRing
+        + VecZnxAddScalarInplace
+        + VecZnxAutomorphismInplace<B>
+        + VecZnxBigAllocBytes
+        + VecZnxBigAddInplace<B>
+        + VecZnxSubScalarInplace
+        + VecZnxCopy
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>,
+    B: Backend
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxImpl<B>
+        + TakeSvpPPolImpl<B>
+        + TakeVecZnxBigImpl<B>,
+{
+    let basek: usize = 12;
+    let k_ksk: usize = 60;
+    let digits: usize = k_ksk.div_ceil(basek) - 1;
+    (1..3).for_each(|rank| {
+        (1..digits + 1).for_each(|di| {
+            let n: usize = module.n();
+            let rows: usize = (k_ksk - di * basek) / (di * basek);
+
+            let mut atk_compressed: GGLWEAutomorphismKeyCompressed<Vec<u8>> =
+                GGLWEAutomorphismKeyCompressed::alloc(n, basek, k_ksk, rows, di, rank);
+
+            let mut source_xs: Source = Source::new([0u8; 32]);
+            let mut source_xe: Source = Source::new([0u8; 32]);
+
+            let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(GGLWEAutomorphismKey::encrypt_sk_scratch_space(
+                module, basek, k_ksk, rank,
+            ));
+
+            let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+            sk.fill_ternary_prob(0.5, &mut source_xs);
+
+            let p = -5;
+
+            let seed_xa: [u8; 32] = [1u8; 32];
+
+            atk_compressed.encrypt_sk(module, p, &sk, seed_xa, &mut source_xe, scratch.borrow());
+
+            let mut sk_out: GLWESecret<Vec<u8>> = sk.clone();
+            (0..atk_compressed.rank()).for_each(|i| {
+                module.vec_znx_automorphism(
+                    module.galois_element_inv(p),
+                    &mut sk_out.data.as_vec_znx_mut(),
+                    i,
+                    &sk.data.as_vec_znx(),
+                    i,
+                );
+            });
+            let sk_out_prepared = sk_out.prepare_alloc(module, scratch.borrow());
+
+            let mut atk: GGLWEAutomorphismKey<Vec<u8>> = GGLWEAutomorphismKey::alloc(n, basek, k_ksk, rows, di, rank);
+            atk.decompress(module, &atk_compressed);
+
+            atk.key
+                .key
+                .assert_noise(module, &sk_out_prepared, &sk.data, SIGMA);
+        });
+    });
+}

poulpy-core/src/tests/test_suite/encryption/gglwe_ct.rs

@@ -0,0 +1,191 @@
+use poulpy_hal::{
+    api::{
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
+        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxCopy, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform,
+        VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
+        VecZnxSubScalarInplace, VecZnxSwitchRing, VmpPMatAlloc, VmpPrepare,
+    },
+    layouts::{Backend, Module, ScratchOwned},
+    oep::{
+        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
+        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl, VecZnxBigAllocBytesImpl, VecZnxDftAllocBytesImpl,
+    },
+    source::Source,
+};
+
+use crate::{
+    encryption::SIGMA,
+    layouts::{
+        GGLWESwitchingKey, GLWESecret,
+        compressed::{Decompress, GGLWESwitchingKeyCompressed},
+        prepared::{GLWESecretPrepared, PrepareAlloc},
+    },
+};
+
+pub fn test_gglwe_switching_key_encrypt_sk<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxSwitchRing
+        + VecZnxAddScalarInplace
+        + VecZnxBigAllocBytes
+        + VecZnxBigAddInplace<B>
+        + VecZnxSubScalarInplace
+        + VecZnxCopy
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>
+        + VecZnxDftAllocBytesImpl<B>
+        + VecZnxBigAllocBytesImpl<B>
+        + TakeSvpPPolImpl<B>,
+{
+    let basek: usize = 12;
+    let k_ksk: usize = 54;
+    let digits: usize = k_ksk / basek;
+    (1..3).for_each(|rank_in| {
+        (1..3).for_each(|rank_out| {
+            (1..digits + 1).for_each(|di| {
+                let n: usize = module.n();
+                let rows: usize = (k_ksk - di * basek) / (di * basek);
+
+                let mut ksk: GGLWESwitchingKey<Vec<u8>> = GGLWESwitchingKey::alloc(n, basek, k_ksk, rows, di, rank_in, rank_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]);
+
+                let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(GGLWESwitchingKey::encrypt_sk_scratch_space(
+                    module, basek, k_ksk, rank_in, rank_out,
+                ));
+
+                let mut sk_in: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_in);
+                sk_in.fill_ternary_prob(0.5, &mut source_xs);
+
+                let mut sk_out: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_out);
+                sk_out.fill_ternary_prob(0.5, &mut source_xs);
+                let sk_out_prepared: GLWESecretPrepared<Vec<u8>, B> = sk_out.prepare_alloc(module, scratch.borrow());
+
+                ksk.encrypt_sk(
+                    module,
+                    &sk_in,
+                    &sk_out,
+                    &mut source_xa,
+                    &mut source_xe,
+                    scratch.borrow(),
+                );
+
+                ksk.key
+                    .assert_noise(module, &sk_out_prepared, &sk_in.data, SIGMA);
+            });
+        });
+    });
+}
+
+pub fn test_gglwe_switching_key_compressed_encrypt_sk<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxSwitchRing
+        + VecZnxAddScalarInplace
+        + VecZnxBigAllocBytes
+        + VecZnxBigAddInplace<B>
+        + VecZnxSubScalarInplace
+        + VecZnxCopy
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>
+        + VecZnxDftAllocBytesImpl<B>
+        + VecZnxBigAllocBytesImpl<B>
+        + TakeSvpPPolImpl<B>,
+{
+    let basek: usize = 12;
+    let k_ksk: usize = 54;
+    let digits: usize = k_ksk / basek;
+    (1..3).for_each(|rank_in| {
+        (1..3).for_each(|rank_out| {
+            (1..digits + 1).for_each(|di| {
+                let n: usize = module.n();
+                let rows: usize = (k_ksk - di * basek) / (di * basek);
+
+                let mut ksk_compressed: GGLWESwitchingKeyCompressed<Vec<u8>> =
+                    GGLWESwitchingKeyCompressed::alloc(n, basek, k_ksk, rows, di, rank_in, rank_out);
+
+                let mut source_xs: Source = Source::new([0u8; 32]);
+                let mut source_xe: Source = Source::new([0u8; 32]);
+
+                let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(GGLWESwitchingKeyCompressed::encrypt_sk_scratch_space(
+                    module, basek, k_ksk, rank_in, rank_out,
+                ));
+
+                let mut sk_in: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_in);
+                sk_in.fill_ternary_prob(0.5, &mut source_xs);
+
+                let mut sk_out: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_out);
+                sk_out.fill_ternary_prob(0.5, &mut source_xs);
+                let sk_out_prepared: GLWESecretPrepared<Vec<u8>, B> = sk_out.prepare_alloc(module, scratch.borrow());
+
+                let seed_xa = [1u8; 32];
+
+                ksk_compressed.encrypt_sk(
+                    module,
+                    &sk_in,
+                    &sk_out,
+                    seed_xa,
+                    &mut source_xe,
+                    scratch.borrow(),
+                );
+
+                let mut ksk: GGLWESwitchingKey<Vec<u8>> = GGLWESwitchingKey::alloc(n, basek, k_ksk, rows, di, rank_in, rank_out);
+                ksk.decompress(module, &ksk_compressed);
+
+                ksk.key
+                    .assert_noise(module, &sk_out_prepared, &sk_in.data, SIGMA);
+            });
+        });
+    });
+}

poulpy-core/src/tests/test_suite/encryption/ggsw_ct.rs

@@ -0,0 +1,196 @@
+use poulpy_hal::{
+    api::{
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAlloc,
+        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxCopy, VecZnxDftAlloc, VecZnxDftAllocBytes,
+        VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA, VecZnxNormalize, VecZnxNormalizeInplace,
+        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VmpPMatAlloc, VmpPrepare,
+    },
+    layouts::{Backend, Module, ScalarZnx, ScratchOwned},
+    oep::{
+        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
+        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl, VecZnxBigAllocBytesImpl, VecZnxDftAllocBytesImpl,
+    },
+    source::Source,
+};
+
+use crate::{
+    encryption::SIGMA,
+    layouts::{
+        GGSWCiphertext, GLWESecret,
+        compressed::{Decompress, GGSWCiphertextCompressed},
+        prepared::{GLWESecretPrepared, PrepareAlloc},
+    },
+};
+
+pub fn test_ggsw_encrypt_sk<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxAddScalarInplace
+        + VecZnxBigAllocBytes
+        + VecZnxBigAddInplace<B>
+        + VecZnxCopy
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>
+        + VecZnxBigAlloc<B>
+        + VecZnxDftAlloc<B>
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxIdftApplyTmpA<B>,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + TakeSvpPPolImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>
+        + VecZnxDftAllocBytesImpl<B>
+        + VecZnxBigAllocBytesImpl<B>
+        + TakeSvpPPolImpl<B>,
+{
+    let basek: usize = 12;
+    let k: usize = 54;
+    let digits: usize = k / basek;
+    (1..3).for_each(|rank| {
+        (1..digits + 1).for_each(|di| {
+            let n: usize = module.n();
+            let rows: usize = (k - di * basek) / (di * basek);
+
+            let mut ct: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k, rows, di, rank);
+
+            let mut pt_scalar: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
+
+            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]);
+
+            pt_scalar.fill_ternary_hw(0, n, &mut source_xs);
+
+            let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(GGSWCiphertext::encrypt_sk_scratch_space(
+                module, basek, k, rank,
+            ));
+
+            let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+            sk.fill_ternary_prob(0.5, &mut source_xs);
+            let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
+
+            ct.encrypt_sk(
+                module,
+                &pt_scalar,
+                &sk_prepared,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            let noise_f = |_col_i: usize| -(k as f64) + SIGMA.log2() + 0.5;
+
+            ct.assert_noise(module, &sk_prepared, &pt_scalar, noise_f);
+        });
+    });
+}
+
+pub fn test_ggsw_compressed_encrypt_sk<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxAddScalarInplace
+        + VecZnxBigAllocBytes
+        + VecZnxBigAddInplace<B>
+        + VecZnxCopy
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>
+        + VecZnxBigAlloc<B>
+        + VecZnxDftAlloc<B>
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxIdftApplyTmpA<B>,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>
+        + VecZnxDftAllocBytesImpl<B>
+        + VecZnxBigAllocBytesImpl<B>
+        + TakeSvpPPolImpl<B>,
+{
+    let basek: usize = 12;
+    let k: usize = 54;
+    let digits: usize = k / basek;
+    (1..3).for_each(|rank| {
+        (1..digits + 1).for_each(|di| {
+            let n: usize = module.n();
+            let rows: usize = (k - di * basek) / (di * basek);
+
+            let mut ct_compressed: GGSWCiphertextCompressed<Vec<u8>> =
+                GGSWCiphertextCompressed::alloc(n, basek, k, rows, di, rank);
+
+            let mut pt_scalar: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
+
+            let mut source_xs: Source = Source::new([0u8; 32]);
+            let mut source_xe: Source = Source::new([0u8; 32]);
+
+            pt_scalar.fill_ternary_hw(0, n, &mut source_xs);
+
+            let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(GGSWCiphertextCompressed::encrypt_sk_scratch_space(
+                module, basek, k, rank,
+            ));
+
+            let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+            sk.fill_ternary_prob(0.5, &mut source_xs);
+            let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
+
+            let seed_xa: [u8; 32] = [1u8; 32];
+
+            ct_compressed.encrypt_sk(
+                module,
+                &pt_scalar,
+                &sk_prepared,
+                seed_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            let noise_f = |_col_i: usize| -(k as f64) + SIGMA.log2() + 0.5;
+
+            let mut ct: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k, rows, di, rank);
+            ct.decompress(module, &ct_compressed);
+
+            ct.assert_noise(module, &sk_prepared, &pt_scalar, noise_f);
+        });
+    });
+}

poulpy-core/src/tests/test_suite/encryption/glwe_ct.rs

@@ -0,0 +1,395 @@
+use poulpy_hal::{
+    api::{
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes,
+        SvpPrepare, VecZnxAddInplace, VecZnxAddNormal, VecZnxBigAddInplace, VecZnxBigAddNormal, VecZnxBigAddSmallInplace,
+        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxCopy, VecZnxDftAlloc, VecZnxDftAllocBytes, VecZnxDftApply,
+        VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub,
+        VecZnxSubABInplace,
+    },
+    layouts::{Backend, Module, ScratchOwned},
+    oep::{
+        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
+        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl,
+    },
+    source::Source,
+};
+
+use crate::{
+    encryption::SIGMA,
+    layouts::{
+        GLWECiphertext, GLWEPlaintext, GLWEPublicKey, GLWESecret, Infos,
+        compressed::{Decompress, GLWECiphertextCompressed},
+        prepared::{GLWEPublicKeyPrepared, GLWESecretPrepared, PrepareAlloc},
+    },
+    operations::GLWEOperations,
+};
+
+pub fn test_glwe_encrypt_sk<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigAllocBytes
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxBigAddInplace<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigNormalize<B>
+        + VecZnxNormalizeTmpBytes
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxDftAllocBytes
+        + VecZnxBigAllocBytes
+        + SvpPPolAllocBytes
+        + SvpPrepare<B>
+        + SvpApplyDftToDft<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxBigAddNormal<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigNormalize<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + TakeSvpPPolImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>,
+{
+    let basek: usize = 8;
+    let k_ct: usize = 54;
+    let k_pt: usize = 30;
+
+    for rank in 1..3 {
+        let n = module.n();
+        let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_ct, rank);
+        let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_pt);
+        let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_pt);
+
+        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]);
+
+        let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+            GLWECiphertext::encrypt_sk_scratch_space(module, basek, ct.k())
+                | GLWECiphertext::decrypt_scratch_space(module, basek, ct.k()),
+        );
+
+        let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+        sk.fill_ternary_prob(0.5, &mut source_xs);
+        let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
+
+        module.vec_znx_fill_uniform(basek, &mut pt_want.data, 0, &mut source_xa);
+
+        ct.encrypt_sk(
+            module,
+            &pt_want,
+            &sk_prepared,
+            &mut source_xa,
+            &mut source_xe,
+            scratch.borrow(),
+        );
+
+        ct.decrypt(module, &mut pt_have, &sk_prepared, scratch.borrow());
+
+        pt_want.sub_inplace_ab(module, &pt_have);
+
+        let noise_have: f64 = pt_want.data.std(basek, 0) * (ct.k() as f64).exp2();
+        let noise_want: f64 = SIGMA;
+
+        assert!(noise_have <= noise_want + 0.2);
+    }
+}
+
+pub fn test_glwe_compressed_encrypt_sk<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigAllocBytes
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxBigAddInplace<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigNormalize<B>
+        + VecZnxNormalizeTmpBytes
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxDftAllocBytes
+        + VecZnxBigAllocBytes
+        + SvpPPolAllocBytes
+        + SvpPrepare<B>
+        + SvpApplyDftToDft<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxBigAddNormal<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigNormalize<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + VecZnxCopy,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + TakeSvpPPolImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>,
+{
+    let basek: usize = 8;
+    let k_ct: usize = 54;
+    let k_pt: usize = 30;
+
+    for rank in 1..3 {
+        let n = module.n();
+        let mut ct_compressed: GLWECiphertextCompressed<Vec<u8>> = GLWECiphertextCompressed::alloc(n, basek, k_ct, rank);
+
+        let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_pt);
+        let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_pt);
+
+        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]);
+
+        let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+            GLWECiphertextCompressed::encrypt_sk_scratch_space(module, basek, k_ct)
+                | GLWECiphertext::decrypt_scratch_space(module, basek, k_ct),
+        );
+
+        let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+        sk.fill_ternary_prob(0.5, &mut source_xs);
+        let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
+
+        module.vec_znx_fill_uniform(basek, &mut pt_want.data, 0, &mut source_xa);
+
+        let seed_xa: [u8; 32] = [1u8; 32];
+
+        ct_compressed.encrypt_sk(
+            module,
+            &pt_want,
+            &sk_prepared,
+            seed_xa,
+            &mut source_xe,
+            scratch.borrow(),
+        );
+
+        let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_ct, rank);
+        ct.decompress(module, &ct_compressed);
+
+        ct.decrypt(module, &mut pt_have, &sk_prepared, scratch.borrow());
+
+        pt_want.sub_inplace_ab(module, &pt_have);
+
+        let noise_have: f64 = pt_want.data.std(basek, 0) * (ct.k() as f64).exp2();
+        let noise_want: f64 = SIGMA;
+
+        assert!(
+            noise_have <= noise_want + 0.2,
+            "{} <= {}",
+            noise_have,
+            noise_want + 0.2
+        );
+    }
+}
+
+pub fn test_glwe_encrypt_zero_sk<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigAllocBytes
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxBigAddInplace<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigNormalize<B>
+        + VecZnxNormalizeTmpBytes
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxDftAllocBytes
+        + VecZnxBigAllocBytes
+        + SvpPPolAllocBytes
+        + SvpPrepare<B>
+        + SvpApplyDftToDft<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxBigAddNormal<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigNormalize<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + TakeSvpPPolImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>,
+{
+    let basek: usize = 8;
+    let k_ct: usize = 54;
+
+    for rank in 1..3 {
+        let n = module.n();
+        let mut pt: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_ct);
+
+        let mut source_xs: Source = Source::new([0u8; 32]);
+        let mut source_xe: Source = Source::new([1u8; 32]);
+        let mut source_xa: Source = Source::new([0u8; 32]);
+
+        let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+            GLWECiphertext::decrypt_scratch_space(module, basek, k_ct)
+                | GLWECiphertext::encrypt_sk_scratch_space(module, basek, k_ct),
+        );
+
+        let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+        sk.fill_ternary_prob(0.5, &mut source_xs);
+        let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
+
+        let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_ct, rank);
+
+        ct.encrypt_zero_sk(
+            module,
+            &sk_prepared,
+            &mut source_xa,
+            &mut source_xe,
+            scratch.borrow(),
+        );
+        ct.decrypt(module, &mut pt, &sk_prepared, scratch.borrow());
+
+        assert!((SIGMA - pt.data.std(basek, 0) * (k_ct as f64).exp2()) <= 0.2);
+    }
+}
+
+pub fn test_glwe_encrypt_pk<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigAllocBytes
+        + VecZnxBigAddInplace<B>
+        + VecZnxCopy
+        + VecZnxDftAlloc<B>
+        + SvpApplyDftToDft<B>
+        + VecZnxBigAddNormal<B>,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + TakeSvpPPolImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>,
+{
+    let basek: usize = 8;
+    let k_ct: usize = 54;
+    let k_pk: usize = 54;
+
+    for rank in 1..3 {
+        let n: usize = module.n();
+        let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_ct, rank);
+        let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_ct);
+        let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, 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]);
+        let mut source_xu: Source = Source::new([0u8; 32]);
+
+        let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+            GLWECiphertext::encrypt_sk_scratch_space(module, basek, ct.k())
+                | GLWECiphertext::decrypt_scratch_space(module, basek, ct.k())
+                | GLWECiphertext::encrypt_pk_scratch_space(module, basek, k_pk),
+        );
+
+        let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+        sk.fill_ternary_prob(0.5, &mut source_xs);
+        let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
+
+        let mut pk: GLWEPublicKey<Vec<u8>> = GLWEPublicKey::alloc(n, basek, k_pk, rank);
+        pk.generate_from_sk(module, &sk_prepared, &mut source_xa, &mut source_xe);
+
+        module.vec_znx_fill_uniform(basek, &mut pt_want.data, 0, &mut source_xa);
+
+        let pk_prepared: GLWEPublicKeyPrepared<Vec<u8>, B> = pk.prepare_alloc(module, scratch.borrow());
+
+        ct.encrypt_pk(
+            module,
+            &pt_want,
+            &pk_prepared,
+            &mut source_xu,
+            &mut source_xe,
+            scratch.borrow(),
+        );
+
+        ct.decrypt(module, &mut pt_have, &sk_prepared, scratch.borrow());
+
+        pt_want.sub_inplace_ab(module, &pt_have);
+
+        let noise_have: f64 = pt_want.data.std(basek, 0).log2();
+        let noise_want: f64 = ((((rank as f64) + 1.0) * n as f64 * 0.5 * SIGMA * SIGMA).sqrt()).log2() - (k_ct as f64);
+
+        assert!(
+            noise_have <= noise_want + 0.2,
+            "{} {}",
+            noise_have,
+            noise_want
+        );
+    }
+}

poulpy-core/src/tests/test_suite/encryption/glwe_tsk.rs

@@ -0,0 +1,250 @@
+use poulpy_hal::{
+    api::{
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes,
+        SvpPrepare, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
+        VecZnxBigAlloc, VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxCopy, VecZnxDftAlloc, VecZnxDftAllocBytes, VecZnxDftApply,
+        VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA, VecZnxNormalize, VecZnxNormalizeInplace,
+        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VecZnxSubScalarInplace, VecZnxSwitchRing,
+    },
+    layouts::{Backend, Module, ScratchOwned, VecZnxDft},
+    oep::{
+        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
+        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl, VecZnxBigAllocBytesImpl, VecZnxDftAllocBytesImpl,
+    },
+    source::Source,
+};
+
+use crate::{
+    encryption::SIGMA,
+    layouts::{
+        GGLWETensorKey, GLWEPlaintext, GLWESecret, Infos,
+        compressed::{Decompress, GGLWETensorKeyCompressed},
+        prepared::{GLWESecretPrepared, PrepareAlloc},
+    },
+};
+
+pub fn test_gglwe_tensor_key_encrypt_sk<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigAllocBytes
+        + VecZnxBigAddInplace<B>
+        + VecZnxCopy
+        + VecZnxDftAlloc<B>
+        + SvpApplyDftToDft<B>
+        + VecZnxBigAlloc<B>
+        + VecZnxIdftApplyTmpA<B>
+        + VecZnxAddScalarInplace
+        + VecZnxSwitchRing
+        + VecZnxSubScalarInplace,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>
+        + VecZnxDftAllocBytesImpl<B>
+        + VecZnxBigAllocBytesImpl<B>
+        + TakeSvpPPolImpl<B>,
+{
+    let basek: usize = 8;
+    let k: usize = 54;
+
+    (1..3).for_each(|rank| {
+        let n: usize = module.n();
+        let rows: usize = k / basek;
+
+        let mut tensor_key: GGLWETensorKey<Vec<u8>> = GGLWETensorKey::alloc(n, basek, k, rows, 1, rank);
+
+        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]);
+
+        let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(GGLWETensorKey::encrypt_sk_scratch_space(
+            module,
+            basek,
+            tensor_key.k(),
+            rank,
+        ));
+
+        let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+        sk.fill_ternary_prob(0.5, &mut source_xs);
+        let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
+
+        tensor_key.encrypt_sk(
+            module,
+            &sk,
+            &mut source_xa,
+            &mut source_xe,
+            scratch.borrow(),
+        );
+
+        let mut pt: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k);
+
+        let mut sk_ij_dft = module.vec_znx_dft_alloc(1, 1);
+        let mut sk_ij_big = module.vec_znx_big_alloc(1, 1);
+        let mut sk_ij: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, 1);
+        let mut sk_dft: VecZnxDft<Vec<u8>, B> = module.vec_znx_dft_alloc(rank, 1);
+
+        (0..rank).for_each(|i| {
+            module.vec_znx_dft_apply(1, 0, &mut sk_dft, i, &sk.data.as_vec_znx(), i);
+        });
+
+        (0..rank).for_each(|i| {
+            (0..rank).for_each(|j| {
+                module.svp_apply_dft_to_dft(&mut sk_ij_dft, 0, &sk_prepared.data, j, &sk_dft, i);
+                module.vec_znx_idft_apply_tmpa(&mut sk_ij_big, 0, &mut sk_ij_dft, 0);
+                module.vec_znx_big_normalize(
+                    basek,
+                    &mut sk_ij.data.as_vec_znx_mut(),
+                    0,
+                    &sk_ij_big,
+                    0,
+                    scratch.borrow(),
+                );
+                (0..tensor_key.rank_in()).for_each(|col_i| {
+                    (0..tensor_key.rows()).for_each(|row_i| {
+                        tensor_key
+                            .at(i, j)
+                            .at(row_i, col_i)
+                            .decrypt(module, &mut pt, &sk_prepared, scratch.borrow());
+
+                        module.vec_znx_sub_scalar_inplace(&mut pt.data, 0, row_i, &sk_ij.data, col_i);
+
+                        let std_pt: f64 = pt.data.std(basek, 0) * (k as f64).exp2();
+                        assert!((SIGMA - std_pt).abs() <= 0.5, "{} {}", SIGMA, std_pt);
+                    });
+                });
+            });
+        });
+    });
+}
+
+pub fn test_gglwe_tensor_key_compressed_encrypt_sk<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigAllocBytes
+        + VecZnxBigAddInplace<B>
+        + VecZnxCopy
+        + VecZnxDftAlloc<B>
+        + SvpApplyDftToDft<B>
+        + VecZnxBigAlloc<B>
+        + VecZnxIdftApplyTmpA<B>
+        + VecZnxAddScalarInplace
+        + VecZnxSwitchRing
+        + VecZnxSubScalarInplace,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>
+        + VecZnxDftAllocBytesImpl<B>
+        + VecZnxBigAllocBytesImpl<B>
+        + TakeSvpPPolImpl<B>,
+{
+    let basek = 8;
+    let k = 54;
+    (1..3).for_each(|rank| {
+        let n: usize = module.n();
+        let rows: usize = k / basek;
+
+        let mut tensor_key_compressed: GGLWETensorKeyCompressed<Vec<u8>> =
+            GGLWETensorKeyCompressed::alloc(n, basek, k, rows, 1, rank);
+
+        let mut source_xs: Source = Source::new([0u8; 32]);
+        let mut source_xe: Source = Source::new([0u8; 32]);
+
+        let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(GGLWETensorKeyCompressed::encrypt_sk_scratch_space(
+            module,
+            basek,
+            tensor_key_compressed.k(),
+            rank,
+        ));
+
+        let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+        sk.fill_ternary_prob(0.5, &mut source_xs);
+        let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
+
+        let seed_xa: [u8; 32] = [1u8; 32];
+
+        tensor_key_compressed.encrypt_sk(module, &sk, seed_xa, &mut source_xe, scratch.borrow());
+
+        let mut tensor_key: GGLWETensorKey<Vec<u8>> = GGLWETensorKey::alloc(n, basek, k, rows, 1, rank);
+        tensor_key.decompress(module, &tensor_key_compressed);
+
+        let mut pt: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k);
+
+        let mut sk_ij_dft = module.vec_znx_dft_alloc(1, 1);
+        let mut sk_ij_big = module.vec_znx_big_alloc(1, 1);
+        let mut sk_ij: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, 1);
+        let mut sk_dft: VecZnxDft<Vec<u8>, B> = module.vec_znx_dft_alloc(rank, 1);
+
+        (0..rank).for_each(|i| {
+            module.vec_znx_dft_apply(1, 0, &mut sk_dft, i, &sk.data.as_vec_znx(), i);
+        });
+
+        (0..rank).for_each(|i| {
+            (0..rank).for_each(|j| {
+                module.svp_apply_dft_to_dft(&mut sk_ij_dft, 0, &sk_prepared.data, j, &sk_dft, i);
+                module.vec_znx_idft_apply_tmpa(&mut sk_ij_big, 0, &mut sk_ij_dft, 0);
+                module.vec_znx_big_normalize(
+                    basek,
+                    &mut sk_ij.data.as_vec_znx_mut(),
+                    0,
+                    &sk_ij_big,
+                    0,
+                    scratch.borrow(),
+                );
+                (0..tensor_key.rank_in()).for_each(|col_i| {
+                    (0..tensor_key.rows()).for_each(|row_i| {
+                        tensor_key
+                            .at(i, j)
+                            .at(row_i, col_i)
+                            .decrypt(module, &mut pt, &sk_prepared, scratch.borrow());
+
+                        module.vec_znx_sub_scalar_inplace(&mut pt.data, 0, row_i, &sk_ij.data, col_i);
+
+                        let std_pt: f64 = pt.data.std(basek, 0) * (k as f64).exp2();
+                        assert!((SIGMA - std_pt).abs() <= 0.5, "{} {}", SIGMA, std_pt);
+                    });
+                });
+            });
+        });
+    });
+}

poulpy-core/src/tests/test_suite/external_product/gglwe_ksk.rs

@@ -0,0 +1,323 @@
+use poulpy_hal::{
+    api::{
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
+        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxCopy, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform,
+        VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxRotateInplace, VecZnxSub,
+        VecZnxSubABInplace, VecZnxSubScalarInplace, VecZnxSwitchRing, VmpApplyDftToDft, VmpApplyDftToDftAdd,
+        VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPrepare,
+    },
+    layouts::{Backend, Module, ScalarZnx, ScalarZnxToMut, ScratchOwned, ZnxViewMut},
+    oep::{
+        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
+        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl, VecZnxBigAllocBytesImpl, VecZnxDftAllocBytesImpl,
+    },
+    source::Source,
+};
+
+use crate::{
+    encryption::SIGMA,
+    layouts::{
+        GGLWESwitchingKey, GGSWCiphertext, GLWESecret,
+        prepared::{GGSWCiphertextPrepared, GLWESecretPrepared, PrepareAlloc},
+    },
+    noise::noise_ggsw_product,
+};
+
+#[allow(clippy::too_many_arguments)]
+pub fn test_gglwe_switching_key_external_product<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxBigAllocBytes
+        + VecZnxBigAddInplace<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxSwitchRing
+        + VecZnxAddScalarInplace
+        + VecZnxSubScalarInplace
+        + VecZnxCopy
+        + VmpPMatAlloc<B>
+        + VecZnxRotateInplace<B>
+        + VmpApplyDftToDftTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VmpPrepare<B>,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>
+        + VecZnxDftAllocBytesImpl<B>
+        + VecZnxBigAllocBytesImpl<B>
+        + TakeSvpPPolImpl<B>,
+{
+    let basek: usize = 12;
+    let k_in: usize = 60;
+    let digits: usize = k_in.div_ceil(basek);
+    (1..3).for_each(|rank_in| {
+        (1..3).for_each(|rank_out| {
+            (1..digits + 1).for_each(|di| {
+                let k_ggsw: usize = k_in + basek * di;
+                let k_out: usize = k_in; // Better capture noise.
+
+                let n: usize = module.n();
+                let rows: usize = k_in.div_ceil(basek * di);
+                let digits_in: usize = 1;
+
+                let mut ct_gglwe_in: GGLWESwitchingKey<Vec<u8>> =
+                    GGLWESwitchingKey::alloc(n, basek, k_in, rows, digits_in, rank_in, rank_out);
+                let mut ct_gglwe_out: GGLWESwitchingKey<Vec<u8>> =
+                    GGLWESwitchingKey::alloc(n, basek, k_out, rows, digits_in, rank_in, rank_out);
+                let mut ct_rgsw: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_ggsw, rows, di, rank_out);
+
+                let mut pt_rgsw: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
+
+                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]);
+
+                let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+                    GGLWESwitchingKey::encrypt_sk_scratch_space(module, basek, k_in, rank_in, rank_out)
+                        | GGLWESwitchingKey::external_product_scratch_space(module, basek, k_out, k_in, k_ggsw, di, rank_out)
+                        | GGSWCiphertext::encrypt_sk_scratch_space(module, basek, k_ggsw, rank_out),
+                );
+
+                let r: usize = 1;
+
+                pt_rgsw.to_mut().raw_mut()[r] = 1; // X^{r}
+
+                let var_xs: f64 = 0.5;
+
+                let mut sk_in: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_in);
+                sk_in.fill_ternary_prob(var_xs, &mut source_xs);
+
+                let mut sk_out: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_out);
+                sk_out.fill_ternary_prob(var_xs, &mut source_xs);
+                let sk_out_prepared: GLWESecretPrepared<Vec<u8>, B> = sk_out.prepare_alloc(module, scratch.borrow());
+
+                // gglwe_{s1}(s0) = s0 -> s1
+                ct_gglwe_in.encrypt_sk(
+                    module,
+                    &sk_in,
+                    &sk_out,
+                    &mut source_xa,
+                    &mut source_xe,
+                    scratch.borrow(),
+                );
+
+                ct_rgsw.encrypt_sk(
+                    module,
+                    &pt_rgsw,
+                    &sk_out_prepared,
+                    &mut source_xa,
+                    &mut source_xe,
+                    scratch.borrow(),
+                );
+
+                let ct_rgsw_prepared: GGSWCiphertextPrepared<Vec<u8>, B> = ct_rgsw.prepare_alloc(module, scratch.borrow());
+
+                // gglwe_(m) (x) RGSW_(X^k) = gglwe_(m * X^k)
+                ct_gglwe_out.external_product(module, &ct_gglwe_in, &ct_rgsw_prepared, scratch.borrow());
+
+                (0..rank_in).for_each(|i| {
+                    module.vec_znx_rotate_inplace(
+                        r as i64,
+                        &mut sk_in.data.as_vec_znx_mut(),
+                        i,
+                        scratch.borrow(),
+                    ); // * X^{r}
+                });
+
+                let var_gct_err_lhs: f64 = SIGMA * SIGMA;
+                let var_gct_err_rhs: f64 = 0f64;
+
+                let var_msg: f64 = 1f64 / n as f64; // X^{k}
+                let var_a0_err: f64 = SIGMA * SIGMA;
+                let var_a1_err: f64 = 1f64 / 12f64;
+
+                let max_noise: f64 = noise_ggsw_product(
+                    n as f64,
+                    basek * di,
+                    var_xs,
+                    var_msg,
+                    var_a0_err,
+                    var_a1_err,
+                    var_gct_err_lhs,
+                    var_gct_err_rhs,
+                    rank_out as f64,
+                    k_in,
+                    k_ggsw,
+                );
+
+                ct_gglwe_out
+                    .key
+                    .assert_noise(module, &sk_out_prepared, &sk_in.data, max_noise + 0.5);
+            });
+        });
+    });
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn test_gglwe_switching_key_external_product_inplace<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxBigAllocBytes
+        + VecZnxBigAddInplace<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxSwitchRing
+        + VecZnxAddScalarInplace
+        + VecZnxSubScalarInplace
+        + VecZnxCopy
+        + VmpPMatAlloc<B>
+        + VecZnxRotateInplace<B>
+        + VmpApplyDftToDftTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VmpPrepare<B>,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>
+        + VecZnxDftAllocBytesImpl<B>
+        + VecZnxBigAllocBytesImpl<B>
+        + TakeSvpPPolImpl<B>,
+{
+    let basek: usize = 12;
+    let k_ct: usize = 60;
+    let digits: usize = k_ct.div_ceil(basek);
+    (1..3).for_each(|rank_in| {
+        (1..3).for_each(|rank_out| {
+            (1..digits).for_each(|di| {
+                let k_ggsw: usize = k_ct + basek * di;
+
+                let n: usize = module.n();
+                let rows: usize = k_ct.div_ceil(basek * di);
+
+                let digits_in: usize = 1;
+
+                let mut ct_gglwe: GGLWESwitchingKey<Vec<u8>> =
+                    GGLWESwitchingKey::alloc(n, basek, k_ct, rows, digits_in, rank_in, rank_out);
+                let mut ct_rgsw: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_ggsw, rows, di, rank_out);
+
+                let mut pt_rgsw: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
+
+                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]);
+
+                let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+                    GGLWESwitchingKey::encrypt_sk_scratch_space(module, basek, k_ct, rank_in, rank_out)
+                        | GGLWESwitchingKey::external_product_inplace_scratch_space(module, basek, k_ct, k_ggsw, di, rank_out)
+                        | GGSWCiphertext::encrypt_sk_scratch_space(module, basek, k_ggsw, rank_out),
+                );
+
+                let r: usize = 1;
+
+                pt_rgsw.to_mut().raw_mut()[r] = 1; // X^{r}
+
+                let var_xs: f64 = 0.5;
+
+                let mut sk_in: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_in);
+                sk_in.fill_ternary_prob(var_xs, &mut source_xs);
+
+                let mut sk_out: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_out);
+                sk_out.fill_ternary_prob(var_xs, &mut source_xs);
+                let sk_out_prepared: GLWESecretPrepared<Vec<u8>, B> = sk_out.prepare_alloc(module, scratch.borrow());
+
+                // gglwe_{s1}(s0) = s0 -> s1
+                ct_gglwe.encrypt_sk(
+                    module,
+                    &sk_in,
+                    &sk_out,
+                    &mut source_xa,
+                    &mut source_xe,
+                    scratch.borrow(),
+                );
+
+                ct_rgsw.encrypt_sk(
+                    module,
+                    &pt_rgsw,
+                    &sk_out_prepared,
+                    &mut source_xa,
+                    &mut source_xe,
+                    scratch.borrow(),
+                );
+
+                let ct_rgsw_prepared: GGSWCiphertextPrepared<Vec<u8>, B> = ct_rgsw.prepare_alloc(module, scratch.borrow());
+
+                // gglwe_(m) (x) RGSW_(X^k) = gglwe_(m * X^k)
+                ct_gglwe.external_product_inplace(module, &ct_rgsw_prepared, scratch.borrow());
+
+                (0..rank_in).for_each(|i| {
+                    module.vec_znx_rotate_inplace(
+                        r as i64,
+                        &mut sk_in.data.as_vec_znx_mut(),
+                        i,
+                        scratch.borrow(),
+                    ); // * X^{r}
+                });
+
+                let var_gct_err_lhs: f64 = SIGMA * SIGMA;
+                let var_gct_err_rhs: f64 = 0f64;
+
+                let var_msg: f64 = 1f64 / n as f64; // X^{k}
+                let var_a0_err: f64 = SIGMA * SIGMA;
+                let var_a1_err: f64 = 1f64 / 12f64;
+
+                let max_noise: f64 = noise_ggsw_product(
+                    n as f64,
+                    basek * di,
+                    var_xs,
+                    var_msg,
+                    var_a0_err,
+                    var_a1_err,
+                    var_gct_err_lhs,
+                    var_gct_err_rhs,
+                    rank_out as f64,
+                    k_ct,
+                    k_ggsw,
+                );
+
+                ct_gglwe
+                    .key
+                    .assert_noise(module, &sk_out_prepared, &sk_in.data, max_noise + 0.5);
+            });
+        });
+    });
+}

poulpy-core/src/tests/test_suite/external_product/ggsw_ct.rs

@@ -0,0 +1,307 @@
+use poulpy_hal::{
+    api::{
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAlloc,
+        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxCopy, VecZnxDftAlloc, VecZnxDftAllocBytes,
+        VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA, VecZnxNormalize, VecZnxNormalizeInplace,
+        VecZnxNormalizeTmpBytes, VecZnxRotateInplace, VecZnxSub, VecZnxSubABInplace, VmpApplyDftToDft, VmpApplyDftToDftAdd,
+        VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPrepare,
+    },
+    layouts::{Backend, Module, ScalarZnx, ScalarZnxToMut, ScratchOwned, ZnxViewMut},
+    oep::{
+        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
+        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl, VecZnxBigAllocBytesImpl, VecZnxDftAllocBytesImpl,
+    },
+    source::Source,
+};
+
+use crate::{
+    encryption::SIGMA,
+    layouts::{
+        GGSWCiphertext, GLWESecret,
+        prepared::{GGSWCiphertextPrepared, GLWESecretPrepared, PrepareAlloc},
+    },
+    noise::noise_ggsw_product,
+};
+
+#[allow(clippy::too_many_arguments)]
+pub fn test_ggsw_external_product<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxBigAllocBytes
+        + VecZnxBigAddInplace<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxAddScalarInplace
+        + VecZnxCopy
+        + VmpPMatAlloc<B>
+        + VecZnxRotateInplace<B>
+        + VmpApplyDftToDftTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VmpPrepare<B>
+        + VecZnxBigAlloc<B>
+        + VecZnxDftAlloc<B>
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxIdftApplyTmpA<B>,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>
+        + VecZnxDftAllocBytesImpl<B>
+        + VecZnxBigAllocBytesImpl<B>
+        + TakeSvpPPolImpl<B>,
+{
+    let basek: usize = 12;
+    let k_in: usize = 60;
+    let digits: usize = k_in.div_ceil(basek);
+    (1..3).for_each(|rank| {
+        (1..digits + 1).for_each(|di| {
+            let k_ggsw: usize = k_in + basek * di;
+            println!("test external_product digits: {} ranks: {}", di, rank);
+            let k_out: usize = k_in; // Better capture noise.
+
+            let n: usize = module.n();
+            let rows: usize = k_in.div_ceil(basek * di);
+            let rows_in: usize = k_in.div_euclid(basek * di);
+            let digits_in: usize = 1;
+
+            let mut ct_ggsw_lhs_in: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_in, rows_in, digits_in, rank);
+            let mut ct_ggsw_lhs_out: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_out, rows_in, digits_in, rank);
+            let mut ct_ggsw_rhs: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_ggsw, rows, di, rank);
+            let mut pt_ggsw_lhs: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
+            let mut pt_ggsw_rhs: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
+
+            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]);
+
+            pt_ggsw_lhs.fill_ternary_prob(0, 0.5, &mut source_xs);
+
+            let k: usize = 1;
+
+            pt_ggsw_rhs.to_mut().raw_mut()[k] = 1; //X^{k}
+
+            let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+                GGSWCiphertext::encrypt_sk_scratch_space(module, basek, k_ggsw, rank)
+                    | GGSWCiphertext::external_product_scratch_space(module, basek, k_out, k_in, k_ggsw, di, rank),
+            );
+
+            let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+            sk.fill_ternary_prob(0.5, &mut source_xs);
+            let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
+
+            ct_ggsw_rhs.encrypt_sk(
+                module,
+                &pt_ggsw_rhs,
+                &sk_prepared,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            ct_ggsw_lhs_in.encrypt_sk(
+                module,
+                &pt_ggsw_lhs,
+                &sk_prepared,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            let ct_rhs_prepared: GGSWCiphertextPrepared<Vec<u8>, B> = ct_ggsw_rhs.prepare_alloc(module, scratch.borrow());
+
+            ct_ggsw_lhs_out.external_product(module, &ct_ggsw_lhs_in, &ct_rhs_prepared, scratch.borrow());
+
+            module.vec_znx_rotate_inplace(
+                k as i64,
+                &mut pt_ggsw_lhs.as_vec_znx_mut(),
+                0,
+                scratch.borrow(),
+            );
+
+            let var_gct_err_lhs: f64 = SIGMA * SIGMA;
+            let var_gct_err_rhs: f64 = 0f64;
+
+            let var_msg: f64 = 1f64 / n as f64; // X^{k}
+            let var_a0_err: f64 = SIGMA * SIGMA;
+            let var_a1_err: f64 = 1f64 / 12f64;
+
+            let max_noise = |_col_j: usize| -> f64 {
+                noise_ggsw_product(
+                    n as f64,
+                    basek * di,
+                    0.5,
+                    var_msg,
+                    var_a0_err,
+                    var_a1_err,
+                    var_gct_err_lhs,
+                    var_gct_err_rhs,
+                    rank as f64,
+                    k_in,
+                    k_ggsw,
+                ) + 0.5
+            };
+
+            ct_ggsw_lhs_out.assert_noise(module, &sk_prepared, &pt_ggsw_lhs, max_noise);
+        });
+    });
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn test_ggsw_external_product_inplace<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxBigAllocBytes
+        + VecZnxBigAddInplace<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxAddScalarInplace
+        + VecZnxCopy
+        + VmpPMatAlloc<B>
+        + VecZnxRotateInplace<B>
+        + VmpApplyDftToDftTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VmpPrepare<B>
+        + VecZnxBigAlloc<B>
+        + VecZnxDftAlloc<B>
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxIdftApplyTmpA<B>,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>
+        + VecZnxDftAllocBytesImpl<B>
+        + VecZnxBigAllocBytesImpl<B>
+        + TakeSvpPPolImpl<B>,
+{
+    let basek: usize = 12;
+    let k_ct: usize = 60;
+    let digits: usize = k_ct.div_ceil(basek);
+    (1..3).for_each(|rank| {
+        (1..digits).for_each(|di| {
+            let k_ggsw: usize = k_ct + basek * di;
+
+            let n: usize = module.n();
+            let rows: usize = k_ct.div_ceil(di * basek);
+            let rows_in: usize = k_ct.div_euclid(basek * di);
+            let digits_in: usize = 1;
+
+            let mut ct_ggsw_lhs: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_ct, rows_in, digits_in, rank);
+            let mut ct_ggsw_rhs: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_ggsw, rows, di, rank);
+
+            let mut pt_ggsw_lhs: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
+            let mut pt_ggsw_rhs: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
+
+            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]);
+
+            pt_ggsw_lhs.fill_ternary_prob(0, 0.5, &mut source_xs);
+
+            let k: usize = 1;
+
+            pt_ggsw_rhs.to_mut().raw_mut()[k] = 1; //X^{k}
+
+            let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+                GGSWCiphertext::encrypt_sk_scratch_space(module, basek, k_ggsw, rank)
+                    | GGSWCiphertext::external_product_inplace_scratch_space(module, basek, k_ct, k_ggsw, di, rank),
+            );
+
+            let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+            sk.fill_ternary_prob(0.5, &mut source_xs);
+            let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
+
+            ct_ggsw_rhs.encrypt_sk(
+                module,
+                &pt_ggsw_rhs,
+                &sk_prepared,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            ct_ggsw_lhs.encrypt_sk(
+                module,
+                &pt_ggsw_lhs,
+                &sk_prepared,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            let ct_rhs_prepared: GGSWCiphertextPrepared<Vec<u8>, B> = ct_ggsw_rhs.prepare_alloc(module, scratch.borrow());
+
+            ct_ggsw_lhs.external_product_inplace(module, &ct_rhs_prepared, scratch.borrow());
+
+            module.vec_znx_rotate_inplace(
+                k as i64,
+                &mut pt_ggsw_lhs.as_vec_znx_mut(),
+                0,
+                scratch.borrow(),
+            );
+
+            let var_gct_err_lhs: f64 = SIGMA * SIGMA;
+            let var_gct_err_rhs: f64 = 0f64;
+
+            let var_msg: f64 = 1f64 / n as f64; // X^{k}
+            let var_a0_err: f64 = SIGMA * SIGMA;
+            let var_a1_err: f64 = 1f64 / 12f64;
+
+            let max_noise = |_col_j: usize| -> f64 {
+                noise_ggsw_product(
+                    n as f64,
+                    basek * di,
+                    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,
+                ) + 0.5
+            };
+
+            ct_ggsw_lhs.assert_noise(module, &sk_prepared, &pt_ggsw_lhs, max_noise);
+        });
+    });
+}

poulpy-core/src/tests/test_suite/external_product/glwe_ct.rs

@@ -0,0 +1,295 @@
+use poulpy_hal::{
+    api::{
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
+        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume,
+        VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxRotateInplace, VecZnxSub, VecZnxSubABInplace,
+        VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPrepare,
+    },
+    layouts::{Backend, Module, ScalarZnx, ScratchOwned, ZnxViewMut},
+    oep::{
+        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
+        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl,
+    },
+    source::Source,
+};
+
+use crate::{
+    encryption::SIGMA,
+    layouts::{
+        GGSWCiphertext, GLWECiphertext, GLWEPlaintext, GLWESecret, Infos,
+        prepared::{GGSWCiphertextPrepared, GLWESecretPrepared, PrepareAlloc},
+    },
+    noise::noise_ggsw_product,
+};
+
+#[allow(clippy::too_many_arguments)]
+pub fn test_glwe_external_product<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxBigAllocBytes
+        + VecZnxBigAddInplace<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxAddScalarInplace
+        + VecZnxRotateInplace<B>
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>
+        + VmpApplyDftToDftTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + TakeSvpPPolImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>,
+{
+    let basek: usize = 12;
+    let k_in: usize = 45;
+    let digits: usize = k_in.div_ceil(basek);
+    (1..3).for_each(|rank| {
+        (1..digits + 1).for_each(|di| {
+            let k_ggsw: usize = k_in + basek * di;
+            let k_out: usize = k_ggsw; // Better capture noise
+
+            let n: usize = module.n();
+            let rows: usize = k_in.div_ceil(basek * digits);
+
+            let mut ct_ggsw: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_ggsw, rows, digits, rank);
+            let mut ct_glwe_in: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_in, rank);
+            let mut ct_glwe_out: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_out, rank);
+            let mut pt_rgsw: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
+            let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_in);
+
+            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
+            module.vec_znx_fill_uniform(basek, &mut pt_want.data, 0, &mut source_xa);
+
+            pt_want.data.at_mut(0, 0)[1] = 1;
+
+            let k: usize = 1;
+
+            pt_rgsw.raw_mut()[k] = 1; // X^{k}
+
+            let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+                GGSWCiphertext::encrypt_sk_scratch_space(module, basek, ct_ggsw.k(), rank)
+                    | GLWECiphertext::encrypt_sk_scratch_space(module, basek, ct_glwe_in.k())
+                    | GLWECiphertext::external_product_scratch_space(
+                        module,
+                        basek,
+                        ct_glwe_out.k(),
+                        ct_glwe_in.k(),
+                        ct_ggsw.k(),
+                        digits,
+                        rank,
+                    ),
+            );
+
+            let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+            sk.fill_ternary_prob(0.5, &mut source_xs);
+            let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
+
+            ct_ggsw.encrypt_sk(
+                module,
+                &pt_rgsw,
+                &sk_prepared,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            ct_glwe_in.encrypt_sk(
+                module,
+                &pt_want,
+                &sk_prepared,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            let ct_ggsw_prepared: GGSWCiphertextPrepared<Vec<u8>, B> = ct_ggsw.prepare_alloc(module, scratch.borrow());
+
+            ct_glwe_out.external_product(module, &ct_glwe_in, &ct_ggsw_prepared, scratch.borrow());
+
+            module.vec_znx_rotate_inplace(k as i64, &mut pt_want.data, 0, scratch.borrow());
+
+            let var_gct_err_lhs: f64 = SIGMA * SIGMA;
+            let var_gct_err_rhs: f64 = 0f64;
+
+            let var_msg: f64 = 1f64 / n as f64; // X^{k}
+            let var_a0_err: f64 = SIGMA * SIGMA;
+            let var_a1_err: f64 = 1f64 / 12f64;
+
+            let max_noise: f64 = noise_ggsw_product(
+                n as f64,
+                basek * digits,
+                0.5,
+                var_msg,
+                var_a0_err,
+                var_a1_err,
+                var_gct_err_lhs,
+                var_gct_err_rhs,
+                rank as f64,
+                k_in,
+                k_ggsw,
+            );
+
+            ct_glwe_out.assert_noise(module, &sk_prepared, &pt_want, max_noise + 0.5);
+        });
+    });
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn test_glwe_external_product_inplace<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDftInplace<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + SvpPrepare<B>
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxBigAllocBytes
+        + VecZnxBigAddInplace<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxAddScalarInplace
+        + VecZnxRotateInplace<B>
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>
+        + VmpApplyDftToDftTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + TakeSvpPPolImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>,
+{
+    let basek: usize = 12;
+    let k_ct: usize = 60;
+    let digits: usize = k_ct.div_ceil(basek);
+    (1..3).for_each(|rank| {
+        (1..digits + 1).for_each(|di| {
+            let k_ggsw: usize = k_ct + basek * di;
+
+            let n: usize = module.n();
+            let rows: usize = k_ct.div_ceil(basek * digits);
+
+            let mut ct_ggsw: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_ggsw, rows, digits, rank);
+            let mut ct_glwe: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_ct, rank);
+            let mut pt_rgsw: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
+            let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, 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
+            module.vec_znx_fill_uniform(basek, &mut pt_want.data, 0, &mut source_xa);
+
+            pt_want.data.at_mut(0, 0)[1] = 1;
+
+            let k: usize = 1;
+
+            pt_rgsw.raw_mut()[k] = 1; // X^{k}
+
+            let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+                GGSWCiphertext::encrypt_sk_scratch_space(module, basek, ct_ggsw.k(), rank)
+                    | GLWECiphertext::encrypt_sk_scratch_space(module, basek, ct_glwe.k())
+                    | GLWECiphertext::external_product_inplace_scratch_space(
+                        module,
+                        basek,
+                        ct_glwe.k(),
+                        ct_ggsw.k(),
+                        digits,
+                        rank,
+                    ),
+            );
+
+            let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+            sk.fill_ternary_prob(0.5, &mut source_xs);
+            let sk_prepared: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
+
+            ct_ggsw.encrypt_sk(
+                module,
+                &pt_rgsw,
+                &sk_prepared,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            ct_glwe.encrypt_sk(
+                module,
+                &pt_want,
+                &sk_prepared,
+                &mut source_xa,
+                &mut source_xe,
+                scratch.borrow(),
+            );
+
+            let ct_ggsw_prepared: GGSWCiphertextPrepared<Vec<u8>, B> = ct_ggsw.prepare_alloc(module, scratch.borrow());
+
+            ct_glwe.external_product_inplace(module, &ct_ggsw_prepared, scratch.borrow());
+
+            module.vec_znx_rotate_inplace(k as i64, &mut pt_want.data, 0, scratch.borrow());
+
+            let var_gct_err_lhs: f64 = SIGMA * SIGMA;
+            let var_gct_err_rhs: f64 = 0f64;
+
+            let var_msg: f64 = 1f64 / n as f64; // X^{k}
+            let var_a0_err: f64 = SIGMA * SIGMA;
+            let var_a1_err: f64 = 1f64 / 12f64;
+
+            let max_noise: f64 = noise_ggsw_product(
+                n as f64,
+                basek * digits,
+                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,
+            );
+
+            ct_glwe.assert_noise(module, &sk_prepared, &pt_want, max_noise + 0.5);
+        });
+    });
+}