Add BDD Arithmetic (#98)

* Added some circuit, evaluation + some layouts

* Refactor + memory reduction

* Rows -> Dnum, Digits -> Dsize

* fix #96 + glwe_packing (indirectly CBT)

* clippy

poulpy-schemes/src/tfhe/bdd_arithmetic/ciphertexts/block.rs

@@ -0,0 +1,215 @@
+use std::marker::PhantomData;
+
+use poulpy_core::layouts::{Base2K, GLWECiphertext, GLWEInfos, GLWEPlaintextLayout, LWEInfos, Rank, TorusPrecision};
+
+use poulpy_core::{TakeGLWEPt, layouts::prepared::GLWESecretPrepared};
+use poulpy_hal::api::VecZnxBigAllocBytes;
+#[cfg(test)]
+use poulpy_hal::api::{
+    ScratchAvailable, TakeVecZnx, VecZnxAddInplace, VecZnxAddNormal, VecZnxFillUniform, VecZnxNormalize, VecZnxSub,
+};
+#[cfg(test)]
+use poulpy_hal::source::Source;
+use poulpy_hal::{
+    api::{
+        TakeVecZnxBig, TakeVecZnxDft, VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigNormalize, VecZnxDftAllocBytes,
+        VecZnxDftApply, VecZnxIdftApplyConsume, VecZnxNormalizeTmpBytes,
+    },
+    layouts::{Backend, Data, DataMut, DataRef, Module, Scratch},
+};
+
+use poulpy_hal::api::{SvpApplyDftToDftInplace, VecZnxNormalizeInplace, VecZnxSubInplace};
+
+use crate::tfhe::bdd_arithmetic::{FromBits, ToBits, UnsignedInteger};
+
+/// An FHE ciphertext encrypting the bits of an [UnsignedInteger].
+pub struct FheUintBlocks<D: Data, T: UnsignedInteger> {
+    pub(crate) blocks: Vec<GLWECiphertext<D>>,
+    pub(crate) _base: u8,
+    pub(crate) _phantom: PhantomData<T>,
+}
+
+impl<D: DataRef, T: UnsignedInteger> LWEInfos for FheUintBlocks<D, T> {
+    fn base2k(&self) -> poulpy_core::layouts::Base2K {
+        self.blocks[0].base2k()
+    }
+
+    fn k(&self) -> poulpy_core::layouts::TorusPrecision {
+        self.blocks[0].k()
+    }
+
+    fn n(&self) -> poulpy_core::layouts::Degree {
+        self.blocks[0].n()
+    }
+}
+
+impl<D: DataRef, T: UnsignedInteger> GLWEInfos for FheUintBlocks<D, T> {
+    fn rank(&self) -> poulpy_core::layouts::Rank {
+        self.blocks[0].rank()
+    }
+}
+
+impl<T: UnsignedInteger> FheUintBlocks<Vec<u8>, T> {
+    #[allow(dead_code)]
+    pub(crate) fn alloc<A, BE: Backend>(module: &Module<BE>, infos: &A) -> Self
+    where
+        A: GLWEInfos,
+    {
+        Self::alloc_with(module, infos.base2k(), infos.k(), infos.rank())
+    }
+
+    #[allow(dead_code)]
+    pub(crate) fn alloc_with<BE: Backend>(module: &Module<BE>, base2k: Base2K, k: TorusPrecision, rank: Rank) -> Self {
+        Self {
+            blocks: (0..T::WORD_SIZE)
+                .map(|_| GLWECiphertext::alloc_with(module.n().into(), base2k, k, rank))
+                .collect(),
+            _base: 1,
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<D: DataMut, T: UnsignedInteger + ToBits> FheUintBlocks<D, T> {
+    #[allow(dead_code)]
+    #[cfg(test)]
+    pub(crate) fn encrypt_sk<S, BE: Backend>(
+        &mut self,
+        module: &Module<BE>,
+        value: T,
+        sk: &GLWESecretPrepared<S, BE>,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        S: DataRef,
+        Module<BE>: VecZnxDftAllocBytes
+            + VecZnxBigNormalize<BE>
+            + VecZnxDftApply<BE>
+            + SvpApplyDftToDftInplace<BE>
+            + VecZnxIdftApplyConsume<BE>
+            + VecZnxNormalizeTmpBytes
+            + VecZnxFillUniform
+            + VecZnxSubInplace
+            + VecZnxAddInplace
+            + VecZnxNormalizeInplace<BE>
+            + VecZnxAddNormal
+            + VecZnxNormalize<BE>
+            + VecZnxSub,
+        Scratch<BE>: TakeVecZnxDft<BE> + ScratchAvailable + TakeVecZnx + TakeGLWEPt<BE>,
+    {
+        use poulpy_core::layouts::GLWEPlaintextLayout;
+
+        #[cfg(debug_assertions)]
+        {
+            assert!(module.n().is_multiple_of(T::WORD_SIZE));
+            assert_eq!(self.n(), module.n() as u32);
+            assert_eq!(sk.n(), module.n() as u32);
+        }
+
+        let pt_infos = GLWEPlaintextLayout {
+            n: self.n(),
+            base2k: self.base2k(),
+            k: 1_usize.into(),
+        };
+
+        let (mut pt, scratch_1) = scratch.take_glwe_pt(&pt_infos);
+
+        for i in 0..T::WORD_SIZE {
+            pt.encode_coeff_i64(value.bit(i) as i64, TorusPrecision(1), 0);
+            self.blocks[i].encrypt_sk(&module, &pt, sk, source_xa, source_xe, scratch_1);
+        }
+    }
+}
+
+impl<D: DataRef, T: UnsignedInteger + FromBits + ToBits> FheUintBlocks<D, T> {
+    pub fn decrypt<S: DataRef, BE: Backend>(
+        &self,
+        module: &Module<BE>,
+        sk: &GLWESecretPrepared<S, BE>,
+        scratch: &mut Scratch<BE>,
+    ) -> T
+    where
+        Module<BE>: VecZnxDftApply<BE>
+            + SvpApplyDftToDftInplace<BE>
+            + VecZnxIdftApplyConsume<BE>
+            + VecZnxBigAddInplace<BE>
+            + VecZnxBigAddSmallInplace<BE>
+            + VecZnxBigNormalize<BE>,
+        Scratch<BE>: TakeVecZnxDft<BE> + TakeVecZnxBig<BE> + TakeGLWEPt<BE>,
+    {
+        #[cfg(debug_assertions)]
+        {
+            assert!(module.n().is_multiple_of(T::WORD_SIZE));
+            assert_eq!(self.n(), module.n() as u32);
+            assert_eq!(sk.n(), module.n() as u32);
+        }
+
+        let pt_infos = GLWEPlaintextLayout {
+            n: self.n(),
+            base2k: self.base2k(),
+            k: self.k(),
+        };
+
+        let (mut pt, scratch_1) = scratch.take_glwe_pt(&pt_infos);
+
+        let mut bits: Vec<u8> = vec![0u8; T::WORD_SIZE];
+
+        let base2k: usize = self.base2k().into();
+        let scale: f64 = 4.0 / ((1 << base2k) as f64);
+
+        for (i, bit) in bits.iter_mut().enumerate().take(T::WORD_SIZE) {
+            self.blocks[i].decrypt(module, &mut pt, sk, scratch_1);
+            let value: i64 = pt.decode_coeff_i64(base2k.into(), 0);
+            *bit = ((value as f64) * scale).round() as u8;
+        }
+
+        T::from_bits(&bits)
+    }
+
+    pub fn noise<S: DataRef, BE: Backend>(
+        &self,
+        module: &Module<BE>,
+        sk: &GLWESecretPrepared<S, BE>,
+        want: T,
+        scratch: &mut Scratch<BE>,
+    ) -> Vec<f64>
+    where
+        Module<BE>: VecZnxDftAllocBytes
+            + VecZnxBigAllocBytes
+            + VecZnxDftApply<BE>
+            + SvpApplyDftToDftInplace<BE>
+            + VecZnxIdftApplyConsume<BE>
+            + VecZnxBigAddInplace<BE>
+            + VecZnxBigAddSmallInplace<BE>
+            + VecZnxBigNormalize<BE>
+            + VecZnxNormalizeTmpBytes
+            + VecZnxSubInplace
+            + VecZnxNormalizeInplace<BE>,
+        Scratch<BE>: TakeGLWEPt<BE> + TakeVecZnxDft<BE> + TakeVecZnxBig<BE>,
+    {
+        #[cfg(debug_assertions)]
+        {
+            assert!(module.n().is_multiple_of(T::WORD_SIZE));
+            assert_eq!(self.n(), module.n() as u32);
+            assert_eq!(sk.n(), module.n() as u32);
+        }
+
+        let pt_infos = GLWEPlaintextLayout {
+            n: self.n(),
+            base2k: self.base2k(),
+            k: 1_usize.into(),
+        };
+
+        let (mut pt_want, scratch_1) = scratch.take_glwe_pt(&pt_infos);
+
+        let mut noise: Vec<f64> = vec![0f64; T::WORD_SIZE];
+
+        for (i, noise_i) in noise.iter_mut().enumerate().take(T::WORD_SIZE) {
+            pt_want.encode_coeff_i64(want.bit(i) as i64, TorusPrecision(2), 0);
+            *noise_i = self.blocks[i].noise(module, sk, &pt_want, scratch_1);
+        }
+
+        noise
+    }
+}

poulpy-schemes/src/tfhe/bdd_arithmetic/ciphertexts/block_prepared.rs

@@ -0,0 +1,282 @@
+use std::marker::PhantomData;
+
+use poulpy_core::layouts::{
+    Base2K, Dnum, Dsize, GGSWInfos, GLWEInfos, LWEInfos, Rank, TorusPrecision, prepared::GGSWCiphertextPrepared,
+};
+#[cfg(test)]
+use poulpy_core::{
+    TakeGGSW,
+    layouts::{GGSWCiphertext, prepared::GLWESecretPrepared},
+};
+use poulpy_hal::{
+    api::VmpPMatAlloc,
+    layouts::{Backend, Data, DataMut, DataRef, Module, Scratch},
+};
+#[cfg(test)]
+use poulpy_hal::{
+    api::{
+        ScratchAvailable, SvpApplyDftToDftInplace, TakeScalarZnx, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal,
+        VecZnxAddScalarInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAlloc, VecZnxBigAllocBytes,
+        VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxDftAlloc, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform,
+        VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub,
+        VecZnxSubInplace, VmpPrepare,
+    },
+    oep::{ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeVecZnxBigImpl, TakeVecZnxDftImpl},
+    source::Source,
+};
+
+use crate::tfhe::bdd_arithmetic::{FheUintBlocks, FheUintPrepare, ToBits, UnsignedInteger};
+
+#[cfg(test)]
+pub(crate) struct FheUintBlocksPrepDebug<D: Data, T: UnsignedInteger> {
+    pub(crate) blocks: Vec<GGSWCiphertext<D>>,
+    pub(crate) _base: u8,
+    pub(crate) _phantom: PhantomData<T>,
+}
+
+#[cfg(test)]
+impl<T: UnsignedInteger> FheUintBlocksPrepDebug<Vec<u8>, T> {
+    #[allow(dead_code)]
+    pub(crate) fn alloc<A, BE: Backend>(module: &Module<BE>, infos: &A) -> Self
+    where
+        A: GGSWInfos,
+    {
+        Self::alloc_with(
+            module,
+            infos.base2k(),
+            infos.k(),
+            infos.dnum(),
+            infos.dsize(),
+            infos.rank(),
+        )
+    }
+
+    #[allow(dead_code)]
+    pub(crate) fn alloc_with<BE: Backend>(
+        module: &Module<BE>,
+        base2k: Base2K,
+        k: TorusPrecision,
+        dnum: Dnum,
+        dsize: Dsize,
+        rank: Rank,
+    ) -> Self {
+        Self {
+            blocks: (0..T::WORD_SIZE)
+                .map(|_| GGSWCiphertext::alloc_with(module.n().into(), base2k, k, rank, dnum, dsize))
+                .collect(),
+            _base: 1,
+            _phantom: PhantomData,
+        }
+    }
+}
+
+/// A prepared FHE ciphertext encrypting the bits of an [UnsignedInteger].
+pub struct FheUintBlocksPrep<D: Data, B: Backend, T: UnsignedInteger> {
+    pub(crate) blocks: Vec<GGSWCiphertextPrepared<D, B>>,
+    pub(crate) _base: u8,
+    pub(crate) _phantom: PhantomData<T>,
+}
+
+impl<T: UnsignedInteger, BE: Backend> FheUintBlocksPrep<Vec<u8>, BE, T>
+where
+    Module<BE>: VmpPMatAlloc<BE>,
+{
+    #[allow(dead_code)]
+    pub(crate) fn alloc<A>(module: &Module<BE>, infos: &A) -> Self
+    where
+        A: GGSWInfos,
+    {
+        Self::alloc_with(
+            module,
+            infos.base2k(),
+            infos.k(),
+            infos.dnum(),
+            infos.dsize(),
+            infos.rank(),
+        )
+    }
+
+    #[allow(dead_code)]
+    pub(crate) fn alloc_with(module: &Module<BE>, base2k: Base2K, k: TorusPrecision, dnum: Dnum, dsize: Dsize, rank: Rank) -> Self
+    where
+        Module<BE>: VmpPMatAlloc<BE>,
+    {
+        Self {
+            blocks: (0..T::WORD_SIZE)
+                .map(|_| GGSWCiphertextPrepared::alloc_with(module, base2k, k, dnum, dsize, rank))
+                .collect(),
+            _base: 1,
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<D: DataMut, T: UnsignedInteger + ToBits, BE: Backend> FheUintBlocksPrep<D, BE, T> {
+    #[allow(dead_code)]
+    #[cfg(test)]
+    pub(crate) fn encrypt_sk<S>(
+        &mut self,
+        module: &Module<BE>,
+        value: T,
+        sk: &GLWESecretPrepared<S, BE>,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        S: DataRef,
+        Module<BE>: VecZnxAddScalarInplace
+            + VecZnxDftAllocBytes
+            + VecZnxBigNormalize<BE>
+            + VecZnxDftApply<BE>
+            + SvpApplyDftToDftInplace<BE>
+            + VecZnxIdftApplyConsume<BE>
+            + VecZnxNormalizeTmpBytes
+            + VecZnxFillUniform
+            + VecZnxSubInplace
+            + VecZnxAddInplace
+            + VecZnxNormalizeInplace<BE>
+            + VecZnxAddNormal
+            + VecZnxNormalize<BE>
+            + VecZnxSub
+            + VmpPrepare<BE>,
+        Scratch<BE>: TakeVecZnxDft<BE> + ScratchAvailable + TakeVecZnx + TakeGGSW + TakeScalarZnx,
+    {
+        #[cfg(debug_assertions)]
+        {
+            assert!(module.n().is_multiple_of(T::WORD_SIZE));
+            assert_eq!(self.n(), module.n() as u32);
+            assert_eq!(sk.n(), module.n() as u32);
+        }
+
+        let (mut tmp_ggsw, scratch_1) = scratch.take_ggsw(self);
+        let (mut pt, scratch_2) = scratch_1.take_scalar_znx(module.n(), 1);
+
+        for i in 0..T::WORD_SIZE {
+            use poulpy_core::layouts::prepared::Prepare;
+            use poulpy_hal::layouts::ZnxViewMut;
+
+            pt.at_mut(0, 0)[0] = value.bit(i) as i64;
+            tmp_ggsw.encrypt_sk(&module, &pt, sk, source_xa, source_xe, scratch_2);
+            self.blocks[i].prepare(module, &tmp_ggsw, scratch_2);
+        }
+    }
+
+    /// Prepares [FheUintBits] to [FheUintBitsPrep].
+    pub fn prepare<BIT, KEY>(&mut self, module: &Module<BE>, bits: &FheUintBlocks<BIT, T>, key: &KEY, scratch: &mut Scratch<BE>)
+    where
+        BIT: DataRef,
+        KEY: FheUintPrepare<BE, FheUintBlocksPrep<D, BE, T>, FheUintBlocks<BIT, T>>,
+    {
+        key.prepare(module, self, bits, scratch);
+    }
+}
+
+#[cfg(test)]
+impl<D: DataMut, T: UnsignedInteger + ToBits> FheUintBlocksPrepDebug<D, T> {
+    pub(crate) fn prepare<BIT, KEY, BE: Backend>(
+        &mut self,
+        module: &Module<BE>,
+        bits: &FheUintBlocks<BIT, T>,
+        key: &KEY,
+        scratch: &mut Scratch<BE>,
+    ) where
+        BIT: DataRef,
+        KEY: FheUintPrepare<BE, FheUintBlocksPrepDebug<D, T>, FheUintBlocks<BIT, T>>,
+    {
+        key.prepare(module, self, bits, scratch);
+    }
+}
+
+#[cfg(test)]
+impl<D: DataRef, T: UnsignedInteger + ToBits> FheUintBlocksPrepDebug<D, T> {
+    #[allow(dead_code)]
+    pub(crate) fn noise<S: DataRef, BE: Backend>(&self, module: &Module<BE>, sk: &GLWESecretPrepared<S, BE>, want: T)
+    where
+        Module<BE>: VecZnxDftAllocBytes
+            + VecZnxBigAllocBytes
+            + VecZnxDftApply<BE>
+            + SvpApplyDftToDftInplace<BE>
+            + VecZnxIdftApplyConsume<BE>
+            + VecZnxBigAddInplace<BE>
+            + VecZnxBigAddSmallInplace<BE>
+            + VecZnxBigNormalize<BE>
+            + VecZnxNormalizeTmpBytes
+            + VecZnxBigAlloc<BE>
+            + VecZnxDftAlloc<BE>
+            + VecZnxBigNormalizeTmpBytes
+            + VecZnxIdftApplyTmpA<BE>
+            + VecZnxAddScalarInplace
+            + VecZnxSubInplace,
+        BE: Backend + TakeVecZnxDftImpl<BE> + TakeVecZnxBigImpl<BE> + ScratchOwnedAllocImpl<BE> + ScratchOwnedBorrowImpl<BE>,
+    {
+        for (i, ggsw) in self.blocks.iter().enumerate() {
+            use poulpy_hal::layouts::{ScalarZnx, ZnxViewMut};
+            let mut pt_want = ScalarZnx::alloc(self.n().into(), 1);
+            pt_want.at_mut(0, 0)[0] = want.bit(i) as i64;
+            ggsw.print_noise(module, sk, &pt_want);
+        }
+    }
+}
+
+impl<D: DataRef, T: UnsignedInteger, B: Backend> LWEInfos for FheUintBlocksPrep<D, B, T> {
+    fn base2k(&self) -> poulpy_core::layouts::Base2K {
+        self.blocks[0].base2k()
+    }
+
+    fn k(&self) -> poulpy_core::layouts::TorusPrecision {
+        self.blocks[0].k()
+    }
+
+    fn n(&self) -> poulpy_core::layouts::Degree {
+        self.blocks[0].n()
+    }
+}
+
+impl<D: DataRef, T: UnsignedInteger, B: Backend> GLWEInfos for FheUintBlocksPrep<D, B, T> {
+    fn rank(&self) -> poulpy_core::layouts::Rank {
+        self.blocks[0].rank()
+    }
+}
+
+impl<D: DataRef, T: UnsignedInteger, B: Backend> GGSWInfos for FheUintBlocksPrep<D, B, T> {
+    fn dsize(&self) -> poulpy_core::layouts::Dsize {
+        self.blocks[0].dsize()
+    }
+
+    fn dnum(&self) -> poulpy_core::layouts::Dnum {
+        self.blocks[0].dnum()
+    }
+}
+
+#[cfg(test)]
+impl<D: DataRef, T: UnsignedInteger> LWEInfos for FheUintBlocksPrepDebug<D, T> {
+    fn base2k(&self) -> poulpy_core::layouts::Base2K {
+        self.blocks[0].base2k()
+    }
+
+    fn k(&self) -> poulpy_core::layouts::TorusPrecision {
+        self.blocks[0].k()
+    }
+
+    fn n(&self) -> poulpy_core::layouts::Degree {
+        self.blocks[0].n()
+    }
+}
+
+#[cfg(test)]
+impl<D: DataRef, T: UnsignedInteger> GLWEInfos for FheUintBlocksPrepDebug<D, T> {
+    fn rank(&self) -> poulpy_core::layouts::Rank {
+        self.blocks[0].rank()
+    }
+}
+
+#[cfg(test)]
+impl<D: DataRef, T: UnsignedInteger> GGSWInfos for FheUintBlocksPrepDebug<D, T> {
+    fn dsize(&self) -> poulpy_core::layouts::Dsize {
+        self.blocks[0].dsize()
+    }
+
+    fn dnum(&self) -> poulpy_core::layouts::Dnum {
+        self.blocks[0].dnum()
+    }
+}

poulpy-schemes/src/tfhe/bdd_arithmetic/ciphertexts/mod.rs

@@ -0,0 +1,7 @@
+mod block;
+mod block_prepared;
+mod word;
+
+pub use block::*;
+pub use block_prepared::*;
+pub use word::*;

poulpy-schemes/src/tfhe/bdd_arithmetic/ciphertexts/word.rs

@@ -0,0 +1,198 @@
+use itertools::Itertools;
+use poulpy_core::{
+    GLWEOperations, TakeGLWECtSlice, TakeGLWEPt, glwe_packing,
+    layouts::{
+        GLWECiphertext, GLWEInfos, GLWEPlaintextLayout, LWEInfos, TorusPrecision,
+        prepared::{GGLWEAutomorphismKeyPrepared, GLWESecretPrepared},
+    },
+};
+use poulpy_hal::{
+    api::{
+        ScratchAvailable, SvpApplyDftToDftInplace, TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal,
+        VecZnxAddScalarInplace, VecZnxAutomorphismInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
+        VecZnxBigAutomorphismInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxBigSubSmallNegateInplace, VecZnxCopy,
+        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxDftCopy, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA,
+        VecZnxNegateInplace, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxRotate, VecZnxRotateInplace,
+        VecZnxRshInplace, VecZnxSub, VecZnxSubInplace, VecZnxSwitchRing, VmpApplyDftToDft, VmpApplyDftToDftAdd,
+        VmpApplyDftToDftTmpBytes,
+    },
+    layouts::{Backend, Data, DataMut, DataRef, Module, Scratch},
+    source::Source,
+};
+use std::{collections::HashMap, marker::PhantomData};
+
+use crate::tfhe::bdd_arithmetic::{FromBits, ToBits, UnsignedInteger};
+
+/// A FHE ciphertext encrypting a [UnsignedInteger].
+pub struct FheUintWord<D: Data, T: UnsignedInteger>(pub(crate) GLWECiphertext<D>, pub(crate) PhantomData<T>);
+
+impl<D: DataMut, T: UnsignedInteger> FheUintWord<D, T> {
+    #[allow(dead_code)]
+    fn post_process<ATK, BE: Backend>(
+        &mut self,
+        module: &Module<BE>,
+        mut tmp_res: Vec<GLWECiphertext<&mut [u8]>>,
+        auto_keys: &HashMap<i64, GGLWEAutomorphismKeyPrepared<ATK, BE>>,
+        scratch: &mut Scratch<BE>,
+    ) where
+        ATK: DataRef,
+        Module<BE>: VecZnxSub
+            + VecZnxCopy
+            + VecZnxNegateInplace
+            + VecZnxDftAllocBytes
+            + VecZnxAddInplace
+            + VmpApplyDftToDftTmpBytes
+            + VecZnxNormalizeTmpBytes
+            + VecZnxDftApply<BE>
+            + VmpApplyDftToDft<BE>
+            + VmpApplyDftToDftAdd<BE>
+            + VecZnxIdftApplyConsume<BE>
+            + VecZnxBigNormalize<BE>
+            + VecZnxNormalize<BE>
+            + VecZnxRotateInplace<BE>
+            + VecZnxNormalizeInplace<BE>
+            + VecZnxSwitchRing
+            + VecZnxBigAutomorphismInplace<BE>
+            + VecZnxRshInplace<BE>
+            + VecZnxDftCopy<BE>
+            + VecZnxIdftApplyTmpA<BE>
+            + VecZnxSubInplace
+            + VecZnxBigNormalizeTmpBytes
+            + VecZnxBigAddSmallInplace<BE>
+            + VecZnxAutomorphismInplace<BE>
+            + VecZnxBigSubSmallNegateInplace<BE>
+            + VecZnxRotate,
+        Scratch<BE>: TakeVecZnxDft<BE> + ScratchAvailable + TakeVecZnx + TakeGLWECtSlice,
+    {
+        // Repacks the GLWE ciphertexts bits
+        let gap: usize = module.n() / T::WORD_SIZE;
+        let log_gap: usize = (usize::BITS - (gap - 1).leading_zeros()) as usize;
+        let mut cts: HashMap<usize, &mut GLWECiphertext<&mut [u8]>> = HashMap::new();
+        for (i, ct) in tmp_res.iter_mut().enumerate().take(T::WORD_SIZE) {
+            cts.insert(i * gap, ct);
+        }
+        glwe_packing(module, &mut cts, log_gap, auto_keys, scratch);
+
+        // And copies the repacked ciphertext on the receiver.
+        self.0.copy(module, cts.remove(&0).unwrap())
+    }
+}
+
+impl<D: DataRef, T: UnsignedInteger> LWEInfos for FheUintWord<D, T> {
+    fn base2k(&self) -> poulpy_core::layouts::Base2K {
+        self.0.base2k()
+    }
+
+    fn k(&self) -> poulpy_core::layouts::TorusPrecision {
+        self.0.k()
+    }
+
+    fn n(&self) -> poulpy_core::layouts::Degree {
+        self.0.n()
+    }
+}
+
+impl<D: DataRef, T: UnsignedInteger> GLWEInfos for FheUintWord<D, T> {
+    fn rank(&self) -> poulpy_core::layouts::Rank {
+        self.0.rank()
+    }
+}
+
+impl<D: DataMut, T: UnsignedInteger + ToBits> FheUintWord<D, T> {
+    pub fn encrypt_sk<S: DataRef, BE: Backend>(
+        &mut self,
+        module: &Module<BE>,
+        data: T,
+        sk: &GLWESecretPrepared<S, BE>,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        Module<BE>: VecZnxAddScalarInplace
+            + VecZnxDftAllocBytes
+            + VecZnxBigNormalize<BE>
+            + VecZnxDftApply<BE>
+            + SvpApplyDftToDftInplace<BE>
+            + VecZnxIdftApplyConsume<BE>
+            + VecZnxNormalizeTmpBytes
+            + VecZnxFillUniform
+            + VecZnxSubInplace
+            + VecZnxAddInplace
+            + VecZnxNormalizeInplace<BE>
+            + VecZnxAddNormal
+            + VecZnxNormalize<BE>
+            + VecZnxSub,
+        Scratch<BE>: TakeVecZnxDft<BE> + ScratchAvailable + TakeVecZnx + TakeGLWEPt<BE>,
+    {
+        #[cfg(debug_assertions)]
+        {
+            assert!(module.n().is_multiple_of(T::WORD_SIZE));
+            assert_eq!(self.n(), module.n() as u32);
+            assert_eq!(sk.n(), module.n() as u32);
+        }
+
+        let gap: usize = module.n() / T::WORD_SIZE;
+
+        let mut data_bits: Vec<i64> = vec![0i64; module.n()];
+
+        for i in 0..T::WORD_SIZE {
+            data_bits[i * gap] = data.bit(i) as i64
+        }
+
+        let pt_infos = GLWEPlaintextLayout {
+            n: self.n(),
+            base2k: self.base2k(),
+            k: 1_usize.into(),
+        };
+
+        let (mut pt, scratch_1) = scratch.take_glwe_pt(&pt_infos);
+
+        pt.encode_vec_i64(&data_bits, TorusPrecision(1));
+        self.0
+            .encrypt_sk(module, &pt, sk, source_xa, source_xe, scratch_1);
+    }
+}
+
+impl<D: DataRef, T: UnsignedInteger + FromBits> FheUintWord<D, T> {
+    pub fn decrypt<S: DataRef, BE: Backend>(
+        &self,
+        module: &Module<BE>,
+        sk: &GLWESecretPrepared<S, BE>,
+        scratch: &mut Scratch<BE>,
+    ) -> T
+    where
+        Module<BE>: VecZnxDftApply<BE>
+            + SvpApplyDftToDftInplace<BE>
+            + VecZnxIdftApplyConsume<BE>
+            + VecZnxBigAddInplace<BE>
+            + VecZnxBigAddSmallInplace<BE>
+            + VecZnxBigNormalize<BE>,
+        Scratch<BE>: TakeVecZnxDft<BE> + TakeVecZnxBig<BE> + TakeGLWEPt<BE>,
+    {
+        #[cfg(debug_assertions)]
+        {
+            assert!(module.n().is_multiple_of(T::WORD_SIZE));
+            assert_eq!(self.n(), module.n() as u32);
+            assert_eq!(sk.n(), module.n() as u32);
+        }
+
+        let gap: usize = module.n() / T::WORD_SIZE;
+
+        let pt_infos = GLWEPlaintextLayout {
+            n: self.n(),
+            base2k: self.base2k(),
+            k: 1_usize.into(),
+        };
+
+        let (mut pt, scratch_1) = scratch.take_glwe_pt(&pt_infos);
+
+        self.0.decrypt(module, &mut pt, sk, scratch_1);
+
+        let mut data: Vec<i64> = vec![0i64; module.n()];
+
+        pt.decode_vec_i64(&mut data, TorusPrecision(1));
+
+        let bits: Vec<u8> = data.iter().step_by(gap).map(|c| *c as u8).collect_vec();
+        T::from_bits(&bits)
+    }
+}