wip

poulpy-schemes/benches/circuit_bootstrapping.rs

@@ -3,16 +3,16 @@ use std::hint::black_box;
 use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
 use poulpy_backend::{FFT64Avx, FFT64Ref, FFT64Spqlios};
 use poulpy_core::layouts::{
-    Dsize, GGLWEAutomorphismKeyLayout, GGLWETensorKeyLayout, GGSWCiphertext, GGSWCiphertextLayout, GLWESecret, LWECiphertext,
-    LWECiphertextLayout, LWESecret, prepared::PrepareAlloc,
+    AutomorphismKeyLayout, Dsize, GGSW, GGSWLayout, GLWESecret, LWE, LWELayout, LWESecret, TensorKeyLayout,
+    prepared::PrepareAlloc,
 };
 use poulpy_hal::{
     api::{
         ModuleNew, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolAlloc,
-        SvpPPolAllocBytes, SvpPrepare, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism,
-        VecZnxAutomorphismInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAlloc, VecZnxBigAllocBytes,
-        VecZnxBigAutomorphismInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxBigSubSmallNegateInplace, VecZnxCopy,
-        VecZnxDftAddInplace, VecZnxDftAlloc, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxDftCopy, VecZnxFillUniform,
+        SvpPPolBytesOf, SvpPrepare, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism,
+        VecZnxAutomorphismInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAlloc, VecZnxBigAutomorphismInplace,
+        VecZnxBigBytesOf, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxBigSubSmallNegateInplace, VecZnxCopy,
+        VecZnxDftAddInplace, VecZnxDftAlloc, VecZnxDftApply, VecZnxDftBytesOf, VecZnxDftCopy, VecZnxFillUniform,
         VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA, VecZnxNegateInplace, VecZnxNormalize, VecZnxNormalizeInplace,
         VecZnxNormalizeTmpBytes, VecZnxRotate, VecZnxRotateInplace, VecZnxRotateInplaceTmpBytes, VecZnxRshInplace, VecZnxSub,
         VecZnxSubInplace, VecZnxSwitchRing, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes, VmpPMatAlloc,
@@ -42,7 +42,7 @@ where
         + VecZnxFillUniform
         + VecZnxAddNormal
         + VecZnxNormalizeInplace<B>
-        + VecZnxDftAllocBytes
+        + VecZnxDftBytesOf
         + VecZnxBigNormalize<B>
         + VecZnxDftApply<B>
         + SvpApplyDftToDftInplace<B>
@@ -55,7 +55,7 @@ where
         + VecZnxAddScalarInplace
         + VecZnxAutomorphism
         + VecZnxSwitchRing
-        + VecZnxBigAllocBytes
+        + VecZnxBigBytesOf
         + VecZnxIdftApplyTmpA<B>
         + SvpApplyDftToDft<B>
         + VecZnxBigAddInplace<B>
@@ -70,7 +70,7 @@ where
         + VmpApplyDftToDftTmpBytes
         + VmpApplyDftToDft<B>
         + VmpApplyDftToDftAdd<B>
-        + SvpPPolAllocBytes
+        + SvpPPolBytesOf
         + VecZnxRotateInplace<B>
         + VecZnxBigAutomorphismInplace<B>
         + VecZnxRshInplace<B>
@@ -80,7 +80,7 @@ where
         + VecZnxAutomorphismInplace<B>
         + VecZnxBigSubSmallNegateInplace<B>
         + VecZnxRotateInplaceTmpBytes
-        + VecZnxBigAllocBytes
+        + VecZnxBigBytesOf
         + VecZnxDftAddInplace<B>
         + VecZnxRotate
         + ZnFillUniform
@@ -113,8 +113,8 @@ where
         extension_factor: usize,
         k_pt: usize,
         block_size: usize,
-        lwe_infos: LWECiphertextLayout,
-        ggsw_infos: GGSWCiphertextLayout,
+        lwe_infos: LWELayout,
+        ggsw_infos: GGSWLayout,
         cbt_infos: CircuitBootstrappingKeyLayout,
     }
 
@@ -124,7 +124,7 @@ where
             + VecZnxFillUniform
             + VecZnxAddNormal
             + VecZnxNormalizeInplace<B>
-            + VecZnxDftAllocBytes
+            + VecZnxDftBytesOf
             + VecZnxBigNormalize<B>
             + VecZnxDftApply<B>
             + SvpApplyDftToDftInplace<B>
@@ -137,7 +137,7 @@ where
             + VecZnxAddScalarInplace
             + VecZnxAutomorphism
             + VecZnxSwitchRing
-            + VecZnxBigAllocBytes
+            + VecZnxBigBytesOf
             + VecZnxIdftApplyTmpA<B>
             + SvpApplyDftToDft<B>
             + VecZnxBigAddInplace<B>
@@ -152,7 +152,7 @@ where
             + VmpApplyDftToDftTmpBytes
             + VmpApplyDftToDft<B>
             + VmpApplyDftToDftAdd<B>
-            + SvpPPolAllocBytes
+            + SvpPPolBytesOf
             + VecZnxRotateInplace<B>
             + VecZnxBigAutomorphismInplace<B>
             + VecZnxRshInplace<B>
@@ -162,7 +162,7 @@ where
             + VecZnxAutomorphismInplace<B>
             + VecZnxBigSubSmallNegateInplace<B>
             + VecZnxRotateInplaceTmpBytes
-            + VecZnxBigAllocBytes
+            + VecZnxBigBytesOf
             + VecZnxDftAddInplace<B>
             + VecZnxRotate
             + ZnFillUniform
@@ -188,8 +188,8 @@ where
         // Scratch space (4MB)
         let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(1 << 22);
 
-        let n_glwe: poulpy_core::layouts::Degree = params.cbt_infos.layout_brk.n_glwe();
-        let n_lwe: poulpy_core::layouts::Degree = params.cbt_infos.layout_brk.n_lwe();
+        let n_glwe: poulpy_core::layouts::RingDegree = params.cbt_infos.layout_brk.n_glwe();
+        let n_lwe: poulpy_core::layouts::RingDegree = params.cbt_infos.layout_brk.n_lwe();
         let rank: poulpy_core::layouts::Rank = params.cbt_infos.layout_brk.rank;
 
         let module: Module<B> = Module::<B>::new(n_glwe.as_u32() as u64);
@@ -202,10 +202,10 @@ where
         sk_lwe.fill_binary_block(params.block_size, &mut source_xs);
         sk_lwe.fill_zero();
 
-        let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc_with(n_glwe, rank);
+        let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc(n_glwe, rank);
         sk_glwe.fill_ternary_prob(0.5, &mut source_xs);
 
-        let ct_lwe: LWECiphertext<Vec<u8>> = LWECiphertext::alloc(&params.lwe_infos);
+        let ct_lwe: LWE<Vec<u8>> = LWE::alloc_from_infos(&params.lwe_infos);
 
         // Circuit bootstrapping evaluation key
         let cbt_key: CircuitBootstrappingKey<Vec<u8>, BRA> = CircuitBootstrappingKey::encrypt_sk(
@@ -218,7 +218,7 @@ where
             scratch.borrow(),
         );
 
-        let mut res: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(&params.ggsw_infos);
+        let mut res: GGSW<Vec<u8>> = GGSW::alloc_from_infos(&params.ggsw_infos);
         let cbt_prepared: CircuitBootstrappingKeyPrepared<Vec<u8>, BRA, B> = cbt_key.prepare_alloc(&module, scratch.borrow());
 
         move || {
@@ -238,13 +238,13 @@ where
         name: String::from("1-bit"),
         extension_factor: 1,
         k_pt: 1,
-        lwe_infos: LWECiphertextLayout {
+        lwe_infos: LWELayout {
             n: 574_u32.into(),
             k: 13_u32.into(),
             base2k: 13_u32.into(),
         },
         block_size: 7,
-        ggsw_infos: GGSWCiphertextLayout {
+        ggsw_infos: GGSWLayout {
             n: 1024_u32.into(),
             base2k: 13_u32.into(),
             k: 26_u32.into(),
@@ -261,7 +261,7 @@ where
                 dnum: 3_u32.into(),
                 rank: 2_u32.into(),
             },
-            layout_atk: GGLWEAutomorphismKeyLayout {
+            layout_atk: AutomorphismKeyLayout {
                 n: 1024_u32.into(),
                 base2k: 13_u32.into(),
                 k: 52_u32.into(),
@@ -269,7 +269,7 @@ where
                 dsize: Dsize(1),
                 rank: 2_u32.into(),
             },
-            layout_tsk: GGLWETensorKeyLayout {
+            layout_tsk: TensorKeyLayout {
                 n: 1024_u32.into(),
                 base2k: 13_u32.into(),
                 k: 52_u32.into(),

poulpy-schemes/examples/circuit_bootstrapping.rs

@@ -1,9 +1,9 @@
 use poulpy_core::{
     GLWEOperations,
     layouts::{
-        GGLWEAutomorphismKeyLayout, GGLWETensorKeyLayout, GGSWCiphertext, GGSWCiphertextLayout, GLWECiphertext,
-        GLWECiphertextLayout, GLWEPlaintext, GLWESecret, LWECiphertext, LWECiphertextLayout, LWEInfos, LWEPlaintext, LWESecret,
-        prepared::{GGSWCiphertextPrepared, GLWESecretPrepared, PrepareAlloc},
+        AutomorphismKeyLayout, GGSW, GGSWLayout, GLWE, GLWELayout, GLWEPlaintext, GLWESecret, LWE, LWEInfos, LWELayout,
+        LWEPlaintext, LWESecret, TensorKeyLayout,
+        prepared::{GGSWPrepared, GLWESecretPrepared, PrepareAlloc},
     },
 };
 use std::time::Instant;
@@ -89,7 +89,7 @@ fn main() {
             dnum: rows_brk.into(),
             rank: rank.into(),
         },
-        layout_atk: GGLWEAutomorphismKeyLayout {
+        layout_atk: AutomorphismKeyLayout {
             n: n_glwe.into(),
             base2k: base2k.into(),
             k: k_trace.into(),
@@ -97,7 +97,7 @@ fn main() {
             dsize: 1_u32.into(),
             rank: rank.into(),
         },
-        layout_tsk: GGLWETensorKeyLayout {
+        layout_tsk: TensorKeyLayout {
             n: n_glwe.into(),
             base2k: base2k.into(),
             k: k_tsk.into(),
@@ -107,7 +107,7 @@ fn main() {
         },
     };
 
-    let ggsw_infos: GGSWCiphertextLayout = GGSWCiphertextLayout {
+    let ggsw_infos: GGSWLayout = GGSWLayout {
         n: n_glwe.into(),
         base2k: base2k.into(),
         k: k_ggsw_res.into(),
@@ -116,7 +116,7 @@ fn main() {
         rank: rank.into(),
     };
 
-    let lwe_infos = LWECiphertextLayout {
+    let lwe_infos = LWELayout {
         n: n_lwe.into(),
         k: k_lwe_ct.into(),
         base2k: base2k.into(),
@@ -140,7 +140,7 @@ fn main() {
     sk_lwe.fill_zero();
 
     // GLWE secret
-    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc_with(n_glwe.into(), rank.into());
+    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc(n_glwe.into(), rank.into());
     sk_glwe.fill_ternary_prob(0.5, &mut source_xs);
     // sk_glwe.fill_zero();
 
@@ -151,7 +151,7 @@ fn main() {
     let data: i64 = 1 % (1 << k_lwe_pt);
 
     // LWE plaintext
-    let mut pt_lwe: LWEPlaintext<Vec<u8>> = LWEPlaintext::alloc_with(base2k.into(), k_lwe_pt.into());
+    let mut pt_lwe: LWEPlaintext<Vec<u8>> = LWEPlaintext::alloc(base2k.into(), k_lwe_pt.into());
 
     // LWE plaintext(data * 2^{- (k_lwe_pt - 1)})
     pt_lwe.encode_i64(data, (k_lwe_pt + 1).into()); // +1 for padding bit
@@ -167,7 +167,7 @@ fn main() {
     println!("pt_lwe: {pt_lwe}");
 
     // LWE ciphertext
-    let mut ct_lwe: LWECiphertext<Vec<u8>> = LWECiphertext::alloc(&lwe_infos);
+    let mut ct_lwe: LWE<Vec<u8>> = LWE::alloc_from_infos(&lwe_infos);
 
     // Encrypt LWE Plaintext
     ct_lwe.encrypt_sk(&module, &pt_lwe, &sk_lwe, &mut source_xa, &mut source_xe);
@@ -187,7 +187,7 @@ fn main() {
     println!("CBT-KGEN: {} ms", now.elapsed().as_millis());
 
     // Output GGSW
-    let mut res: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(&ggsw_infos);
+    let mut res: GGSW<Vec<u8>> = GGSW::alloc_from_infos(&ggsw_infos);
 
     // Circuit bootstrapping key prepared (opaque backend dependant write only struct)
     let cbt_prepared: CircuitBootstrappingKeyPrepared<Vec<u8>, CGGI, BackendImpl> =
@@ -214,7 +214,7 @@ fn main() {
 
     // Tests RLWE(1) * GGSW(data)
 
-    let glwe_infos: GLWECiphertextLayout = GLWECiphertextLayout {
+    let glwe_infos: GLWELayout = GLWELayout {
         n: n_glwe.into(),
         base2k: base2k.into(),
         k: (k_ggsw_res - base2k).into(),
@@ -222,11 +222,11 @@ fn main() {
     };
 
     // GLWE ciphertext modulus
-    let mut ct_glwe: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&glwe_infos);
+    let mut ct_glwe: GLWE<Vec<u8>> = GLWE::alloc_from_infos(&glwe_infos);
 
     // Some GLWE plaintext with signed data
     let k_glwe_pt: usize = 3;
-    let mut pt_glwe: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(&glwe_infos);
+    let mut pt_glwe: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc_from_infos(&glwe_infos);
     let mut data_vec: Vec<i64> = vec![0i64; n_glwe];
     data_vec
         .iter_mut()
@@ -249,13 +249,13 @@ fn main() {
     );
 
     // Prepare GGSW output of circuit bootstrapping (opaque backend dependant write only struct)
-    let res_prepared: GGSWCiphertextPrepared<Vec<u8>, BackendImpl> = res.prepare_alloc(&module, scratch.borrow());
+    let res_prepared: GGSWPrepared<Vec<u8>, BackendImpl> = res.prepare_alloc(&module, scratch.borrow());
 
     // Apply GLWE x GGSW
     ct_glwe.external_product_inplace(&module, &res_prepared, scratch.borrow());
 
     // Decrypt
-    let mut pt_res: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(&glwe_infos);
+    let mut pt_res: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc_from_infos(&glwe_infos);
     ct_glwe.decrypt(&module, &mut pt_res, &sk_glwe_prepared, scratch.borrow());
 
     println!("pt_res: {:?}", &pt_res.data.at(0, 0)[..64]);

poulpy-schemes/src/tfhe/bdd_arithmetic/bdd_2w_to_1w.rs

@@ -1,5 +1,5 @@
 use itertools::Itertools;
-use poulpy_core::layouts::prepared::GGSWCiphertextPreparedToRef;
+use poulpy_core::layouts::prepared::GGSWPreparedToRef;
 use poulpy_hal::layouts::{Backend, DataMut, DataRef, Module, Scratch};
 
 use crate::tfhe::bdd_arithmetic::{
@@ -60,15 +60,11 @@ pub fn eval_bdd_2w_to_1w<R: DataMut, A: DataRef, B: DataRef, T: UnsignedInteger,
     }
 
     // Collects inputs into a single array
-    let inputs: Vec<&dyn GGSWCiphertextPreparedToRef<BE>> = a
+    let inputs: Vec<&dyn GGSWPreparedToRef<BE>> = a
         .blocks
         .iter()
-        .map(|x| x as &dyn GGSWCiphertextPreparedToRef<BE>)
-        .chain(
-            b.blocks
-                .iter()
-                .map(|x| x as &dyn GGSWCiphertextPreparedToRef<BE>),
-        )
+        .map(|x| x as &dyn GGSWPreparedToRef<BE>)
+        .chain(b.blocks.iter().map(|x| x as &dyn GGSWPreparedToRef<BE>))
         .collect_vec();
 
     // Evaluates out[i] = circuit[i](a, b)

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

@@ -1,9 +1,9 @@
 use std::marker::PhantomData;
 
-use poulpy_core::layouts::{Base2K, GLWECiphertext, GLWEInfos, GLWEPlaintextLayout, LWEInfos, Rank, TorusPrecision};
+use poulpy_core::layouts::{Base2K, GLWE, GLWEInfos, GLWEPlaintextLayout, LWEInfos, Rank, TorusPrecision};
 
-use poulpy_core::{TakeGLWEPt, layouts::prepared::GLWESecretPrepared};
-use poulpy_hal::api::VecZnxBigAllocBytes;
+use poulpy_core::{TakeGLWEPlaintext, layouts::prepared::GLWESecretPrepared};
+use poulpy_hal::api::VecZnxBigBytesOf;
 #[cfg(test)]
 use poulpy_hal::api::{
     ScratchAvailable, TakeVecZnx, VecZnxAddInplace, VecZnxAddNormal, VecZnxFillUniform, VecZnxNormalize, VecZnxSub,
@@ -12,8 +12,8 @@ use poulpy_hal::api::{
 use poulpy_hal::source::Source;
 use poulpy_hal::{
     api::{
-        TakeVecZnxBig, TakeVecZnxDft, VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigNormalize, VecZnxDftAllocBytes,
-        VecZnxDftApply, VecZnxIdftApplyConsume, VecZnxNormalizeTmpBytes,
+        TakeVecZnxBig, TakeVecZnxDft, VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigNormalize, VecZnxDftApply,
+        VecZnxDftBytesOf, VecZnxIdftApplyConsume, VecZnxNormalizeTmpBytes,
     },
     layouts::{Backend, Data, DataMut, DataRef, Module, Scratch},
 };
@@ -24,7 +24,7 @@ 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) blocks: Vec<GLWE<D>>,
     pub(crate) _base: u8,
     pub(crate) _phantom: PhantomData<T>,
 }
@@ -38,7 +38,7 @@ impl<D: DataRef, T: UnsignedInteger> LWEInfos for FheUintBlocks<D, T> {
         self.blocks[0].k()
     }
 
-    fn n(&self) -> poulpy_core::layouts::Degree {
+    fn n(&self) -> poulpy_core::layouts::RingDegree {
         self.blocks[0].n()
     }
 }
@@ -62,7 +62,7 @@ impl<T: UnsignedInteger> FheUintBlocks<Vec<u8>, T> {
     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))
+                .map(|_| GLWE::alloc(module.n().into(), base2k, k, rank))
                 .collect(),
             _base: 1,
             _phantom: PhantomData,
@@ -83,7 +83,7 @@ impl<D: DataMut, T: UnsignedInteger + ToBits> FheUintBlocks<D, T> {
         scratch: &mut Scratch<BE>,
     ) where
         S: DataRef,
-        Module<BE>: VecZnxDftAllocBytes
+        Module<BE>: VecZnxDftBytesOf
             + VecZnxBigNormalize<BE>
             + VecZnxDftApply<BE>
             + SvpApplyDftToDftInplace<BE>
@@ -96,7 +96,7 @@ impl<D: DataMut, T: UnsignedInteger + ToBits> FheUintBlocks<D, T> {
             + VecZnxAddNormal
             + VecZnxNormalize<BE>
             + VecZnxSub,
-        Scratch<BE>: TakeVecZnxDft<BE> + ScratchAvailable + TakeVecZnx + TakeGLWEPt<BE>,
+        Scratch<BE>: TakeVecZnxDft<BE> + ScratchAvailable + TakeVecZnx + TakeGLWEPlaintext<BE>,
     {
         use poulpy_core::layouts::GLWEPlaintextLayout;
 
@@ -136,7 +136,7 @@ impl<D: DataRef, T: UnsignedInteger + FromBits + ToBits> FheUintBlocks<D, T> {
             + VecZnxBigAddInplace<BE>
             + VecZnxBigAddSmallInplace<BE>
             + VecZnxBigNormalize<BE>,
-        Scratch<BE>: TakeVecZnxDft<BE> + TakeVecZnxBig<BE> + TakeGLWEPt<BE>,
+        Scratch<BE>: TakeVecZnxDft<BE> + TakeVecZnxBig<BE> + TakeGLWEPlaintext<BE>,
     {
         #[cfg(debug_assertions)]
         {
@@ -175,8 +175,8 @@ impl<D: DataRef, T: UnsignedInteger + FromBits + ToBits> FheUintBlocks<D, T> {
         scratch: &mut Scratch<BE>,
     ) -> Vec<f64>
     where
-        Module<BE>: VecZnxDftAllocBytes
-            + VecZnxBigAllocBytes
+        Module<BE>: VecZnxDftBytesOf
+            + VecZnxBigBytesOf
             + VecZnxDftApply<BE>
             + SvpApplyDftToDftInplace<BE>
             + VecZnxIdftApplyConsume<BE>
@@ -186,7 +186,7 @@ impl<D: DataRef, T: UnsignedInteger + FromBits + ToBits> FheUintBlocks<D, T> {
             + VecZnxNormalizeTmpBytes
             + VecZnxSubInplace
             + VecZnxNormalizeInplace<BE>,
-        Scratch<BE>: TakeGLWEPt<BE> + TakeVecZnxDft<BE> + TakeVecZnxBig<BE>,
+        Scratch<BE>: TakeGLWEPlaintext<BE> + TakeVecZnxDft<BE> + TakeVecZnxBig<BE>,
     {
         #[cfg(debug_assertions)]
         {

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

@@ -1,12 +1,10 @@
 use std::marker::PhantomData;
 
-use poulpy_core::layouts::{
-    Base2K, Dnum, Dsize, GGSWInfos, GLWEInfos, LWEInfos, Rank, TorusPrecision, prepared::GGSWCiphertextPrepared,
-};
+use poulpy_core::layouts::{Base2K, Dnum, Dsize, GGSWInfos, GLWEInfos, LWEInfos, Rank, TorusPrecision, prepared::GGSWPrepared};
 #[cfg(test)]
 use poulpy_core::{
     TakeGGSW,
-    layouts::{GGSWCiphertext, prepared::GLWESecretPrepared},
+    layouts::{GGSW, prepared::GLWESecretPrepared},
 };
 use poulpy_hal::{
     api::VmpPMatAlloc,
@@ -16,8 +14,8 @@ use poulpy_hal::{
 use poulpy_hal::{
     api::{
         ScratchAvailable, SvpApplyDftToDftInplace, TakeScalarZnx, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal,
-        VecZnxAddScalarInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAlloc, VecZnxBigAllocBytes,
-        VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxDftAlloc, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform,
+        VecZnxAddScalarInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAlloc, VecZnxBigBytesOf,
+        VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxDftAlloc, VecZnxDftApply, VecZnxDftBytesOf, VecZnxFillUniform,
         VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub,
         VecZnxSubInplace, VmpPrepare,
     },
@@ -29,7 +27,7 @@ use crate::tfhe::bdd_arithmetic::{FheUintBlocks, FheUintPrepare, ToBits, Unsigne
 
 #[cfg(test)]
 pub(crate) struct FheUintBlocksPrepDebug<D: Data, T: UnsignedInteger> {
-    pub(crate) blocks: Vec<GGSWCiphertext<D>>,
+    pub(crate) blocks: Vec<GGSW<D>>,
     pub(crate) _base: u8,
     pub(crate) _phantom: PhantomData<T>,
 }
@@ -62,7 +60,7 @@ impl<T: UnsignedInteger> FheUintBlocksPrepDebug<Vec<u8>, T> {
     ) -> Self {
         Self {
             blocks: (0..T::WORD_SIZE)
-                .map(|_| GGSWCiphertext::alloc_with(module.n().into(), base2k, k, rank, dnum, dsize))
+                .map(|_| GGSW::alloc(module.n().into(), base2k, k, rank, dnum, dsize))
                 .collect(),
             _base: 1,
             _phantom: PhantomData,
@@ -72,7 +70,7 @@ impl<T: UnsignedInteger> FheUintBlocksPrepDebug<Vec<u8>, T> {
 
 /// 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) blocks: Vec<GGSWPrepared<D, B>>,
     pub(crate) _base: u8,
     pub(crate) _phantom: PhantomData<T>,
 }
@@ -103,7 +101,7 @@ where
     {
         Self {
             blocks: (0..T::WORD_SIZE)
-                .map(|_| GGSWCiphertextPrepared::alloc_with(module, base2k, k, dnum, dsize, rank))
+                .map(|_| GGSWPrepared::alloc(module, base2k, k, dnum, dsize, rank))
                 .collect(),
             _base: 1,
             _phantom: PhantomData,
@@ -125,7 +123,7 @@ impl<D: DataMut, T: UnsignedInteger + ToBits, BE: Backend> FheUintBlocksPrep<D,
     ) where
         S: DataRef,
         Module<BE>: VecZnxAddScalarInplace
-            + VecZnxDftAllocBytes
+            + VecZnxDftBytesOf
             + VecZnxBigNormalize<BE>
             + VecZnxDftApply<BE>
             + SvpApplyDftToDftInplace<BE>
@@ -192,8 +190,8 @@ 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
+        Module<BE>: VecZnxDftBytesOf
+            + VecZnxBigBytesOf
             + VecZnxDftApply<BE>
             + SvpApplyDftToDftInplace<BE>
             + VecZnxIdftApplyConsume<BE>
@@ -227,7 +225,7 @@ impl<D: DataRef, T: UnsignedInteger, B: Backend> LWEInfos for FheUintBlocksPrep<
         self.blocks[0].k()
     }
 
-    fn n(&self) -> poulpy_core::layouts::Degree {
+    fn n(&self) -> poulpy_core::layouts::RingDegree {
         self.blocks[0].n()
     }
 }
@@ -258,7 +256,7 @@ impl<D: DataRef, T: UnsignedInteger> LWEInfos for FheUintBlocksPrepDebug<D, T> {
         self.blocks[0].k()
     }
 
-    fn n(&self) -> poulpy_core::layouts::Degree {
+    fn n(&self) -> poulpy_core::layouts::RingDegree {
         self.blocks[0].n()
     }
 }

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

@@ -1,9 +1,9 @@
 use itertools::Itertools;
 use poulpy_core::{
-    GLWEOperations, TakeGLWECtSlice, TakeGLWEPt, glwe_packing,
+    GLWEOperations, TakeGLWEPlaintext, TakeGLWESlice, glwe_packing,
     layouts::{
-        GLWECiphertext, GLWEInfos, GLWEPlaintextLayout, LWEInfos, TorusPrecision,
-        prepared::{GGLWEAutomorphismKeyPrepared, GLWESecretPrepared},
+        GLWE, GLWEInfos, GLWEPlaintextLayout, LWEInfos, TorusPrecision,
+        prepared::{AutomorphismKeyPrepared, GLWESecretPrepared},
     },
 };
 use poulpy_hal::{
@@ -11,7 +11,7 @@ use poulpy_hal::{
         ScratchAvailable, SvpApplyDftToDftInplace, TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal,
         VecZnxAddScalarInplace, VecZnxAutomorphismInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
         VecZnxBigAutomorphismInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxBigSubSmallNegateInplace, VecZnxCopy,
-        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxDftCopy, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA,
+        VecZnxDftApply, VecZnxDftBytesOf, VecZnxDftCopy, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA,
         VecZnxNegateInplace, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxRotate, VecZnxRotateInplace,
         VecZnxRshInplace, VecZnxSub, VecZnxSubInplace, VecZnxSwitchRing, VmpApplyDftToDft, VmpApplyDftToDftAdd,
         VmpApplyDftToDftTmpBytes,
@@ -24,22 +24,22 @@ 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>);
+pub struct FheUintWord<D: Data, T: UnsignedInteger>(pub(crate) GLWE<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>>,
+        mut tmp_res: Vec<GLWE<&mut [u8]>>,
+        auto_keys: &HashMap<i64, AutomorphismKeyPrepared<ATK, BE>>,
         scratch: &mut Scratch<BE>,
     ) where
         ATK: DataRef,
         Module<BE>: VecZnxSub
             + VecZnxCopy
             + VecZnxNegateInplace
-            + VecZnxDftAllocBytes
+            + VecZnxDftBytesOf
             + VecZnxAddInplace
             + VmpApplyDftToDftTmpBytes
             + VecZnxNormalizeTmpBytes
@@ -62,12 +62,12 @@ impl<D: DataMut, T: UnsignedInteger> FheUintWord<D, T> {
             + VecZnxAutomorphismInplace<BE>
             + VecZnxBigSubSmallNegateInplace<BE>
             + VecZnxRotate,
-        Scratch<BE>: TakeVecZnxDft<BE> + ScratchAvailable + TakeVecZnx + TakeGLWECtSlice,
+        Scratch<BE>: TakeVecZnxDft<BE> + ScratchAvailable + TakeVecZnx + TakeGLWESlice,
     {
         // 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();
+        let mut cts: HashMap<usize, &mut GLWE<&mut [u8]>> = HashMap::new();
         for (i, ct) in tmp_res.iter_mut().enumerate().take(T::WORD_SIZE) {
             cts.insert(i * gap, ct);
         }
@@ -87,7 +87,7 @@ impl<D: DataRef, T: UnsignedInteger> LWEInfos for FheUintWord<D, T> {
         self.0.k()
     }
 
-    fn n(&self) -> poulpy_core::layouts::Degree {
+    fn n(&self) -> poulpy_core::layouts::RingDegree {
         self.0.n()
     }
 }
@@ -109,7 +109,7 @@ impl<D: DataMut, T: UnsignedInteger + ToBits> FheUintWord<D, T> {
         scratch: &mut Scratch<BE>,
     ) where
         Module<BE>: VecZnxAddScalarInplace
-            + VecZnxDftAllocBytes
+            + VecZnxDftBytesOf
             + VecZnxBigNormalize<BE>
             + VecZnxDftApply<BE>
             + SvpApplyDftToDftInplace<BE>
@@ -122,7 +122,7 @@ impl<D: DataMut, T: UnsignedInteger + ToBits> FheUintWord<D, T> {
             + VecZnxAddNormal
             + VecZnxNormalize<BE>
             + VecZnxSub,
-        Scratch<BE>: TakeVecZnxDft<BE> + ScratchAvailable + TakeVecZnx + TakeGLWEPt<BE>,
+        Scratch<BE>: TakeVecZnxDft<BE> + ScratchAvailable + TakeVecZnx + TakeGLWEPlaintext<BE>,
     {
         #[cfg(debug_assertions)]
         {
@@ -167,7 +167,7 @@ impl<D: DataRef, T: UnsignedInteger + FromBits> FheUintWord<D, T> {
             + VecZnxBigAddInplace<BE>
             + VecZnxBigAddSmallInplace<BE>
             + VecZnxBigNormalize<BE>,
-        Scratch<BE>: TakeVecZnxDft<BE> + TakeVecZnxBig<BE> + TakeGLWEPt<BE>,
+        Scratch<BE>: TakeVecZnxDft<BE> + TakeVecZnxBig<BE> + TakeGLWEPlaintext<BE>,
     {
         #[cfg(debug_assertions)]
         {

poulpy-schemes/src/tfhe/bdd_arithmetic/eval.rs

@@ -1,9 +1,9 @@
 use itertools::Itertools;
 use poulpy_core::{
-    GLWEExternalProductInplace, GLWEOperations, TakeGLWECtSlice,
+    GLWEExternalProductInplace, GLWEOperations, TakeGLWESlice,
     layouts::{
-        GLWECiphertext, GLWECiphertextToMut, LWEInfos,
-        prepared::{GGSWCiphertextPrepared, GGSWCiphertextPreparedToRef},
+        GLWE, GLWEToMut, LWEInfos,
+        prepared::{GGSWPrepared, GGSWPreparedToRef},
     },
 };
 use poulpy_hal::{
@@ -38,8 +38,8 @@ where
     fn execute<O>(
         &self,
         module: &Module<BE>,
-        out: &mut [GLWECiphertext<O>],
-        inputs: &[&dyn GGSWCiphertextPreparedToRef<BE>],
+        out: &mut [GLWE<O>],
+        inputs: &[&dyn GGSWPreparedToRef<BE>],
         scratch: &mut Scratch<BE>,
     ) where
         O: DataMut;
@@ -49,13 +49,13 @@ impl<C: BitCircuitInfo, const N: usize, T: UnsignedInteger, BE: Backend> Circuit
 where
     Self: GetBitCircuitInfo<T>,
     Module<BE>: Cmux<BE> + VecZnxCopy,
-    Scratch<BE>: TakeGLWECtSlice,
+    Scratch<BE>: TakeGLWESlice,
 {
     fn execute<O>(
         &self,
         module: &Module<BE>,
-        out: &mut [GLWECiphertext<O>],
-        inputs: &[&dyn GGSWCiphertextPreparedToRef<BE>],
+        out: &mut [GLWE<O>],
+        inputs: &[&dyn GGSWPreparedToRef<BE>],
         scratch: &mut Scratch<BE>,
     ) where
         O: DataMut,
@@ -159,14 +159,8 @@ impl Node {
 }
 
 pub trait Cmux<BE: Backend> {
-    fn cmux<O, T, F, S>(
-        &self,
-        out: &mut GLWECiphertext<O>,
-        t: &GLWECiphertext<T>,
-        f: &GLWECiphertext<F>,
-        s: &GGSWCiphertextPrepared<S, BE>,
-        scratch: &mut Scratch<BE>,
-    ) where
+    fn cmux<O, T, F, S>(&self, out: &mut GLWE<O>, t: &GLWE<T>, f: &GLWE<F>, s: &GGSWPrepared<S, BE>, scratch: &mut Scratch<BE>)
+    where
         O: DataMut,
         T: DataRef,
         F: DataRef,
@@ -177,14 +171,8 @@ impl<BE: Backend> Cmux<BE> for Module<BE>
 where
     Module<BE>: GLWEExternalProductInplace<BE> + VecZnxSub + VecZnxCopy + VecZnxNegateInplace + VecZnxAddInplace,
 {
-    fn cmux<O, T, F, S>(
-        &self,
-        out: &mut GLWECiphertext<O>,
-        t: &GLWECiphertext<T>,
-        f: &GLWECiphertext<F>,
-        s: &GGSWCiphertextPrepared<S, BE>,
-        scratch: &mut Scratch<BE>,
-    ) where
+    fn cmux<O, T, F, S>(&self, out: &mut GLWE<O>, t: &GLWE<T>, f: &GLWE<F>, s: &GGSWPrepared<S, BE>, scratch: &mut Scratch<BE>)
+    where
         O: DataMut,
         T: DataRef,
         F: DataRef,

poulpy-schemes/src/tfhe/bdd_arithmetic/key.rs

@@ -9,18 +9,18 @@ use crate::tfhe::{
     },
 };
 use poulpy_core::{
-    TakeGGSW, TakeGLWECt,
+    TakeGGSW, TakeGLWE,
     layouts::{
-        GLWESecret, GLWEToLWEKey, GLWEToLWEKeyLayout, LWECiphertext, LWESecret,
+        GLWESecret, GLWEToLWEKeyLayout, GLWEToLWESwitchingKey, LWE, LWESecret,
         prepared::{GLWEToLWESwitchingKeyPrepared, Prepare, PrepareAlloc},
     },
 };
 use poulpy_hal::{
     api::{
-        ScratchAvailable, SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx,
+        ScratchAvailable, SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolBytesOf, SvpPrepare, TakeScalarZnx,
         TakeSvpPPol, TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace,
         VecZnxAutomorphism, VecZnxAutomorphismInplace, VecZnxBigAddSmallInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
-        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA, VecZnxNormalize,
+        VecZnxDftApply, VecZnxDftBytesOf, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA, VecZnxNormalize,
         VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxRotate, VecZnxSub, VecZnxSubInplace, VecZnxSwitchRing,
         VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes, VmpPrepare,
     },
@@ -56,7 +56,7 @@ where
     BRA: BlindRotationAlgo,
 {
     cbt: CircuitBootstrappingKey<CBT, BRA>,
-    ks: GLWEToLWEKey<LWE>,
+    ks: GLWEToLWESwitchingKey<LWE>,
 }
 
 impl<BRA: BlindRotationAlgo> BDDKey<Vec<u8>, Vec<u8>, BRA> {
@@ -77,7 +77,7 @@ impl<BRA: BlindRotationAlgo> BDDKey<Vec<u8>, Vec<u8>, BRA> {
         Module<BE>: SvpApplyDftToDft<BE>
             + VecZnxIdftApplyTmpA<BE>
             + VecZnxAddScalarInplace
-            + VecZnxDftAllocBytes
+            + VecZnxDftBytesOf
             + VecZnxBigNormalize<BE>
             + VecZnxDftApply<BE>
             + SvpApplyDftToDftInplace<BE>
@@ -92,13 +92,13 @@ impl<BRA: BlindRotationAlgo> BDDKey<Vec<u8>, Vec<u8>, BRA> {
             + VecZnxSub
             + SvpPrepare<BE>
             + VecZnxSwitchRing
-            + SvpPPolAllocBytes
+            + SvpPPolBytesOf
             + SvpPPolAlloc<BE>
             + VecZnxAutomorphism
             + VecZnxAutomorphismInplace<BE>,
         Scratch<BE>: TakeVecZnxDft<BE> + ScratchAvailable + TakeVecZnx + TakeScalarZnx + TakeSvpPPol<BE> + TakeVecZnxBig<BE>,
     {
-        let mut ks: GLWEToLWEKey<Vec<u8>> = GLWEToLWEKey::alloc(&infos.ks_infos());
+        let mut ks: GLWEToLWESwitchingKey<Vec<u8>> = GLWEToLWESwitchingKey::alloc(&infos.ks_infos());
         ks.encrypt_sk(module, sk_lwe, sk_glwe, source_xa, source_xe, scratch);
 
         Self {
@@ -131,7 +131,7 @@ impl<CBT: DataMut, LWE: DataMut, BRA: BlindRotationAlgo, BE: Backend> PrepareAll
     for BDDKey<CBT, LWE, BRA>
 where
     CircuitBootstrappingKey<CBT, BRA>: PrepareAlloc<BE, CircuitBootstrappingKeyPrepared<CBT, BRA, BE>>,
-    GLWEToLWEKey<LWE>: PrepareAlloc<BE, GLWEToLWESwitchingKeyPrepared<LWE, BE>>,
+    GLWEToLWESwitchingKey<LWE>: PrepareAlloc<BE, GLWEToLWESwitchingKeyPrepared<LWE, BE>>,
 {
     fn prepare_alloc(&self, module: &Module<BE>, scratch: &mut Scratch<BE>) -> BDDKeyPrepared<CBT, LWE, BRA, BE> {
         BDDKeyPrepared {
@@ -157,7 +157,7 @@ where
     BE: Backend,
     Module<BE>: VmpPrepare<BE>
         + VecZnxRotate
-        + VecZnxDftAllocBytes
+        + VecZnxDftBytesOf
         + VmpApplyDftToDftTmpBytes
         + VecZnxBigNormalizeTmpBytes
         + VmpApplyDftToDft<BE>
@@ -168,7 +168,7 @@ where
         + VecZnxBigNormalize<BE>
         + VecZnxNormalize<BE>
         + VecZnxNormalizeTmpBytes,
-    Scratch<BE>: ScratchAvailable + TakeVecZnxDft<BE> + TakeGLWECt + TakeVecZnx + TakeGGSW,
+    Scratch<BE>: ScratchAvailable + TakeVecZnxDft<BE> + TakeGLWE + TakeVecZnx + TakeGGSW,
     CircuitBootstrappingKeyPrepared<CBT, BRA, BE>: CirtuitBootstrappingExecute<BE>,
 {
     fn prepare(
@@ -182,7 +182,7 @@ where
         {
             assert_eq!(out.blocks.len(), bits.blocks.len());
         }
-        let mut lwe: LWECiphertext<Vec<u8>> = LWECiphertext::alloc(&bits.blocks[0]); //TODO: add TakeLWE
+        let mut lwe: LWE<Vec<u8>> = LWE::alloc(&bits.blocks[0]); //TODO: add TakeLWE
         let (mut tmp_ggsw, scratch_1) = scratch.take_ggsw(out);
         for (dst, src) in out.blocks.iter_mut().zip(bits.blocks.iter()) {
             lwe.from_glwe(module, src, &self.ks, scratch_1);
@@ -206,7 +206,7 @@ where
     BE: Backend,
     Module<BE>: VmpPrepare<BE>
         + VecZnxRotate
-        + VecZnxDftAllocBytes
+        + VecZnxDftBytesOf
         + VmpApplyDftToDftTmpBytes
         + VecZnxBigNormalizeTmpBytes
         + VmpApplyDftToDft<BE>
@@ -217,7 +217,7 @@ where
         + VecZnxBigNormalize<BE>
         + VecZnxNormalize<BE>
         + VecZnxNormalizeTmpBytes,
-    Scratch<BE>: ScratchAvailable + TakeVecZnxDft<BE> + TakeGLWECt + TakeVecZnx + TakeGGSW,
+    Scratch<BE>: ScratchAvailable + TakeVecZnxDft<BE> + TakeGLWE + TakeVecZnx + TakeGGSW,
     CircuitBootstrappingKeyPrepared<CBT, BRA, BE>: CirtuitBootstrappingExecute<BE>,
 {
     fn prepare(
@@ -231,7 +231,7 @@ where
         {
             assert_eq!(out.blocks.len(), bits.blocks.len());
         }
-        let mut lwe: LWECiphertext<Vec<u8>> = LWECiphertext::alloc(&bits.blocks[0]); //TODO: add TakeLWE
+        let mut lwe: LWE<Vec<u8>> = LWE::alloc(&bits.blocks[0]); //TODO: add TakeLWE
         for (dst, src) in out.blocks.iter_mut().zip(bits.blocks.iter()) {
             lwe.from_glwe(module, src, &self.ks, scratch);
             self.cbt

poulpy-schemes/src/tfhe/bdd_arithmetic/parameters.rs

@@ -1,7 +1,7 @@
 #[cfg(test)]
 use poulpy_core::layouts::{
-    Base2K, Degree, Dnum, Dsize, GGLWEAutomorphismKeyLayout, GGLWETensorKeyLayout, GGSWCiphertextLayout, GLWECiphertextLayout,
-    GLWEToLWEKeyLayout, Rank, TorusPrecision,
+    AutomorphismKeyLayout, Base2K, Dnum, Dsize, GGSWLayout, GLWELayout, GLWEToLWEKeyLayout, Rank, RingDegree, TensorKeyLayout,
+    TorusPrecision,
 };
 
 #[cfg(test)]
@@ -25,16 +25,16 @@ pub(crate) const TEST_BLOCK_SIZE: u32 = 7;
 pub(crate) const TEST_RANK: u32 = 2;
 
 #[cfg(test)]
-pub(crate) static TEST_GLWE_INFOS: GLWECiphertextLayout = GLWECiphertextLayout {
-    n: Degree(TEST_N_GLWE),
+pub(crate) static TEST_GLWE_INFOS: GLWELayout = GLWELayout {
+    n: RingDegree(TEST_N_GLWE),
     base2k: Base2K(TEST_BASE2K),
     k: TorusPrecision(TEST_K_GLWE),
     rank: Rank(TEST_RANK),
 };
 
 #[cfg(test)]
-pub(crate) static TEST_GGSW_INFOS: GGSWCiphertextLayout = GGSWCiphertextLayout {
-    n: Degree(TEST_N_GLWE),
+pub(crate) static TEST_GGSW_INFOS: GGSWLayout = GGSWLayout {
+    n: RingDegree(TEST_N_GLWE),
     base2k: Base2K(TEST_BASE2K),
     k: TorusPrecision(TEST_K_GGSW),
     rank: Rank(TEST_RANK),
@@ -46,23 +46,23 @@ pub(crate) static TEST_GGSW_INFOS: GGSWCiphertextLayout = GGSWCiphertextLayout {
 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),
+            n_glwe: RingDegree(TEST_N_GLWE),
+            n_lwe: RingDegree(TEST_N_LWE),
             base2k: Base2K(TEST_BASE2K),
             k: TorusPrecision(52),
             dnum: Dnum(3),
             rank: Rank(TEST_RANK),
         },
-        layout_atk: GGLWEAutomorphismKeyLayout {
-            n: Degree(TEST_N_GLWE),
+        layout_atk: AutomorphismKeyLayout {
+            n: RingDegree(TEST_N_GLWE),
             base2k: Base2K(TEST_BASE2K),
             k: TorusPrecision(52),
             rank: Rank(TEST_RANK),
             dnum: Dnum(3),
             dsize: Dsize(1),
         },
-        layout_tsk: GGLWETensorKeyLayout {
-            n: Degree(TEST_N_GLWE),
+        layout_tsk: TensorKeyLayout {
+            n: RingDegree(TEST_N_GLWE),
             base2k: Base2K(TEST_BASE2K),
             k: TorusPrecision(52),
             rank: Rank(TEST_RANK),
@@ -71,7 +71,7 @@ pub(crate) static TEST_BDD_KEY_LAYOUT: BDDKeyLayout = BDDKeyLayout {
         },
     },
     ks: GLWEToLWEKeyLayout {
-        n: Degree(TEST_N_GLWE),
+        n: RingDegree(TEST_N_GLWE),
         base2k: Base2K(TEST_BASE2K),
         k: TorusPrecision(39),
         rank_in: Rank(TEST_RANK),

poulpy-schemes/src/tfhe/bdd_arithmetic/test.rs

@@ -2,20 +2,20 @@ use std::time::Instant;
 
 use poulpy_backend::FFT64Ref;
 use poulpy_core::{
-    TakeGGSW, TakeGLWEPt,
+    TakeGGSW, TakeGLWEPlaintext,
     layouts::{
-        GGSWCiphertextLayout, GLWECiphertextLayout, GLWESecret, LWEInfos, LWESecret,
+        GGSWLayout, GLWELayout, GLWESecret, LWEInfos, LWESecret,
         prepared::{GLWESecretPrepared, PrepareAlloc},
     },
 };
 use poulpy_hal::{
     api::{
         ModuleNew, ScratchAvailable, ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDft, SvpApplyDftToDftInplace,
-        SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeSlice, TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft,
+        SvpPPolAlloc, SvpPPolBytesOf, SvpPrepare, TakeScalarZnx, TakeSlice, TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft,
         VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism, VecZnxAutomorphismInplace,
-        VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAlloc, VecZnxBigAllocBytes, VecZnxBigAutomorphismInplace,
+        VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAlloc, VecZnxBigAutomorphismInplace, VecZnxBigBytesOf,
         VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxBigSubSmallNegateInplace, VecZnxCopy, VecZnxDftAddInplace,
-        VecZnxDftAlloc, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxDftCopy, VecZnxFillUniform, VecZnxIdftApplyConsume,
+        VecZnxDftAlloc, VecZnxDftApply, VecZnxDftBytesOf, VecZnxDftCopy, VecZnxFillUniform, VecZnxIdftApplyConsume,
         VecZnxIdftApplyTmpA, VecZnxNegateInplace, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxRotate,
         VecZnxRotateInplace, VecZnxRotateInplaceTmpBytes, VecZnxRshInplace, VecZnxSub, VecZnxSubInplace, VecZnxSwitchRing,
         VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPrepare, ZnAddNormal, ZnFillUniform,
@@ -51,7 +51,7 @@ where
     Module<BE>: ModuleNew<BE> + SvpPPolAlloc<BE> + SvpPrepare<BE> + VmpPMatAlloc<BE>,
     ScratchOwned<BE>: ScratchOwnedAlloc<BE> + ScratchOwnedBorrow<BE>,
     Module<BE>: VecZnxAddScalarInplace
-        + VecZnxDftAllocBytes
+        + VecZnxDftBytesOf
         + VecZnxBigNormalize<BE>
         + VecZnxDftApply<BE>
         + SvpApplyDftToDftInplace<BE>
@@ -68,16 +68,16 @@ where
     Scratch<BE>: TakeVecZnxDft<BE> + ScratchAvailable + TakeVecZnx + TakeGGSW + TakeScalarZnx + TakeSlice,
     Module<BE>: VecZnxCopy + VecZnxNegateInplace + VmpApplyDftToDftTmpBytes + VmpApplyDftToDft<BE> + VmpApplyDftToDftAdd<BE>,
     Module<BE>: VecZnxBigAddInplace<BE> + VecZnxBigAddSmallInplace<BE> + VecZnxBigNormalize<BE>,
-    Scratch<BE>: TakeVecZnxDft<BE> + TakeVecZnxBig<BE> + TakeGLWEPt<BE>,
+    Scratch<BE>: TakeVecZnxDft<BE> + TakeVecZnxBig<BE> + TakeGLWEPlaintext<BE>,
     Module<BE>: VecZnxAutomorphism
         + VecZnxSwitchRing
-        + VecZnxBigAllocBytes
+        + VecZnxBigBytesOf
         + VecZnxIdftApplyTmpA<BE>
         + SvpApplyDftToDft<BE>
         + VecZnxBigAlloc<BE>
         + VecZnxDftAlloc<BE>
         + VecZnxBigNormalizeTmpBytes
-        + SvpPPolAllocBytes
+        + SvpPPolBytesOf
         + VecZnxRotateInplace<BE>
         + VecZnxBigAutomorphismInplace<BE>
         + VecZnxRshInplace<BE>
@@ -85,7 +85,7 @@ where
         + VecZnxAutomorphismInplace<BE>
         + VecZnxBigSubSmallNegateInplace<BE>
         + VecZnxRotateInplaceTmpBytes
-        + VecZnxBigAllocBytes
+        + VecZnxBigBytesOf
         + VecZnxDftAddInplace<BE>
         + VecZnxRotate
         + ZnFillUniform
@@ -107,8 +107,8 @@ where
     BlindRotationKeyPrepared<Vec<u8>, BRA, BE>: BlincRotationExecute<BE>,
     BlindRotationKey<Vec<u8>, BRA>: BlindRotationKeyAlloc + BlindRotationKeyEncryptSk<BE>,
 {
-    let glwe_infos: GLWECiphertextLayout = TEST_GLWE_INFOS;
-    let ggsw_infos: GGSWCiphertextLayout = TEST_GGSW_INFOS;
+    let glwe_infos: GLWELayout = TEST_GLWE_INFOS;
+    let ggsw_infos: GGSWLayout = TEST_GGSW_INFOS;
 
     let n_glwe: usize = glwe_infos.n().into();
 
@@ -120,7 +120,7 @@ where
 
     let mut scratch: ScratchOwned<BE> = ScratchOwned::alloc(1 << 22);
 
-    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc(&glwe_infos);
+    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_infos);
     sk_glwe.fill_ternary_prob(0.5, &mut source_xs);
     let sk_glwe_prep: GLWESecretPrepared<Vec<u8>, BE> = sk_glwe.prepare_alloc(&module, scratch.borrow());
 

poulpy-schemes/src/tfhe/blind_rotation/cggi_algo.rs

@@ -1,9 +1,9 @@
 use itertools::izip;
 use poulpy_hal::{
     api::{
-        ScratchAvailable, SvpApplyDftToDft, SvpPPolAllocBytes, TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft, TakeVecZnxDftSlice,
-        TakeVecZnxSlice, VecZnxAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAllocBytes, VecZnxBigNormalize,
-        VecZnxBigNormalizeTmpBytes, VecZnxCopy, VecZnxDftAdd, VecZnxDftAddInplace, VecZnxDftAllocBytes, VecZnxDftApply,
+        ScratchAvailable, SvpApplyDftToDft, SvpPPolBytesOf, TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft, TakeVecZnxDftSlice,
+        TakeVecZnxSlice, VecZnxAddInplace, VecZnxBigAddSmallInplace, VecZnxBigBytesOf, VecZnxBigNormalize,
+        VecZnxBigNormalizeTmpBytes, VecZnxCopy, VecZnxDftAdd, VecZnxDftAddInplace, VecZnxDftApply, VecZnxDftBytesOf,
         VecZnxDftSubInplace, VecZnxDftZero, VecZnxIdftApply, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpBytes,
         VecZnxMulXpMinusOneInplace, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxRotate,
         VecZnxSubInplace, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
@@ -12,8 +12,8 @@ use poulpy_hal::{
 };
 
 use poulpy_core::{
-    Distribution, GLWEOperations, TakeGLWECt,
-    layouts::{GGSWInfos, GLWECiphertext, GLWECiphertextToMut, GLWEInfos, LWECiphertext, LWECiphertextToRef, LWEInfos},
+    Distribution, GLWEOperations, TakeGLWE,
+    layouts::{GGSWInfos, GLWE, GLWEInfos, GLWEToMut, LWE, LWEInfos, LWEToRef},
 };
 
 use crate::tfhe::blind_rotation::{
@@ -21,7 +21,7 @@ use crate::tfhe::blind_rotation::{
 };
 
 #[allow(clippy::too_many_arguments)]
-pub fn cggi_blind_rotate_scratch_space<B: Backend, OUT, GGSW>(
+pub fn cggi_blind_rotate_tmp_bytes<B: Backend, OUT, GGSW>(
     module: &Module<B>,
     block_size: usize,
     extension_factor: usize,
@@ -31,10 +31,10 @@ pub fn cggi_blind_rotate_scratch_space<B: Backend, OUT, GGSW>(
 where
     OUT: GLWEInfos,
     GGSW: GGSWInfos,
-    Module<B>: VecZnxDftAllocBytes
+    Module<B>: VecZnxDftBytesOf
         + VmpApplyDftToDftTmpBytes
         + VecZnxNormalizeTmpBytes
-        + VecZnxBigAllocBytes
+        + VecZnxBigBytesOf
         + VecZnxIdftApplyTmpBytes
         + VecZnxBigNormalizeTmpBytes,
 {
@@ -43,14 +43,14 @@ where
     if block_size > 1 {
         let cols: usize = (brk_infos.rank() + 1).into();
         let dnum: usize = brk_infos.dnum().into();
-        let acc_dft: usize = module.vec_znx_dft_alloc_bytes(cols, dnum) * extension_factor;
-        let acc_big: usize = module.vec_znx_big_alloc_bytes(1, brk_size);
-        let vmp_res: usize = module.vec_znx_dft_alloc_bytes(cols, brk_size) * extension_factor;
-        let vmp_xai: usize = module.vec_znx_dft_alloc_bytes(1, brk_size);
+        let acc_dft: usize = module.bytes_of_vec_znx_dft(cols, dnum) * extension_factor;
+        let acc_big: usize = module.bytes_of_vec_znx_big(1, brk_size);
+        let vmp_res: usize = module.bytes_of_vec_znx_dft(cols, brk_size) * extension_factor;
+        let vmp_xai: usize = module.bytes_of_vec_znx_dft(1, brk_size);
         let acc_dft_add: usize = vmp_res;
         let vmp: usize = module.vmp_apply_dft_to_dft_tmp_bytes(brk_size, dnum, dnum, 2, 2, brk_size); // GGSW product: (1 x 2) x (2 x 2)
         let acc: usize = if extension_factor > 1 {
-            VecZnx::alloc_bytes(module.n(), cols, glwe_infos.size()) * extension_factor
+            VecZnx::bytes_of(module.n(), cols, glwe_infos.size()) * extension_factor
         } else {
             0
         };
@@ -61,16 +61,15 @@ where
             + vmp_xai
             + (vmp | (acc_big + (module.vec_znx_big_normalize_tmp_bytes() | module.vec_znx_idft_apply_tmp_bytes())))
     } else {
-        GLWECiphertext::alloc_bytes(glwe_infos)
-            + GLWECiphertext::external_product_inplace_scratch_space(module, glwe_infos, brk_infos)
+        GLWE::bytes_of(glwe_infos) + GLWE::external_product_inplace_tmp_bytes(module, glwe_infos, brk_infos)
     }
 }
 
 impl<D: DataRef, B: Backend> BlincRotationExecute<B> for BlindRotationKeyPrepared<D, CGGI, B>
 where
-    Module<B>: VecZnxBigAllocBytes
-        + VecZnxDftAllocBytes
-        + SvpPPolAllocBytes
+    Module<B>: VecZnxBigBytesOf
+        + VecZnxDftBytesOf
+        + SvpPPolBytesOf
         + VmpApplyDftToDftTmpBytes
         + VecZnxBigNormalizeTmpBytes
         + VecZnxIdftApplyTmpBytes
@@ -99,8 +98,8 @@ where
     fn execute<DR: DataMut, DI: DataRef>(
         &self,
         module: &Module<B>,
-        res: &mut GLWECiphertext<DR>,
-        lwe: &LWECiphertext<DI>,
+        res: &mut GLWE<DR>,
+        lwe: &LWE<DI>,
         lut: &LookUpTable,
         scratch: &mut Scratch<B>,
     ) {
@@ -121,8 +120,8 @@ where
 
 fn execute_block_binary_extended<DataRes, DataIn, DataBrk, B: Backend>(
     module: &Module<B>,
-    res: &mut GLWECiphertext<DataRes>,
-    lwe: &LWECiphertext<DataIn>,
+    res: &mut GLWE<DataRes>,
+    lwe: &LWE<DataIn>,
     lut: &LookUpTable,
     brk: &BlindRotationKeyPrepared<DataBrk, CGGI, B>,
     scratch: &mut Scratch<B>,
@@ -130,9 +129,9 @@ fn execute_block_binary_extended<DataRes, DataIn, DataBrk, B: Backend>(
     DataRes: DataMut,
     DataIn: DataRef,
     DataBrk: DataRef,
-    Module<B>: VecZnxBigAllocBytes
-        + VecZnxDftAllocBytes
-        + SvpPPolAllocBytes
+    Module<B>: VecZnxBigBytesOf
+        + VecZnxDftBytesOf
+        + SvpPPolBytesOf
         + VmpApplyDftToDftTmpBytes
         + VecZnxBigNormalizeTmpBytes
         + VecZnxIdftApplyTmpBytes
@@ -179,7 +178,7 @@ fn execute_block_binary_extended<DataRes, DataIn, DataBrk, B: Backend>(
     }
 
     let mut lwe_2n: Vec<i64> = vec![0i64; (lwe.n() + 1).as_usize()]; // TODO: from scratch space
-    let lwe_ref: LWECiphertext<&[u8]> = lwe.to_ref();
+    let lwe_ref: LWE<&[u8]> = lwe.to_ref();
 
     let two_n: usize = 2 * n_glwe;
     let two_n_ext: usize = 2 * lut.domain_size();
@@ -288,8 +287,8 @@ fn execute_block_binary_extended<DataRes, DataIn, DataBrk, B: Backend>(
 
 fn execute_block_binary<DataRes, DataIn, DataBrk, B: Backend>(
     module: &Module<B>,
-    res: &mut GLWECiphertext<DataRes>,
-    lwe: &LWECiphertext<DataIn>,
+    res: &mut GLWE<DataRes>,
+    lwe: &LWE<DataIn>,
     lut: &LookUpTable,
     brk: &BlindRotationKeyPrepared<DataBrk, CGGI, B>,
     scratch: &mut Scratch<B>,
@@ -297,9 +296,9 @@ fn execute_block_binary<DataRes, DataIn, DataBrk, B: Backend>(
     DataRes: DataMut,
     DataIn: DataRef,
     DataBrk: DataRef,
-    Module<B>: VecZnxBigAllocBytes
-        + VecZnxDftAllocBytes
-        + SvpPPolAllocBytes
+    Module<B>: VecZnxBigBytesOf
+        + VecZnxDftBytesOf
+        + SvpPPolBytesOf
         + VmpApplyDftToDftTmpBytes
         + VecZnxBigNormalizeTmpBytes
         + VecZnxIdftApplyTmpBytes
@@ -324,8 +323,8 @@ fn execute_block_binary<DataRes, DataIn, DataBrk, B: Backend>(
 {
     let n_glwe: usize = brk.n_glwe().into();
     let mut lwe_2n: Vec<i64> = vec![0i64; (lwe.n() + 1).into()]; // TODO: from scratch space
-    let mut out_mut: GLWECiphertext<&mut [u8]> = res.to_mut();
-    let lwe_ref: LWECiphertext<&[u8]> = lwe.to_ref();
+    let mut out_mut: GLWE<&mut [u8]> = res.to_mut();
+    let lwe_ref: LWE<&[u8]> = lwe.to_ref();
     let two_n: usize = n_glwe << 1;
     let base2k: usize = brk.base2k().into();
     let dnum: usize = brk.dnum().into();
@@ -410,8 +409,8 @@ fn execute_block_binary<DataRes, DataIn, DataBrk, B: Backend>(
 
 fn execute_standard<DataRes, DataIn, DataBrk, B: Backend>(
     module: &Module<B>,
-    res: &mut GLWECiphertext<DataRes>,
-    lwe: &LWECiphertext<DataIn>,
+    res: &mut GLWE<DataRes>,
+    lwe: &LWE<DataIn>,
     lut: &LookUpTable,
     brk: &BlindRotationKeyPrepared<DataBrk, CGGI, B>,
     scratch: &mut Scratch<B>,
@@ -419,9 +418,9 @@ fn execute_standard<DataRes, DataIn, DataBrk, B: Backend>(
     DataRes: DataMut,
     DataIn: DataRef,
     DataBrk: DataRef,
-    Module<B>: VecZnxBigAllocBytes
-        + VecZnxDftAllocBytes
-        + SvpPPolAllocBytes
+    Module<B>: VecZnxBigBytesOf
+        + VecZnxDftBytesOf
+        + SvpPPolBytesOf
         + VmpApplyDftToDftTmpBytes
         + VecZnxBigNormalizeTmpBytes
         + VecZnxIdftApplyTmpBytes
@@ -480,8 +479,8 @@ fn execute_standard<DataRes, DataIn, DataBrk, B: Backend>(
     }
 
     let mut lwe_2n: Vec<i64> = vec![0i64; (lwe.n() + 1).into()]; // TODO: from scratch space
-    let mut out_mut: GLWECiphertext<&mut [u8]> = res.to_mut();
-    let lwe_ref: LWECiphertext<&[u8]> = lwe.to_ref();
+    let mut out_mut: GLWE<&mut [u8]> = res.to_mut();
+    let lwe_ref: LWE<&[u8]> = lwe.to_ref();
 
     mod_switch_2n(
         2 * lut.domain_size(),
@@ -519,7 +518,7 @@ fn execute_standard<DataRes, DataIn, DataBrk, B: Backend>(
     out_mut.normalize_inplace(module, scratch_1);
 }
 
-pub fn mod_switch_2n(n: usize, res: &mut [i64], lwe: &LWECiphertext<&[u8]>, rot_dir: LookUpTableRotationDirection) {
+pub fn mod_switch_2n(n: usize, res: &mut [i64], lwe: &LWE<&[u8]>, rot_dir: LookUpTableRotationDirection) {
     let base2k: usize = lwe.base2k().into();
 
     let log2n: usize = usize::BITS as usize - (n - 1).leading_zeros() as usize + 1;

poulpy-schemes/src/tfhe/blind_rotation/cggi_key.rs

@@ -1,9 +1,8 @@
 use poulpy_hal::{
     api::{
         ScratchAvailable, SvpApplyDftToDftInplace, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal,
-        VecZnxAddScalarInplace, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform,
-        VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace,
-        VmpPMatAlloc, VmpPrepare,
+        VecZnxAddScalarInplace, VecZnxBigNormalize, VecZnxDftApply, VecZnxDftBytesOf, VecZnxFillUniform, VecZnxIdftApplyConsume,
+        VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace, VmpPMatAlloc, VmpPrepare,
     },
     layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, ScalarZnxToRef, Scratch, ZnxView, ZnxViewMut},
     source::Source,
@@ -14,9 +13,9 @@ use std::marker::PhantomData;
 use poulpy_core::{
     Distribution,
     layouts::{
-        GGSWCiphertext, GGSWInfos, LWESecret,
-        compressed::GGSWCiphertextCompressed,
-        prepared::{GGSWCiphertextPrepared, GLWESecretPrepared},
+        GGSW, GGSWInfos, LWESecret,
+        compressed::GGSWCompressed,
+        prepared::{GGSWPrepared, GLWESecretPrepared},
     },
 };
 
@@ -30,9 +29,9 @@ impl BlindRotationKeyAlloc for BlindRotationKey<Vec<u8>, CGGI> {
     where
         A: BlindRotationKeyInfos,
     {
-        let mut data: Vec<GGSWCiphertext<Vec<u8>>> = Vec::with_capacity(infos.n_lwe().into());
+        let mut data: Vec<GGSW<Vec<u8>>> = Vec::with_capacity(infos.n_lwe().into());
         for _ in 0..infos.n_lwe().as_usize() {
-            data.push(GGSWCiphertext::alloc(infos));
+            data.push(GGSW::alloc_from_infos(infos));
         }
 
         Self {
@@ -44,19 +43,19 @@ impl BlindRotationKeyAlloc for BlindRotationKey<Vec<u8>, CGGI> {
 }
 
 impl BlindRotationKey<Vec<u8>, CGGI> {
-    pub fn generate_from_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+    pub fn generate_from_sk_tmp_bytes<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
     where
         A: GGSWInfos,
-        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes,
+        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftBytesOf,
     {
-        GGSWCiphertext::encrypt_sk_scratch_space(module, infos)
+        GGSW::encrypt_sk_tmp_bytes(module, infos)
     }
 }
 
 impl<D: DataMut, B: Backend> BlindRotationKeyEncryptSk<B> for BlindRotationKey<D, CGGI>
 where
     Module<B>: VecZnxAddScalarInplace
-        + VecZnxDftAllocBytes
+        + VecZnxDftBytesOf
         + VecZnxBigNormalize<B>
         + VecZnxDftApply<B>
         + SvpApplyDftToDftInplace<B>
@@ -121,8 +120,8 @@ where
     where
         A: BlindRotationKeyInfos,
     {
-        let mut data: Vec<GGSWCiphertextPrepared<Vec<u8>, B>> = Vec::with_capacity(infos.n_lwe().into());
-        (0..infos.n_lwe().as_usize()).for_each(|_| data.push(GGSWCiphertextPrepared::alloc(module, infos)));
+        let mut data: Vec<GGSWPrepared<Vec<u8>, B>> = Vec::with_capacity(infos.n_lwe().into());
+        (0..infos.n_lwe().as_usize()).for_each(|_| data.push(GGSWPrepared::alloc_from_infos(module, infos)));
         Self {
             data,
             dist: Distribution::NONE,
@@ -137,8 +136,8 @@ impl BlindRotationKeyCompressed<Vec<u8>, CGGI> {
     where
         A: BlindRotationKeyInfos,
     {
-        let mut data: Vec<GGSWCiphertextCompressed<Vec<u8>>> = Vec::with_capacity(infos.n_lwe().into());
-        (0..infos.n_lwe().as_usize()).for_each(|_| data.push(GGSWCiphertextCompressed::alloc(infos)));
+        let mut data: Vec<GGSWCompressed<Vec<u8>>> = Vec::with_capacity(infos.n_lwe().into());
+        (0..infos.n_lwe().as_usize()).for_each(|_| data.push(GGSWCompressed::alloc_from_infos(infos)));
         Self {
             keys: data,
             dist: Distribution::NONE,
@@ -146,12 +145,12 @@ impl BlindRotationKeyCompressed<Vec<u8>, CGGI> {
         }
     }
 
-    pub fn generate_from_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+    pub fn generate_from_sk_tmp_bytes<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
     where
         A: GGSWInfos,
-        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes,
+        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftBytesOf,
     {
-        GGSWCiphertextCompressed::encrypt_sk_scratch_space(module, infos)
+        GGSWCompressed::encrypt_sk_tmp_bytes(module, infos)
     }
 }
 
@@ -169,7 +168,7 @@ impl<D: DataMut> BlindRotationKeyCompressed<D, CGGI> {
         DataSkGLWE: DataRef,
         DataSkLWE: DataRef,
         Module<B>: VecZnxAddScalarInplace
-            + VecZnxDftAllocBytes
+            + VecZnxDftBytesOf
             + VecZnxBigNormalize<B>
             + VecZnxDftApply<B>
             + SvpApplyDftToDftInplace<B>

poulpy-schemes/src/tfhe/blind_rotation/key.rs

@@ -8,7 +8,7 @@ use std::{fmt, marker::PhantomData};
 use poulpy_core::{
     Distribution,
     layouts::{
-        Base2K, Degree, Dnum, Dsize, GGSWCiphertext, GGSWInfos, GLWEInfos, LWEInfos, LWESecret, Rank, TorusPrecision,
+        Base2K, Dnum, Dsize, GGSW, GGSWInfos, GLWEInfos, LWEInfos, LWESecret, Rank, RingDegree, TorusPrecision,
         prepared::GLWESecretPrepared,
     },
 };
@@ -19,8 +19,8 @@ use crate::tfhe::blind_rotation::BlindRotationAlgo;
 
 #[derive(PartialEq, Eq, Copy, Clone, Debug)]
 pub struct BlindRotationKeyLayout {
-    pub n_glwe: Degree,
-    pub n_lwe: Degree,
+    pub n_glwe: RingDegree,
+    pub n_lwe: RingDegree,
     pub base2k: Base2K,
     pub k: TorusPrecision,
     pub dnum: Dnum,
@@ -28,11 +28,11 @@ pub struct BlindRotationKeyLayout {
 }
 
 impl BlindRotationKeyInfos for BlindRotationKeyLayout {
-    fn n_glwe(&self) -> Degree {
+    fn n_glwe(&self) -> RingDegree {
         self.n_glwe
     }
 
-    fn n_lwe(&self) -> Degree {
+    fn n_lwe(&self) -> RingDegree {
         self.n_lwe
     }
 }
@@ -62,7 +62,7 @@ impl LWEInfos for BlindRotationKeyLayout {
         self.k
     }
 
-    fn n(&self) -> Degree {
+    fn n(&self) -> RingDegree {
         self.n_glwe
     }
 }
@@ -71,8 +71,8 @@ pub trait BlindRotationKeyInfos
 where
     Self: GGSWInfos,
 {
-    fn n_glwe(&self) -> Degree;
-    fn n_lwe(&self) -> Degree;
+    fn n_glwe(&self) -> RingDegree;
+    fn n_lwe(&self) -> RingDegree;
 }
 
 pub trait BlindRotationKeyAlloc {
@@ -98,7 +98,7 @@ pub trait BlindRotationKeyEncryptSk<B: Backend> {
 
 #[derive(Clone)]
 pub struct BlindRotationKey<D: Data, BRT: BlindRotationAlgo> {
-    pub(crate) keys: Vec<GGSWCiphertext<D>>,
+    pub(crate) keys: Vec<GGSW<D>>,
     pub(crate) dist: Distribution,
     pub(crate) _phantom: PhantomData<BRT>,
 }
@@ -178,12 +178,12 @@ impl<D: DataRef, BRT: BlindRotationAlgo> WriterTo for BlindRotationKey<D, BRT> {
 }
 
 impl<D: DataRef, BRT: BlindRotationAlgo> BlindRotationKeyInfos for BlindRotationKey<D, BRT> {
-    fn n_glwe(&self) -> Degree {
+    fn n_glwe(&self) -> RingDegree {
         self.n()
     }
 
-    fn n_lwe(&self) -> Degree {
-        Degree(self.keys.len() as u32)
+    fn n_lwe(&self) -> RingDegree {
+        RingDegree(self.keys.len() as u32)
     }
 }
 
@@ -206,7 +206,7 @@ impl<D: DataRef, BRT: BlindRotationAlgo> LWEInfos for BlindRotationKey<D, BRT> {
         self.keys[0].k()
     }
 
-    fn n(&self) -> Degree {
+    fn n(&self) -> RingDegree {
         self.keys[0].n()
     }
 

poulpy-schemes/src/tfhe/blind_rotation/key_compressed.rs

@@ -8,14 +8,14 @@ use std::{fmt, marker::PhantomData};
 use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
 use poulpy_core::{
     Distribution,
-    layouts::{Base2K, Degree, Dsize, GGSWInfos, GLWEInfos, LWEInfos, TorusPrecision, compressed::GGSWCiphertextCompressed},
+    layouts::{Base2K, Dsize, GGSWInfos, GLWEInfos, LWEInfos, RingDegree, TorusPrecision, compressed::GGSWCompressed},
 };
 
 use crate::tfhe::blind_rotation::{BlindRotationAlgo, BlindRotationKeyInfos};
 
 #[derive(Clone)]
 pub struct BlindRotationKeyCompressed<D: Data, BRT: BlindRotationAlgo> {
-    pub(crate) keys: Vec<GGSWCiphertextCompressed<D>>,
+    pub(crate) keys: Vec<GGSWCompressed<D>>,
     pub(crate) dist: Distribution,
     pub(crate) _phantom: PhantomData<BRT>,
 }
@@ -94,17 +94,17 @@ impl<D: DataRef, BRT: BlindRotationAlgo> WriterTo for BlindRotationKeyCompressed
 }
 
 impl<D: DataRef, BRA: BlindRotationAlgo> BlindRotationKeyInfos for BlindRotationKeyCompressed<D, BRA> {
-    fn n_glwe(&self) -> Degree {
+    fn n_glwe(&self) -> RingDegree {
         self.n()
     }
 
-    fn n_lwe(&self) -> Degree {
-        Degree(self.keys.len() as u32)
+    fn n_lwe(&self) -> RingDegree {
+        RingDegree(self.keys.len() as u32)
     }
 }
 
 impl<D: DataRef, BRA: BlindRotationAlgo> LWEInfos for BlindRotationKeyCompressed<D, BRA> {
-    fn n(&self) -> Degree {
+    fn n(&self) -> RingDegree {
         self.keys[0].n()
     }
 

poulpy-schemes/src/tfhe/blind_rotation/key_prepared.rs

@@ -8,8 +8,8 @@ use std::marker::PhantomData;
 use poulpy_core::{
     Distribution,
     layouts::{
-        Base2K, Degree, Dnum, Dsize, GGSWInfos, GLWEInfos, LWEInfos, Rank, TorusPrecision,
-        prepared::{GGSWCiphertextPrepared, Prepare, PrepareAlloc},
+        Base2K, Dnum, Dsize, GGSWInfos, GLWEInfos, LWEInfos, Rank, RingDegree, TorusPrecision,
+        prepared::{GGSWPrepared, Prepare, PrepareAlloc},
     },
 };
 
@@ -23,19 +23,19 @@ pub trait BlindRotationKeyPreparedAlloc<B: Backend> {
 
 #[derive(PartialEq, Eq)]
 pub struct BlindRotationKeyPrepared<D: Data, BRT: BlindRotationAlgo, B: Backend> {
-    pub(crate) data: Vec<GGSWCiphertextPrepared<D, B>>,
+    pub(crate) data: Vec<GGSWPrepared<D, B>>,
     pub(crate) dist: Distribution,
     pub(crate) x_pow_a: Option<Vec<SvpPPol<Vec<u8>, B>>>,
     pub(crate) _phantom: PhantomData<BRT>,
 }
 
 impl<D: Data, BRT: BlindRotationAlgo, B: Backend> BlindRotationKeyInfos for BlindRotationKeyPrepared<D, BRT, B> {
-    fn n_glwe(&self) -> Degree {
+    fn n_glwe(&self) -> RingDegree {
         self.n()
     }
 
-    fn n_lwe(&self) -> Degree {
-        Degree(self.data.len() as u32)
+    fn n_lwe(&self) -> RingDegree {
+        RingDegree(self.data.len() as u32)
     }
 }
 
@@ -48,7 +48,7 @@ impl<D: Data, BRT: BlindRotationAlgo, B: Backend> LWEInfos for BlindRotationKeyP
         self.data[0].k()
     }
 
-    fn n(&self) -> Degree {
+    fn n(&self) -> RingDegree {
         self.data[0].n()
     }
 

poulpy-schemes/src/tfhe/blind_rotation/mod.rs

@@ -14,7 +14,7 @@ pub use lut::*;
 
 pub mod tests;
 
-use poulpy_core::layouts::{GLWECiphertext, LWECiphertext};
+use poulpy_core::layouts::{GLWE, LWE};
 use poulpy_hal::layouts::{Backend, DataMut, DataRef, Module, Scratch};
 
 pub trait BlindRotationAlgo {}
@@ -27,8 +27,8 @@ pub trait BlincRotationExecute<B: Backend> {
     fn execute<DR: DataMut, DI: DataRef>(
         &self,
         module: &Module<B>,
-        res: &mut GLWECiphertext<DR>,
-        lwe: &LWECiphertext<DI>,
+        res: &mut GLWE<DR>,
+        lwe: &LWE<DI>,
         lut: &LookUpTable,
         scratch: &mut Scratch<B>,
     );

poulpy-schemes/src/tfhe/blind_rotation/tests/generic_blind_rotation.rs

@@ -1,9 +1,9 @@
 use poulpy_hal::{
     api::{
-        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes,
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolBytesOf,
         SvpPrepare, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
-        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxCopy, VecZnxDftAdd, VecZnxDftAddInplace,
-        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxDftSubInplace, VecZnxDftZero, VecZnxFillUniform, VecZnxIdftApply,
+        VecZnxBigBytesOf, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxCopy, VecZnxDftAdd, VecZnxDftAddInplace,
+        VecZnxDftApply, VecZnxDftBytesOf, VecZnxDftSubInplace, VecZnxDftZero, VecZnxFillUniform, VecZnxIdftApply,
         VecZnxIdftApplyConsume, VecZnxIdftApplyTmpBytes, VecZnxMulXpMinusOneInplace, VecZnxNormalize, VecZnxNormalizeInplace,
         VecZnxNormalizeTmpBytes, VecZnxRotate, VecZnxRotateInplace, VecZnxRotateInplaceTmpBytes, VecZnxSub, VecZnxSubInplace,
         VecZnxSwitchRing, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPrepare, ZnAddNormal,
@@ -19,20 +19,19 @@ use poulpy_hal::{
 
 use crate::tfhe::blind_rotation::{
     BlincRotationExecute, BlindRotationKey, BlindRotationKeyAlloc, BlindRotationKeyEncryptSk, BlindRotationKeyLayout,
-    BlindRotationKeyPrepared, CGGI, LookUpTable, cggi_blind_rotate_scratch_space, mod_switch_2n,
+    BlindRotationKeyPrepared, CGGI, LookUpTable, cggi_blind_rotate_tmp_bytes, mod_switch_2n,
 };
 
 use poulpy_core::layouts::{
-    GLWECiphertext, GLWECiphertextLayout, GLWEPlaintext, GLWESecret, LWECiphertext, LWECiphertextLayout, LWECiphertextToRef,
-    LWEInfos, LWEPlaintext, LWESecret,
+    GLWE, GLWELayout, GLWEPlaintext, GLWESecret, LWE, LWEInfos, LWELayout, LWEPlaintext, LWESecret, LWEToRef,
     prepared::{GLWESecretPrepared, PrepareAlloc},
 };
 
 pub fn test_blind_rotation<B>(module: &Module<B>, n_lwe: usize, block_size: usize, extension_factor: usize)
 where
-    Module<B>: VecZnxBigAllocBytes
-        + VecZnxDftAllocBytes
-        + SvpPPolAllocBytes
+    Module<B>: VecZnxBigBytesOf
+        + VecZnxDftBytesOf
+        + SvpPPolBytesOf
         + VmpApplyDftToDftTmpBytes
         + VecZnxBigNormalizeTmpBytes
         + VecZnxIdftApplyTmpBytes
@@ -111,31 +110,31 @@ where
         rank: rank.into(),
     };
 
-    let glwe_infos: GLWECiphertextLayout = GLWECiphertextLayout {
+    let glwe_infos: GLWELayout = GLWELayout {
         n: n_glwe.into(),
         base2k: base2k.into(),
         k: k_res.into(),
         rank: rank.into(),
     };
 
-    let lwe_infos: LWECiphertextLayout = LWECiphertextLayout {
+    let lwe_infos: LWELayout = LWELayout {
         n: n_lwe.into(),
         k: k_lwe.into(),
         base2k: base2k.into(),
     };
 
-    let mut scratch: ScratchOwned<B> = ScratchOwned::<B>::alloc(BlindRotationKey::generate_from_sk_scratch_space(
+    let mut scratch: ScratchOwned<B> = ScratchOwned::<B>::alloc(BlindRotationKey::generate_from_sk_tmp_bytes(
         module, &brk_infos,
     ));
 
-    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc(&glwe_infos);
+    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_infos);
     sk_glwe.fill_ternary_prob(0.5, &mut source_xs);
     let sk_glwe_dft: GLWESecretPrepared<Vec<u8>, B> = sk_glwe.prepare_alloc(module, scratch.borrow());
 
     let mut sk_lwe: LWESecret<Vec<u8>> = LWESecret::alloc(n_lwe.into());
     sk_lwe.fill_binary_block(block_size, &mut source_xs);
 
-    let mut scratch_br: ScratchOwned<B> = ScratchOwned::<B>::alloc(cggi_blind_rotate_scratch_space(
+    let mut scratch_br: ScratchOwned<B> = ScratchOwned::<B>::alloc(cggi_blind_rotate_tmp_bytes(
         module,
         block_size,
         extension_factor,
@@ -154,9 +153,9 @@ where
         scratch.borrow(),
     );
 
-    let mut lwe: LWECiphertext<Vec<u8>> = LWECiphertext::alloc(&lwe_infos);
+    let mut lwe: LWE<Vec<u8>> = LWE::alloc_from_infos(&lwe_infos);
 
-    let mut pt_lwe: LWEPlaintext<Vec<u8>> = LWEPlaintext::alloc(&lwe_infos);
+    let mut pt_lwe: LWEPlaintext<Vec<u8>> = LWEPlaintext::alloc_from_infos(&lwe_infos);
 
     let x: i64 = 15 % (message_modulus as i64);
 
@@ -175,13 +174,13 @@ where
     let mut lut: LookUpTable = LookUpTable::alloc(module, base2k, k_lut, extension_factor);
     lut.set(module, &f_vec, log_message_modulus + 1);
 
-    let mut res: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&glwe_infos);
+    let mut res: GLWE<Vec<u8>> = GLWE::alloc_from_infos(&glwe_infos);
 
     let brk_prepared: BlindRotationKeyPrepared<Vec<u8>, CGGI, B> = brk.prepare_alloc(module, scratch.borrow());
 
     brk_prepared.execute(module, &mut res, &lwe, &lut, scratch_br.borrow());
 
-    let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(&glwe_infos);
+    let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc_from_infos(&glwe_infos);
 
     res.decrypt(module, &mut pt_have, &sk_glwe_dft, scratch.borrow());
 

poulpy-schemes/src/tfhe/circuit_bootstrapping/circuit.rs

@@ -3,9 +3,9 @@ use std::collections::HashMap;
 use poulpy_hal::{
     api::{
         ScratchAvailable, TakeMatZnx, TakeSlice, TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft, TakeVecZnxDftSlice, TakeVecZnxSlice,
-        VecZnxAddInplace, VecZnxAutomorphismInplace, VecZnxBigAddSmallInplace, VecZnxBigAllocBytes, VecZnxBigAutomorphismInplace,
+        VecZnxAddInplace, VecZnxAutomorphismInplace, VecZnxBigAddSmallInplace, VecZnxBigAutomorphismInplace, VecZnxBigBytesOf,
         VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxBigSubSmallNegateInplace, VecZnxCopy, VecZnxDftAddInplace,
-        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxDftCopy, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA, VecZnxNegateInplace,
+        VecZnxDftApply, VecZnxDftBytesOf, VecZnxDftCopy, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA, VecZnxNegateInplace,
         VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxRotate, VecZnxRotateInplace,
         VecZnxRotateInplaceTmpBytes, VecZnxRshInplace, VecZnxSub, VecZnxSubInplace, VecZnxSwitchRing, VmpApplyDftToDft,
         VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
@@ -15,12 +15,12 @@ use poulpy_hal::{
 };
 
 use poulpy_core::{
-    GLWEOperations, TakeGGLWE, TakeGLWECt,
-    layouts::{Dsize, GGLWECiphertextLayout, GGSWInfos, GLWEInfos, LWEInfos},
+    GLWEOperations, TakeGGLWE, TakeGLWE,
+    layouts::{Dsize, GGLWELayout, GGSWInfos, GLWEInfos, LWEInfos},
 };
 
 use poulpy_core::glwe_packing;
-use poulpy_core::layouts::{GGSWCiphertext, GLWECiphertext, LWECiphertext, prepared::GGLWEAutomorphismKeyPrepared};
+use poulpy_core::layouts::{GGSW, GLWE, LWE, prepared::AutomorphismKeyPrepared};
 
 use crate::tfhe::{
     blind_rotation::{
@@ -44,7 +44,7 @@ where
         + VecZnxNegateInplace
         + VecZnxCopy
         + VecZnxSubInplace
-        + VecZnxDftAllocBytes
+        + VecZnxDftBytesOf
         + VmpApplyDftToDftTmpBytes
         + VecZnxBigNormalizeTmpBytes
         + VmpApplyDftToDft<B>
@@ -56,7 +56,7 @@ where
         + VecZnxAutomorphismInplace<B>
         + VecZnxBigSubSmallNegateInplace<B>
         + VecZnxRotateInplaceTmpBytes
-        + VecZnxBigAllocBytes
+        + VecZnxBigBytesOf
         + VecZnxDftAddInplace<B>
         + VecZnxRotate
         + VecZnxNormalize<B>,
@@ -74,8 +74,8 @@ where
     fn execute_to_constant<DM: DataMut, DR: DataRef>(
         &self,
         module: &Module<B>,
-        res: &mut GGSWCiphertext<DM>,
-        lwe: &LWECiphertext<DR>,
+        res: &mut GGSW<DM>,
+        lwe: &LWE<DR>,
         log_domain: usize,
         extension_factor: usize,
         scratch: &mut Scratch<B>,
@@ -97,8 +97,8 @@ where
         &self,
         module: &Module<B>,
         log_gap_out: usize,
-        res: &mut GGSWCiphertext<DM>,
-        lwe: &LWECiphertext<DR>,
+        res: &mut GGSW<DM>,
+        lwe: &LWE<DR>,
         log_domain: usize,
         extension_factor: usize,
         scratch: &mut Scratch<B>,
@@ -122,8 +122,8 @@ pub fn circuit_bootstrap_core<DRes, DLwe, DBrk, BRA: BlindRotationAlgo, B>(
     to_exponent: bool,
     module: &Module<B>,
     log_gap_out: usize,
-    res: &mut GGSWCiphertext<DRes>,
-    lwe: &LWECiphertext<DLwe>,
+    res: &mut GGSW<DRes>,
+    lwe: &LWE<DLwe>,
     log_domain: usize,
     extension_factor: usize,
     key: &CircuitBootstrappingKeyPrepared<DBrk, BRA, B>,
@@ -145,7 +145,7 @@ pub fn circuit_bootstrap_core<DRes, DLwe, DBrk, BRA: BlindRotationAlgo, B>(
         + VecZnxNegateInplace
         + VecZnxCopy
         + VecZnxSubInplace
-        + VecZnxDftAllocBytes
+        + VecZnxDftBytesOf
         + VmpApplyDftToDftTmpBytes
         + VecZnxBigNormalizeTmpBytes
         + VmpApplyDftToDft<B>
@@ -156,7 +156,7 @@ pub fn circuit_bootstrap_core<DRes, DLwe, DBrk, BRA: BlindRotationAlgo, B>(
         + VecZnxBigNormalize<B>
         + VecZnxAutomorphismInplace<B>
         + VecZnxBigSubSmallNegateInplace<B>
-        + VecZnxBigAllocBytes
+        + VecZnxBigBytesOf
         + VecZnxDftAddInplace<B>
         + VecZnxRotateInplaceTmpBytes
         + VecZnxRotate
@@ -214,7 +214,7 @@ pub fn circuit_bootstrap_core<DRes, DLwe, DBrk, BRA: BlindRotationAlgo, B>(
     // TODO: separate GGSW k from output of blind rotation k
     let (mut res_glwe, scratch_1) = scratch.take_glwe_ct(res);
 
-    let gglwe_infos: GGLWECiphertextLayout = GGLWECiphertextLayout {
+    let gglwe_infos: GGLWELayout = GGLWELayout {
         n: n.into(),
         base2k: base2k.into(),
         k: k.into(),
@@ -233,7 +233,7 @@ pub fn circuit_bootstrap_core<DRes, DLwe, DBrk, BRA: BlindRotationAlgo, B>(
     let log_gap_in: usize = (usize::BITS - (gap * alpha - 1).leading_zeros()) as _;
 
     (0..dnum).for_each(|i| {
-        let mut tmp_glwe: GLWECiphertext<&mut [u8]> = tmp_gglwe.at_mut(i, 0);
+        let mut tmp_glwe: GLWE<&mut [u8]> = tmp_gglwe.at_mut(i, 0);
 
         if to_exponent {
             // Isolates i-th LUT and moves coefficients according to requested gap.
@@ -263,12 +263,12 @@ pub fn circuit_bootstrap_core<DRes, DLwe, DBrk, BRA: BlindRotationAlgo, B>(
 #[allow(clippy::too_many_arguments)]
 fn post_process<DataRes, DataA, B: Backend>(
     module: &Module<B>,
-    res: &mut GLWECiphertext<DataRes>,
-    a: &GLWECiphertext<DataA>,
+    res: &mut GLWE<DataRes>,
+    a: &GLWE<DataA>,
     log_gap_in: usize,
     log_gap_out: usize,
     log_domain: usize,
-    auto_keys: &HashMap<i64, GGLWEAutomorphismKeyPrepared<Vec<u8>, B>>,
+    auto_keys: &HashMap<i64, AutomorphismKeyPrepared<Vec<u8>, B>>,
     scratch: &mut Scratch<B>,
 ) where
     DataRes: DataMut,
@@ -286,7 +286,7 @@ fn post_process<DataRes, DataA, B: Backend>(
         + VecZnxNegateInplace
         + VecZnxCopy
         + VecZnxSubInplace
-        + VecZnxDftAllocBytes
+        + VecZnxDftBytesOf
         + VmpApplyDftToDftTmpBytes
         + VecZnxBigNormalizeTmpBytes
         + VmpApplyDftToDft<B>
@@ -303,7 +303,7 @@ fn post_process<DataRes, DataA, B: Backend>(
 {
     let log_n: usize = module.log_n();
 
-    let mut cts: HashMap<usize, &mut GLWECiphertext<Vec<u8>>> = HashMap::new();
+    let mut cts: HashMap<usize, &mut GLWE<Vec<u8>>> = HashMap::new();
 
     // First partial trace, vanishes all coefficients which are not multiples of gap_in
     // [1, 1, 1, 1, 0, 0, 0, ..., 0, 0, -1, -1, -1, -1] -> [1, 0, 0, 0, 0, 0, 0, ..., 0, 0, 0, 0, 0, 0]
@@ -322,7 +322,7 @@ fn post_process<DataRes, DataA, B: Backend>(
         let steps: usize = 1 << log_domain;
 
         // TODO: from Scratch
-        let mut cts_vec: Vec<GLWECiphertext<Vec<u8>>> = Vec::new();
+        let mut cts_vec: Vec<GLWE<Vec<u8>>> = Vec::new();
 
         for i in 0..steps {
             if i != 0 {
@@ -336,7 +336,7 @@ fn post_process<DataRes, DataA, B: Backend>(
         }
 
         glwe_packing(module, &mut cts, log_gap_out, auto_keys, scratch);
-        let packed: &mut GLWECiphertext<Vec<u8>> = cts.remove(&0).unwrap();
+        let packed: &mut GLWE<Vec<u8>> = cts.remove(&0).unwrap();
         res.trace(
             module,
             log_n - log_gap_out,

poulpy-schemes/src/tfhe/circuit_bootstrapping/key.rs

@@ -1,15 +1,15 @@
 use poulpy_core::layouts::{
-    GGLWEAutomorphismKey, GGLWEAutomorphismKeyLayout, GGLWEInfos, GGLWETensorKey, GGLWETensorKeyLayout, GGSWInfos,
-    GLWECiphertext, GLWEInfos, GLWESecret, LWEInfos, LWESecret,
-    prepared::{GGLWEAutomorphismKeyPrepared, GGLWETensorKeyPrepared, GLWESecretPrepared, PrepareAlloc},
+    AutomorphismKey, AutomorphismKeyLayout, GGLWEInfos, GGSWInfos, GLWE, GLWEInfos, GLWESecret, LWEInfos, LWESecret, TensorKey,
+    TensorKeyLayout,
+    prepared::{AutomorphismKeyPrepared, GLWESecretPrepared, PrepareAlloc, TensorKeyPrepared},
 };
 use std::collections::HashMap;
 
 use poulpy_hal::{
     api::{
-        ScratchAvailable, SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx,
+        ScratchAvailable, SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolBytesOf, SvpPrepare, TakeScalarZnx,
         TakeSvpPPol, TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace,
-        VecZnxAutomorphism, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume,
+        VecZnxAutomorphism, VecZnxBigNormalize, VecZnxDftApply, VecZnxDftBytesOf, VecZnxFillUniform, VecZnxIdftApplyConsume,
         VecZnxIdftApplyTmpA, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace,
         VecZnxSwitchRing, VmpPMatAlloc, VmpPrepare,
     },
@@ -24,19 +24,19 @@ use crate::tfhe::blind_rotation::{
 
 pub trait CircuitBootstrappingKeyInfos {
     fn brk_infos(&self) -> BlindRotationKeyLayout;
-    fn atk_infos(&self) -> GGLWEAutomorphismKeyLayout;
-    fn tsk_infos(&self) -> GGLWETensorKeyLayout;
+    fn atk_infos(&self) -> AutomorphismKeyLayout;
+    fn tsk_infos(&self) -> TensorKeyLayout;
 }
 
 #[derive(Debug, Clone, Copy)]
 pub struct CircuitBootstrappingKeyLayout {
     pub layout_brk: BlindRotationKeyLayout,
-    pub layout_atk: GGLWEAutomorphismKeyLayout,
-    pub layout_tsk: GGLWETensorKeyLayout,
+    pub layout_atk: AutomorphismKeyLayout,
+    pub layout_tsk: TensorKeyLayout,
 }
 
 impl CircuitBootstrappingKeyInfos for CircuitBootstrappingKeyLayout {
-    fn atk_infos(&self) -> GGLWEAutomorphismKeyLayout {
+    fn atk_infos(&self) -> AutomorphismKeyLayout {
         self.layout_atk
     }
 
@@ -44,7 +44,7 @@ impl CircuitBootstrappingKeyInfos for CircuitBootstrappingKeyLayout {
         self.layout_brk
     }
 
-    fn tsk_infos(&self) -> GGLWETensorKeyLayout {
+    fn tsk_infos(&self) -> TensorKeyLayout {
         self.layout_tsk
     }
 }
@@ -68,8 +68,8 @@ pub trait CircuitBootstrappingKeyEncryptSk<B: Backend> {
 
 pub struct CircuitBootstrappingKey<D: Data, BRA: BlindRotationAlgo> {
     pub(crate) brk: BlindRotationKey<D, BRA>,
-    pub(crate) tsk: GGLWETensorKey<Vec<u8>>,
-    pub(crate) atk: HashMap<i64, GGLWEAutomorphismKey<Vec<u8>>>,
+    pub(crate) tsk: TensorKey<Vec<u8>>,
+    pub(crate) atk: HashMap<i64, AutomorphismKey<Vec<u8>>>,
 }
 
 impl<BRA: BlindRotationAlgo, B: Backend> CircuitBootstrappingKeyEncryptSk<B> for CircuitBootstrappingKey<Vec<u8>, BRA>
@@ -78,7 +78,7 @@ where
     Module<B>: SvpApplyDftToDft<B>
         + VecZnxIdftApplyTmpA<B>
         + VecZnxAddScalarInplace
-        + VecZnxDftAllocBytes
+        + VecZnxDftBytesOf
         + VecZnxBigNormalize<B>
         + VecZnxDftApply<B>
         + SvpApplyDftToDftInplace<B>
@@ -93,7 +93,7 @@ where
         + VecZnxSub
         + SvpPrepare<B>
         + VecZnxSwitchRing
-        + SvpPPolAllocBytes
+        + SvpPPolBytesOf
         + SvpPPolAlloc<B>
         + VecZnxAutomorphism,
     Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx + TakeScalarZnx + TakeSvpPPol<B> + TakeVecZnxBig<B>,
@@ -117,14 +117,14 @@ where
         assert_eq!(sk_glwe.n(), cbt_infos.atk_infos().n());
         assert_eq!(sk_glwe.n(), cbt_infos.tsk_infos().n());
 
-        let atk_infos: GGLWEAutomorphismKeyLayout = cbt_infos.atk_infos();
+        let atk_infos: AutomorphismKeyLayout = cbt_infos.atk_infos();
         let brk_infos: BlindRotationKeyLayout = cbt_infos.brk_infos();
-        let trk_infos: GGLWETensorKeyLayout = cbt_infos.tsk_infos();
+        let trk_infos: TensorKeyLayout = cbt_infos.tsk_infos();
 
-        let mut auto_keys: HashMap<i64, GGLWEAutomorphismKey<Vec<u8>>> = HashMap::new();
-        let gal_els: Vec<i64> = GLWECiphertext::trace_galois_elements(module);
+        let mut auto_keys: HashMap<i64, AutomorphismKey<Vec<u8>>> = HashMap::new();
+        let gal_els: Vec<i64> = GLWE::trace_galois_elements(module);
         gal_els.iter().for_each(|gal_el| {
-            let mut key: GGLWEAutomorphismKey<Vec<u8>> = GGLWEAutomorphismKey::alloc(&atk_infos);
+            let mut key: AutomorphismKey<Vec<u8>> = AutomorphismKey::alloc_from_infos(&atk_infos);
             key.encrypt_sk(module, *gal_el, sk_glwe, source_xa, source_xe, scratch);
             auto_keys.insert(*gal_el, key);
         });
@@ -141,7 +141,7 @@ where
             scratch,
         );
 
-        let mut tsk: GGLWETensorKey<Vec<u8>> = GGLWETensorKey::alloc(&trk_infos);
+        let mut tsk: TensorKey<Vec<u8>> = TensorKey::alloc_from_infos(&trk_infos);
         tsk.encrypt_sk(module, sk_glwe, source_xa, source_xe, scratch);
 
         Self {
@@ -154,14 +154,14 @@ where
 
 pub struct CircuitBootstrappingKeyPrepared<D: Data, BRA: BlindRotationAlgo, B: Backend> {
     pub(crate) brk: BlindRotationKeyPrepared<D, BRA, B>,
-    pub(crate) tsk: GGLWETensorKeyPrepared<Vec<u8>, B>,
-    pub(crate) atk: HashMap<i64, GGLWEAutomorphismKeyPrepared<Vec<u8>, B>>,
+    pub(crate) tsk: TensorKeyPrepared<Vec<u8>, B>,
+    pub(crate) atk: HashMap<i64, AutomorphismKeyPrepared<Vec<u8>, B>>,
 }
 
 impl<D: DataRef, BRA: BlindRotationAlgo, B: Backend> CircuitBootstrappingKeyInfos for CircuitBootstrappingKeyPrepared<D, BRA, B> {
-    fn atk_infos(&self) -> GGLWEAutomorphismKeyLayout {
+    fn atk_infos(&self) -> AutomorphismKeyLayout {
         let (_, atk) = self.atk.iter().next().expect("atk is empty");
-        GGLWEAutomorphismKeyLayout {
+        AutomorphismKeyLayout {
             n: atk.n(),
             base2k: atk.base2k(),
             k: atk.k(),
@@ -182,8 +182,8 @@ impl<D: DataRef, BRA: BlindRotationAlgo, B: Backend> CircuitBootstrappingKeyInfo
         }
     }
 
-    fn tsk_infos(&self) -> GGLWETensorKeyLayout {
-        GGLWETensorKeyLayout {
+    fn tsk_infos(&self) -> TensorKeyLayout {
+        TensorKeyLayout {
             n: self.tsk.n(),
             base2k: self.tsk.base2k(),
             k: self.tsk.k(),
@@ -199,13 +199,13 @@ impl<D: DataRef, BRA: BlindRotationAlgo, B: Backend> PrepareAlloc<B, CircuitBoot
 where
     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>>,
+    TensorKey<D>: PrepareAlloc<B, TensorKeyPrepared<Vec<u8>, B>>,
+    AutomorphismKey<D>: PrepareAlloc<B, AutomorphismKeyPrepared<Vec<u8>, B>>,
 {
     fn prepare_alloc(&self, module: &Module<B>, scratch: &mut Scratch<B>) -> CircuitBootstrappingKeyPrepared<Vec<u8>, BRA, B> {
         let brk: BlindRotationKeyPrepared<Vec<u8>, BRA, B> = self.brk.prepare_alloc(module, scratch);
-        let tsk: GGLWETensorKeyPrepared<Vec<u8>, B> = self.tsk.prepare_alloc(module, scratch);
-        let mut atk: HashMap<i64, GGLWEAutomorphismKeyPrepared<Vec<u8>, B>> = HashMap::new();
+        let tsk: TensorKeyPrepared<Vec<u8>, B> = self.tsk.prepare_alloc(module, scratch);
+        let mut atk: HashMap<i64, AutomorphismKeyPrepared<Vec<u8>, B>> = HashMap::new();
         for (key, value) in &self.atk {
             atk.insert(*key, value.prepare_alloc(module, scratch));
         }

poulpy-schemes/src/tfhe/circuit_bootstrapping/mod.rs

@@ -5,7 +5,7 @@ pub mod tests;
 pub use circuit::*;
 pub use key::*;
 
-use poulpy_core::layouts::{GGSWCiphertext, LWECiphertext};
+use poulpy_core::layouts::{GGSW, LWE};
 
 use poulpy_hal::layouts::{Backend, DataMut, DataRef, Module, Scratch};
 
@@ -13,8 +13,8 @@ pub trait CirtuitBootstrappingExecute<B: Backend> {
     fn execute_to_constant<DM: DataMut, DR: DataRef>(
         &self,
         module: &Module<B>,
-        res: &mut GGSWCiphertext<DM>,
-        lwe: &LWECiphertext<DR>,
+        res: &mut GGSW<DM>,
+        lwe: &LWE<DR>,
         log_domain: usize,
         extension_factor: usize,
         scratch: &mut Scratch<B>,
@@ -25,8 +25,8 @@ pub trait CirtuitBootstrappingExecute<B: Backend> {
         &self,
         module: &Module<B>,
         log_gap_out: usize,
-        res: &mut GGSWCiphertext<DM>,
-        lwe: &LWECiphertext<DR>,
+        res: &mut GGSW<DM>,
+        lwe: &LWE<DR>,
         log_domain: usize,
         extension_factor: usize,
         scratch: &mut Scratch<B>,

poulpy-schemes/src/tfhe/circuit_bootstrapping/tests/circuit_bootstrapping.rs

@@ -2,11 +2,11 @@ use std::time::Instant;
 
 use poulpy_hal::{
     api::{
-        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes,
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolBytesOf,
         SvpPrepare, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism, VecZnxAutomorphismInplace,
-        VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAlloc, VecZnxBigAllocBytes, VecZnxBigAutomorphismInplace,
+        VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigAlloc, VecZnxBigAutomorphismInplace, VecZnxBigBytesOf,
         VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxBigSubSmallNegateInplace, VecZnxCopy, VecZnxDftAddInplace,
-        VecZnxDftAlloc, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxDftCopy, VecZnxFillUniform, VecZnxIdftApplyConsume,
+        VecZnxDftAlloc, VecZnxDftApply, VecZnxDftBytesOf, VecZnxDftCopy, VecZnxFillUniform, VecZnxIdftApplyConsume,
         VecZnxIdftApplyTmpA, VecZnxNegateInplace, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxRotate,
         VecZnxRotateInplace, VecZnxRotateInplaceTmpBytes, VecZnxRshInplace, VecZnxSub, VecZnxSubInplace, VecZnxSwitchRing,
         VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPrepare, ZnAddNormal, ZnFillUniform,
@@ -31,13 +31,11 @@ use crate::tfhe::{
     },
 };
 
-use poulpy_core::layouts::{
-    Dsize, GGLWEAutomorphismKeyLayout, GGLWETensorKeyLayout, GGSWCiphertextLayout, LWECiphertextLayout, prepared::PrepareAlloc,
-};
+use poulpy_core::layouts::{AutomorphismKeyLayout, Dsize, GGSWLayout, LWELayout, TensorKeyLayout, prepared::PrepareAlloc};
 
 use poulpy_core::layouts::{
-    GGSWCiphertext, GLWECiphertext, GLWEPlaintext, GLWESecret, LWECiphertext, LWEPlaintext, LWESecret,
-    prepared::{GGSWCiphertextPrepared, GLWESecretPrepared},
+    GGSW, GLWE, GLWEPlaintext, GLWESecret, LWE, LWEPlaintext, LWESecret,
+    prepared::{GGSWPrepared, GLWESecretPrepared},
 };
 
 pub fn test_circuit_bootstrapping_to_exponent<B, BRA: BlindRotationAlgo>(module: &Module<B>)
@@ -45,7 +43,7 @@ where
     Module<B>: VecZnxFillUniform
         + VecZnxAddNormal
         + VecZnxNormalizeInplace<B>
-        + VecZnxDftAllocBytes
+        + VecZnxDftBytesOf
         + VecZnxBigNormalize<B>
         + VecZnxDftApply<B>
         + SvpApplyDftToDftInplace<B>
@@ -58,7 +56,7 @@ where
         + VecZnxAddScalarInplace
         + VecZnxAutomorphism
         + VecZnxSwitchRing
-        + VecZnxBigAllocBytes
+        + VecZnxBigBytesOf
         + VecZnxIdftApplyTmpA<B>
         + SvpApplyDftToDft<B>
         + VecZnxBigAddInplace<B>
@@ -73,7 +71,7 @@ where
         + VmpApplyDftToDftTmpBytes
         + VmpApplyDftToDft<B>
         + VmpApplyDftToDftAdd<B>
-        + SvpPPolAllocBytes
+        + SvpPPolBytesOf
         + VecZnxRotateInplace<B>
         + VecZnxBigAutomorphismInplace<B>
         + VecZnxRshInplace<B>
@@ -83,7 +81,7 @@ where
         + VecZnxAutomorphismInplace<B>
         + VecZnxBigSubSmallNegateInplace<B>
         + VecZnxRotateInplaceTmpBytes
-        + VecZnxBigAllocBytes
+        + VecZnxBigBytesOf
         + VecZnxDftAddInplace<B>
         + VecZnxRotate
         + ZnFillUniform
@@ -128,7 +126,7 @@ where
     let k_ggsw_res: usize = 4 * base2k;
     let rows_ggsw_res: usize = 2;
 
-    let lwe_infos: LWECiphertextLayout = LWECiphertextLayout {
+    let lwe_infos: LWELayout = LWELayout {
         n: n_lwe.into(),
         k: k_lwe_ct.into(),
         base2k: base2k.into(),
@@ -143,7 +141,7 @@ where
             dnum: rows_brk.into(),
             rank: rank.into(),
         },
-        layout_atk: GGLWEAutomorphismKeyLayout {
+        layout_atk: AutomorphismKeyLayout {
             n: n_glwe.into(),
             base2k: base2k.into(),
             k: k_atk.into(),
@@ -151,7 +149,7 @@ where
             rank: rank.into(),
             dsize: Dsize(1),
         },
-        layout_tsk: GGLWETensorKeyLayout {
+        layout_tsk: TensorKeyLayout {
             n: n_glwe.into(),
             base2k: base2k.into(),
             k: k_tsk.into(),
@@ -161,7 +159,7 @@ where
         },
     };
 
-    let ggsw_infos: GGSWCiphertextLayout = GGSWCiphertextLayout {
+    let ggsw_infos: GGSWLayout = GGSWLayout {
         n: n_glwe.into(),
         base2k: base2k.into(),
         k: k_ggsw_res.into(),
@@ -179,19 +177,19 @@ where
     let mut sk_lwe: LWESecret<Vec<u8>> = LWESecret::alloc(n_lwe.into());
     sk_lwe.fill_binary_block(block_size, &mut source_xs);
 
-    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc_with(n_glwe.into(), rank.into());
+    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc(n_glwe.into(), rank.into());
     sk_glwe.fill_ternary_prob(0.5, &mut source_xs);
 
     let sk_glwe_prepared: GLWESecretPrepared<Vec<u8>, B> = sk_glwe.prepare_alloc(module, scratch.borrow());
 
     let data: i64 = 1;
 
-    let mut pt_lwe: LWEPlaintext<Vec<u8>> = LWEPlaintext::alloc_with(base2k.into(), k_lwe_pt.into());
+    let mut pt_lwe: LWEPlaintext<Vec<u8>> = LWEPlaintext::alloc(base2k.into(), k_lwe_pt.into());
     pt_lwe.encode_i64(data, (k_lwe_pt + 1).into());
 
     println!("pt_lwe: {pt_lwe}");
 
-    let mut ct_lwe: LWECiphertext<Vec<u8>> = LWECiphertext::alloc(&lwe_infos);
+    let mut ct_lwe: LWE<Vec<u8>> = LWE::alloc_from_infos(&lwe_infos);
     ct_lwe.encrypt_sk(module, &pt_lwe, &sk_lwe, &mut source_xa, &mut source_xe);
 
     let now: Instant = Instant::now();
@@ -206,7 +204,7 @@ where
     );
     println!("CBT-KGEN: {} ms", now.elapsed().as_millis());
 
-    let mut res: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(&ggsw_infos);
+    let mut res: GGSW<Vec<u8>> = GGSW::alloc_from_infos(&ggsw_infos);
 
     let log_gap_out = 1;
 
@@ -236,8 +234,8 @@ where
 
     res.print_noise(module, &sk_glwe_prepared, &pt_ggsw);
 
-    let mut ct_glwe: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&ggsw_infos);
-    let mut pt_glwe: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(&ggsw_infos);
+    let mut ct_glwe: GLWE<Vec<u8>> = GLWE::alloc_from_infos(&ggsw_infos);
+    let mut pt_glwe: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc_from_infos(&ggsw_infos);
     pt_glwe.data.at_mut(0, 0)[0] = 1 << (base2k - 2);
 
     ct_glwe.encrypt_sk(
@@ -249,11 +247,11 @@ where
         scratch.borrow(),
     );
 
-    let res_prepared: GGSWCiphertextPrepared<Vec<u8>, B> = res.prepare_alloc(module, scratch.borrow());
+    let res_prepared: GGSWPrepared<Vec<u8>, B> = res.prepare_alloc(module, scratch.borrow());
 
     ct_glwe.external_product_inplace(module, &res_prepared, scratch.borrow());
 
-    let mut pt_res: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(&ggsw_infos);
+    let mut pt_res: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc_from_infos(&ggsw_infos);
     ct_glwe.decrypt(module, &mut pt_res, &sk_glwe_prepared, scratch.borrow());
 
     // Parameters are set such that the first limb should be noiseless.
@@ -267,7 +265,7 @@ where
     Module<B>: VecZnxFillUniform
         + VecZnxAddNormal
         + VecZnxNormalizeInplace<B>
-        + VecZnxDftAllocBytes
+        + VecZnxDftBytesOf
         + VecZnxBigNormalize<B>
         + VecZnxDftApply<B>
         + SvpApplyDftToDftInplace<B>
@@ -280,7 +278,7 @@ where
         + VecZnxAddScalarInplace
         + VecZnxAutomorphism
         + VecZnxSwitchRing
-        + VecZnxBigAllocBytes
+        + VecZnxBigBytesOf
         + VecZnxIdftApplyTmpA<B>
         + SvpApplyDftToDft<B>
         + VecZnxBigAddInplace<B>
@@ -295,7 +293,7 @@ where
         + VmpApplyDftToDftTmpBytes
         + VmpApplyDftToDft<B>
         + VmpApplyDftToDftAdd<B>
-        + SvpPPolAllocBytes
+        + SvpPPolBytesOf
         + VecZnxRotateInplace<B>
         + VecZnxBigAutomorphismInplace<B>
         + VecZnxRotateInplaceTmpBytes
@@ -305,7 +303,7 @@ where
         + VecZnxCopy
         + VecZnxAutomorphismInplace<B>
         + VecZnxBigSubSmallNegateInplace<B>
-        + VecZnxBigAllocBytes
+        + VecZnxBigBytesOf
         + VecZnxDftAddInplace<B>
         + VecZnxRotate
         + ZnFillUniform
@@ -350,7 +348,7 @@ where
     let k_ggsw_res: usize = 4 * base2k;
     let rows_ggsw_res: usize = 3;
 
-    let lwe_infos: LWECiphertextLayout = LWECiphertextLayout {
+    let lwe_infos: LWELayout = LWELayout {
         n: n_lwe.into(),
         k: k_lwe_ct.into(),
         base2k: base2k.into(),
@@ -365,7 +363,7 @@ where
             dnum: rows_brk.into(),
             rank: rank.into(),
         },
-        layout_atk: GGLWEAutomorphismKeyLayout {
+        layout_atk: AutomorphismKeyLayout {
             n: n_glwe.into(),
             base2k: base2k.into(),
             k: k_atk.into(),
@@ -373,7 +371,7 @@ where
             rank: rank.into(),
             dsize: Dsize(1),
         },
-        layout_tsk: GGLWETensorKeyLayout {
+        layout_tsk: TensorKeyLayout {
             n: n_glwe.into(),
             base2k: base2k.into(),
             k: k_tsk.into(),
@@ -383,7 +381,7 @@ where
         },
     };
 
-    let ggsw_infos: GGSWCiphertextLayout = GGSWCiphertextLayout {
+    let ggsw_infos: GGSWLayout = GGSWLayout {
         n: n_glwe.into(),
         base2k: base2k.into(),
         k: k_ggsw_res.into(),
@@ -401,19 +399,19 @@ where
     let mut sk_lwe: LWESecret<Vec<u8>> = LWESecret::alloc(n_lwe.into());
     sk_lwe.fill_binary_block(block_size, &mut source_xs);
 
-    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc_with(n_glwe.into(), rank.into());
+    let mut sk_glwe: GLWESecret<Vec<u8>> = GLWESecret::alloc(n_glwe.into(), rank.into());
     sk_glwe.fill_ternary_prob(0.5, &mut source_xs);
 
     let sk_glwe_prepared: GLWESecretPrepared<Vec<u8>, B> = sk_glwe.prepare_alloc(module, scratch.borrow());
 
     let data: i64 = 1;
 
-    let mut pt_lwe: LWEPlaintext<Vec<u8>> = LWEPlaintext::alloc_with(base2k.into(), k_lwe_pt.into());
+    let mut pt_lwe: LWEPlaintext<Vec<u8>> = LWEPlaintext::alloc(base2k.into(), k_lwe_pt.into());
     pt_lwe.encode_i64(data, (k_lwe_pt + 1).into());
 
     println!("pt_lwe: {pt_lwe}");
 
-    let mut ct_lwe: LWECiphertext<Vec<u8>> = LWECiphertext::alloc(&lwe_infos);
+    let mut ct_lwe: LWE<Vec<u8>> = LWE::alloc_from_infos(&lwe_infos);
     ct_lwe.encrypt_sk(module, &pt_lwe, &sk_lwe, &mut source_xa, &mut source_xe);
 
     let now: Instant = Instant::now();
@@ -428,7 +426,7 @@ where
     );
     println!("CBT-KGEN: {} ms", now.elapsed().as_millis());
 
-    let mut res: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(&ggsw_infos);
+    let mut res: GGSW<Vec<u8>> = GGSW::alloc_from_infos(&ggsw_infos);
 
     let cbt_prepared: CircuitBootstrappingKeyPrepared<Vec<u8>, BRA, B> = cbt_key.prepare_alloc(module, scratch.borrow());
 
@@ -449,8 +447,8 @@ where
 
     res.print_noise(module, &sk_glwe_prepared, &pt_ggsw);
 
-    let mut ct_glwe: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&ggsw_infos);
-    let mut pt_glwe: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(&ggsw_infos);
+    let mut ct_glwe: GLWE<Vec<u8>> = GLWE::alloc_from_infos(&ggsw_infos);
+    let mut pt_glwe: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc_from_infos(&ggsw_infos);
     pt_glwe.data.at_mut(0, 0)[0] = 1 << (base2k - k_lwe_pt - 1);
 
     ct_glwe.encrypt_sk(
@@ -462,11 +460,11 @@ where
         scratch.borrow(),
     );
 
-    let res_prepared: GGSWCiphertextPrepared<Vec<u8>, B> = res.prepare_alloc(module, scratch.borrow());
+    let res_prepared: GGSWPrepared<Vec<u8>, B> = res.prepare_alloc(module, scratch.borrow());
 
     ct_glwe.external_product_inplace(module, &res_prepared, scratch.borrow());
 
-    let mut pt_res: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(&ggsw_infos);
+    let mut pt_res: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc_from_infos(&ggsw_infos);
     ct_glwe.decrypt(module, &mut pt_res, &sk_glwe_prepared, scratch.borrow());
 
     // Parameters are set such that the first limb should be noiseless.