Add tests to BDD

poulpy-schemes/src/tfhe/bdd_arithmetic/tests/test_suite/add.rs

@@ -0,0 +1,93 @@
+use poulpy_core::{
+    GGSWNoise, GLWEDecrypt, GLWEEncryptSk, GLWENoise, ScratchTakeCore,
+    layouts::{GGSWLayout, GLWELayout, GLWESecret, GLWESecretPreparedFactory, LWEInfos, prepared::GLWESecretPrepared},
+};
+use poulpy_hal::{
+    api::{ModuleNew, ScratchOwnedAlloc, ScratchOwnedBorrow},
+    layouts::{Backend, Module, Scratch, ScratchOwned},
+    source::Source,
+};
+use rand::RngCore;
+
+use crate::tfhe::{
+    bdd_arithmetic::{
+        Add, BDDKeyEncryptSk, BDDKeyPreparedFactory, ExecuteBDDCircuit2WTo1W, FheUintBlockDebugPrepare, FheUintBlocks,
+        FheUintBlocksPrepare, FheUintBlocksPrepared, FheUintBlocksPreparedEncryptSk, FheUintBlocksPreparedFactory,
+        tests::test_suite::{TEST_GGSW_INFOS, TEST_GLWE_INFOS},
+    },
+    blind_rotation::{BlindRotationAlgo, BlindRotationKey, BlindRotationKeyFactory},
+};
+
+pub fn test_bdd_add<BRA: BlindRotationAlgo, BE: Backend>()
+where
+    Module<BE>: ModuleNew<BE>
+        + GLWESecretPreparedFactory<BE>
+        + GLWEDecrypt<BE>
+        + GLWENoise<BE>
+        + FheUintBlocksPreparedFactory<u32, BE>
+        + FheUintBlocksPreparedEncryptSk<u32, BE>
+        + FheUintBlockDebugPrepare<BRA, u32, BE>
+        + BDDKeyEncryptSk<BRA, BE>
+        + BDDKeyPreparedFactory<BRA, BE>
+        + GGSWNoise<BE>
+        + FheUintBlocksPrepare<BRA, u32, BE>
+        + ExecuteBDDCircuit2WTo1W<u32, BE>
+        + GLWEEncryptSk<BE>,
+    BlindRotationKey<Vec<u8>, BRA>: BlindRotationKeyFactory<BRA>,
+    ScratchOwned<BE>: ScratchOwnedAlloc<BE> + ScratchOwnedBorrow<BE>,
+    Scratch<BE>: ScratchTakeCore<BE>,
+{
+    let glwe_infos: GLWELayout = TEST_GLWE_INFOS;
+    let ggsw_infos: GGSWLayout = TEST_GGSW_INFOS;
+
+    let n_glwe: usize = glwe_infos.n().into();
+
+    let module: Module<BE> = Module::<BE>::new(n_glwe as u64);
+    let mut source: Source = Source::new([6u8; 32]);
+    let mut source_xs: Source = Source::new([1u8; 32]);
+    let mut source_xa: Source = Source::new([2u8; 32]);
+    let mut source_xe: Source = Source::new([3u8; 32]);
+
+    let mut scratch: ScratchOwned<BE> = ScratchOwned::alloc(1 << 22);
+
+    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_infos);
+    sk_glwe.fill_ternary_prob(0.5, &mut source_xs);
+    let mut sk_glwe_prep: GLWESecretPrepared<Vec<u8>, BE> = GLWESecretPrepared::alloc_from_infos(&module, &glwe_infos);
+    sk_glwe_prep.prepare(&module, &sk_glwe);
+
+    let mut res: FheUintBlocks<Vec<u8>, u32> = FheUintBlocks::<Vec<u8>, u32>::alloc_from_infos(&module, &glwe_infos);
+    let mut a_enc_prep: FheUintBlocksPrepared<Vec<u8>, u32, BE> =
+        FheUintBlocksPrepared::<Vec<u8>, u32, BE>::alloc(&module, &ggsw_infos);
+    let mut b_enc_prep: FheUintBlocksPrepared<Vec<u8>, u32, BE> =
+        FheUintBlocksPrepared::<Vec<u8>, u32, BE>::alloc(&module, &ggsw_infos);
+
+    let a: u32 = source.next_u32();
+    let b: u32 = source.next_u32();
+
+    source.fill_bytes(&mut scratch.borrow().data);
+    a_enc_prep.encrypt_sk(
+        &module,
+        a,
+        &sk_glwe_prep,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+    source.fill_bytes(&mut scratch.borrow().data);
+    b_enc_prep.encrypt_sk(
+        &module,
+        b,
+        &sk_glwe_prep,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+
+    // d + a
+    res.add(&module, &a_enc_prep, &b_enc_prep, scratch.borrow());
+
+    assert_eq!(
+        res.decrypt(&module, &sk_glwe_prep, scratch.borrow()),
+        a.wrapping_add(b)
+    );
+}

poulpy-schemes/src/tfhe/bdd_arithmetic/tests/test_suite/and.rs

@@ -0,0 +1,89 @@
+use poulpy_core::{
+    GGSWNoise, GLWEDecrypt, GLWEEncryptSk, GLWENoise, ScratchTakeCore,
+    layouts::{GGSWLayout, GLWELayout, GLWESecret, GLWESecretPreparedFactory, LWEInfos, prepared::GLWESecretPrepared},
+};
+use poulpy_hal::{
+    api::{ModuleNew, ScratchOwnedAlloc, ScratchOwnedBorrow},
+    layouts::{Backend, Module, Scratch, ScratchOwned},
+    source::Source,
+};
+use rand::RngCore;
+
+use crate::tfhe::{
+    bdd_arithmetic::{
+        And, BDDKeyEncryptSk, BDDKeyPreparedFactory, ExecuteBDDCircuit2WTo1W, FheUintBlockDebugPrepare, FheUintBlocks,
+        FheUintBlocksPrepare, FheUintBlocksPrepared, FheUintBlocksPreparedEncryptSk, FheUintBlocksPreparedFactory,
+        tests::test_suite::{TEST_GGSW_INFOS, TEST_GLWE_INFOS},
+    },
+    blind_rotation::{BlindRotationAlgo, BlindRotationKey, BlindRotationKeyFactory},
+};
+
+pub fn test_bdd_and<BRA: BlindRotationAlgo, BE: Backend>()
+where
+    Module<BE>: ModuleNew<BE>
+        + GLWESecretPreparedFactory<BE>
+        + GLWEDecrypt<BE>
+        + GLWENoise<BE>
+        + FheUintBlocksPreparedFactory<u32, BE>
+        + FheUintBlocksPreparedEncryptSk<u32, BE>
+        + FheUintBlockDebugPrepare<BRA, u32, BE>
+        + BDDKeyEncryptSk<BRA, BE>
+        + BDDKeyPreparedFactory<BRA, BE>
+        + GGSWNoise<BE>
+        + FheUintBlocksPrepare<BRA, u32, BE>
+        + ExecuteBDDCircuit2WTo1W<u32, BE>
+        + GLWEEncryptSk<BE>,
+    BlindRotationKey<Vec<u8>, BRA>: BlindRotationKeyFactory<BRA>,
+    ScratchOwned<BE>: ScratchOwnedAlloc<BE> + ScratchOwnedBorrow<BE>,
+    Scratch<BE>: ScratchTakeCore<BE>,
+{
+    let glwe_infos: GLWELayout = TEST_GLWE_INFOS;
+    let ggsw_infos: GGSWLayout = TEST_GGSW_INFOS;
+
+    let n_glwe: usize = glwe_infos.n().into();
+
+    let module: Module<BE> = Module::<BE>::new(n_glwe as u64);
+    let mut source: Source = Source::new([6u8; 32]);
+    let mut source_xs: Source = Source::new([1u8; 32]);
+    let mut source_xa: Source = Source::new([2u8; 32]);
+    let mut source_xe: Source = Source::new([3u8; 32]);
+
+    let mut scratch: ScratchOwned<BE> = ScratchOwned::alloc(1 << 22);
+
+    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_infos);
+    sk_glwe.fill_ternary_prob(0.5, &mut source_xs);
+    let mut sk_glwe_prep: GLWESecretPrepared<Vec<u8>, BE> = GLWESecretPrepared::alloc_from_infos(&module, &glwe_infos);
+    sk_glwe_prep.prepare(&module, &sk_glwe);
+
+    let mut res: FheUintBlocks<Vec<u8>, u32> = FheUintBlocks::<Vec<u8>, u32>::alloc_from_infos(&module, &glwe_infos);
+    let mut a_enc_prep: FheUintBlocksPrepared<Vec<u8>, u32, BE> =
+        FheUintBlocksPrepared::<Vec<u8>, u32, BE>::alloc(&module, &ggsw_infos);
+    let mut b_enc_prep: FheUintBlocksPrepared<Vec<u8>, u32, BE> =
+        FheUintBlocksPrepared::<Vec<u8>, u32, BE>::alloc(&module, &ggsw_infos);
+
+    let a: u32 = source.next_u32();
+    let b: u32 = source.next_u32();
+
+    source.fill_bytes(&mut scratch.borrow().data);
+    a_enc_prep.encrypt_sk(
+        &module,
+        a,
+        &sk_glwe_prep,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+    source.fill_bytes(&mut scratch.borrow().data);
+    b_enc_prep.encrypt_sk(
+        &module,
+        b,
+        &sk_glwe_prep,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+
+    res.and(&module, &a_enc_prep, &b_enc_prep, scratch.borrow());
+
+    assert_eq!(res.decrypt(&module, &sk_glwe_prep, scratch.borrow()), a & b);
+}

poulpy-schemes/src/tfhe/bdd_arithmetic/tests/test_suite/mod.rs

@@ -0,0 +1,92 @@
+mod add;
+mod and;
+mod or;
+mod prepare;
+mod sll;
+mod slt;
+mod sltu;
+mod sra;
+mod srl;
+mod sub;
+mod xor;
+
+pub use add::*;
+pub use and::*;
+pub use or::*;
+pub use prepare::*;
+pub use sll::*;
+pub use slt::*;
+pub use sltu::*;
+pub use sra::*;
+pub use srl::*;
+pub use sub::*;
+pub use xor::*;
+
+use poulpy_core::layouts::{
+    Base2K, Degree, Dnum, Dsize, GGSWLayout, GLWEAutomorphismKeyLayout, GLWELayout, GLWETensorKeyLayout, GLWEToLWEKeyLayout,
+    Rank, TorusPrecision,
+};
+
+use crate::tfhe::{
+    bdd_arithmetic::BDDKeyLayout, blind_rotation::BlindRotationKeyLayout, circuit_bootstrapping::CircuitBootstrappingKeyLayout,
+};
+
+pub(crate) const TEST_N_GLWE: u32 = 512;
+pub(crate) const TEST_N_LWE: u32 = 77;
+pub(crate) const TEST_BASE2K: u32 = 13;
+pub(crate) const TEST_K_GLWE: u32 = 26;
+pub(crate) const TEST_K_GGSW: u32 = 39;
+pub(crate) const TEST_BLOCK_SIZE: u32 = 7;
+pub(crate) const TEST_RANK: u32 = 2;
+
+pub(crate) static TEST_GLWE_INFOS: GLWELayout = GLWELayout {
+    n: Degree(TEST_N_GLWE),
+    base2k: Base2K(TEST_BASE2K),
+    k: TorusPrecision(TEST_K_GLWE),
+    rank: Rank(TEST_RANK),
+};
+
+pub(crate) static TEST_GGSW_INFOS: GGSWLayout = GGSWLayout {
+    n: Degree(TEST_N_GLWE),
+    base2k: Base2K(TEST_BASE2K),
+    k: TorusPrecision(TEST_K_GGSW),
+    rank: Rank(TEST_RANK),
+    dnum: Dnum(2),
+    dsize: Dsize(1),
+};
+
+pub(crate) static TEST_BDD_KEY_LAYOUT: BDDKeyLayout = BDDKeyLayout {
+    cbt: CircuitBootstrappingKeyLayout {
+        layout_brk: BlindRotationKeyLayout {
+            n_glwe: Degree(TEST_N_GLWE),
+            n_lwe: Degree(TEST_N_LWE),
+            base2k: Base2K(TEST_BASE2K),
+            k: TorusPrecision(52),
+            dnum: Dnum(3),
+            rank: Rank(TEST_RANK),
+        },
+        layout_atk: GLWEAutomorphismKeyLayout {
+            n: Degree(TEST_N_GLWE),
+            base2k: Base2K(TEST_BASE2K),
+            k: TorusPrecision(52),
+            rank: Rank(TEST_RANK),
+            dnum: Dnum(3),
+            dsize: Dsize(1),
+        },
+        layout_tsk: GLWETensorKeyLayout {
+            n: Degree(TEST_N_GLWE),
+            base2k: Base2K(TEST_BASE2K),
+            k: TorusPrecision(52),
+            rank: Rank(TEST_RANK),
+            dnum: Dnum(3),
+            dsize: Dsize(1),
+        },
+    },
+    ks: GLWEToLWEKeyLayout {
+        n: Degree(TEST_N_GLWE),
+        base2k: Base2K(TEST_BASE2K),
+        k: TorusPrecision(39),
+        rank_in: Rank(TEST_RANK),
+        dnum: Dnum(2),
+    },
+};

poulpy-schemes/src/tfhe/bdd_arithmetic/tests/test_suite/or.rs

@@ -0,0 +1,89 @@
+use poulpy_core::{
+    GGSWNoise, GLWEDecrypt, GLWEEncryptSk, GLWENoise, ScratchTakeCore,
+    layouts::{GGSWLayout, GLWELayout, GLWESecret, GLWESecretPreparedFactory, LWEInfos, prepared::GLWESecretPrepared},
+};
+use poulpy_hal::{
+    api::{ModuleNew, ScratchOwnedAlloc, ScratchOwnedBorrow},
+    layouts::{Backend, Module, Scratch, ScratchOwned},
+    source::Source,
+};
+use rand::RngCore;
+
+use crate::tfhe::{
+    bdd_arithmetic::{
+        BDDKeyEncryptSk, BDDKeyPreparedFactory, ExecuteBDDCircuit2WTo1W, FheUintBlockDebugPrepare, FheUintBlocks,
+        FheUintBlocksPrepare, FheUintBlocksPrepared, FheUintBlocksPreparedEncryptSk, FheUintBlocksPreparedFactory, Or,
+        tests::test_suite::{TEST_GGSW_INFOS, TEST_GLWE_INFOS},
+    },
+    blind_rotation::{BlindRotationAlgo, BlindRotationKey, BlindRotationKeyFactory},
+};
+
+pub fn test_bdd_or<BRA: BlindRotationAlgo, BE: Backend>()
+where
+    Module<BE>: ModuleNew<BE>
+        + GLWESecretPreparedFactory<BE>
+        + GLWEDecrypt<BE>
+        + GLWENoise<BE>
+        + FheUintBlocksPreparedFactory<u32, BE>
+        + FheUintBlocksPreparedEncryptSk<u32, BE>
+        + FheUintBlockDebugPrepare<BRA, u32, BE>
+        + BDDKeyEncryptSk<BRA, BE>
+        + BDDKeyPreparedFactory<BRA, BE>
+        + GGSWNoise<BE>
+        + FheUintBlocksPrepare<BRA, u32, BE>
+        + ExecuteBDDCircuit2WTo1W<u32, BE>
+        + GLWEEncryptSk<BE>,
+    BlindRotationKey<Vec<u8>, BRA>: BlindRotationKeyFactory<BRA>,
+    ScratchOwned<BE>: ScratchOwnedAlloc<BE> + ScratchOwnedBorrow<BE>,
+    Scratch<BE>: ScratchTakeCore<BE>,
+{
+    let glwe_infos: GLWELayout = TEST_GLWE_INFOS;
+    let ggsw_infos: GGSWLayout = TEST_GGSW_INFOS;
+
+    let n_glwe: usize = glwe_infos.n().into();
+
+    let module: Module<BE> = Module::<BE>::new(n_glwe as u64);
+    let mut source: Source = Source::new([6u8; 32]);
+    let mut source_xs: Source = Source::new([1u8; 32]);
+    let mut source_xa: Source = Source::new([2u8; 32]);
+    let mut source_xe: Source = Source::new([3u8; 32]);
+
+    let mut scratch: ScratchOwned<BE> = ScratchOwned::alloc(1 << 22);
+
+    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_infos);
+    sk_glwe.fill_ternary_prob(0.5, &mut source_xs);
+    let mut sk_glwe_prep: GLWESecretPrepared<Vec<u8>, BE> = GLWESecretPrepared::alloc_from_infos(&module, &glwe_infos);
+    sk_glwe_prep.prepare(&module, &sk_glwe);
+
+    let mut res: FheUintBlocks<Vec<u8>, u32> = FheUintBlocks::<Vec<u8>, u32>::alloc_from_infos(&module, &glwe_infos);
+    let mut a_enc_prep: FheUintBlocksPrepared<Vec<u8>, u32, BE> =
+        FheUintBlocksPrepared::<Vec<u8>, u32, BE>::alloc(&module, &ggsw_infos);
+    let mut b_enc_prep: FheUintBlocksPrepared<Vec<u8>, u32, BE> =
+        FheUintBlocksPrepared::<Vec<u8>, u32, BE>::alloc(&module, &ggsw_infos);
+
+    let a: u32 = source.next_u32();
+    let b: u32 = source.next_u32();
+
+    source.fill_bytes(&mut scratch.borrow().data);
+    a_enc_prep.encrypt_sk(
+        &module,
+        a,
+        &sk_glwe_prep,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+    source.fill_bytes(&mut scratch.borrow().data);
+    b_enc_prep.encrypt_sk(
+        &module,
+        b,
+        &sk_glwe_prep,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+
+    res.or(&module, &a_enc_prep, &b_enc_prep, scratch.borrow());
+
+    assert_eq!(res.decrypt(&module, &sk_glwe_prep, scratch.borrow()), a | b);
+}

poulpy-schemes/src/tfhe/bdd_arithmetic/tests/test_suite/prepare.rs

@@ -0,0 +1,117 @@
+use poulpy_core::{
+    GGSWNoise, GLWEDecrypt, GLWEEncryptSk, GLWENoise, SIGMA, ScratchTakeCore,
+    layouts::{GGSWLayout, GLWELayout, GLWESecret, GLWESecretPreparedFactory, LWEInfos, LWESecret, prepared::GLWESecretPrepared},
+};
+use poulpy_hal::{
+    api::{ModuleNew, ScratchOwnedAlloc, ScratchOwnedBorrow},
+    layouts::{Backend, Module, Scratch, ScratchOwned},
+    source::Source,
+};
+use rand::RngCore;
+
+use crate::tfhe::{
+    bdd_arithmetic::{
+        BDDKey, BDDKeyEncryptSk, BDDKeyLayout, BDDKeyPrepared, BDDKeyPreparedFactory, ExecuteBDDCircuit2WTo1W,
+        FheUintBlockDebugPrepare, FheUintBlocks, FheUintBlocksPrepare, FheUintBlocksPreparedDebug,
+        FheUintBlocksPreparedEncryptSk, FheUintBlocksPreparedFactory,
+        tests::test_suite::{TEST_BASE2K, TEST_BDD_KEY_LAYOUT, TEST_BLOCK_SIZE, TEST_GGSW_INFOS, TEST_GLWE_INFOS, TEST_N_LWE},
+    },
+    blind_rotation::{BlindRotationAlgo, BlindRotationKey, BlindRotationKeyFactory},
+};
+
+pub fn test_bdd_prepare<BRA: BlindRotationAlgo, BE: Backend>()
+where
+    Module<BE>: ModuleNew<BE>
+        + GLWESecretPreparedFactory<BE>
+        + GLWEDecrypt<BE>
+        + GLWENoise<BE>
+        + FheUintBlocksPreparedFactory<u32, BE>
+        + FheUintBlocksPreparedEncryptSk<u32, BE>
+        + FheUintBlockDebugPrepare<BRA, u32, BE>
+        + BDDKeyEncryptSk<BRA, BE>
+        + BDDKeyPreparedFactory<BRA, BE>
+        + GGSWNoise<BE>
+        + FheUintBlocksPrepare<BRA, u32, BE>
+        + ExecuteBDDCircuit2WTo1W<u32, BE>
+        + GLWEEncryptSk<BE>,
+    BlindRotationKey<Vec<u8>, BRA>: BlindRotationKeyFactory<BRA>,
+    ScratchOwned<BE>: ScratchOwnedAlloc<BE> + ScratchOwnedBorrow<BE>,
+    Scratch<BE>: ScratchTakeCore<BE>,
+{
+    let glwe_infos: GLWELayout = TEST_GLWE_INFOS;
+    let ggsw_infos: GGSWLayout = TEST_GGSW_INFOS;
+
+    let n_glwe: usize = glwe_infos.n().into();
+
+    let module: Module<BE> = Module::<BE>::new(n_glwe as u64);
+    let mut source: Source = Source::new([6u8; 32]);
+    let mut source_xs: Source = Source::new([1u8; 32]);
+    let mut source_xa: Source = Source::new([2u8; 32]);
+    let mut source_xe: Source = Source::new([3u8; 32]);
+
+    let mut scratch: ScratchOwned<BE> = ScratchOwned::alloc(1 << 22);
+
+    // GLWE Secret
+    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_infos);
+    sk_glwe.fill_ternary_prob(0.5, &mut source_xs);
+
+    let mut sk_glwe_prep: GLWESecretPrepared<Vec<u8>, BE> = GLWESecretPrepared::alloc_from_infos(&module, &glwe_infos);
+    sk_glwe_prep.prepare(&module, &sk_glwe);
+
+    // LWE Secret
+    let n_lwe: u32 = TEST_N_LWE;
+    let block_size: u32 = TEST_BLOCK_SIZE;
+    let mut sk_lwe: LWESecret<Vec<u8>> = LWESecret::alloc(n_lwe.into());
+    sk_lwe.fill_binary_block(block_size as usize, &mut source_xs);
+
+    // CBT KEY
+    let bdd_key_infos: BDDKeyLayout = TEST_BDD_KEY_LAYOUT;
+
+    let mut bdd_key: BDDKey<Vec<u8>, BRA> = BDDKey::alloc_from_infos(&bdd_key_infos);
+
+    source.fill_bytes(&mut scratch.borrow().data);
+    scratch.borrow().data.fill(0);
+    bdd_key.encrypt_sk(
+        &module,
+        &sk_lwe,
+        &sk_glwe,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+    let mut bdd_key_prepared: BDDKeyPrepared<Vec<u8>, BRA, BE> = BDDKeyPrepared::alloc_from_infos(&module, &bdd_key_infos);
+    source.fill_bytes(&mut scratch.borrow().data);
+    bdd_key_prepared.prepare(&module, &bdd_key, scratch.borrow());
+
+    // GLWE(value)
+    let mut c_enc: FheUintBlocks<Vec<u8>, u32> = FheUintBlocks::alloc_from_infos(&module, &glwe_infos);
+    let value: u32 = source.next_u32();
+    c_enc.encrypt_sk(
+        &module,
+        value,
+        &sk_glwe_prep,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+
+    // GGSW(0)
+    let mut c_enc_prep_debug: FheUintBlocksPreparedDebug<Vec<u8>, u32> =
+        FheUintBlocksPreparedDebug::<Vec<u8>, u32>::alloc_from_infos(&module, &ggsw_infos);
+
+    // GGSW(value)
+    c_enc_prep_debug.prepare(&module, &c_enc, &bdd_key_prepared, scratch.borrow());
+
+    let max_noise = |col_i: usize| {
+        let mut noise: f64 = -(ggsw_infos.size() as f64 * TEST_BASE2K as f64) + SIGMA.log2() + 1.0;
+        noise += 0.5 * ggsw_infos.log_n() as f64;
+        if col_i != 0 {
+            noise += 0.5 * ggsw_infos.log_n() as f64
+        }
+        noise
+    };
+
+    // c_enc_prep_debug.print_noise(&module, &sk_glwe_prep, value);
+
+    c_enc_prep_debug.assert_noise(&module, &sk_glwe_prep, value, &max_noise);
+}

poulpy-schemes/src/tfhe/bdd_arithmetic/tests/test_suite/sll.rs

@@ -0,0 +1,92 @@
+use poulpy_core::{
+    GGSWNoise, GLWEDecrypt, GLWEEncryptSk, GLWENoise, ScratchTakeCore,
+    layouts::{GGSWLayout, GLWELayout, GLWESecret, GLWESecretPreparedFactory, LWEInfos, prepared::GLWESecretPrepared},
+};
+use poulpy_hal::{
+    api::{ModuleNew, ScratchOwnedAlloc, ScratchOwnedBorrow},
+    layouts::{Backend, Module, Scratch, ScratchOwned},
+    source::Source,
+};
+use rand::RngCore;
+
+use crate::tfhe::{
+    bdd_arithmetic::{
+        BDDKeyEncryptSk, BDDKeyPreparedFactory, ExecuteBDDCircuit2WTo1W, FheUintBlockDebugPrepare, FheUintBlocks,
+        FheUintBlocksPrepare, FheUintBlocksPrepared, FheUintBlocksPreparedEncryptSk, FheUintBlocksPreparedFactory, Sll,
+        tests::test_suite::{TEST_GGSW_INFOS, TEST_GLWE_INFOS},
+    },
+    blind_rotation::{BlindRotationAlgo, BlindRotationKey, BlindRotationKeyFactory},
+};
+
+pub fn test_bdd_sll<BRA: BlindRotationAlgo, BE: Backend>()
+where
+    Module<BE>: ModuleNew<BE>
+        + GLWESecretPreparedFactory<BE>
+        + GLWEDecrypt<BE>
+        + GLWENoise<BE>
+        + FheUintBlocksPreparedFactory<u32, BE>
+        + FheUintBlocksPreparedEncryptSk<u32, BE>
+        + FheUintBlockDebugPrepare<BRA, u32, BE>
+        + BDDKeyEncryptSk<BRA, BE>
+        + BDDKeyPreparedFactory<BRA, BE>
+        + GGSWNoise<BE>
+        + FheUintBlocksPrepare<BRA, u32, BE>
+        + ExecuteBDDCircuit2WTo1W<u32, BE>
+        + GLWEEncryptSk<BE>,
+    BlindRotationKey<Vec<u8>, BRA>: BlindRotationKeyFactory<BRA>,
+    ScratchOwned<BE>: ScratchOwnedAlloc<BE> + ScratchOwnedBorrow<BE>,
+    Scratch<BE>: ScratchTakeCore<BE>,
+{
+    let glwe_infos: GLWELayout = TEST_GLWE_INFOS;
+    let ggsw_infos: GGSWLayout = TEST_GGSW_INFOS;
+
+    let n_glwe: usize = glwe_infos.n().into();
+
+    let module: Module<BE> = Module::<BE>::new(n_glwe as u64);
+    let mut source: Source = Source::new([6u8; 32]);
+    let mut source_xs: Source = Source::new([1u8; 32]);
+    let mut source_xa: Source = Source::new([2u8; 32]);
+    let mut source_xe: Source = Source::new([3u8; 32]);
+
+    let mut scratch: ScratchOwned<BE> = ScratchOwned::alloc(1 << 22);
+
+    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_infos);
+    sk_glwe.fill_ternary_prob(0.5, &mut source_xs);
+    let mut sk_glwe_prep: GLWESecretPrepared<Vec<u8>, BE> = GLWESecretPrepared::alloc_from_infos(&module, &glwe_infos);
+    sk_glwe_prep.prepare(&module, &sk_glwe);
+
+    let mut res: FheUintBlocks<Vec<u8>, u32> = FheUintBlocks::<Vec<u8>, u32>::alloc_from_infos(&module, &glwe_infos);
+    let mut a_enc_prep: FheUintBlocksPrepared<Vec<u8>, u32, BE> =
+        FheUintBlocksPrepared::<Vec<u8>, u32, BE>::alloc(&module, &ggsw_infos);
+    let mut b_enc_prep: FheUintBlocksPrepared<Vec<u8>, u32, BE> =
+        FheUintBlocksPrepared::<Vec<u8>, u32, BE>::alloc(&module, &ggsw_infos);
+
+    let a: u32 = source.next_u32();
+    let b: u32 = source.next_u32() & 15;
+
+    source.fill_bytes(&mut scratch.borrow().data);
+    a_enc_prep.encrypt_sk(
+        &module,
+        a,
+        &sk_glwe_prep,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+    source.fill_bytes(&mut scratch.borrow().data);
+    b_enc_prep.encrypt_sk(
+        &module,
+        b,
+        &sk_glwe_prep,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+
+    res.sll(&module, &a_enc_prep, &b_enc_prep, scratch.borrow());
+
+    assert_eq!(
+        res.decrypt(&module, &sk_glwe_prep, scratch.borrow()),
+        a.wrapping_shl(b)
+    );
+}

poulpy-schemes/src/tfhe/bdd_arithmetic/tests/test_suite/slt.rs

@@ -0,0 +1,93 @@
+use poulpy_core::{
+    GGSWNoise, GLWEDecrypt, GLWEEncryptSk, GLWENoise, ScratchTakeCore,
+    layouts::{GGSWLayout, GLWELayout, GLWESecret, GLWESecretPreparedFactory, LWEInfos, prepared::GLWESecretPrepared},
+};
+use poulpy_hal::{
+    api::{ModuleNew, ScratchOwnedAlloc, ScratchOwnedBorrow},
+    layouts::{Backend, Module, Scratch, ScratchOwned},
+    source::Source,
+};
+use rand::RngCore;
+
+use crate::tfhe::{
+    bdd_arithmetic::{
+        BDDKeyEncryptSk, BDDKeyPreparedFactory, ExecuteBDDCircuit2WTo1W, FheUintBlockDebugPrepare, FheUintBlocks,
+        FheUintBlocksPrepare, FheUintBlocksPrepared, FheUintBlocksPreparedEncryptSk, FheUintBlocksPreparedFactory, Slt,
+        tests::test_suite::{TEST_GGSW_INFOS, TEST_GLWE_INFOS},
+    },
+    blind_rotation::{BlindRotationAlgo, BlindRotationKey, BlindRotationKeyFactory},
+};
+
+pub fn test_bdd_slt<BRA: BlindRotationAlgo, BE: Backend>()
+where
+    Module<BE>: ModuleNew<BE>
+        + GLWESecretPreparedFactory<BE>
+        + GLWEDecrypt<BE>
+        + GLWENoise<BE>
+        + FheUintBlocksPreparedFactory<u32, BE>
+        + FheUintBlocksPreparedEncryptSk<u32, BE>
+        + FheUintBlockDebugPrepare<BRA, u32, BE>
+        + BDDKeyEncryptSk<BRA, BE>
+        + BDDKeyPreparedFactory<BRA, BE>
+        + GGSWNoise<BE>
+        + FheUintBlocksPrepare<BRA, u32, BE>
+        + ExecuteBDDCircuit2WTo1W<u32, BE>
+        + GLWEEncryptSk<BE>,
+    BlindRotationKey<Vec<u8>, BRA>: BlindRotationKeyFactory<BRA>,
+    ScratchOwned<BE>: ScratchOwnedAlloc<BE> + ScratchOwnedBorrow<BE>,
+    Scratch<BE>: ScratchTakeCore<BE>,
+{
+    let glwe_infos: GLWELayout = TEST_GLWE_INFOS;
+    let ggsw_infos: GGSWLayout = TEST_GGSW_INFOS;
+
+    let n_glwe: usize = glwe_infos.n().into();
+
+    let module: Module<BE> = Module::<BE>::new(n_glwe as u64);
+    let mut source: Source = Source::new([6u8; 32]);
+    let mut source_xs: Source = Source::new([1u8; 32]);
+    let mut source_xa: Source = Source::new([2u8; 32]);
+    let mut source_xe: Source = Source::new([3u8; 32]);
+
+    let mut scratch: ScratchOwned<BE> = ScratchOwned::alloc(1 << 22);
+
+    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_infos);
+    sk_glwe.fill_ternary_prob(0.5, &mut source_xs);
+    let mut sk_glwe_prep: GLWESecretPrepared<Vec<u8>, BE> = GLWESecretPrepared::alloc_from_infos(&module, &glwe_infos);
+    sk_glwe_prep.prepare(&module, &sk_glwe);
+
+    let mut res: FheUintBlocks<Vec<u8>, u32> = FheUintBlocks::<Vec<u8>, u32>::alloc_from_infos(&module, &glwe_infos);
+    let mut a_enc_prep: FheUintBlocksPrepared<Vec<u8>, u32, BE> =
+        FheUintBlocksPrepared::<Vec<u8>, u32, BE>::alloc(&module, &ggsw_infos);
+    let mut b_enc_prep: FheUintBlocksPrepared<Vec<u8>, u32, BE> =
+        FheUintBlocksPrepared::<Vec<u8>, u32, BE>::alloc(&module, &ggsw_infos);
+
+    let a: u32 = source.next_u32();
+    let b: u32 = source.next_u32();
+
+    source.fill_bytes(&mut scratch.borrow().data);
+    a_enc_prep.encrypt_sk(
+        &module,
+        a,
+        &sk_glwe_prep,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+    source.fill_bytes(&mut scratch.borrow().data);
+    b_enc_prep.encrypt_sk(
+        &module,
+        b,
+        &sk_glwe_prep,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+
+    // d + a
+    res.slt(&module, &a_enc_prep, &b_enc_prep, scratch.borrow());
+
+    assert_eq!(
+        res.decrypt(&module, &sk_glwe_prep, scratch.borrow()),
+        ((a as i32) < (b as i32)) as u32
+    );
+}

poulpy-schemes/src/tfhe/bdd_arithmetic/tests/test_suite/sltu.rs

@@ -0,0 +1,93 @@
+use poulpy_core::{
+    GGSWNoise, GLWEDecrypt, GLWEEncryptSk, GLWENoise, ScratchTakeCore,
+    layouts::{GGSWLayout, GLWELayout, GLWESecret, GLWESecretPreparedFactory, LWEInfos, prepared::GLWESecretPrepared},
+};
+use poulpy_hal::{
+    api::{ModuleNew, ScratchOwnedAlloc, ScratchOwnedBorrow},
+    layouts::{Backend, Module, Scratch, ScratchOwned},
+    source::Source,
+};
+use rand::RngCore;
+
+use crate::tfhe::{
+    bdd_arithmetic::{
+        BDDKeyEncryptSk, BDDKeyPreparedFactory, ExecuteBDDCircuit2WTo1W, FheUintBlockDebugPrepare, FheUintBlocks,
+        FheUintBlocksPrepare, FheUintBlocksPrepared, FheUintBlocksPreparedEncryptSk, FheUintBlocksPreparedFactory, Sltu,
+        tests::test_suite::{TEST_GGSW_INFOS, TEST_GLWE_INFOS},
+    },
+    blind_rotation::{BlindRotationAlgo, BlindRotationKey, BlindRotationKeyFactory},
+};
+
+pub fn test_bdd_sltu<BRA: BlindRotationAlgo, BE: Backend>()
+where
+    Module<BE>: ModuleNew<BE>
+        + GLWESecretPreparedFactory<BE>
+        + GLWEDecrypt<BE>
+        + GLWENoise<BE>
+        + FheUintBlocksPreparedFactory<u32, BE>
+        + FheUintBlocksPreparedEncryptSk<u32, BE>
+        + FheUintBlockDebugPrepare<BRA, u32, BE>
+        + BDDKeyEncryptSk<BRA, BE>
+        + BDDKeyPreparedFactory<BRA, BE>
+        + GGSWNoise<BE>
+        + FheUintBlocksPrepare<BRA, u32, BE>
+        + ExecuteBDDCircuit2WTo1W<u32, BE>
+        + GLWEEncryptSk<BE>,
+    BlindRotationKey<Vec<u8>, BRA>: BlindRotationKeyFactory<BRA>,
+    ScratchOwned<BE>: ScratchOwnedAlloc<BE> + ScratchOwnedBorrow<BE>,
+    Scratch<BE>: ScratchTakeCore<BE>,
+{
+    let glwe_infos: GLWELayout = TEST_GLWE_INFOS;
+    let ggsw_infos: GGSWLayout = TEST_GGSW_INFOS;
+
+    let n_glwe: usize = glwe_infos.n().into();
+
+    let module: Module<BE> = Module::<BE>::new(n_glwe as u64);
+    let mut source: Source = Source::new([6u8; 32]);
+    let mut source_xs: Source = Source::new([1u8; 32]);
+    let mut source_xa: Source = Source::new([2u8; 32]);
+    let mut source_xe: Source = Source::new([3u8; 32]);
+
+    let mut scratch: ScratchOwned<BE> = ScratchOwned::alloc(1 << 22);
+
+    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_infos);
+    sk_glwe.fill_ternary_prob(0.5, &mut source_xs);
+    let mut sk_glwe_prep: GLWESecretPrepared<Vec<u8>, BE> = GLWESecretPrepared::alloc_from_infos(&module, &glwe_infos);
+    sk_glwe_prep.prepare(&module, &sk_glwe);
+
+    let mut res: FheUintBlocks<Vec<u8>, u32> = FheUintBlocks::<Vec<u8>, u32>::alloc_from_infos(&module, &glwe_infos);
+    let mut a_enc_prep: FheUintBlocksPrepared<Vec<u8>, u32, BE> =
+        FheUintBlocksPrepared::<Vec<u8>, u32, BE>::alloc(&module, &ggsw_infos);
+    let mut b_enc_prep: FheUintBlocksPrepared<Vec<u8>, u32, BE> =
+        FheUintBlocksPrepared::<Vec<u8>, u32, BE>::alloc(&module, &ggsw_infos);
+
+    let a: u32 = source.next_u32();
+    let b: u32 = source.next_u32();
+
+    source.fill_bytes(&mut scratch.borrow().data);
+    a_enc_prep.encrypt_sk(
+        &module,
+        a,
+        &sk_glwe_prep,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+    source.fill_bytes(&mut scratch.borrow().data);
+    b_enc_prep.encrypt_sk(
+        &module,
+        b,
+        &sk_glwe_prep,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+
+    // d + a
+    res.sltu(&module, &a_enc_prep, &b_enc_prep, scratch.borrow());
+
+    assert_eq!(
+        res.decrypt(&module, &sk_glwe_prep, scratch.borrow()),
+        (a < b) as u32
+    );
+}

poulpy-schemes/src/tfhe/bdd_arithmetic/tests/test_suite/sra.rs

@@ -0,0 +1,92 @@
+use poulpy_core::{
+    GGSWNoise, GLWEDecrypt, GLWEEncryptSk, GLWENoise, ScratchTakeCore,
+    layouts::{GGSWLayout, GLWELayout, GLWESecret, GLWESecretPreparedFactory, LWEInfos, prepared::GLWESecretPrepared},
+};
+use poulpy_hal::{
+    api::{ModuleNew, ScratchOwnedAlloc, ScratchOwnedBorrow},
+    layouts::{Backend, Module, Scratch, ScratchOwned},
+    source::Source,
+};
+use rand::RngCore;
+
+use crate::tfhe::{
+    bdd_arithmetic::{
+        BDDKeyEncryptSk, BDDKeyPreparedFactory, ExecuteBDDCircuit2WTo1W, FheUintBlockDebugPrepare, FheUintBlocks,
+        FheUintBlocksPrepare, FheUintBlocksPrepared, FheUintBlocksPreparedEncryptSk, FheUintBlocksPreparedFactory, Sra,
+        tests::test_suite::{TEST_GGSW_INFOS, TEST_GLWE_INFOS},
+    },
+    blind_rotation::{BlindRotationAlgo, BlindRotationKey, BlindRotationKeyFactory},
+};
+
+pub fn test_bdd_sra<BRA: BlindRotationAlgo, BE: Backend>()
+where
+    Module<BE>: ModuleNew<BE>
+        + GLWESecretPreparedFactory<BE>
+        + GLWEDecrypt<BE>
+        + GLWENoise<BE>
+        + FheUintBlocksPreparedFactory<u32, BE>
+        + FheUintBlocksPreparedEncryptSk<u32, BE>
+        + FheUintBlockDebugPrepare<BRA, u32, BE>
+        + BDDKeyEncryptSk<BRA, BE>
+        + BDDKeyPreparedFactory<BRA, BE>
+        + GGSWNoise<BE>
+        + FheUintBlocksPrepare<BRA, u32, BE>
+        + ExecuteBDDCircuit2WTo1W<u32, BE>
+        + GLWEEncryptSk<BE>,
+    BlindRotationKey<Vec<u8>, BRA>: BlindRotationKeyFactory<BRA>,
+    ScratchOwned<BE>: ScratchOwnedAlloc<BE> + ScratchOwnedBorrow<BE>,
+    Scratch<BE>: ScratchTakeCore<BE>,
+{
+    let glwe_infos: GLWELayout = TEST_GLWE_INFOS;
+    let ggsw_infos: GGSWLayout = TEST_GGSW_INFOS;
+
+    let n_glwe: usize = glwe_infos.n().into();
+
+    let module: Module<BE> = Module::<BE>::new(n_glwe as u64);
+    let mut source: Source = Source::new([6u8; 32]);
+    let mut source_xs: Source = Source::new([1u8; 32]);
+    let mut source_xa: Source = Source::new([2u8; 32]);
+    let mut source_xe: Source = Source::new([3u8; 32]);
+
+    let mut scratch: ScratchOwned<BE> = ScratchOwned::alloc(1 << 22);
+
+    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_infos);
+    sk_glwe.fill_ternary_prob(0.5, &mut source_xs);
+    let mut sk_glwe_prep: GLWESecretPrepared<Vec<u8>, BE> = GLWESecretPrepared::alloc_from_infos(&module, &glwe_infos);
+    sk_glwe_prep.prepare(&module, &sk_glwe);
+
+    let mut res: FheUintBlocks<Vec<u8>, u32> = FheUintBlocks::<Vec<u8>, u32>::alloc_from_infos(&module, &glwe_infos);
+    let mut a_enc_prep: FheUintBlocksPrepared<Vec<u8>, u32, BE> =
+        FheUintBlocksPrepared::<Vec<u8>, u32, BE>::alloc(&module, &ggsw_infos);
+    let mut b_enc_prep: FheUintBlocksPrepared<Vec<u8>, u32, BE> =
+        FheUintBlocksPrepared::<Vec<u8>, u32, BE>::alloc(&module, &ggsw_infos);
+
+    let a: u32 = source.next_u32();
+    let b: u32 = source.next_u32() & 15;
+
+    source.fill_bytes(&mut scratch.borrow().data);
+    a_enc_prep.encrypt_sk(
+        &module,
+        a,
+        &sk_glwe_prep,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+    source.fill_bytes(&mut scratch.borrow().data);
+    b_enc_prep.encrypt_sk(
+        &module,
+        b,
+        &sk_glwe_prep,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+
+    res.sra(&module, &a_enc_prep, &b_enc_prep, scratch.borrow());
+
+    assert_eq!(
+        res.decrypt(&module, &sk_glwe_prep, scratch.borrow()),
+        ((a as i32) >> b) as u32
+    );
+}

poulpy-schemes/src/tfhe/bdd_arithmetic/tests/test_suite/srl.rs

@@ -0,0 +1,92 @@
+use poulpy_core::{
+    GGSWNoise, GLWEDecrypt, GLWEEncryptSk, GLWENoise, ScratchTakeCore,
+    layouts::{GGSWLayout, GLWELayout, GLWESecret, GLWESecretPreparedFactory, LWEInfos, prepared::GLWESecretPrepared},
+};
+use poulpy_hal::{
+    api::{ModuleNew, ScratchOwnedAlloc, ScratchOwnedBorrow},
+    layouts::{Backend, Module, Scratch, ScratchOwned},
+    source::Source,
+};
+use rand::RngCore;
+
+use crate::tfhe::{
+    bdd_arithmetic::{
+        BDDKeyEncryptSk, BDDKeyPreparedFactory, ExecuteBDDCircuit2WTo1W, FheUintBlockDebugPrepare, FheUintBlocks,
+        FheUintBlocksPrepare, FheUintBlocksPrepared, FheUintBlocksPreparedEncryptSk, FheUintBlocksPreparedFactory, Srl,
+        tests::test_suite::{TEST_GGSW_INFOS, TEST_GLWE_INFOS},
+    },
+    blind_rotation::{BlindRotationAlgo, BlindRotationKey, BlindRotationKeyFactory},
+};
+
+pub fn test_bdd_srl<BRA: BlindRotationAlgo, BE: Backend>()
+where
+    Module<BE>: ModuleNew<BE>
+        + GLWESecretPreparedFactory<BE>
+        + GLWEDecrypt<BE>
+        + GLWENoise<BE>
+        + FheUintBlocksPreparedFactory<u32, BE>
+        + FheUintBlocksPreparedEncryptSk<u32, BE>
+        + FheUintBlockDebugPrepare<BRA, u32, BE>
+        + BDDKeyEncryptSk<BRA, BE>
+        + BDDKeyPreparedFactory<BRA, BE>
+        + GGSWNoise<BE>
+        + FheUintBlocksPrepare<BRA, u32, BE>
+        + ExecuteBDDCircuit2WTo1W<u32, BE>
+        + GLWEEncryptSk<BE>,
+    BlindRotationKey<Vec<u8>, BRA>: BlindRotationKeyFactory<BRA>,
+    ScratchOwned<BE>: ScratchOwnedAlloc<BE> + ScratchOwnedBorrow<BE>,
+    Scratch<BE>: ScratchTakeCore<BE>,
+{
+    let glwe_infos: GLWELayout = TEST_GLWE_INFOS;
+    let ggsw_infos: GGSWLayout = TEST_GGSW_INFOS;
+
+    let n_glwe: usize = glwe_infos.n().into();
+
+    let module: Module<BE> = Module::<BE>::new(n_glwe as u64);
+    let mut source: Source = Source::new([6u8; 32]);
+    let mut source_xs: Source = Source::new([1u8; 32]);
+    let mut source_xa: Source = Source::new([2u8; 32]);
+    let mut source_xe: Source = Source::new([3u8; 32]);
+
+    let mut scratch: ScratchOwned<BE> = ScratchOwned::alloc(1 << 22);
+
+    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_infos);
+    sk_glwe.fill_ternary_prob(0.5, &mut source_xs);
+    let mut sk_glwe_prep: GLWESecretPrepared<Vec<u8>, BE> = GLWESecretPrepared::alloc_from_infos(&module, &glwe_infos);
+    sk_glwe_prep.prepare(&module, &sk_glwe);
+
+    let mut res: FheUintBlocks<Vec<u8>, u32> = FheUintBlocks::<Vec<u8>, u32>::alloc_from_infos(&module, &glwe_infos);
+    let mut a_enc_prep: FheUintBlocksPrepared<Vec<u8>, u32, BE> =
+        FheUintBlocksPrepared::<Vec<u8>, u32, BE>::alloc(&module, &ggsw_infos);
+    let mut b_enc_prep: FheUintBlocksPrepared<Vec<u8>, u32, BE> =
+        FheUintBlocksPrepared::<Vec<u8>, u32, BE>::alloc(&module, &ggsw_infos);
+
+    let a: u32 = source.next_u32();
+    let b: u32 = source.next_u32() & 15;
+
+    source.fill_bytes(&mut scratch.borrow().data);
+    a_enc_prep.encrypt_sk(
+        &module,
+        a,
+        &sk_glwe_prep,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+    source.fill_bytes(&mut scratch.borrow().data);
+    b_enc_prep.encrypt_sk(
+        &module,
+        b,
+        &sk_glwe_prep,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+
+    res.srl(&module, &a_enc_prep, &b_enc_prep, scratch.borrow());
+
+    assert_eq!(
+        res.decrypt(&module, &sk_glwe_prep, scratch.borrow()),
+        a >> b
+    );
+}

poulpy-schemes/src/tfhe/bdd_arithmetic/tests/test_suite/sub.rs

@@ -0,0 +1,92 @@
+use poulpy_core::{
+    GGSWNoise, GLWEDecrypt, GLWEEncryptSk, GLWENoise, ScratchTakeCore,
+    layouts::{GGSWLayout, GLWELayout, GLWESecret, GLWESecretPreparedFactory, LWEInfos, prepared::GLWESecretPrepared},
+};
+use poulpy_hal::{
+    api::{ModuleNew, ScratchOwnedAlloc, ScratchOwnedBorrow},
+    layouts::{Backend, Module, Scratch, ScratchOwned},
+    source::Source,
+};
+use rand::RngCore;
+
+use crate::tfhe::{
+    bdd_arithmetic::{
+        BDDKeyEncryptSk, BDDKeyPreparedFactory, ExecuteBDDCircuit2WTo1W, FheUintBlockDebugPrepare, FheUintBlocks,
+        FheUintBlocksPrepare, FheUintBlocksPrepared, FheUintBlocksPreparedEncryptSk, FheUintBlocksPreparedFactory, Sub,
+        tests::test_suite::{TEST_GGSW_INFOS, TEST_GLWE_INFOS},
+    },
+    blind_rotation::{BlindRotationAlgo, BlindRotationKey, BlindRotationKeyFactory},
+};
+
+pub fn test_bdd_sub<BRA: BlindRotationAlgo, BE: Backend>()
+where
+    Module<BE>: ModuleNew<BE>
+        + GLWESecretPreparedFactory<BE>
+        + GLWEDecrypt<BE>
+        + GLWENoise<BE>
+        + FheUintBlocksPreparedFactory<u32, BE>
+        + FheUintBlocksPreparedEncryptSk<u32, BE>
+        + FheUintBlockDebugPrepare<BRA, u32, BE>
+        + BDDKeyEncryptSk<BRA, BE>
+        + BDDKeyPreparedFactory<BRA, BE>
+        + GGSWNoise<BE>
+        + FheUintBlocksPrepare<BRA, u32, BE>
+        + ExecuteBDDCircuit2WTo1W<u32, BE>
+        + GLWEEncryptSk<BE>,
+    BlindRotationKey<Vec<u8>, BRA>: BlindRotationKeyFactory<BRA>,
+    ScratchOwned<BE>: ScratchOwnedAlloc<BE> + ScratchOwnedBorrow<BE>,
+    Scratch<BE>: ScratchTakeCore<BE>,
+{
+    let glwe_infos: GLWELayout = TEST_GLWE_INFOS;
+    let ggsw_infos: GGSWLayout = TEST_GGSW_INFOS;
+
+    let n_glwe: usize = glwe_infos.n().into();
+
+    let module: Module<BE> = Module::<BE>::new(n_glwe as u64);
+    let mut source: Source = Source::new([6u8; 32]);
+    let mut source_xs: Source = Source::new([1u8; 32]);
+    let mut source_xa: Source = Source::new([2u8; 32]);
+    let mut source_xe: Source = Source::new([3u8; 32]);
+
+    let mut scratch: ScratchOwned<BE> = ScratchOwned::alloc(1 << 22);
+
+    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_infos);
+    sk_glwe.fill_ternary_prob(0.5, &mut source_xs);
+    let mut sk_glwe_prep: GLWESecretPrepared<Vec<u8>, BE> = GLWESecretPrepared::alloc_from_infos(&module, &glwe_infos);
+    sk_glwe_prep.prepare(&module, &sk_glwe);
+
+    let mut res: FheUintBlocks<Vec<u8>, u32> = FheUintBlocks::<Vec<u8>, u32>::alloc_from_infos(&module, &glwe_infos);
+    let mut a_enc_prep: FheUintBlocksPrepared<Vec<u8>, u32, BE> =
+        FheUintBlocksPrepared::<Vec<u8>, u32, BE>::alloc(&module, &ggsw_infos);
+    let mut b_enc_prep: FheUintBlocksPrepared<Vec<u8>, u32, BE> =
+        FheUintBlocksPrepared::<Vec<u8>, u32, BE>::alloc(&module, &ggsw_infos);
+
+    let a: u32 = source.next_u32();
+    let b: u32 = source.next_u32();
+
+    source.fill_bytes(&mut scratch.borrow().data);
+    a_enc_prep.encrypt_sk(
+        &module,
+        a,
+        &sk_glwe_prep,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+    source.fill_bytes(&mut scratch.borrow().data);
+    b_enc_prep.encrypt_sk(
+        &module,
+        b,
+        &sk_glwe_prep,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+
+    res.sub(&module, &a_enc_prep, &b_enc_prep, scratch.borrow());
+
+    assert_eq!(
+        res.decrypt(&module, &sk_glwe_prep, scratch.borrow()),
+        a.wrapping_sub(b)
+    );
+}

poulpy-schemes/src/tfhe/bdd_arithmetic/tests/test_suite/xor.rs

@@ -0,0 +1,89 @@
+use poulpy_core::{
+    GGSWNoise, GLWEDecrypt, GLWEEncryptSk, GLWENoise, ScratchTakeCore,
+    layouts::{GGSWLayout, GLWELayout, GLWESecret, GLWESecretPreparedFactory, LWEInfos, prepared::GLWESecretPrepared},
+};
+use poulpy_hal::{
+    api::{ModuleNew, ScratchOwnedAlloc, ScratchOwnedBorrow},
+    layouts::{Backend, Module, Scratch, ScratchOwned},
+    source::Source,
+};
+use rand::RngCore;
+
+use crate::tfhe::{
+    bdd_arithmetic::{
+        BDDKeyEncryptSk, BDDKeyPreparedFactory, ExecuteBDDCircuit2WTo1W, FheUintBlockDebugPrepare, FheUintBlocks,
+        FheUintBlocksPrepare, FheUintBlocksPrepared, FheUintBlocksPreparedEncryptSk, FheUintBlocksPreparedFactory, Xor,
+        tests::test_suite::{TEST_GGSW_INFOS, TEST_GLWE_INFOS},
+    },
+    blind_rotation::{BlindRotationAlgo, BlindRotationKey, BlindRotationKeyFactory},
+};
+
+pub fn test_bdd_xor<BRA: BlindRotationAlgo, BE: Backend>()
+where
+    Module<BE>: ModuleNew<BE>
+        + GLWESecretPreparedFactory<BE>
+        + GLWEDecrypt<BE>
+        + GLWENoise<BE>
+        + FheUintBlocksPreparedFactory<u32, BE>
+        + FheUintBlocksPreparedEncryptSk<u32, BE>
+        + FheUintBlockDebugPrepare<BRA, u32, BE>
+        + BDDKeyEncryptSk<BRA, BE>
+        + BDDKeyPreparedFactory<BRA, BE>
+        + GGSWNoise<BE>
+        + FheUintBlocksPrepare<BRA, u32, BE>
+        + ExecuteBDDCircuit2WTo1W<u32, BE>
+        + GLWEEncryptSk<BE>,
+    BlindRotationKey<Vec<u8>, BRA>: BlindRotationKeyFactory<BRA>,
+    ScratchOwned<BE>: ScratchOwnedAlloc<BE> + ScratchOwnedBorrow<BE>,
+    Scratch<BE>: ScratchTakeCore<BE>,
+{
+    let glwe_infos: GLWELayout = TEST_GLWE_INFOS;
+    let ggsw_infos: GGSWLayout = TEST_GGSW_INFOS;
+
+    let n_glwe: usize = glwe_infos.n().into();
+
+    let module: Module<BE> = Module::<BE>::new(n_glwe as u64);
+    let mut source: Source = Source::new([6u8; 32]);
+    let mut source_xs: Source = Source::new([1u8; 32]);
+    let mut source_xa: Source = Source::new([2u8; 32]);
+    let mut source_xe: Source = Source::new([3u8; 32]);
+
+    let mut scratch: ScratchOwned<BE> = ScratchOwned::alloc(1 << 22);
+
+    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_infos);
+    sk_glwe.fill_ternary_prob(0.5, &mut source_xs);
+    let mut sk_glwe_prep: GLWESecretPrepared<Vec<u8>, BE> = GLWESecretPrepared::alloc_from_infos(&module, &glwe_infos);
+    sk_glwe_prep.prepare(&module, &sk_glwe);
+
+    let mut res: FheUintBlocks<Vec<u8>, u32> = FheUintBlocks::<Vec<u8>, u32>::alloc_from_infos(&module, &glwe_infos);
+    let mut a_enc_prep: FheUintBlocksPrepared<Vec<u8>, u32, BE> =
+        FheUintBlocksPrepared::<Vec<u8>, u32, BE>::alloc(&module, &ggsw_infos);
+    let mut b_enc_prep: FheUintBlocksPrepared<Vec<u8>, u32, BE> =
+        FheUintBlocksPrepared::<Vec<u8>, u32, BE>::alloc(&module, &ggsw_infos);
+
+    let a: u32 = source.next_u32();
+    let b: u32 = source.next_u32();
+
+    source.fill_bytes(&mut scratch.borrow().data);
+    a_enc_prep.encrypt_sk(
+        &module,
+        a,
+        &sk_glwe_prep,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+    source.fill_bytes(&mut scratch.borrow().data);
+    b_enc_prep.encrypt_sk(
+        &module,
+        b,
+        &sk_glwe_prep,
+        &mut source_xa,
+        &mut source_xe,
+        scratch.borrow(),
+    );
+
+    res.xor(&module, &a_enc_prep, &b_enc_prep, scratch.borrow());
+
+    assert_eq!(res.decrypt(&module, &sk_glwe_prep, scratch.borrow()), a ^ b);
+}