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

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/automorphism/mod.rs

@@ -0,0 +1,7 @@
+mod gglwe_atk;
+mod ggsw_ct;
+mod glwe_ct;
+
+pub use gglwe_atk::*;
+pub use ggsw_ct::*;
+pub use glwe_ct::*;

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

@@ -0,0 +1,236 @@
+use poulpy_hal::{
+    api::{
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphismInplace, VecZnxBigAddInplace,
+        VecZnxBigAddSmallInplace, VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxDftAllocBytes,
+        VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace,
+        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VecZnxSwitchRing, VmpApplyDftToDft, VmpApplyDftToDftAdd,
+        VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPrepare, ZnAddNormal, ZnFillUniform, ZnNormalizeInplace,
+    },
+    layouts::{Backend, Module, ScratchOwned, ZnxView},
+    oep::{
+        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
+        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl,
+    },
+    source::Source,
+};
+
+use crate::layouts::{
+    GLWECiphertext, GLWEPlaintext, GLWESecret, GLWEToLWESwitchingKey, Infos, LWECiphertext, LWEPlaintext, LWESecret,
+    LWEToGLWESwitchingKey,
+    prepared::{GLWESecretPrepared, GLWEToLWESwitchingKeyPrepared, LWEToGLWESwitchingKeyPrepared, PrepareAlloc},
+};
+
+pub fn test_lwe_to_glwe<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
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>
+        + VmpApplyDftToDftTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxSwitchRing
+        + VecZnxAutomorphismInplace<B>
+        + ZnNormalizeInplace<B>
+        + ZnFillUniform
+        + ZnAddNormal,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + TakeSvpPPolImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>,
+{
+    let n: usize = module.n();
+    let basek: usize = 17;
+
+    let rank: usize = 2;
+
+    let n_lwe: usize = 22;
+    let k_lwe_ct: usize = 2 * basek;
+    let k_lwe_pt: usize = 8;
+
+    let k_glwe_ct: usize = 3 * basek;
+
+    let k_ksk: usize = k_lwe_ct + basek;
+
+    let mut source_xs: Source = Source::new([0u8; 32]);
+    let mut source_xa: Source = Source::new([0u8; 32]);
+    let mut source_xe: Source = Source::new([0u8; 32]);
+
+    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+        LWEToGLWESwitchingKey::encrypt_sk_scratch_space(module, basek, k_ksk, rank)
+            | GLWECiphertext::from_lwe_scratch_space(module, basek, k_lwe_ct, k_glwe_ct, k_ksk, rank)
+            | GLWECiphertext::decrypt_scratch_space(module, basek, k_glwe_ct),
+    );
+
+    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+    sk_glwe.fill_ternary_prob(0.5, &mut source_xs);
+
+    let sk_glwe_prepared: GLWESecretPrepared<Vec<u8>, B> = sk_glwe.prepare_alloc(module, scratch.borrow());
+
+    let mut sk_lwe: LWESecret<Vec<u8>> = LWESecret::alloc(n_lwe);
+    sk_lwe.fill_ternary_prob(0.5, &mut source_xs);
+
+    let data: i64 = 17;
+
+    let mut lwe_pt: LWEPlaintext<Vec<u8>> = LWEPlaintext::alloc(basek, k_lwe_pt);
+    lwe_pt.encode_i64(data, k_lwe_pt);
+
+    let mut lwe_ct: LWECiphertext<Vec<u8>> = LWECiphertext::alloc(n_lwe, basek, k_lwe_ct);
+    lwe_ct.encrypt_sk(module, &lwe_pt, &sk_lwe, &mut source_xa, &mut source_xe);
+
+    let mut ksk: LWEToGLWESwitchingKey<Vec<u8>> = LWEToGLWESwitchingKey::alloc(n, basek, k_ksk, lwe_ct.size(), rank);
+
+    ksk.encrypt_sk(
+        module,
+        &sk_lwe,
+        &sk_glwe,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+
+    let mut glwe_ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_glwe_ct, rank);
+
+    let ksk_prepared: LWEToGLWESwitchingKeyPrepared<Vec<u8>, B> = ksk.prepare_alloc(module, scratch.borrow());
+
+    glwe_ct.from_lwe(module, &lwe_ct, &ksk_prepared, scratch.borrow());
+
+    let mut glwe_pt: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_glwe_ct);
+    glwe_ct.decrypt(module, &mut glwe_pt, &sk_glwe_prepared, scratch.borrow());
+
+    assert_eq!(glwe_pt.data.at(0, 0)[0], lwe_pt.data.at(0, 0)[0]);
+}
+
+pub fn test_glwe_to_lwe<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
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>
+        + VmpApplyDftToDftTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxSwitchRing
+        + VecZnxAutomorphismInplace<B>
+        + ZnNormalizeInplace<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 basek: usize = 17;
+
+    let rank: usize = 2;
+
+    let n_lwe: usize = 22;
+    let k_lwe_ct: usize = 2 * basek;
+    let k_lwe_pt: usize = 8;
+
+    let k_glwe_ct: usize = 3 * basek;
+
+    let k_ksk: usize = k_lwe_ct + basek;
+
+    let mut source_xs: Source = Source::new([0u8; 32]);
+    let mut source_xa: Source = Source::new([0u8; 32]);
+    let mut source_xe: Source = Source::new([0u8; 32]);
+
+    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+        LWEToGLWESwitchingKey::encrypt_sk_scratch_space(module, basek, k_ksk, rank)
+            | LWECiphertext::from_glwe_scratch_space(module, basek, k_lwe_ct, k_glwe_ct, k_ksk, rank)
+            | GLWECiphertext::decrypt_scratch_space(module, basek, k_glwe_ct),
+    );
+
+    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+    sk_glwe.fill_ternary_prob(0.5, &mut source_xs);
+
+    let sk_glwe_prepared: GLWESecretPrepared<Vec<u8>, B> = sk_glwe.prepare_alloc(module, scratch.borrow());
+
+    let mut sk_lwe = LWESecret::alloc(n_lwe);
+    sk_lwe.fill_ternary_prob(0.5, &mut source_xs);
+
+    let data: i64 = 17;
+    let mut glwe_pt: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_glwe_ct);
+    glwe_pt.encode_coeff_i64(data, k_lwe_pt, 0);
+
+    let mut glwe_ct = GLWECiphertext::alloc(n, basek, k_glwe_ct, rank);
+    glwe_ct.encrypt_sk(
+        module,
+        &glwe_pt,
+        &sk_glwe_prepared,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+
+    let mut ksk: GLWEToLWESwitchingKey<Vec<u8>> = GLWEToLWESwitchingKey::alloc(n, basek, k_ksk, glwe_ct.size(), rank);
+
+    ksk.encrypt_sk(
+        module,
+        &sk_lwe,
+        &sk_glwe,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+
+    let mut lwe_ct: LWECiphertext<Vec<u8>> = LWECiphertext::alloc(n_lwe, basek, k_lwe_ct);
+
+    let ksk_prepared: GLWEToLWESwitchingKeyPrepared<Vec<u8>, B> = ksk.prepare_alloc(module, scratch.borrow());
+
+    lwe_ct.from_glwe(module, &glwe_ct, &ksk_prepared, scratch.borrow());
+
+    let mut lwe_pt: LWEPlaintext<Vec<u8>> = LWEPlaintext::alloc(basek, k_lwe_ct);
+    lwe_ct.decrypt(module, &mut lwe_pt, &sk_lwe);
+
+    assert_eq!(glwe_pt.data.at(0, 0)[0], lwe_pt.data.at(0, 0)[0]);
+}

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/encryption/mod.rs

@@ -0,0 +1,11 @@
+mod gglwe_atk;
+mod gglwe_ct;
+mod ggsw_ct;
+mod glwe_ct;
+mod glwe_tsk;
+
+pub use gglwe_atk::*;
+pub use gglwe_ct::*;
+pub use ggsw_ct::*;
+pub use glwe_ct::*;
+pub use glwe_tsk::*;

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);
+        });
+    });
+}

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

