Traits cleaning, CBT example & bug fixes (#72)

* Some cleaning, CBT example, fix mod switch and add LUT correctness test to BR test * finished trait cleaning * removed trait aliastoutside of backend
2026-02-10 13:16:44 +01:00 · 2025-08-16 18:23:22 +02:00
parent c7219c35e9
commit 3a828740cc
99 changed files with 3267 additions and 1220 deletions
--- a/schemes/src/lib.rs
+++ b/schemes/src/lib.rs
@@ -1,2 +1 @@
-#![feature(trait_alias)]
 pub mod tfhe;
--- a/schemes/src/tfhe/blind_rotation/cggi_algo.rs
+++ b/schemes/src/tfhe/blind_rotation/cggi_algo.rs
@@ -1,10 +1,11 @@
 use backend::hal::{
    api::{
        ScratchAvailable, SvpApply, SvpPPolAllocBytes, TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft, TakeVecZnxDftSlice,
-        TakeVecZnxSlice, VecZnxAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAllocBytes, VecZnxBigNormalizeTmpBytes, VecZnxCopy,
-        VecZnxDftAdd, VecZnxDftAddInplace, VecZnxDftAllocBytes, VecZnxDftFromVecZnx, VecZnxDftSubABInplace, VecZnxDftToVecZnxBig,
-        VecZnxDftToVecZnxBigTmpBytes, VecZnxDftZero, VecZnxMulXpMinusOneInplace, VecZnxNormalize, VecZnxNormalizeInplace,
-        VecZnxRotate, VecZnxSubABInplace, VmpApplyTmpBytes, ZnxView, ZnxZero,
+        TakeVecZnxSlice, VecZnxAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAllocBytes, VecZnxBigNormalize,
+        VecZnxBigNormalizeTmpBytes, VecZnxCopy, VecZnxDftAdd, VecZnxDftAddInplace, VecZnxDftAllocBytes, VecZnxDftFromVecZnx,
+        VecZnxDftSubABInplace, VecZnxDftToVecZnxBig, VecZnxDftToVecZnxBigConsume, VecZnxDftToVecZnxBigTmpBytes, VecZnxDftZero,
+        VecZnxMulXpMinusOneInplace, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxRotate,
+        VecZnxSubABInplace, VmpApply, VmpApplyAdd, VmpApplyTmpBytes, ZnxView, ZnxZero,
    },
    layouts::{Backend, DataMut, DataRef, Module, Scratch, SvpPPol, VecZnx},
 };
@@ -13,36 +14,12 @@ use itertools::izip;
 use core::{
    Distribution, GLWEOperations, TakeGLWECt,
    layouts::{GLWECiphertext, GLWECiphertextToMut, Infos, LWECiphertext, LWECiphertextToRef},
-    trait_families::GLWEExternalProductFamily,
 };

 use crate::tfhe::blind_rotation::{
    BlincRotationExecute, BlindRotationKeyPrepared, CGGI, LookUpTable, LookUpTableRotationDirection,
 };

-pub trait CCGIBlindRotationFamily<B: Backend> = VecZnxBigAllocBytes
-    + VecZnxDftAllocBytes
-    + SvpPPolAllocBytes
-    + VmpApplyTmpBytes
-    + VecZnxBigNormalizeTmpBytes
-    + VecZnxDftToVecZnxBigTmpBytes
-    + VecZnxDftToVecZnxBig<B>
-    + VecZnxDftAdd<B>
-    + VecZnxDftAddInplace<B>
-    + VecZnxDftFromVecZnx<B>
-    + VecZnxDftZero<B>
-    + SvpApply<B>
-    + VecZnxDftSubABInplace<B>
-    + VecZnxBigAddSmallInplace<B>
-    + GLWEExternalProductFamily<B>
-    + VecZnxRotate
-    + VecZnxAddInplace
-    + VecZnxSubABInplace
-    + VecZnxNormalize<B>
-    + VecZnxNormalizeInplace<B>
-    + VecZnxCopy
-    + VecZnxMulXpMinusOneInplace;
-
 pub fn cggi_blind_rotate_scratch_space<B: Backend>(
    module: &Module<B>,
    n: usize,
@@ -55,7 +32,12 @@ pub fn cggi_blind_rotate_scratch_space<B: Backend>(
    rank: usize,
 ) -> usize
 where
-    Module<B>: CCGIBlindRotationFamily<B>,
+    Module<B>: VecZnxDftAllocBytes
+        + VmpApplyTmpBytes
+        + VecZnxNormalizeTmpBytes
+        + VecZnxBigAllocBytes
+        + VecZnxDftToVecZnxBigTmpBytes
+        + VecZnxBigNormalizeTmpBytes,
 {
    let brk_size: usize = k_brk.div_ceil(basek);

@@ -89,7 +71,32 @@ where

 impl<D: DataRef, B: Backend> BlincRotationExecute<B> for BlindRotationKeyPrepared<D, CGGI, B>
 where
-    Module<B>: CCGIBlindRotationFamily<B>,
+    Module<B>: VecZnxBigAllocBytes
+        + VecZnxDftAllocBytes
+        + SvpPPolAllocBytes
+        + VmpApplyTmpBytes
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxDftToVecZnxBigTmpBytes
+        + VecZnxDftToVecZnxBig<B>
+        + VecZnxDftAdd<B>
+        + VecZnxDftAddInplace<B>
+        + VecZnxDftFromVecZnx<B>
+        + VecZnxDftZero<B>
+        + SvpApply<B>
+        + VecZnxDftSubABInplace<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxRotate
+        + VecZnxAddInplace
+        + VecZnxSubABInplace
+        + VecZnxNormalize<B>
+        + VecZnxNormalizeInplace<B>
+        + VecZnxCopy
+        + VecZnxMulXpMinusOneInplace
+        + VmpApply<B>
+        + VmpApplyAdd<B>
+        + VecZnxDftToVecZnxBigConsume<B>
+        + VecZnxBigNormalize<B>
+        + VecZnxNormalizeTmpBytes,
    Scratch<B>: TakeVecZnxDftSlice<B> + TakeVecZnxDft<B> + TakeVecZnxBig<B> + TakeVecZnxSlice + TakeVecZnx + ScratchAvailable,
 {
    fn execute<DR: DataMut, DI: DataRef>(
@@ -126,7 +133,29 @@ fn execute_block_binary_extended<DataRes, DataIn, DataBrk, B: Backend>(
    DataRes: DataMut,
    DataIn: DataRef,
    DataBrk: DataRef,
-    Module<B>: CCGIBlindRotationFamily<B>,
+    Module<B>: VecZnxBigAllocBytes
+        + VecZnxDftAllocBytes
+        + SvpPPolAllocBytes
+        + VmpApplyTmpBytes
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxDftToVecZnxBigTmpBytes
+        + VecZnxDftToVecZnxBig<B>
+        + VecZnxDftAdd<B>
+        + VecZnxDftAddInplace<B>
+        + VecZnxDftFromVecZnx<B>
+        + VecZnxDftZero<B>
+        + SvpApply<B>
+        + VecZnxDftSubABInplace<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxRotate
+        + VecZnxAddInplace
+        + VecZnxSubABInplace
+        + VecZnxNormalize<B>
+        + VecZnxNormalizeInplace<B>
+        + VecZnxCopy
+        + VecZnxMulXpMinusOneInplace
+        + VecZnxBigNormalize<B>
+        + VmpApply<B>,
    Scratch<B>: TakeVecZnxDftSlice<B> + TakeVecZnxDft<B> + TakeVecZnxBig<B> + TakeVecZnxSlice + ScratchAvailable + TakeVecZnx,
 {
    let n_glwe: usize = brk.n();
@@ -271,7 +300,29 @@ fn execute_block_binary<DataRes, DataIn, DataBrk, B: Backend>(
    DataRes: DataMut,
    DataIn: DataRef,
    DataBrk: DataRef,
-    Module<B>: CCGIBlindRotationFamily<B>,
+    Module<B>: VecZnxBigAllocBytes
+        + VecZnxDftAllocBytes
+        + SvpPPolAllocBytes
+        + VmpApplyTmpBytes
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxDftToVecZnxBigTmpBytes
+        + VecZnxDftToVecZnxBig<B>
+        + VecZnxDftAdd<B>
+        + VecZnxDftAddInplace<B>
+        + VecZnxDftFromVecZnx<B>
+        + VecZnxDftZero<B>
+        + SvpApply<B>
+        + VecZnxDftSubABInplace<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxRotate
+        + VecZnxAddInplace
+        + VecZnxSubABInplace
+        + VecZnxNormalize<B>
+        + VecZnxNormalizeInplace<B>
+        + VecZnxCopy
+        + VecZnxMulXpMinusOneInplace
+        + VmpApply<B>
+        + VecZnxBigNormalize<B>,
    Scratch<B>: TakeVecZnxDftSlice<B> + TakeVecZnxDft<B> + TakeVecZnxBig<B> + TakeVecZnxSlice + ScratchAvailable + TakeVecZnx,
 {
    let n_glwe: usize = brk.n();
@@ -363,7 +414,32 @@ fn execute_standard<DataRes, DataIn, DataBrk, B: Backend>(
    DataRes: DataMut,
    DataIn: DataRef,
    DataBrk: DataRef,
-    Module<B>: CCGIBlindRotationFamily<B>,
+    Module<B>: VecZnxBigAllocBytes
+        + VecZnxDftAllocBytes
+        + SvpPPolAllocBytes
+        + VmpApplyTmpBytes
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxDftToVecZnxBigTmpBytes
+        + VecZnxDftToVecZnxBig<B>
+        + VecZnxDftAdd<B>
+        + VecZnxDftAddInplace<B>
+        + VecZnxDftFromVecZnx<B>
+        + VecZnxDftZero<B>
+        + SvpApply<B>
+        + VecZnxDftSubABInplace<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxRotate
+        + VecZnxAddInplace
+        + VecZnxSubABInplace
+        + VecZnxNormalize<B>
+        + VecZnxNormalizeInplace<B>
+        + VecZnxCopy
+        + VecZnxMulXpMinusOneInplace
+        + VmpApply<B>
+        + VmpApplyAdd<B>
+        + VecZnxDftToVecZnxBigConsume<B>
+        + VecZnxBigNormalize<B>
+        + VecZnxNormalizeTmpBytes,
    Scratch<B>: TakeVecZnxDftSlice<B> + TakeVecZnxDft<B> + TakeVecZnxBig<B> + TakeVecZnxSlice + ScratchAvailable + TakeVecZnx,
 {
    #[cfg(debug_assertions)]
@@ -454,7 +530,7 @@ pub(crate) fn mod_switch_2n(n: usize, res: &mut [i64], lwe: &LWECiphertext<&[u8]
    }

    if basek > log2n {
-        let diff: usize = basek - log2n;
+        let diff: usize = basek - (log2n - 1); // additional -1 because we map to [-N/2, N/2) instead of [0, N)
        res.iter_mut().for_each(|x| {
            *x = div_round_by_pow2(x, diff);
        })
--- a/schemes/src/tfhe/blind_rotation/cggi_key.rs
+++ b/schemes/src/tfhe/blind_rotation/cggi_key.rs
@@ -1,6 +1,9 @@
 use backend::hal::{
    api::{
-        ScratchAvailable, TakeVecZnx, TakeVecZnxDft, VecZnxAddScalarInplace, VmpPMatAlloc, VmpPMatPrepare, ZnxView, ZnxViewMut,
+        ScratchAvailable, SvpApplyInplace, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace,
+        VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftFromVecZnx, VecZnxDftToVecZnxBigConsume, VecZnxFillUniform,
+        VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace, VmpPMatAlloc,
+        VmpPrepare, ZnxView, ZnxViewMut,
    },
    layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, ScalarZnxToRef, Scratch},
 };
@@ -15,7 +18,6 @@ use core::{
        compressed::GGSWCiphertextCompressed,
        prepared::{GGSWCiphertextPrepared, GLWESecretPrepared},
    },
-    trait_families::GGSWEncryptSkFamily,
 };

 use crate::tfhe::blind_rotation::{
@@ -38,7 +40,7 @@ impl BlindRotationKeyAlloc for BlindRotationKey<Vec<u8>, CGGI> {
 impl BlindRotationKey<Vec<u8>, CGGI> {
    pub fn generate_from_sk_scratch_space<B: Backend>(module: &Module<B>, n: usize, basek: usize, k: usize, rank: usize) -> usize
    where
-        Module<B>: GGSWEncryptSkFamily<B>,
+        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes,
    {
        GGSWCiphertext::encrypt_sk_scratch_space(module, n, basek, k, rank)
    }
@@ -46,7 +48,20 @@ impl BlindRotationKey<Vec<u8>, CGGI> {

 impl<D: DataMut, B: Backend> BlindRotationKeyEncryptSk<B> for BlindRotationKey<D, CGGI>
 where
-    Module<B>: GGSWEncryptSkFamily<B> + VecZnxAddScalarInplace,
+    Module<B>: VecZnxAddScalarInplace
+        + VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftFromVecZnx<B>
+        + SvpApplyInplace<B>
+        + VecZnxDftToVecZnxBigConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub,
    Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
 {
    fn encrypt_sk<DataSkGLWE, DataSkLWE>(
@@ -92,7 +107,7 @@ where

 impl<B: Backend> BlindRotationKeyPreparedAlloc<B> for BlindRotationKeyPrepared<Vec<u8>, CGGI, B>
 where
-    Module<B>: VmpPMatAlloc<B> + VmpPMatPrepare<B>,
+    Module<B>: VmpPMatAlloc<B> + VmpPrepare<B>,
 {
    fn alloc(module: &Module<B>, n_glwe: usize, n_lwe: usize, basek: usize, k: usize, rows: usize, rank: usize) -> Self {
        let mut data: Vec<GGSWCiphertextPrepared<Vec<u8>, B>> = Vec::with_capacity(n_lwe);
@@ -127,7 +142,7 @@ impl BlindRotationKeyCompressed<Vec<u8>, CGGI> {

    pub fn generate_from_sk_scratch_space<B: Backend>(module: &Module<B>, n: usize, basek: usize, k: usize, rank: usize) -> usize
    where
-        Module<B>: GGSWEncryptSkFamily<B>,
+        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes,
    {
        GGSWCiphertextCompressed::encrypt_sk_scratch_space(module, n, basek, k, rank)
    }
@@ -146,7 +161,20 @@ impl<D: DataMut> BlindRotationKeyCompressed<D, CGGI> {
    ) where
        DataSkGLWE: DataRef,
        DataSkLWE: DataRef,
-        Module<B>: GGSWEncryptSkFamily<B> + VecZnxAddScalarInplace,
+        Module<B>: VecZnxAddScalarInplace
+            + VecZnxDftAllocBytes
+            + VecZnxBigNormalize<B>
+            + VecZnxDftFromVecZnx<B>
+            + SvpApplyInplace<B>
+            + VecZnxDftToVecZnxBigConsume<B>
+            + VecZnxNormalizeTmpBytes
+            + VecZnxFillUniform
+            + VecZnxSubABInplace
+            + VecZnxAddInplace
+            + VecZnxNormalizeInplace<B>
+            + VecZnxAddNormal
+            + VecZnxNormalize<B>
+            + VecZnxSub,
        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
    {
        #[cfg(debug_assertions)]
--- a/schemes/src/tfhe/blind_rotation/key_prepared.rs
+++ b/schemes/src/tfhe/blind_rotation/key_prepared.rs
@@ -1,5 +1,5 @@
 use backend::hal::{
-    api::{SvpPPolAlloc, SvpPrepare, VmpPMatAlloc, VmpPMatPrepare},
+    api::{SvpPPolAlloc, SvpPrepare, VmpPMatAlloc, VmpPrepare},
    layouts::{Backend, Data, DataMut, DataRef, Module, ScalarZnx, Scratch, SvpPPol},
 };

@@ -89,7 +89,7 @@ where
 impl<DM: DataMut, DR: DataRef, BRA: BlindRotationAlgo, B: Backend> Prepare<B, BlindRotationKey<DR, BRA>>
    for BlindRotationKeyPrepared<DM, BRA, B>
 where
-    Module<B>: VmpPMatAlloc<B> + VmpPMatPrepare<B> + SvpPPolAlloc<B> + SvpPrepare<B>,
+    Module<B>: VmpPMatAlloc<B> + VmpPrepare<B> + SvpPPolAlloc<B> + SvpPrepare<B>,
 {
    fn prepare(&mut self, module: &Module<B>, other: &BlindRotationKey<DR, BRA>, scratch: &mut Scratch<B>) {
        #[cfg(debug_assertions)]
--- a/schemes/src/tfhe/blind_rotation/lut.rs
+++ b/schemes/src/tfhe/blind_rotation/lut.rs
@@ -183,6 +183,7 @@ impl DivRound for usize {
    }
 }

+#[allow(dead_code)]
 fn max_bit_size(vec: &[i64]) -> u32 {
    vec.iter()
        .map(|&v| {
--- a/schemes/src/tfhe/blind_rotation/tests/generic_blind_rotation.rs
+++ b/schemes/src/tfhe/blind_rotation/tests/generic_blind_rotation.rs
@@ -1,7 +1,12 @@
 use backend::hal::{
    api::{
-        ScratchOwnedAlloc, ScratchOwnedBorrow, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxFillUniform, VecZnxRotateInplace,
-        VecZnxSub, VecZnxSwithcDegree, VmpPMatAlloc, VmpPMatPrepare, ZnxView,
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApply, SvpApplyInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
+        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxCopy, VecZnxDftAdd, VecZnxDftAddInplace,
+        VecZnxDftAllocBytes, VecZnxDftFromVecZnx, VecZnxDftSubABInplace, VecZnxDftToVecZnxBig, VecZnxDftToVecZnxBigConsume,
+        VecZnxDftToVecZnxBigTmpBytes, VecZnxDftZero, VecZnxFillUniform, VecZnxMulXpMinusOneInplace, VecZnxNormalize,
+        VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxRotate, VecZnxRotateInplace, VecZnxSub, VecZnxSubABInplace,
+        VecZnxSwithcDegree, VmpApply, VmpApplyAdd, VmpApplyTmpBytes, VmpPMatAlloc, VmpPrepare, ZnxView,
    },
    layouts::{Backend, Module, ScratchOwned},
    oep::{
@@ -12,23 +17,45 @@ use backend::hal::{
 use sampling::source::Source;

 use crate::tfhe::blind_rotation::{
-    BlincRotationExecute, BlindRotationKey, BlindRotationKeyAlloc, BlindRotationKeyEncryptSk, BlindRotationKeyPrepared,
-    CCGIBlindRotationFamily, CGGI, LookUpTable, cggi_blind_rotate_scratch_space, mod_switch_2n,
+    BlincRotationExecute, BlindRotationKey, BlindRotationKeyAlloc, BlindRotationKeyEncryptSk, BlindRotationKeyPrepared, CGGI,
+    LookUpTable, cggi_blind_rotate_scratch_space, mod_switch_2n,
 };

-use core::{
-    layouts::{
-        GLWECiphertext, GLWEPlaintext, GLWESecret, Infos, LWECiphertext, LWECiphertextToRef, LWEPlaintext, LWESecret,
-        prepared::{GLWESecretPrepared, PrepareAlloc},
-    },
-    trait_families::{GLWEDecryptFamily, GLWESecretPreparedModuleFamily},
+use core::layouts::{
+    GLWECiphertext, GLWEPlaintext, GLWESecret, Infos, LWECiphertext, LWECiphertextToRef, LWEPlaintext, LWESecret,
+    prepared::{GLWESecretPrepared, PrepareAlloc},
 };

 pub fn test_blind_rotation<B: Backend>(module: &Module<B>, n_lwe: usize, block_size: usize, extension_factor: usize)
 where
-    Module<B>: CCGIBlindRotationFamily<B>
-        + GLWESecretPreparedModuleFamily<B>
-        + GLWEDecryptFamily<B>
+    Module<B>: VecZnxBigAllocBytes
+        + VecZnxDftAllocBytes
+        + SvpPPolAllocBytes
+        + VmpApplyTmpBytes
+        + VecZnxBigNormalizeTmpBytes
+        + VecZnxDftToVecZnxBigTmpBytes
+        + VecZnxDftToVecZnxBig<B>
+        + VecZnxDftAdd<B>
+        + VecZnxDftAddInplace<B>
+        + VecZnxDftFromVecZnx<B>
+        + VecZnxDftZero<B>
+        + SvpApply<B>
+        + VecZnxDftSubABInplace<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxRotate
+        + VecZnxAddInplace
+        + VecZnxSubABInplace
+        + VecZnxNormalize<B>
+        + VecZnxNormalizeInplace<B>
+        + VecZnxCopy
+        + VecZnxMulXpMinusOneInplace
+        + SvpPrepare<B>
+        + SvpPPolAlloc<B>
+        + SvpApplyInplace<B>
+        + VecZnxDftToVecZnxBigConsume<B>
+        + VecZnxBigAddInplace<B>
+        + VecZnxBigNormalize<B>
+        + VecZnxNormalizeTmpBytes
        + VecZnxFillUniform
        + VecZnxAddNormal
        + VecZnxAddScalarInplace
@@ -36,7 +63,9 @@ where
        + VecZnxSwithcDegree
        + VecZnxSub
        + VmpPMatAlloc<B>
-        + VmpPMatPrepare<B>,
+        + VmpPrepare<B>
+        + VmpApply<B>
+        + VmpApplyAdd<B>,
    B: VecZnxDftAllocBytesImpl<B>
        + VecZnxBigAllocBytesImpl<B>
        + ScratchOwnedAllocImpl<B>
@@ -57,7 +86,9 @@ where
    let k_res: usize = 2 * basek;
    let rank: usize = 1;

-    let message_modulus: usize = 1 << 4;
+    let log_message_modulus = 4;
+
+    let message_modulus: usize = 1 << log_message_modulus;

    let mut source_xs: Source = Source::new([2u8; 32]);
    let mut source_xe: Source = Source::new([2u8; 32]);
@@ -103,10 +134,9 @@ where

    let mut pt_lwe: LWEPlaintext<Vec<u8>> = LWEPlaintext::alloc(basek, k_lwe);

-    let x: i64 = 2;
-    let bits: usize = 8;
+    let x: i64 = 15 % (message_modulus as i64);

-    pt_lwe.encode_i64(x, bits);
+    pt_lwe.encode_i64(x, log_message_modulus + 1);

    lwe.encrypt_sk(
        module,
@@ -117,13 +147,16 @@ where
        3.2,
    );

-    let mut f: Vec<i64> = vec![0i64; message_modulus];
-    f.iter_mut()
+    let f = |x: i64| -> i64 { 2 * x + 1 };
+
+    let mut f_vec: Vec<i64> = vec![0i64; message_modulus];
+    f_vec
+        .iter_mut()
        .enumerate()
-        .for_each(|(i, x)| *x = 2 * (i as i64) + 1);
+        .for_each(|(i, x)| *x = f(i as i64));

    let mut lut: LookUpTable = LookUpTable::alloc(n, basek, k_lut, extension_factor);
-    lut.set(module, &f, message_modulus);
+    lut.set(module, &f_vec, log_message_modulus + 1);

    let mut res: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_res, rank);

@@ -157,4 +190,12 @@ where
    // First limb should be exactly equal (test are parameterized such that the noise does not reach
    // the first limb)
    assert_eq!(pt_have.data.at(0, 0), lut.data[0].at(0, 0));
+
+    // Verify that it effectively compute f(x)
+    let mut have: i64 = pt_have.decode_coeff_i64(log_message_modulus + 1, 0);
+
+    // Get positive representative and assert equality
+    have = (have + message_modulus as i64) % (message_modulus as i64);
+
+    assert_eq!(have, f(x) % (message_modulus as i64));
 }
--- a/schemes/src/tfhe/circuit_bootstrapping/circuit_bootstrapping.rs
+++ b/schemes/src/tfhe/circuit_bootstrapping/circuit_bootstrapping.rs
@@ -1,50 +1,58 @@
-use std::{collections::HashMap, time::Instant, usize};
+use std::{collections::HashMap, usize};

 use backend::hal::{
    api::{
        ScratchAvailable, TakeMatZnx, TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft, TakeVecZnxDftSlice, TakeVecZnxSlice,
-        VecZnxAddInplace, VecZnxAutomorphismInplace, VecZnxBigAutomorphismInplace, VecZnxBigSubSmallBInplace, VecZnxCopy,
-        VecZnxDftCopy, VecZnxDftToVecZnxBigTmpA, VecZnxNegateInplace, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes,
-        VecZnxRotateInplace, VecZnxRshInplace, VecZnxSub, VecZnxSubABInplace, VecZnxSwithcDegree,
+        VecZnxAddInplace, VecZnxAutomorphismInplace, VecZnxBigAddSmallInplace, VecZnxBigAllocBytes, VecZnxBigAutomorphismInplace,
+        VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxBigSubSmallBInplace, VecZnxCopy, VecZnxDftAddInplace,
+        VecZnxDftAllocBytes, VecZnxDftCopy, VecZnxDftFromVecZnx, VecZnxDftToVecZnxBigConsume, VecZnxDftToVecZnxBigTmpA,
+        VecZnxNegateInplace, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxRotate, VecZnxRotateInplace,
+        VecZnxRshInplace, VecZnxSub, VecZnxSubABInplace, VecZnxSwithcDegree, VmpApply, VmpApplyAdd, VmpApplyTmpBytes,
    },
    layouts::{Backend, DataMut, DataRef, Module, Scratch},
    oep::{ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl},
 };

-use core::{GLWEOperations, TakeGGLWE, TakeGLWECt, layouts::Infos, trait_families::GLWETraceModuleFamily};
+use core::{GLWEOperations, TakeGGLWE, TakeGLWECt, layouts::Infos};

 use core::layouts::{GGSWCiphertext, GLWECiphertext, LWECiphertext, prepared::GGLWEAutomorphismKeyPrepared};

 use crate::tfhe::{
    blind_rotation::{
-        BlincRotationExecute, BlindRotationAlgo, BlindRotationKeyPrepared, CCGIBlindRotationFamily, LookUpTable,
-        LookUpTableRotationDirection,
+        BlincRotationExecute, BlindRotationAlgo, BlindRotationKeyPrepared, LookUpTable, LookUpTableRotationDirection,
    },
    circuit_bootstrapping::{CircuitBootstrappingKeyPrepared, CirtuitBootstrappingExecute},
 };

-pub trait CircuitBootstrapFamily<B: Backend> = VecZnxRotateInplace
-    + VecZnxNormalizeInplace<B>
-    + VecZnxNormalizeTmpBytes
-    + CCGIBlindRotationFamily<B>
-    + VecZnxSwithcDegree
-    + VecZnxBigAutomorphismInplace<B>
-    + VecZnxRshInplace
-    + VecZnxDftCopy<B>
-    + VecZnxDftToVecZnxBigTmpA<B>
-    + VecZnxSub
-    + VecZnxAddInplace
-    + VecZnxNegateInplace
-    + VecZnxCopy
-    + VecZnxSubABInplace
-    + GLWETraceModuleFamily<B>
-    + VecZnxRotateInplace
-    + VecZnxAutomorphismInplace
-    + VecZnxBigSubSmallBInplace<B>;
-
 impl<D: DataRef, BRA: BlindRotationAlgo, B: Backend> CirtuitBootstrappingExecute<B> for CircuitBootstrappingKeyPrepared<D, BRA, B>
 where
-    Module<B>: CircuitBootstrapFamily<B>,
+    Module<B>: VecZnxRotateInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxSwithcDegree
+        + VecZnxBigAutomorphismInplace<B>
+        + VecZnxRshInplace
+        + VecZnxDftCopy<B>
+        + VecZnxDftToVecZnxBigTmpA<B>
+        + VecZnxSub
+        + VecZnxAddInplace
+        + VecZnxNegateInplace
+        + VecZnxCopy
+        + VecZnxSubABInplace
+        + VecZnxDftAllocBytes
+        + VmpApplyTmpBytes
+        + VecZnxBigNormalizeTmpBytes
+        + VmpApply<B>
+        + VmpApplyAdd<B>
+        + VecZnxDftFromVecZnx<B>
+        + VecZnxDftToVecZnxBigConsume<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigNormalize<B>
+        + VecZnxAutomorphismInplace
+        + VecZnxBigSubSmallBInplace<B>
+        + VecZnxBigAllocBytes
+        + VecZnxDftAddInplace<B>
+        + VecZnxRotate,
    B: ScratchOwnedAllocImpl<B> + ScratchOwnedBorrowImpl<B>,
    Scratch<B>: TakeVecZnx
        + TakeVecZnxDftSlice<B>
@@ -115,7 +123,33 @@ pub fn circuit_bootstrap_core<DRes, DLwe, DBrk, BRA: BlindRotationAlgo, B: Backe
    DRes: DataMut,
    DLwe: DataRef,
    DBrk: DataRef,
-    Module<B>: CircuitBootstrapFamily<B>,
+    Module<B>: VecZnxRotateInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxSwithcDegree
+        + VecZnxBigAutomorphismInplace<B>
+        + VecZnxRshInplace
+        + VecZnxDftCopy<B>
+        + VecZnxDftToVecZnxBigTmpA<B>
+        + VecZnxSub
+        + VecZnxAddInplace
+        + VecZnxNegateInplace
+        + VecZnxCopy
+        + VecZnxSubABInplace
+        + VecZnxDftAllocBytes
+        + VmpApplyTmpBytes
+        + VecZnxBigNormalizeTmpBytes
+        + VmpApply<B>
+        + VmpApplyAdd<B>
+        + VecZnxDftFromVecZnx<B>
+        + VecZnxDftToVecZnxBigConsume<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigNormalize<B>
+        + VecZnxAutomorphismInplace
+        + VecZnxBigSubSmallBInplace<B>
+        + VecZnxBigAllocBytes
+        + VecZnxDftAddInplace<B>
+        + VecZnxRotate,
    B: ScratchOwnedAllocImpl<B> + ScratchOwnedBorrowImpl<B>,
    Scratch<B>: TakeVecZnxDftSlice<B>
        + TakeVecZnxBig<B>
@@ -165,14 +199,10 @@ pub fn circuit_bootstrap_core<DRes, DLwe, DBrk, BRA: BlindRotationAlgo, B: Backe

    // TODO: separate GGSW k from output of blind rotation k
    let (mut res_glwe, scratch1) = scratch.take_glwe_ct(n, basek, k, rank);
-    let (mut tmp_gglwe, scratch2) = scratch1.take_gglwe(n, basek, k, rows, 1, rank, rank);
-
-    let now: Instant = Instant::now();
+    let (mut tmp_gglwe, scratch2) = scratch1.take_gglwe(n, basek, k, rows, 1, rank.max(1), rank);

    key.brk.execute(module, &mut res_glwe, &lwe, &lut, scratch2);

-    println!("blind_rotate: {} ms", now.elapsed().as_millis());
-
    let gap: usize = 2 * lut.drift / lut.extension_factor();

    let log_gap_in: usize = (usize::BITS - (gap * alpha - 1).leading_zeros()) as _;
@@ -181,8 +211,6 @@ pub fn circuit_bootstrap_core<DRes, DLwe, DBrk, BRA: BlindRotationAlgo, B: Backe
        let mut tmp_glwe: GLWECiphertext<&mut [u8]> = tmp_gglwe.at_mut(i, 0);

        if to_exponent {
-            let now: Instant = Instant::now();
-
            // Isolates i-th LUT and moves coefficients according to requested gap.
            post_process(
                module,
@@ -194,7 +222,6 @@ pub fn circuit_bootstrap_core<DRes, DLwe, DBrk, BRA: BlindRotationAlgo, B: Backe
                &key.atk,
                scratch2,
            );
-            println!("post_process: {} ms", now.elapsed().as_millis());
        } else {
            tmp_glwe.trace(module, 0, module.log_n(), &res_glwe, &key.atk, scratch2);
        }
@@ -220,7 +247,31 @@ fn post_process<DataRes, DataA, B: Backend>(
 ) where
    DataRes: DataMut,
    DataA: DataRef,
-    Module<B>: CircuitBootstrapFamily<B>,
+    Module<B>: VecZnxRotateInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxSwithcDegree
+        + VecZnxBigAutomorphismInplace<B>
+        + VecZnxRshInplace
+        + VecZnxDftCopy<B>
+        + VecZnxDftToVecZnxBigTmpA<B>
+        + VecZnxSub
+        + VecZnxAddInplace
+        + VecZnxNegateInplace
+        + VecZnxCopy
+        + VecZnxSubABInplace
+        + VecZnxDftAllocBytes
+        + VmpApplyTmpBytes
+        + VecZnxBigNormalizeTmpBytes
+        + VmpApply<B>
+        + VmpApplyAdd<B>
+        + VecZnxDftFromVecZnx<B>
+        + VecZnxDftToVecZnxBigConsume<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigNormalize<B>
+        + VecZnxAutomorphismInplace
+        + VecZnxBigSubSmallBInplace<B>
+        + VecZnxRotate,
    Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
 {
    let log_n: usize = module.log_n();
@@ -248,10 +299,7 @@ fn post_process<DataRes, DataA, B: Backend>(
            }
            cts.insert(i as usize * (1 << log_gap_out), res.clone());
        });
-
-        let now: Instant = Instant::now();
        pack(module, &mut cts, log_gap_out, auto_keys, scratch);
-        println!("pack: {} ms", now.elapsed().as_millis());
        let packed: GLWECiphertext<Vec<u8>> = cts.remove(&0).unwrap();
        res.trace(
            module,
@@ -271,7 +319,31 @@ pub fn pack<D: DataMut, B: Backend>(
    auto_keys: &HashMap<i64, GGLWEAutomorphismKeyPrepared<Vec<u8>, B>>,
    scratch: &mut Scratch<B>,
 ) where
-    Module<B>: CircuitBootstrapFamily<B>,
+    Module<B>: VecZnxRotateInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxSwithcDegree
+        + VecZnxBigAutomorphismInplace<B>
+        + VecZnxRshInplace
+        + VecZnxDftCopy<B>
+        + VecZnxDftToVecZnxBigTmpA<B>
+        + VecZnxSub
+        + VecZnxAddInplace
+        + VecZnxNegateInplace
+        + VecZnxCopy
+        + VecZnxSubABInplace
+        + VecZnxDftAllocBytes
+        + VmpApplyTmpBytes
+        + VecZnxBigNormalizeTmpBytes
+        + VmpApply<B>
+        + VmpApplyAdd<B>
+        + VecZnxDftFromVecZnx<B>
+        + VecZnxDftToVecZnxBigConsume<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigNormalize<B>
+        + VecZnxAutomorphismInplace
+        + VecZnxBigSubSmallBInplace<B>
+        + VecZnxRotate,
    Scratch<B>: TakeVecZnx + TakeVecZnxDft<B> + ScratchAvailable,
 {
    let log_n: usize = module.log_n();
@@ -281,8 +353,6 @@ pub fn pack<D: DataMut, B: Backend>(
    let rank: usize = cts.get(&0).unwrap().rank();

    (0..log_n - log_gap_out).for_each(|i| {
-        let now: Instant = Instant::now();
-
        let t = 16.min(1 << (log_n - 1 - i));

        let auto_key: &GGLWEAutomorphismKeyPrepared<Vec<u8>, B>;
@@ -314,8 +384,6 @@ pub fn pack<D: DataMut, B: Backend>(
                cts.insert(j, b);
            }
        });
-
-        println!("combine: {} us", now.elapsed().as_micros());
    });
 }

@@ -330,7 +398,31 @@ fn combine<A: DataMut, D: DataMut, DataAK: DataRef, B: Backend>(
    auto_key: &GGLWEAutomorphismKeyPrepared<DataAK, B>,
    scratch: &mut Scratch<B>,
 ) where
-    Module<B>: CircuitBootstrapFamily<B>,
+    Module<B>: VecZnxRotateInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxSwithcDegree
+        + VecZnxBigAutomorphismInplace<B>
+        + VecZnxRshInplace
+        + VecZnxDftCopy<B>
+        + VecZnxDftToVecZnxBigTmpA<B>
+        + VecZnxSub
+        + VecZnxAddInplace
+        + VecZnxNegateInplace
+        + VecZnxCopy
+        + VecZnxSubABInplace
+        + VecZnxDftAllocBytes
+        + VmpApplyTmpBytes
+        + VecZnxBigNormalizeTmpBytes
+        + VmpApply<B>
+        + VmpApplyAdd<B>
+        + VecZnxDftFromVecZnx<B>
+        + VecZnxDftToVecZnxBigConsume<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigNormalize<B>
+        + VecZnxAutomorphismInplace
+        + VecZnxBigSubSmallBInplace<B>
+        + VecZnxRotate,
    Scratch<B>: TakeVecZnx + TakeVecZnxDft<B> + ScratchAvailable,
 {
    // Goal is to evaluate: a = a + b*X^t + phi(a - b*X^t))
--- a/schemes/src/tfhe/circuit_bootstrapping/key.rs
+++ b/schemes/src/tfhe/circuit_bootstrapping/key.rs
@@ -6,17 +6,16 @@ use std::{collections::HashMap, usize};

 use backend::hal::{
    api::{
-        ScratchAvailable, TakeScalarZnx, TakeSvpPPol, TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft, VecZnxAddScalarInplace,
-        VecZnxAutomorphism, VecZnxSwithcDegree, VmpPMatAlloc, VmpPMatPrepare,
+        ScratchAvailable, SvpApply, SvpApplyInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeSvpPPol,
+        TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism,
+        VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftFromVecZnx, VecZnxDftToVecZnxBigConsume, VecZnxDftToVecZnxBigTmpA,
+        VecZnxFillUniform, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubABInplace,
+        VecZnxSwithcDegree, VmpPMatAlloc, VmpPrepare,
    },
    layouts::{Backend, Data, DataRef, Module, Scratch},
 };
 use sampling::source::Source;

-use core::trait_families::{
-    GGLWEAutomorphismKeyEncryptSkFamily, GGLWETensorKeyEncryptSkFamily, GGSWEncryptSkFamily, GLWESecretPreparedModuleFamily,
-};
-
 use crate::tfhe::blind_rotation::{
    BlindRotationAlgo, BlindRotationKey, BlindRotationKeyAlloc, BlindRotationKeyEncryptSk, BlindRotationKeyPrepared,
 };
@@ -52,13 +51,27 @@ pub struct CircuitBootstrappingKey<D: Data, BRA: BlindRotationAlgo> {
 impl<BRA: BlindRotationAlgo, B: Backend> CircuitBootstrappingKeyEncryptSk<B> for CircuitBootstrappingKey<Vec<u8>, BRA>
 where
    BlindRotationKey<Vec<u8>, BRA>: BlindRotationKeyAlloc + BlindRotationKeyEncryptSk<B>,
-    Module<B>: GGSWEncryptSkFamily<B>
-        + GLWESecretPreparedModuleFamily<B>
+    Module<B>: SvpApply<B>
+        + VecZnxDftToVecZnxBigTmpA<B>
        + VecZnxAddScalarInplace
-        + GGLWEAutomorphismKeyEncryptSkFamily<B>
-        + VecZnxAutomorphism
+        + VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftFromVecZnx<B>
+        + SvpApplyInplace<B>
+        + VecZnxDftToVecZnxBigConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<B>
+        + VecZnxAddNormal
+        + VecZnxNormalize<B>
+        + VecZnxSub
+        + SvpPrepare<B>
        + VecZnxSwithcDegree
-        + GGLWETensorKeyEncryptSkFamily<B>,
+        + SvpPPolAllocBytes
+        + SvpPPolAlloc<B>
+        + VecZnxAutomorphism,
    Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx + TakeScalarZnx + TakeSvpPPol<B> + TakeVecZnxBig<B>,
 {
    fn encrypt_sk<DLwe, DGlwe>(
@@ -80,6 +93,7 @@ where
    where
        DLwe: DataRef,
        DGlwe: DataRef,
+        Module<B>:,
    {
        let mut auto_keys: HashMap<i64, GGLWEAutomorphismKey<Vec<u8>>> = HashMap::new();
        let gal_els: Vec<i64> = GLWECiphertext::trace_galois_elements(&module);
@@ -133,7 +147,7 @@ pub struct CircuitBootstrappingKeyPrepared<D: Data, BRA: BlindRotationAlgo, B: B
 impl<D: DataRef, BRA: BlindRotationAlgo, B: Backend> PrepareAlloc<B, CircuitBootstrappingKeyPrepared<Vec<u8>, BRA, B>>
    for CircuitBootstrappingKey<D, BRA>
 where
-    Module<B>: VmpPMatAlloc<B> + VmpPMatPrepare<B>,
+    Module<B>: VmpPMatAlloc<B> + VmpPrepare<B>,
    BlindRotationKey<D, BRA>: PrepareAlloc<B, BlindRotationKeyPrepared<Vec<u8>, BRA, B>>,
    GGLWETensorKey<D>: PrepareAlloc<B, GGLWETensorKeyPrepared<Vec<u8>, B>>,
    GGLWEAutomorphismKey<D>: PrepareAlloc<B, GGLWEAutomorphismKeyPrepared<Vec<u8>, B>>,
--- a/schemes/src/tfhe/circuit_bootstrapping/tests/circuit_bootstrapping.rs
+++ b/schemes/src/tfhe/circuit_bootstrapping/tests/circuit_bootstrapping.rs
@@ -2,9 +2,14 @@ use std::time::Instant;

 use backend::hal::{
    api::{
-        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpPPolAlloc, SvpPrepare, VecZnxAddNormal, VecZnxAddScalarInplace,
-        VecZnxAutomorphism, VecZnxFillUniform, VecZnxNormalizeInplace, VecZnxRotateInplace, VecZnxSwithcDegree, VmpPMatAlloc,
-        VmpPMatPrepare, ZnxView, ZnxViewMut,
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApply, SvpApplyInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism, VecZnxAutomorphismInplace,
+        VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAlloc, VecZnxBigAllocBytes, VecZnxBigAutomorphismInplace,
+        VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxBigSubSmallBInplace, VecZnxCopy, VecZnxDftAddInplace,
+        VecZnxDftAlloc, VecZnxDftAllocBytes, VecZnxDftCopy, VecZnxDftFromVecZnx, VecZnxDftToVecZnxBigConsume,
+        VecZnxDftToVecZnxBigTmpA, VecZnxFillUniform, VecZnxNegateInplace, VecZnxNormalize, VecZnxNormalizeInplace,
+        VecZnxNormalizeTmpBytes, VecZnxRotate, VecZnxRotateInplace, VecZnxRshInplace, VecZnxSub, VecZnxSubABInplace,
+        VecZnxSwithcDegree, VmpApply, VmpApplyAdd, VmpApplyTmpBytes, VmpPMatAlloc, VmpPrepare, ZnxView, ZnxViewMut,
    },
    layouts::{Backend, Module, ScalarZnx, ScratchOwned},
    oep::{
@@ -20,18 +25,11 @@ use crate::tfhe::{
        BlindRotationKeyPrepared,
    },
    circuit_bootstrapping::{
-        CircuitBootstrapFamily, CircuitBootstrappingKey, CircuitBootstrappingKeyEncryptSk, CircuitBootstrappingKeyPrepared,
-        CirtuitBootstrappingExecute,
+        CircuitBootstrappingKey, CircuitBootstrappingKeyEncryptSk, CircuitBootstrappingKeyPrepared, CirtuitBootstrappingExecute,
    },
 };

-use core::{
-    layouts::prepared::PrepareAlloc,
-    trait_families::{
-        GGLWEAutomorphismKeyEncryptSkFamily, GGLWETensorKeyEncryptSkFamily, GGSWAssertNoiseFamily, GGSWEncryptSkFamily,
-        GLWEDecryptFamily,
-    },
-};
+use core::layouts::prepared::PrepareAlloc;

 use core::layouts::{
    GGSWCiphertext, GLWECiphertext, GLWEPlaintext, GLWESecret, LWECiphertext, LWEPlaintext, LWESecret,
@@ -43,19 +41,46 @@ where
    Module<B>: VecZnxFillUniform
        + VecZnxAddNormal
        + VecZnxNormalizeInplace<B>
-        + GGSWEncryptSkFamily<B>
+        + VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftFromVecZnx<B>
+        + SvpApplyInplace<B>
+        + VecZnxDftToVecZnxBigConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalize<B>
+        + VecZnxSub
        + VecZnxAddScalarInplace
-        + GGLWEAutomorphismKeyEncryptSkFamily<B>
        + VecZnxAutomorphism
        + VecZnxSwithcDegree
-        + GGLWETensorKeyEncryptSkFamily<B>
-        + CircuitBootstrapFamily<B>
-        + GLWEDecryptFamily<B>
-        + GGSWAssertNoiseFamily<B>
+        + VecZnxBigAllocBytes
+        + VecZnxDftToVecZnxBigTmpA<B>
+        + SvpApply<B>
+        + VecZnxBigAddInplace<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigAlloc<B>
+        + VecZnxDftAlloc<B>
+        + VecZnxBigNormalizeTmpBytes
        + VmpPMatAlloc<B>
-        + VmpPMatPrepare<B>
+        + VmpPrepare<B>
        + SvpPrepare<B>
-        + SvpPPolAlloc<B>,
+        + SvpPPolAlloc<B>
+        + VmpApplyTmpBytes
+        + VmpApply<B>
+        + VmpApplyAdd<B>
+        + SvpPPolAllocBytes
+        + VecZnxRotateInplace
+        + VecZnxBigAutomorphismInplace<B>
+        + VecZnxRshInplace
+        + VecZnxDftCopy<B>
+        + VecZnxNegateInplace
+        + VecZnxCopy
+        + VecZnxAutomorphismInplace
+        + VecZnxBigSubSmallBInplace<B>
+        + VecZnxBigAllocBytes
+        + VecZnxDftAddInplace<B>
+        + VecZnxRotate,
    B: ScratchOwnedAllocImpl<B>
        + ScratchOwnedBorrowImpl<B>
        + TakeVecZnxDftImpl<B>
@@ -108,7 +133,7 @@ where
    let data: i64 = 1;

    let mut pt_lwe: LWEPlaintext<Vec<u8>> = LWEPlaintext::alloc(basek, k_lwe_pt);
-    pt_lwe.encode_i64(data, k_lwe_pt + 2);
+    pt_lwe.encode_i64(data, k_lwe_pt + 1);

    println!("pt_lwe: {}", pt_lwe);

@@ -203,19 +228,46 @@ where
    Module<B>: VecZnxFillUniform
        + VecZnxAddNormal
        + VecZnxNormalizeInplace<B>
-        + GGSWEncryptSkFamily<B>
+        + VecZnxDftAllocBytes
+        + VecZnxBigNormalize<B>
+        + VecZnxDftFromVecZnx<B>
+        + SvpApplyInplace<B>
+        + VecZnxDftToVecZnxBigConsume<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxSubABInplace
+        + VecZnxAddInplace
+        + VecZnxNormalize<B>
+        + VecZnxSub
        + VecZnxAddScalarInplace
-        + GGLWEAutomorphismKeyEncryptSkFamily<B>
        + VecZnxAutomorphism
        + VecZnxSwithcDegree
-        + GGLWETensorKeyEncryptSkFamily<B>
-        + CircuitBootstrapFamily<B>
-        + GLWEDecryptFamily<B>
-        + GGSWAssertNoiseFamily<B>
+        + VecZnxBigAllocBytes
+        + VecZnxDftToVecZnxBigTmpA<B>
+        + SvpApply<B>
+        + VecZnxBigAddInplace<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigAlloc<B>
+        + VecZnxDftAlloc<B>
+        + VecZnxBigNormalizeTmpBytes
        + VmpPMatAlloc<B>
-        + VmpPMatPrepare<B>
+        + VmpPrepare<B>
        + SvpPrepare<B>
-        + SvpPPolAlloc<B>,
+        + SvpPPolAlloc<B>
+        + VmpApplyTmpBytes
+        + VmpApply<B>
+        + VmpApplyAdd<B>
+        + SvpPPolAllocBytes
+        + VecZnxRotateInplace
+        + VecZnxBigAutomorphismInplace<B>
+        + VecZnxRshInplace
+        + VecZnxDftCopy<B>
+        + VecZnxNegateInplace
+        + VecZnxCopy
+        + VecZnxAutomorphismInplace
+        + VecZnxBigSubSmallBInplace<B>
+        + VecZnxBigAllocBytes
+        + VecZnxDftAddInplace<B>
+        + VecZnxRotate,
    B: ScratchOwnedAllocImpl<B>
        + ScratchOwnedBorrowImpl<B>
        + TakeVecZnxDftImpl<B>
@@ -268,7 +320,7 @@ where
    let data: i64 = 1;

    let mut pt_lwe: LWEPlaintext<Vec<u8>> = LWEPlaintext::alloc(basek, k_lwe_pt);
-    pt_lwe.encode_i64(data, k_lwe_pt + 2);
+    pt_lwe.encode_i64(data, k_lwe_pt + 1);

    println!("pt_lwe: {}", pt_lwe);