@@ -0,0 +1,7 @@
+mod gglwe_ksk;
+mod ggsw_ct;
+mod glwe_ct;
+
+pub use gglwe_ksk::*;
+pub use ggsw_ct::*;
+pub use glwe_ct::*;

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

@@ -0,0 +1,322 @@
+use poulpy_hal::{
+    api::{
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
+        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, 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::{
+        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>)
+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
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>
+        + VmpApplyDftToDftTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxSwitchRing
+        + VecZnxSubScalarInplace,
+    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);
+
+    (1..3).for_each(|rank_in_s0s1| {
+        (1..3).for_each(|rank_out_s0s1| {
+            (1..3).for_each(|rank_out_s1s2| {
+                (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 / basek;
+                    let rows_apply: usize = k_in.div_ceil(basek * di);
+                    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_apply,
+                        di,
+                        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,
+                        di,
+                        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 * di,
+                        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>)
+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
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>
+        + VmpApplyDftToDftTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxSwitchRing
+        + VecZnxSubScalarInplace,
+    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_in| {
+        (1..3).for_each(|rank_out| {
+            (1..digits + 1).for_each(|di| {
+                let k_ksk: 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_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, di, 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, di, 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 * di,
+                    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/test_suite/keyswitch/ggsw_ct.rs

@@ -0,0 +1,309 @@
+use poulpy_hal::{
+    api::{
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes,
+        SvpPrepare, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
+        VecZnxBigAlloc, VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, 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,
+    },
+    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>)
+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
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>
+        + VmpApplyDftToDftTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxSwitchRing
+        + SvpApplyDftToDft<B>
+        + VecZnxIdftApplyTmpA<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 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;
+            let k_out: usize = k_ksk; // Better capture noise.
+
+            let n: usize = module.n();
+            let rows: usize = k_in.div_ceil(di * 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, di, rank);
+            let mut ksk: GGLWESwitchingKey<Vec<u8>> = GGLWESwitchingKey::alloc(n, basek, k_ksk, rows, di, 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, di, k_tsk, di, 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 * 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_out_prepared, &pt_scalar, max_noise);
+        });
+    });
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn test_ggsw_keyswitch_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
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>
+        + VmpApplyDftToDftTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxSwitchRing
+        + SvpApplyDftToDft<B>
+        + VecZnxIdftApplyTmpA<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 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;
+
+            let n: usize = module.n();
+            let rows: usize = k_ct.div_ceil(di * 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, di, rank);
+            let mut ksk: GGLWESwitchingKey<Vec<u8>> = GGLWESwitchingKey::alloc(n, basek, k_ksk, rows, di, 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, di, k_tsk, di, 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 * 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_out_prepared, &pt_scalar, max_noise);
+        });
+    });
+}

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

@@ -0,0 +1,268 @@
+use poulpy_hal::{
+    api::{
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, 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::{
+        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>)
+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
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>
+        + VmpApplyDftToDftTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxSwitchRing,
+    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_in| {
+        (1..3).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
+
+                let n: usize = 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, &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>)
+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
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>
+        + VmpApplyDftToDftTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxSwitchRing,
+    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 = 45;
+    let digits: usize = k_ct.div_ceil(basek);
+
+    (1..3).for_each(|rank| {
+        (1..digits + 1).for_each(|di| {
+            let k_ksk: usize = k_ct + basek * di;
+
+            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, &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/test_suite/keyswitch/lwe_ct.rs

@@ -0,0 +1,127 @@
+use poulpy_hal::{
+    api::{
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphismInplace, VecZnxBigAddInplace,
+        VecZnxBigAddSmallInplace, VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxDftAllocBytes,
+        VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace,
+        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VecZnxSwitchRing, VmpApplyDftToDft, VmpApplyDftToDftAdd,
+        VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPrepare, ZnAddNormal, ZnFillUniform, ZnNormalizeInplace,
+    },
+    layouts::{Backend, Module, ScratchOwned, ZnxView},
+    oep::{
+        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
+        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl,
+    },
+    source::Source,
+};
+
+use crate::layouts::{
+    Infos, LWECiphertext, LWEPlaintext, LWESecret, LWESwitchingKey,
+    prepared::{LWESwitchingKeyPrepared, PrepareAlloc},
+};
+
+pub fn test_lwe_keyswitch<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
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>
+        + VmpApplyDftToDftTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxSwitchRing
+        + VecZnxAutomorphismInplace<B>
+        + ZnNormalizeInplace<B>
+        + ZnFillUniform
+        + ZnAddNormal,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + TakeSvpPPolImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>,
+{
+    let n: usize = module.n();
+    let basek: usize = 17;
+
+    let n_lwe_in: usize = 22;
+    let n_lwe_out: usize = 30;
+    let k_lwe_ct: usize = 2 * basek;
+    let k_lwe_pt: usize = 8;
+
+    let k_ksk: usize = k_lwe_ct + basek;
+
+    let mut source_xs: Source = Source::new([0u8; 32]);
+    let mut source_xa: Source = Source::new([0u8; 32]);
+    let mut source_xe: Source = Source::new([0u8; 32]);
+
+    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+        LWESwitchingKey::encrypt_sk_scratch_space(module, basek, k_ksk)
+            | LWECiphertext::keyswitch_scratch_space(module, basek, k_lwe_ct, k_lwe_ct, k_ksk),
+    );
+
+    let mut sk_lwe_in: LWESecret<Vec<u8>> = LWESecret::alloc(n_lwe_in);
+    sk_lwe_in.fill_ternary_prob(0.5, &mut source_xs);
+
+    let mut sk_lwe_out: LWESecret<Vec<u8>> = LWESecret::alloc(n_lwe_out);
+    sk_lwe_out.fill_ternary_prob(0.5, &mut source_xs);
+
+    let data: i64 = 17;
+
+    let mut lwe_pt_in: LWEPlaintext<Vec<u8>> = LWEPlaintext::alloc(basek, k_lwe_pt);
+
+    lwe_pt_in.encode_i64(data, k_lwe_pt);
+
+    let mut lwe_ct_in: LWECiphertext<Vec<u8>> = LWECiphertext::alloc(n_lwe_in, basek, k_lwe_ct);
+    lwe_ct_in.encrypt_sk(
+        module,
+        &lwe_pt_in,
+        &sk_lwe_in,
+        &mut source_xa,
+        &mut source_xe,
+    );
+
+    let mut ksk: LWESwitchingKey<Vec<u8>> = LWESwitchingKey::alloc(n, basek, k_ksk, lwe_ct_in.size());
+
+    ksk.encrypt_sk(
+        module,
+        &sk_lwe_in,
+        &sk_lwe_out,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+
+    let mut lwe_ct_out: LWECiphertext<Vec<u8>> = LWECiphertext::alloc(n_lwe_out, basek, k_lwe_ct);
+
+    let ksk_prepared: LWESwitchingKeyPrepared<Vec<u8>, B> = ksk.prepare_alloc(module, scratch.borrow());
+
+    lwe_ct_out.keyswitch(module, &lwe_ct_in, &ksk_prepared, scratch.borrow());
+
+    let mut lwe_pt_out: LWEPlaintext<Vec<u8>> = LWEPlaintext::alloc(basek, k_lwe_ct);
+    lwe_ct_out.decrypt(module, &mut lwe_pt_out, &sk_lwe_out);
+
+    assert_eq!(lwe_pt_in.data.at(0, 0)[0], lwe_pt_out.data.at(0, 0)[0]);
+}

poulpy-core/src/tests/test_suite/keyswitch/mod.rs

@@ -0,0 +1,9 @@
+mod gglwe_ct;
+mod ggsw_ct;
+mod glwe_ct;
+mod lwe_ct;
+
+pub use gglwe_ct::*;
+pub use ggsw_ct::*;
+pub use glwe_ct::*;
+pub use lwe_ct::*;

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

@@ -0,0 +1,12 @@
+pub mod automorphism;
+pub mod encryption;
+pub mod external_product;
+pub mod keyswitch;
+
+mod conversion;
+mod packing;
+mod trace;
+
+pub use conversion::*;
+pub use packing::*;
+pub use trace::*;

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

@@ -0,0 +1,196 @@
+use std::collections::HashMap;
+
+use poulpy_hal::{
+    api::{
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism, VecZnxAutomorphismInplace,
+        VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAllocBytes, VecZnxBigAutomorphismInplace, VecZnxBigNormalize,
+        VecZnxBigNormalizeTmpBytes, VecZnxBigSubSmallBInplace, VecZnxCopy, VecZnxDftAllocBytes, VecZnxDftApply,
+        VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNegateInplace, VecZnxNormalize, VecZnxNormalizeInplace,
+        VecZnxNormalizeTmpBytes, VecZnxRotate, VecZnxRotateInplace, VecZnxRshInplace, 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::{
+    GLWEOperations, GLWEPacker,
+    layouts::{
+        GGLWEAutomorphismKey, GLWECiphertext, GLWEPlaintext, GLWESecret,
+        prepared::{GGLWEAutomorphismKeyPrepared, GLWESecretPrepared, PrepareAlloc},
+    },
+};
+
+pub fn test_glwe_packing<B>(module: &Module<B>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxAutomorphism
+        + VecZnxBigAutomorphismInplace<B>
+        + VecZnxBigSubSmallBInplace<B>
+        + VecZnxNegateInplace
+        + VecZnxRshInplace<B>
+        + VecZnxRotateInplace<B>
+        + VecZnxBigNormalize<B>
+        + VecZnxDftApply<B>
+        + VecZnxRotate
+        + 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
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>
+        + VmpApplyDftToDftTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxSwitchRing
+        + VecZnxAutomorphismInplace<B>
+        + VecZnxCopy,
+    B: Backend
+        + TakeVecZnxDftImpl<B>
+        + TakeVecZnxBigImpl<B>
+        + TakeSvpPPolImpl<B>
+        + ScratchOwnedAllocImpl<B>
+        + ScratchOwnedBorrowImpl<B>
+        + ScratchAvailableImpl<B>
+        + TakeScalarZnxImpl<B>
+        + TakeVecZnxImpl<B>,
+{
+    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 n: usize = module.n();
+    let basek: usize = 18;
+    let k_ct: usize = 36;
+    let pt_k: usize = 18;
+    let rank: usize = 3;
+    let digits: usize = 1;
+    let k_ksk: usize = k_ct + basek * digits;
+
+    let rows: usize = k_ct.div_ceil(basek * digits);
+
+    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+        GLWECiphertext::encrypt_sk_scratch_space(module, basek, k_ct)
+            | GGLWEAutomorphismKey::encrypt_sk_scratch_space(module, basek, k_ksk, rank)
+            | GLWEPacker::scratch_space(module, basek, k_ct, k_ksk, 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 pt: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_ct);
+    let mut data: Vec<i64> = vec![0i64; n];
+    data.iter_mut().enumerate().for_each(|(i, x)| {
+        *x = i as i64;
+    });
+
+    pt.encode_vec_i64(&data, pt_k);
+
+    let gal_els: Vec<i64> = GLWEPacker::galois_elements(module);
+
+    let mut auto_keys: HashMap<i64, GGLWEAutomorphismKeyPrepared<Vec<u8>, B>> = HashMap::new();
+    let mut tmp: GGLWEAutomorphismKey<Vec<u8>> = GGLWEAutomorphismKey::alloc(n, basek, k_ksk, 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);
+    });
+
+    let log_batch: usize = 0;
+
+    let mut packer: GLWEPacker = GLWEPacker::new(n, log_batch, basek, k_ct, rank);
+
+    let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_ct, rank);
+
+    ct.encrypt_sk(
+        module,
+        &pt,
+        &sk_dft,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+
+    let log_n: usize = module.log_n();
+
+    (0..n >> log_batch).for_each(|i| {
+        ct.encrypt_sk(
+            module,
+            &pt,
+            &sk_dft,
+            &mut source_xa,
+            &mut source_xe,
+            scratch.borrow(),
+        );
+
+        pt.rotate_inplace(module, -(1 << log_batch), scratch.borrow()); // X^-batch * pt
+
+        if reverse_bits_msb(i, log_n as u32).is_multiple_of(5) {
+            packer.add(module, Some(&ct), &auto_keys, scratch.borrow());
+        } else {
+            packer.add(
+                module,
+                None::<&GLWECiphertext<Vec<u8>>>,
+                &auto_keys,
+                scratch.borrow(),
+            )
+        }
+    });
+
+    let mut res = GLWECiphertext::alloc(n, basek, k_ct, rank);
+    packer.flush(module, &mut res);
+
+    let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k_ct);
+    let mut data: Vec<i64> = vec![0i64; n];
+    data.iter_mut().enumerate().for_each(|(i, x)| {
+        if i.is_multiple_of(5) {
+            *x = reverse_bits_msb(i, log_n as u32) as i64;
+        }
+    });
+
+    pt_want.encode_vec_i64(&data, pt_k);
+
+    res.decrypt(module, &mut pt, &sk_dft, scratch.borrow());
+
+    pt.sub_inplace_ab(module, &pt_want);
+
+    let noise_have: f64 = pt.std().log2();
+    // println!("noise_have: {}", noise_have);
+    assert!(
+        noise_have < -((k_ct - basek) as f64),
+        "noise: {}",
+        noise_have
+    );
+}
+
+#[inline(always)]
+fn reverse_bits_msb(x: usize, n: u32) -> usize {
+    x.reverse_bits() >> (usize::BITS - n)
+}

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

@@ -0,0 +1,172 @@
+use std::collections::HashMap;
+
+use poulpy_hal::{
+    api::{
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism, VecZnxBigAddInplace,
+        VecZnxBigAddSmallInplace, VecZnxBigAllocBytes, VecZnxBigAutomorphismInplace, VecZnxBigNormalize,
+        VecZnxBigNormalizeTmpBytes, VecZnxBigSubSmallBInplace, VecZnxCopy, VecZnxDftAllocBytes, VecZnxDftApply,
+        VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes,
+        VecZnxRotateInplace, VecZnxRshInplace, VecZnxSub, VecZnxSubABInplace, VecZnxSwitchRing, 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>)
+where
+    Module<B>: VecZnxDftAllocBytes
+        + VecZnxAutomorphism
+        + VecZnxBigAutomorphismInplace<B>
+        + VecZnxBigSubSmallBInplace<B>
+        + VecZnxRshInplace<B>
+        + VecZnxRotateInplace<B>
+        + 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
+        + VmpPMatAlloc<B>
+        + VmpPrepare<B>
+        + VmpApplyDftToDftTmpBytes
+        + VmpApplyDftToDft<B>
+        + VmpApplyDftToDftAdd<B>
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxSwitchRing
+        + 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: usize = 54;
+
+    (1..3).for_each(|rank| {
+        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, &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
+        );
+    });
+}