@@ -3,13 +3,8 @@
 use poulpy_hal::{
     DEFAULTALIGN, alloc_aligned,
     api::ScratchFromBytes,
-    layouts::{Backend, MatZnx, ScalarZnx, Scratch, ScratchOwned, SvpPPol, VecZnx, VecZnxBig, VecZnxDft, VmpPMat},
-    oep::{
-        ScratchAvailableImpl, ScratchFromBytesImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, SvpPPolAllocBytesImpl,
-        TakeMatZnxImpl, TakeScalarZnxImpl, TakeSliceImpl, TakeSvpPPolImpl, TakeVecZnxBigImpl, TakeVecZnxDftImpl,
-        TakeVecZnxDftSliceImpl, TakeVecZnxImpl, TakeVecZnxSliceImpl, TakeVmpPMatImpl, VecZnxBigAllocBytesImpl,
-        VecZnxDftAllocBytesImpl, VmpPMatAllocBytesImpl,
-    },
+    layouts::{Backend, Scratch, ScratchOwned},
+    oep::{ScratchAvailableImpl, ScratchFromBytesImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeSliceImpl},
 };
 
 use crate::cpu_fft64_avx::FFT64Avx;
@@ -61,178 +56,6 @@ &mut *(std::ptr::slice_from_raw_parts_mut(take_slice.as_mut_ptr() as *mut T, len)),
                 Scratch::from_bytes(rem_slice),
             )
         }
-    }
-}
-
-unsafe impl<B: Backend> TakeScalarZnxImpl<B> for FFT64Avx
-where
-    B: ScratchFromBytesImpl<B>,
-{
-    fn take_scalar_znx_impl(scratch: &mut Scratch<B>, n: usize, cols: usize) -> (ScalarZnx<&mut [u8]>, &mut Scratch<B>) {
-        let (take_slice, rem_slice) = take_slice_aligned(&mut scratch.data, ScalarZnx::alloc_bytes(n, cols));
-        (
-            ScalarZnx::from_data(take_slice, n, cols),
-            Scratch::from_bytes(rem_slice),
-        )
-    }
-}
-
-unsafe impl<B: Backend> TakeSvpPPolImpl<B> for FFT64Avx
-where
-    B: SvpPPolAllocBytesImpl<B> + ScratchFromBytesImpl<B>,
-{
-    fn take_svp_ppol_impl(scratch: &mut Scratch<B>, n: usize, cols: usize) -> (SvpPPol<&mut [u8], B>, &mut Scratch<B>) {
-        let (take_slice, rem_slice) = take_slice_aligned(&mut scratch.data, B::svp_ppol_alloc_bytes_impl(n, cols));
-        (
-            SvpPPol::from_data(take_slice, n, cols),
-            Scratch::from_bytes(rem_slice),
-        )
-    }
-}
-
-unsafe impl<B: Backend> TakeVecZnxImpl<B> for FFT64Avx
-where
-    B: ScratchFromBytesImpl<B>,
-{
-    fn take_vec_znx_impl(scratch: &mut Scratch<B>, n: usize, cols: usize, size: usize) -> (VecZnx<&mut [u8]>, &mut Scratch<B>) {
-        let (take_slice, rem_slice) = take_slice_aligned(&mut scratch.data, VecZnx::alloc_bytes(n, cols, size));
-        (
-            VecZnx::from_data(take_slice, n, cols, size),
-            Scratch::from_bytes(rem_slice),
-        )
-    }
-}
-
-unsafe impl<B: Backend> TakeVecZnxBigImpl<B> for FFT64Avx
-where
-    B: VecZnxBigAllocBytesImpl<B> + ScratchFromBytesImpl<B>,
-{
-    fn take_vec_znx_big_impl(
-        scratch: &mut Scratch<B>,
-        n: usize,
-        cols: usize,
-        size: usize,
-    ) -> (VecZnxBig<&mut [u8], B>, &mut Scratch<B>) {
-        let (take_slice, rem_slice) = take_slice_aligned(
-            &mut scratch.data,
-            B::vec_znx_big_alloc_bytes_impl(n, cols, size),
-        );
-        (
-            VecZnxBig::from_data(take_slice, n, cols, size),
-            Scratch::from_bytes(rem_slice),
-        )
-    }
-}
-
-unsafe impl<B: Backend> TakeVecZnxDftImpl<B> for FFT64Avx
-where
-    B: VecZnxDftAllocBytesImpl<B> + ScratchFromBytesImpl<B>,
-{
-    fn take_vec_znx_dft_impl(
-        scratch: &mut Scratch<B>,
-        n: usize,
-        cols: usize,
-        size: usize,
-    ) -> (VecZnxDft<&mut [u8], B>, &mut Scratch<B>) {
-        let (take_slice, rem_slice) = take_slice_aligned(
-            &mut scratch.data,
-            B::vec_znx_dft_alloc_bytes_impl(n, cols, size),
-        );
-
-        (
-            VecZnxDft::from_data(take_slice, n, cols, size),
-            Scratch::from_bytes(rem_slice),
-        )
-    }
-}
-
-unsafe impl<B: Backend> TakeVecZnxDftSliceImpl<B> for FFT64Avx
-where
-    B: VecZnxDftAllocBytesImpl<B> + ScratchFromBytesImpl<B> + TakeVecZnxDftImpl<B>,
-{
-    fn take_vec_znx_dft_slice_impl(
-        scratch: &mut Scratch<B>,
-        len: usize,
-        n: usize,
-        cols: usize,
-        size: usize,
-    ) -> (Vec<VecZnxDft<&mut [u8], B>>, &mut Scratch<B>) {
-        let mut scratch: &mut Scratch<B> = scratch;
-        let mut slice: Vec<VecZnxDft<&mut [u8], B>> = Vec::with_capacity(len);
-        for _ in 0..len {
-            let (znx, new_scratch) = B::take_vec_znx_dft_impl(scratch, n, cols, size);
-            scratch = new_scratch;
-            slice.push(znx);
-        }
-        (slice, scratch)
-    }
-}
-
-unsafe impl<B: Backend> TakeVecZnxSliceImpl<B> for FFT64Avx
-where
-    B: ScratchFromBytesImpl<B> + TakeVecZnxImpl<B>,
-{
-    fn take_vec_znx_slice_impl(
-        scratch: &mut Scratch<B>,
-        len: usize,
-        n: usize,
-        cols: usize,
-        size: usize,
-    ) -> (Vec<VecZnx<&mut [u8]>>, &mut Scratch<B>) {
-        let mut scratch: &mut Scratch<B> = scratch;
-        let mut slice: Vec<VecZnx<&mut [u8]>> = Vec::with_capacity(len);
-        for _ in 0..len {
-            let (znx, new_scratch) = B::take_vec_znx_impl(scratch, n, cols, size);
-            scratch = new_scratch;
-            slice.push(znx);
-        }
-        (slice, scratch)
-    }
-}
-
-unsafe impl<B: Backend> TakeVmpPMatImpl<B> for FFT64Avx
-where
-    B: VmpPMatAllocBytesImpl<B> + ScratchFromBytesImpl<B>,
-{
-    fn take_vmp_pmat_impl(
-        scratch: &mut Scratch<B>,
-        n: usize,
-        rows: usize,
-        cols_in: usize,
-        cols_out: usize,
-        size: usize,
-    ) -> (VmpPMat<&mut [u8], B>, &mut Scratch<B>) {
-        let (take_slice, rem_slice) = take_slice_aligned(
-            &mut scratch.data,
-            B::vmp_pmat_alloc_bytes_impl(n, rows, cols_in, cols_out, size),
-        );
-        (
-            VmpPMat::from_data(take_slice, n, rows, cols_in, cols_out, size),
-            Scratch::from_bytes(rem_slice),
-        )
-    }
-}
-
-unsafe impl<B: Backend> TakeMatZnxImpl<B> for FFT64Avx
-where
-    B: ScratchFromBytesImpl<B>,
-{
-    fn take_mat_znx_impl(
-        scratch: &mut Scratch<B>,
-        n: usize,
-        rows: usize,
-        cols_in: usize,
-        cols_out: usize,
-        size: usize,
-    ) -> (MatZnx<&mut [u8]>, &mut Scratch<B>) {
-        let (take_slice, rem_slice) = take_slice_aligned(
-            &mut scratch.data,
-            MatZnx::alloc_bytes(n, rows, cols_in, cols_out, size),
-        );
-        (
-            MatZnx::from_data(take_slice, n, rows, cols_in, cols_out, size),
-            Scratch::from_bytes(rem_slice),
-        )
     }
 }
 

@@ -22,7 +22,7 @@ }
 }
 
 unsafe impl SvpPPolAllocBytesImpl<Self> for FFT64Avx {
-    fn svp_ppol_alloc_bytes_impl(n: usize, cols: usize) -> usize {
+    fn svp_ppol_bytes_of_impl(n: usize, cols: usize) -> usize {
         Self::layout_prep_word_count() * n * cols * size_of::<f64>()
     }
 }

@@ -27,7 +27,7 @@ source::Source,
 };
 
 unsafe impl VecZnxBigAllocBytesImpl<Self> for FFT64Avx {
-    fn vec_znx_big_alloc_bytes_impl(n: usize, cols: usize, size: usize) -> usize {
+    fn vec_znx_big_bytes_of_impl(n: usize, cols: usize, size: usize) -> usize {
         Self::layout_big_word_count() * n * cols * size * size_of::<f64>()
     }
 }

@@ -24,7 +24,7 @@ }
 }
 
 unsafe impl VecZnxDftAllocBytesImpl<Self> for FFT64Avx {
-    fn vec_znx_dft_alloc_bytes_impl(n: usize, cols: usize, size: usize) -> usize {
+    fn vec_znx_dft_bytes_of_impl(n: usize, cols: usize, size: usize) -> usize {
         Self::layout_prep_word_count() * n * cols * size * size_of::<<FFT64Avx as Backend>::ScalarPrep>()
     }
 }

@@ -16,7 +16,7 @@
 use crate::cpu_fft64_avx::{FFT64Avx, module::FFT64ModuleHandle};
 
 unsafe impl VmpPMatAllocBytesImpl<Self> for FFT64Avx {
-    fn vmp_pmat_alloc_bytes_impl(n: usize, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> usize {
+    fn vmp_pmat_bytes_of_impl(n: usize, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> usize {
         Self::layout_prep_word_count() * n * rows * cols_in * cols_out * size * size_of::<f64>()
     }
 }

@@ -3,13 +3,8 @@
 use poulpy_hal::{
     DEFAULTALIGN, alloc_aligned,
     api::ScratchFromBytes,
-    layouts::{Backend, MatZnx, ScalarZnx, Scratch, ScratchOwned, SvpPPol, VecZnx, VecZnxBig, VecZnxDft, VmpPMat},
-    oep::{
-        ScratchAvailableImpl, ScratchFromBytesImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, SvpPPolAllocBytesImpl,
-        TakeMatZnxImpl, TakeScalarZnxImpl, TakeSliceImpl, TakeSvpPPolImpl, TakeVecZnxBigImpl, TakeVecZnxDftImpl,
-        TakeVecZnxDftSliceImpl, TakeVecZnxImpl, TakeVecZnxSliceImpl, TakeVmpPMatImpl, VecZnxBigAllocBytesImpl,
-        VecZnxDftAllocBytesImpl, VmpPMatAllocBytesImpl,
-    },
+    layouts::{Backend, Scratch, ScratchOwned},
+    oep::{ScratchAvailableImpl, ScratchFromBytesImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeSliceImpl},
 };
 
 use crate::cpu_fft64_ref::FFT64Ref;
@@ -61,178 +56,6 @@ &mut *(std::ptr::slice_from_raw_parts_mut(take_slice.as_mut_ptr() as *mut T, len)),
                 Scratch::from_bytes(rem_slice),
             )
         }
-    }
-}
-
-unsafe impl<B: Backend> TakeScalarZnxImpl<B> for FFT64Ref
-where
-    B: ScratchFromBytesImpl<B>,
-{
-    fn take_scalar_znx_impl(scratch: &mut Scratch<B>, n: usize, cols: usize) -> (ScalarZnx<&mut [u8]>, &mut Scratch<B>) {
-        let (take_slice, rem_slice) = take_slice_aligned(&mut scratch.data, ScalarZnx::alloc_bytes(n, cols));
-        (
-            ScalarZnx::from_data(take_slice, n, cols),
-            Scratch::from_bytes(rem_slice),
-        )
-    }
-}
-
-unsafe impl<B: Backend> TakeSvpPPolImpl<B> for FFT64Ref
-where
-    B: SvpPPolAllocBytesImpl<B> + ScratchFromBytesImpl<B>,
-{
-    fn take_svp_ppol_impl(scratch: &mut Scratch<B>, n: usize, cols: usize) -> (SvpPPol<&mut [u8], B>, &mut Scratch<B>) {
-        let (take_slice, rem_slice) = take_slice_aligned(&mut scratch.data, B::svp_ppol_alloc_bytes_impl(n, cols));
-        (
-            SvpPPol::from_data(take_slice, n, cols),
-            Scratch::from_bytes(rem_slice),
-        )
-    }
-}
-
-unsafe impl<B: Backend> TakeVecZnxImpl<B> for FFT64Ref
-where
-    B: ScratchFromBytesImpl<B>,
-{
-    fn take_vec_znx_impl(scratch: &mut Scratch<B>, n: usize, cols: usize, size: usize) -> (VecZnx<&mut [u8]>, &mut Scratch<B>) {
-        let (take_slice, rem_slice) = take_slice_aligned(&mut scratch.data, VecZnx::alloc_bytes(n, cols, size));
-        (
-            VecZnx::from_data(take_slice, n, cols, size),
-            Scratch::from_bytes(rem_slice),
-        )
-    }
-}
-
-unsafe impl<B: Backend> TakeVecZnxBigImpl<B> for FFT64Ref
-where
-    B: VecZnxBigAllocBytesImpl<B> + ScratchFromBytesImpl<B>,
-{
-    fn take_vec_znx_big_impl(
-        scratch: &mut Scratch<B>,
-        n: usize,
-        cols: usize,
-        size: usize,
-    ) -> (VecZnxBig<&mut [u8], B>, &mut Scratch<B>) {
-        let (take_slice, rem_slice) = take_slice_aligned(
-            &mut scratch.data,
-            B::vec_znx_big_alloc_bytes_impl(n, cols, size),
-        );
-        (
-            VecZnxBig::from_data(take_slice, n, cols, size),
-            Scratch::from_bytes(rem_slice),
-        )
-    }
-}
-
-unsafe impl<B: Backend> TakeVecZnxDftImpl<B> for FFT64Ref
-where
-    B: VecZnxDftAllocBytesImpl<B> + ScratchFromBytesImpl<B>,
-{
-    fn take_vec_znx_dft_impl(
-        scratch: &mut Scratch<B>,
-        n: usize,
-        cols: usize,
-        size: usize,
-    ) -> (VecZnxDft<&mut [u8], B>, &mut Scratch<B>) {
-        let (take_slice, rem_slice) = take_slice_aligned(
-            &mut scratch.data,
-            B::vec_znx_dft_alloc_bytes_impl(n, cols, size),
-        );
-
-        (
-            VecZnxDft::from_data(take_slice, n, cols, size),
-            Scratch::from_bytes(rem_slice),
-        )
-    }
-}
-
-unsafe impl<B: Backend> TakeVecZnxDftSliceImpl<B> for FFT64Ref
-where
-    B: VecZnxDftAllocBytesImpl<B> + ScratchFromBytesImpl<B> + TakeVecZnxDftImpl<B>,
-{
-    fn take_vec_znx_dft_slice_impl(
-        scratch: &mut Scratch<B>,
-        len: usize,
-        n: usize,
-        cols: usize,
-        size: usize,
-    ) -> (Vec<VecZnxDft<&mut [u8], B>>, &mut Scratch<B>) {
-        let mut scratch: &mut Scratch<B> = scratch;
-        let mut slice: Vec<VecZnxDft<&mut [u8], B>> = Vec::with_capacity(len);
-        for _ in 0..len {
-            let (znx, new_scratch) = B::take_vec_znx_dft_impl(scratch, n, cols, size);
-            scratch = new_scratch;
-            slice.push(znx);
-        }
-        (slice, scratch)
-    }
-}
-
-unsafe impl<B: Backend> TakeVecZnxSliceImpl<B> for FFT64Ref
-where
-    B: ScratchFromBytesImpl<B> + TakeVecZnxImpl<B>,
-{
-    fn take_vec_znx_slice_impl(
-        scratch: &mut Scratch<B>,
-        len: usize,
-        n: usize,
-        cols: usize,
-        size: usize,
-    ) -> (Vec<VecZnx<&mut [u8]>>, &mut Scratch<B>) {
-        let mut scratch: &mut Scratch<B> = scratch;
-        let mut slice: Vec<VecZnx<&mut [u8]>> = Vec::with_capacity(len);
-        for _ in 0..len {
-            let (znx, new_scratch) = B::take_vec_znx_impl(scratch, n, cols, size);
-            scratch = new_scratch;
-            slice.push(znx);
-        }
-        (slice, scratch)
-    }
-}
-
-unsafe impl<B: Backend> TakeVmpPMatImpl<B> for FFT64Ref
-where
-    B: VmpPMatAllocBytesImpl<B> + ScratchFromBytesImpl<B>,
-{
-    fn take_vmp_pmat_impl(
-        scratch: &mut Scratch<B>,
-        n: usize,
-        rows: usize,
-        cols_in: usize,
-        cols_out: usize,
-        size: usize,
-    ) -> (VmpPMat<&mut [u8], B>, &mut Scratch<B>) {
-        let (take_slice, rem_slice) = take_slice_aligned(
-            &mut scratch.data,
-            B::vmp_pmat_alloc_bytes_impl(n, rows, cols_in, cols_out, size),
-        );
-        (
-            VmpPMat::from_data(take_slice, n, rows, cols_in, cols_out, size),
-            Scratch::from_bytes(rem_slice),
-        )
-    }
-}
-
-unsafe impl<B: Backend> TakeMatZnxImpl<B> for FFT64Ref
-where
-    B: ScratchFromBytesImpl<B>,
-{
-    fn take_mat_znx_impl(
-        scratch: &mut Scratch<B>,
-        n: usize,
-        rows: usize,
-        cols_in: usize,
-        cols_out: usize,
-        size: usize,
-    ) -> (MatZnx<&mut [u8]>, &mut Scratch<B>) {
-        let (take_slice, rem_slice) = take_slice_aligned(
-            &mut scratch.data,
-            MatZnx::alloc_bytes(n, rows, cols_in, cols_out, size),
-        );
-        (
-            MatZnx::from_data(take_slice, n, rows, cols_in, cols_out, size),
-            Scratch::from_bytes(rem_slice),
-        )
     }
 }
 

@@ -22,7 +22,7 @@ }
 }
 
 unsafe impl SvpPPolAllocBytesImpl<Self> for FFT64Ref {
-    fn svp_ppol_alloc_bytes_impl(n: usize, cols: usize) -> usize {
+    fn svp_ppol_bytes_of_impl(n: usize, cols: usize) -> usize {
         Self::layout_prep_word_count() * n * cols * size_of::<f64>()
     }
 }

@@ -27,7 +27,7 @@ source::Source,
 };
 
 unsafe impl VecZnxBigAllocBytesImpl<Self> for FFT64Ref {
-    fn vec_znx_big_alloc_bytes_impl(n: usize, cols: usize, size: usize) -> usize {
+    fn vec_znx_big_bytes_of_impl(n: usize, cols: usize, size: usize) -> usize {
         Self::layout_big_word_count() * n * cols * size * size_of::<f64>()
     }
 }

@@ -24,7 +24,7 @@ }
 }
 
 unsafe impl VecZnxDftAllocBytesImpl<Self> for FFT64Ref {
-    fn vec_znx_dft_alloc_bytes_impl(n: usize, cols: usize, size: usize) -> usize {
+    fn vec_znx_dft_bytes_of_impl(n: usize, cols: usize, size: usize) -> usize {
         Self::layout_prep_word_count() * n * cols * size * size_of::<<FFT64Ref as Backend>::ScalarPrep>()
     }
 }

@@ -16,7 +16,7 @@
 use crate::cpu_fft64_ref::{FFT64Ref, module::FFT64ModuleHandle};
 
 unsafe impl VmpPMatAllocBytesImpl<Self> for FFT64Ref {
-    fn vmp_pmat_alloc_bytes_impl(n: usize, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> usize {
+    fn vmp_pmat_bytes_of_impl(n: usize, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> usize {
         Self::layout_prep_word_count() * n * rows * cols_in * cols_out * size * size_of::<f64>()
     }
 }

@@ -3,13 +3,8 @@
 use poulpy_hal::{
     DEFAULTALIGN, alloc_aligned,
     api::ScratchFromBytes,
-    layouts::{Backend, MatZnx, ScalarZnx, Scratch, ScratchOwned, SvpPPol, VecZnx, VecZnxBig, VecZnxDft, VmpPMat},
-    oep::{
-        ScratchAvailableImpl, ScratchFromBytesImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, SvpPPolAllocBytesImpl,
-        TakeMatZnxImpl, TakeScalarZnxImpl, TakeSliceImpl, TakeSvpPPolImpl, TakeVecZnxBigImpl, TakeVecZnxDftImpl,
-        TakeVecZnxDftSliceImpl, TakeVecZnxImpl, TakeVecZnxSliceImpl, TakeVmpPMatImpl, VecZnxBigAllocBytesImpl,
-        VecZnxDftAllocBytesImpl, VmpPMatAllocBytesImpl,
-    },
+    layouts::{Backend, Scratch, ScratchOwned},
+    oep::{ScratchAvailableImpl, ScratchFromBytesImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeSliceImpl},
 };
 
 use crate::cpu_spqlios::FFT64Spqlios;
@@ -61,178 +56,6 @@ &mut *(std::ptr::slice_from_raw_parts_mut(take_slice.as_mut_ptr() as *mut T, len)),
                 Scratch::from_bytes(rem_slice),
             )
         }
-    }
-}
-
-unsafe impl<B: Backend> TakeScalarZnxImpl<B> for FFT64Spqlios
-where
-    B: ScratchFromBytesImpl<B>,
-{
-    fn take_scalar_znx_impl(scratch: &mut Scratch<B>, n: usize, cols: usize) -> (ScalarZnx<&mut [u8]>, &mut Scratch<B>) {
-        let (take_slice, rem_slice) = take_slice_aligned(&mut scratch.data, ScalarZnx::alloc_bytes(n, cols));
-        (
-            ScalarZnx::from_data(take_slice, n, cols),
-            Scratch::from_bytes(rem_slice),
-        )
-    }
-}
-
-unsafe impl<B: Backend> TakeSvpPPolImpl<B> for FFT64Spqlios
-where
-    B: SvpPPolAllocBytesImpl<B> + ScratchFromBytesImpl<B>,
-{
-    fn take_svp_ppol_impl(scratch: &mut Scratch<B>, n: usize, cols: usize) -> (SvpPPol<&mut [u8], B>, &mut Scratch<B>) {
-        let (take_slice, rem_slice) = take_slice_aligned(&mut scratch.data, B::svp_ppol_alloc_bytes_impl(n, cols));
-        (
-            SvpPPol::from_data(take_slice, n, cols),
-            Scratch::from_bytes(rem_slice),
-        )
-    }
-}
-
-unsafe impl<B: Backend> TakeVecZnxImpl<B> for FFT64Spqlios
-where
-    B: ScratchFromBytesImpl<B>,
-{
-    fn take_vec_znx_impl(scratch: &mut Scratch<B>, n: usize, cols: usize, size: usize) -> (VecZnx<&mut [u8]>, &mut Scratch<B>) {
-        let (take_slice, rem_slice) = take_slice_aligned(&mut scratch.data, VecZnx::alloc_bytes(n, cols, size));
-        (
-            VecZnx::from_data(take_slice, n, cols, size),
-            Scratch::from_bytes(rem_slice),
-        )
-    }
-}
-
-unsafe impl<B: Backend> TakeVecZnxBigImpl<B> for FFT64Spqlios
-where
-    B: VecZnxBigAllocBytesImpl<B> + ScratchFromBytesImpl<B>,
-{
-    fn take_vec_znx_big_impl(
-        scratch: &mut Scratch<B>,
-        n: usize,
-        cols: usize,
-        size: usize,
-    ) -> (VecZnxBig<&mut [u8], B>, &mut Scratch<B>) {
-        let (take_slice, rem_slice) = take_slice_aligned(
-            &mut scratch.data,
-            B::vec_znx_big_alloc_bytes_impl(n, cols, size),
-        );
-        (
-            VecZnxBig::from_data(take_slice, n, cols, size),
-            Scratch::from_bytes(rem_slice),
-        )
-    }
-}
-
-unsafe impl<B: Backend> TakeVecZnxDftImpl<B> for FFT64Spqlios
-where
-    B: VecZnxDftAllocBytesImpl<B> + ScratchFromBytesImpl<B>,
-{
-    fn take_vec_znx_dft_impl(
-        scratch: &mut Scratch<B>,
-        n: usize,
-        cols: usize,
-        size: usize,
-    ) -> (VecZnxDft<&mut [u8], B>, &mut Scratch<B>) {
-        let (take_slice, rem_slice) = take_slice_aligned(
-            &mut scratch.data,
-            B::vec_znx_dft_alloc_bytes_impl(n, cols, size),
-        );
-
-        (
-            VecZnxDft::from_data(take_slice, n, cols, size),
-            Scratch::from_bytes(rem_slice),
-        )
-    }
-}
-
-unsafe impl<B: Backend> TakeVecZnxDftSliceImpl<B> for FFT64Spqlios
-where
-    B: VecZnxDftAllocBytesImpl<B> + ScratchFromBytesImpl<B> + TakeVecZnxDftImpl<B>,
-{
-    fn take_vec_znx_dft_slice_impl(
-        scratch: &mut Scratch<B>,
-        len: usize,
-        n: usize,
-        cols: usize,
-        size: usize,
-    ) -> (Vec<VecZnxDft<&mut [u8], B>>, &mut Scratch<B>) {
-        let mut scratch: &mut Scratch<B> = scratch;
-        let mut slice: Vec<VecZnxDft<&mut [u8], B>> = Vec::with_capacity(len);
-        for _ in 0..len {
-            let (znx, new_scratch) = B::take_vec_znx_dft_impl(scratch, n, cols, size);
-            scratch = new_scratch;
-            slice.push(znx);
-        }
-        (slice, scratch)
-    }
-}
-
-unsafe impl<B: Backend> TakeVecZnxSliceImpl<B> for FFT64Spqlios
-where
-    B: ScratchFromBytesImpl<B> + TakeVecZnxImpl<B>,
-{
-    fn take_vec_znx_slice_impl(
-        scratch: &mut Scratch<B>,
-        len: usize,
-        n: usize,
-        cols: usize,
-        size: usize,
-    ) -> (Vec<VecZnx<&mut [u8]>>, &mut Scratch<B>) {
-        let mut scratch: &mut Scratch<B> = scratch;
-        let mut slice: Vec<VecZnx<&mut [u8]>> = Vec::with_capacity(len);
-        for _ in 0..len {
-            let (znx, new_scratch) = B::take_vec_znx_impl(scratch, n, cols, size);
-            scratch = new_scratch;
-            slice.push(znx);
-        }
-        (slice, scratch)
-    }
-}
-
-unsafe impl<B: Backend> TakeVmpPMatImpl<B> for FFT64Spqlios
-where
-    B: VmpPMatAllocBytesImpl<B> + ScratchFromBytesImpl<B>,
-{
-    fn take_vmp_pmat_impl(
-        scratch: &mut Scratch<B>,
-        n: usize,
-        rows: usize,
-        cols_in: usize,
-        cols_out: usize,
-        size: usize,
-    ) -> (VmpPMat<&mut [u8], B>, &mut Scratch<B>) {
-        let (take_slice, rem_slice) = take_slice_aligned(
-            &mut scratch.data,
-            B::vmp_pmat_alloc_bytes_impl(n, rows, cols_in, cols_out, size),
-        );
-        (
-            VmpPMat::from_data(take_slice, n, rows, cols_in, cols_out, size),
-            Scratch::from_bytes(rem_slice),
-        )
-    }
-}
-
-unsafe impl<B: Backend> TakeMatZnxImpl<B> for FFT64Spqlios
-where
-    B: ScratchFromBytesImpl<B>,
-{
-    fn take_mat_znx_impl(
-        scratch: &mut Scratch<B>,
-        n: usize,
-        rows: usize,
-        cols_in: usize,
-        cols_out: usize,
-        size: usize,
-    ) -> (MatZnx<&mut [u8]>, &mut Scratch<B>) {
-        let (take_slice, rem_slice) = take_slice_aligned(
-            &mut scratch.data,
-            MatZnx::alloc_bytes(n, rows, cols_in, cols_out, size),
-        );
-        (
-            MatZnx::from_data(take_slice, n, rows, cols_in, cols_out, size),
-            Scratch::from_bytes(rem_slice),
-        )
     }
 }
 

@@ -27,7 +27,7 @@ }
 }
 
 unsafe impl SvpPPolAllocBytesImpl<Self> for FFT64Spqlios {
-    fn svp_ppol_alloc_bytes_impl(n: usize, cols: usize) -> usize {
+    fn svp_ppol_bytes_of_impl(n: usize, cols: usize) -> usize {
         FFT64Spqlios::layout_prep_word_count() * n * cols * size_of::<f64>()
     }
 }

@@ -22,7 +22,7 @@ source::Source,
 };
 
 unsafe impl VecZnxBigAllocBytesImpl<Self> for FFT64Spqlios {
-    fn vec_znx_big_alloc_bytes_impl(n: usize, cols: usize, size: usize) -> usize {
+    fn vec_znx_big_bytes_of_impl(n: usize, cols: usize, size: usize) -> usize {
         Self::layout_big_word_count() * n * cols * size * size_of::<f64>()
     }
 }

@@ -30,7 +30,7 @@ }
 }
 
 unsafe impl VecZnxDftAllocBytesImpl<Self> for FFT64Spqlios {
-    fn vec_znx_dft_alloc_bytes_impl(n: usize, cols: usize, size: usize) -> usize {
+    fn vec_znx_dft_bytes_of_impl(n: usize, cols: usize, size: usize) -> usize {
         Self::layout_prep_word_count() * n * cols * size * size_of::<<FFT64Spqlios as Backend>::ScalarPrep>()
     }
 }

@@ -16,7 +16,7 @@ ffi::{vec_znx_dft::vec_znx_dft_t, vmp},
 };
 
 unsafe impl VmpPMatAllocBytesImpl<Self> for FFT64Spqlios {
-    fn vmp_pmat_alloc_bytes_impl(n: usize, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> usize {
+    fn vmp_pmat_bytes_of_impl(n: usize, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> usize {
         Self::layout_prep_word_count() * n * rows * cols_in * cols_out * size * size_of::<f64>()
     }
 }

@@ -18,7 +18,7 @@ }
 }
 
 unsafe impl SvpPPolAllocBytesImpl<Self> for NTT120 {
-    fn svp_ppol_alloc_bytes_impl(n: usize, cols: usize) -> usize {
+    fn svp_ppol_bytes_of_impl(n: usize, cols: usize) -> usize {
         NTT120::layout_prep_word_count() * n * cols * size_of::<i64>()
     }
 }

@@ -3,7 +3,7 @@
 use crate::cpu_spqlios::NTT120;
 
 unsafe impl VecZnxBigAllocBytesImpl<NTT120> for NTT120 {
-    fn vec_znx_big_alloc_bytes_impl(n: usize, cols: usize, size: usize) -> usize {
+    fn vec_znx_big_bytes_of_impl(n: usize, cols: usize, size: usize) -> usize {
         NTT120::layout_big_word_count() * n * cols * size * size_of::<i128>()
     }
 }

@@ -6,7 +6,7 @@
 use crate::cpu_spqlios::NTT120;
 
 unsafe impl VecZnxDftAllocBytesImpl<NTT120> for NTT120 {
-    fn vec_znx_dft_alloc_bytes_impl(n: usize, cols: usize, size: usize) -> usize {
+    fn vec_znx_dft_bytes_of_impl(n: usize, cols: usize, size: usize) -> usize {
         NTT120::layout_prep_word_count() * n * cols * size * size_of::<i64>()
     }
 }

@@ -52,8 +52,8 @@ let mut source_xa: Source = Source::new([2u8; 32]);
 
     // Scratch space
     let mut scratch: ScratchOwned<FFT64> = ScratchOwned::alloc(
-        GLWECiphertext::encrypt_sk_scratch_space(&module, n, base2k, ct.k())
-            | GLWECiphertext::decrypt_scratch_space(&module, n, base2k, ct.k()),
+        GLWECiphertext::encrypt_sk_tmp_bytes(&module, n, base2k, ct.k())
+            | GLWECiphertext::decrypt_tmp_bytes(&module, n, base2k, ct.k()),
     );
 
     // Generate secret-key

@@ -1,7 +1,6 @@
 use poulpy_core::layouts::{
-    Base2K, Degree, Dnum, Dsize, GGSWCiphertext, GGSWCiphertextLayout, GLWECiphertext, GLWECiphertextLayout, GLWESecret, Rank,
-    TorusPrecision,
-    prepared::{GGSWCiphertextPrepared, GLWESecretPrepared, PrepareAlloc},
+    Base2K, Dnum, Dsize, GGSW, GGSWLayout, GLWE, GLWELayout, GLWESecret, Rank, RingDegree, TorusPrecision,
+    prepared::{GGSWPrepared, GLWESecretPrepared, PrepareAlloc},
 };
 use std::hint::black_box;
 
@@ -29,7 +28,7 @@
     fn runner(p: Params) -> impl FnMut() {
         let module: Module<FFT64Spqlios> = Module::<FFT64Spqlios>::new(1 << p.log_n);
 
-        let n: Degree = Degree(module.n() as u32);
+        let n: RingDegree = RingDegree(module.n() as u32);
         let base2k: Base2K = p.base2k;
         let k_ct_in: TorusPrecision = p.k_ct_in;
         let k_ct_out: TorusPrecision = p.k_ct_out;
@@ -39,7 +38,7 @@ let dsize: Dsize = Dsize(1);
 
         let dnum: Dnum = Dnum(1); //(p.k_ct_in.div_ceil(p.base2k);
 
-        let ggsw_layout: GGSWCiphertextLayout = GGSWCiphertextLayout {
+        let ggsw_layout: GGSWLayout = GGSWLayout {
             n,
             base2k,
             k: k_ggsw,
@@ -48,36 +47,36 @@ dsize: dsize,
             rank,
         };
 
-        let glwe_out_layout: GLWECiphertextLayout = GLWECiphertextLayout {
+        let glwe_out_layout: GLWELayout = GLWELayout {
             n,
             base2k,
             k: k_ct_out,
             rank,
         };
 
-        let glwe_in_layout: GLWECiphertextLayout = GLWECiphertextLayout {
+        let glwe_in_layout: GLWELayout = GLWELayout {
             n,
             base2k,
             k: k_ct_in,
             rank,
         };
 
-        let mut ct_ggsw: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(&ggsw_layout);
-        let mut ct_glwe_in: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&glwe_in_layout);
-        let mut ct_glwe_out: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&glwe_out_layout);
+        let mut ct_ggsw: GGSW<Vec<u8>> = GGSW::alloc_from_infos(&ggsw_layout);
+        let mut ct_glwe_in: GLWE<Vec<u8>> = GLWE::alloc_from_infos(&glwe_in_layout);
+        let mut ct_glwe_out: GLWE<Vec<u8>> = GLWE::alloc_from_infos(&glwe_out_layout);
         let pt_rgsw: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n.into(), 1);
 
         let mut scratch: ScratchOwned<FFT64Spqlios> = ScratchOwned::alloc(
-            GGSWCiphertext::encrypt_sk_scratch_space(&module, &ggsw_layout)
-                | GLWECiphertext::encrypt_sk_scratch_space(&module, &glwe_in_layout)
-                | GLWECiphertext::external_product_scratch_space(&module, &glwe_out_layout, &glwe_in_layout, &ggsw_layout),
+            GGSW::encrypt_sk_tmp_bytes(&module, &ggsw_layout)
+                | GLWE::encrypt_sk_tmp_bytes(&module, &glwe_in_layout)
+                | GLWE::external_product_tmp_bytes(&module, &glwe_out_layout, &glwe_in_layout, &ggsw_layout),
         );
 
         let mut source_xs = Source::new([0u8; 32]);
         let mut source_xe = Source::new([0u8; 32]);
         let mut source_xa = Source::new([0u8; 32]);
 
-        let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(&glwe_in_layout);
+        let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_in_layout);
         sk.fill_ternary_prob(0.5, &mut source_xs);
         let sk_dft: GLWESecretPrepared<Vec<u8>, FFT64Spqlios> = sk.prepare_alloc(&module, scratch.borrow());
 
@@ -98,7 +97,7 @@ &mut source_xe,
             scratch.borrow(),
         );
 
-        let ggsw_prepared: GGSWCiphertextPrepared<Vec<u8>, FFT64Spqlios> = ct_ggsw.prepare_alloc(&module, scratch.borrow());
+        let ggsw_prepared: GGSWPrepared<Vec<u8>, FFT64Spqlios> = ct_ggsw.prepare_alloc(&module, scratch.borrow());
 
         move || {
             ct_glwe_out.external_product(&module, &ct_glwe_in, &ggsw_prepared, scratch.borrow());
@@ -138,7 +137,7 @@
     fn runner(p: Params) -> impl FnMut() {
         let module: Module<FFT64Spqlios> = Module::<FFT64Spqlios>::new(1 << p.log_n);
 
-        let n: Degree = Degree(module.n() as u32);
+        let n: RingDegree = RingDegree(module.n() as u32);
         let base2k: Base2K = p.base2k;
         let k_glwe: TorusPrecision = p.k_ct;
         let k_ggsw: TorusPrecision = p.k_ggsw;
@@ -147,7 +146,7 @@ let dsize: Dsize = Dsize(1);
 
         let dnum: Dnum = p.k_ct.div_ceil(p.base2k).into();
 
-        let ggsw_layout: GGSWCiphertextLayout = GGSWCiphertextLayout {
+        let ggsw_layout: GGSWLayout = GGSWLayout {
             n,
             base2k,
             k: k_ggsw,
@@ -156,28 +155,28 @@ dsize: dsize,
             rank,
         };
 
-        let glwe_layout: GLWECiphertextLayout = GLWECiphertextLayout {
+        let glwe_layout: GLWELayout = GLWELayout {
             n,
             base2k,
             k: k_glwe,
             rank,
         };
 
-        let mut ct_ggsw: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(&ggsw_layout);
-        let mut ct_glwe: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&glwe_layout);
+        let mut ct_ggsw: GGSW<Vec<u8>> = GGSW::alloc_from_infos(&ggsw_layout);
+        let mut ct_glwe: GLWE<Vec<u8>> = GLWE::alloc_from_infos(&glwe_layout);
         let pt_rgsw: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n.into(), 1);
 
         let mut scratch: ScratchOwned<FFT64Spqlios> = ScratchOwned::alloc(
-            GGSWCiphertext::encrypt_sk_scratch_space(&module, &ggsw_layout)
-                | GLWECiphertext::encrypt_sk_scratch_space(&module, &glwe_layout)
-                | GLWECiphertext::external_product_inplace_scratch_space(&module, &glwe_layout, &ggsw_layout),
+            GGSW::encrypt_sk_tmp_bytes(&module, &ggsw_layout)
+                | GLWE::encrypt_sk_tmp_bytes(&module, &glwe_layout)
+                | GLWE::external_product_inplace_tmp_bytes(&module, &glwe_layout, &ggsw_layout),
         );
 
         let mut source_xs: Source = Source::new([0u8; 32]);
         let mut source_xe: Source = Source::new([0u8; 32]);
         let mut source_xa: Source = Source::new([0u8; 32]);
 
-        let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(&glwe_layout);
+        let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_layout);
         sk.fill_ternary_prob(0.5, &mut source_xs);
         let sk_dft: GLWESecretPrepared<Vec<u8>, FFT64Spqlios> = sk.prepare_alloc(&module, scratch.borrow());
 
@@ -198,7 +197,7 @@ &mut source_xe,
             scratch.borrow(),
         );
 
-        let ggsw_prepared: GGSWCiphertextPrepared<Vec<u8>, FFT64Spqlios> = ct_ggsw.prepare_alloc(&module, scratch.borrow());
+        let ggsw_prepared: GGSWPrepared<Vec<u8>, FFT64Spqlios> = ct_ggsw.prepare_alloc(&module, scratch.borrow());
 
         move || {
             let scratch_borrow = scratch.borrow();

@@ -1,7 +1,7 @@
 use poulpy_core::layouts::{
-    Base2K, Degree, Dnum, Dsize, GGLWEAutomorphismKey, GGLWEAutomorphismKeyLayout, GGLWESwitchingKey, GGLWESwitchingKeyLayout,
-    GLWECiphertext, GLWECiphertextLayout, GLWESecret, Rank, TorusPrecision,
-    prepared::{GGLWEAutomorphismKeyPrepared, GGLWESwitchingKeyPrepared, GLWESecretPrepared, PrepareAlloc},
+    AutomorphismKey, AutomorphismKeyLayout, Base2K, Dnum, Dsize, GLWE, GLWELayout, GLWESecret, GLWESwitchingKey,
+    GLWESwitchingKeyLayout, Rank, RingDegree, TorusPrecision,
+    prepared::{AutomorphismKeyPrepared, GLWESecretPrepared, GLWESwitchingKeyPrepared, PrepareAlloc},
 };
 use std::{hint::black_box, time::Duration};
 
@@ -29,7 +29,7 @@
     fn runner(p: Params) -> impl FnMut() {
         let module: Module<FFT64Spqlios> = Module::<FFT64Spqlios>::new(1 << p.log_n);
 
-        let n: Degree = Degree(module.n() as u32);
+        let n: RingDegree = RingDegree(module.n() as u32);
         let base2k: Base2K = p.base2k;
         let k_glwe_in: TorusPrecision = p.k_ct_in;
         let k_glwe_out: TorusPrecision = p.k_ct_out;
@@ -39,7 +39,7 @@ let dsize: Dsize = p.dsize;
 
         let dnum: Dnum = p.k_ct_in.div_ceil(p.base2k.0 * dsize.0).into();
 
-        let gglwe_atk_layout: GGLWEAutomorphismKeyLayout = GGLWEAutomorphismKeyLayout {
+        let gglwe_atk_layout: AutomorphismKeyLayout = AutomorphismKeyLayout {
             n,
             base2k,
             k: k_gglwe,
@@ -48,28 +48,28 @@ rank,
             dsize,
         };
 
-        let glwe_in_layout: GLWECiphertextLayout = GLWECiphertextLayout {
+        let glwe_in_layout: GLWELayout = GLWELayout {
             n,
             base2k,
             k: k_glwe_in,
             rank,
         };
 
-        let glwe_out_layout: GLWECiphertextLayout = GLWECiphertextLayout {
+        let glwe_out_layout: GLWELayout = GLWELayout {
             n,
             base2k,
             k: k_glwe_out,
             rank,
         };
 
-        let mut ksk: GGLWEAutomorphismKey<Vec<u8>> = GGLWEAutomorphismKey::alloc(&gglwe_atk_layout);
-        let mut ct_in: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&glwe_in_layout);
-        let mut ct_out: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&glwe_out_layout);
+        let mut ksk: AutomorphismKey<Vec<u8>> = AutomorphismKey::alloc_from_infos(&gglwe_atk_layout);
+        let mut ct_in: GLWE<Vec<u8>> = GLWE::alloc_from_infos(&glwe_in_layout);
+        let mut ct_out: GLWE<Vec<u8>> = GLWE::alloc_from_infos(&glwe_out_layout);
 
         let mut scratch: ScratchOwned<FFT64Spqlios> = ScratchOwned::alloc(
-            GGLWESwitchingKey::encrypt_sk_scratch_space(&module, &gglwe_atk_layout)
-                | GLWECiphertext::encrypt_sk_scratch_space(&module, &glwe_in_layout)
-                | GLWECiphertext::keyswitch_scratch_space(
+            GLWESwitchingKey::encrypt_sk_tmp_bytes(&module, &gglwe_atk_layout)
+                | GLWE::encrypt_sk_tmp_bytes(&module, &glwe_in_layout)
+                | GLWE::keyswitch_tmp_bytes(
                     &module,
                     &glwe_out_layout,
                     &glwe_in_layout,
@@ -81,7 +81,7 @@ let mut source_xs: Source = Source::new([0u8; 32]);
         let mut source_xe: Source = Source::new([0u8; 32]);
         let mut source_xa: Source = Source::new([0u8; 32]);
 
-        let mut sk_in: GLWESecret<Vec<u8>> = GLWESecret::alloc(&glwe_in_layout);
+        let mut sk_in: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_in_layout);
         sk_in.fill_ternary_prob(0.5, &mut source_xs);
         let sk_in_dft: GLWESecretPrepared<Vec<u8>, FFT64Spqlios> = sk_in.prepare_alloc(&module, scratch.borrow());
 
@@ -102,7 +102,7 @@ &mut source_xe,
             scratch.borrow(),
         );
 
-        let ksk_prepared: GGLWEAutomorphismKeyPrepared<Vec<u8>, _> = ksk.prepare_alloc(&module, scratch.borrow());
+        let ksk_prepared: AutomorphismKeyPrepared<Vec<u8>, _> = ksk.prepare_alloc(&module, scratch.borrow());
 
         move || {
             ct_out.automorphism(&module, &ct_in, &ksk_prepared, scratch.borrow());
@@ -148,7 +148,7 @@
     fn runner(p: Params) -> impl FnMut() {
         let module: Module<FFT64Spqlios> = Module::<FFT64Spqlios>::new(1 << p.log_n);
 
-        let n: Degree = Degree(module.n() as u32);
+        let n: RingDegree = RingDegree(module.n() as u32);
         let base2k: Base2K = p.base2k;
         let k_ct: TorusPrecision = p.k_ct;
         let k_ksk: TorusPrecision = p.k_ksk;
@@ -157,7 +157,7 @@ let dsize: Dsize = Dsize(1);
 
         let dnum: Dnum = p.k_ct.div_ceil(p.base2k).into();
 
-        let gglwe_layout: GGLWESwitchingKeyLayout = GGLWESwitchingKeyLayout {
+        let gglwe_layout: GLWESwitchingKeyLayout = GLWESwitchingKeyLayout {
             n,
             base2k,
             k: k_ksk,
@@ -167,31 +167,31 @@ rank_in: rank,
             rank_out: rank,
         };
 
-        let glwe_layout: GLWECiphertextLayout = GLWECiphertextLayout {
+        let glwe_layout: GLWELayout = GLWELayout {
             n,
             base2k,
             k: k_ct,
             rank,
         };
 
-        let mut ksk: GGLWESwitchingKey<Vec<u8>> = GGLWESwitchingKey::alloc(&gglwe_layout);
-        let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&glwe_layout);
+        let mut ksk: GLWESwitchingKey<Vec<u8>> = GLWESwitchingKey::alloc_from_infos(&gglwe_layout);
+        let mut ct: GLWE<Vec<u8>> = GLWE::alloc_from_infos(&glwe_layout);
 
         let mut scratch: ScratchOwned<FFT64Spqlios> = ScratchOwned::alloc(
-            GGLWESwitchingKey::encrypt_sk_scratch_space(&module, &gglwe_layout)
-                | GLWECiphertext::encrypt_sk_scratch_space(&module, &glwe_layout)
-                | GLWECiphertext::keyswitch_inplace_scratch_space(&module, &glwe_layout, &gglwe_layout),
+            GLWESwitchingKey::encrypt_sk_tmp_bytes(&module, &gglwe_layout)
+                | GLWE::encrypt_sk_tmp_bytes(&module, &glwe_layout)
+                | GLWE::keyswitch_inplace_tmp_bytes(&module, &glwe_layout, &gglwe_layout),
         );
 
         let mut source_xs: Source = Source::new([0u8; 32]);
         let mut source_xe: Source = Source::new([0u8; 32]);
         let mut source_xa: Source = Source::new([0u8; 32]);
 
-        let mut sk_in: GLWESecret<Vec<u8>> = GLWESecret::alloc(&glwe_layout);
+        let mut sk_in: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_layout);
         sk_in.fill_ternary_prob(0.5, &mut source_xs);
         let sk_in_dft: GLWESecretPrepared<Vec<u8>, FFT64Spqlios> = sk_in.prepare_alloc(&module, scratch.borrow());
 
-        let mut sk_out: GLWESecret<Vec<u8>> = GLWESecret::alloc(&glwe_layout);
+        let mut sk_out: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_layout);
         sk_out.fill_ternary_prob(0.5, &mut source_xs);
 
         ksk.encrypt_sk(
@@ -211,7 +211,7 @@ &mut source_xe,
             scratch.borrow(),
         );
 
-        let ksk_prepared: GGLWESwitchingKeyPrepared<Vec<u8>, FFT64Spqlios> = ksk.prepare_alloc(&module, scratch.borrow());
+        let ksk_prepared: GLWESwitchingKeyPrepared<Vec<u8>, FFT64Spqlios> = ksk.prepare_alloc(&module, scratch.borrow());
 
         move || {
             ct.keyswitch_inplace(&module, &ksk_prepared, scratch.borrow());

@@ -2,8 +2,7 @@ use poulpy_backend::cpu_spqlios::FFT64Spqlios;
 use poulpy_core::{
     GLWEOperations, SIGMA,
     layouts::{
-        Base2K, Degree, GLWECiphertext, GLWECiphertextLayout, GLWEPlaintext, GLWEPlaintextLayout, GLWESecret, LWEInfos, Rank,
-        TorusPrecision,
+        Base2K, GLWE, GLWELayout, GLWEPlaintext, GLWEPlaintextLayout, GLWESecret, LWEInfos, Rank, RingDegree, TorusPrecision,
         prepared::{GLWESecretPrepared, PrepareAlloc},
     },
 };
@@ -17,7 +16,7 @@ fn main() {
     // Ring degree
     let log_n: usize = 10;
 
-    let n: Degree = Degree(1 << log_n);
+    let n: RingDegree = RingDegree(1 << log_n);
 
     // Base-2-k (implicit digit decomposition)
     let base2k: Base2K = Base2K(14);
@@ -34,7 +33,7 @@
     // Instantiate Module (DFT Tables)
     let module: Module<FFT64Spqlios> = Module::<FFT64Spqlios>::new(n.0 as u64);
 
-    let glwe_ct_infos: GLWECiphertextLayout = GLWECiphertextLayout {
+    let glwe_ct_infos: GLWELayout = GLWELayout {
         n,
         base2k,
         k: k_ct,
@@ -44,9 +43,9 @@
     let glwe_pt_infos: GLWEPlaintextLayout = GLWEPlaintextLayout { n, base2k, k: k_pt };
 
     // Allocates ciphertext & plaintexts
-    let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&glwe_ct_infos);
-    let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(&glwe_pt_infos);
-    let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(&glwe_pt_infos);
+    let mut ct: GLWE<Vec<u8>> = GLWE::alloc_from_infos(&glwe_ct_infos);
+    let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc_from_infos(&glwe_pt_infos);
+    let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc_from_infos(&glwe_pt_infos);
 
     // CPRNG
     let mut source_xs: Source = Source::new([0u8; 32]);
@@ -55,12 +54,11 @@ let mut source_xa: Source = Source::new([2u8; 32]);
 
     // Scratch space
     let mut scratch: ScratchOwned<FFT64Spqlios> = ScratchOwned::alloc(
-        GLWECiphertext::encrypt_sk_scratch_space(&module, &glwe_ct_infos)
-            | GLWECiphertext::decrypt_scratch_space(&module, &glwe_ct_infos),
+        GLWE::encrypt_sk_tmp_bytes(&module, &glwe_ct_infos) | GLWE::decrypt_tmp_bytes(&module, &glwe_ct_infos),
     );
 
     // Generate secret-key
-    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(&glwe_ct_infos);
+    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_ct_infos);
     sk.fill_ternary_prob(0.5, &mut source_xs);
 
     // Backend-prepared secret

@@ -1,16 +1,16 @@
 use poulpy_hal::{
     api::{
-        ScratchAvailable, TakeVecZnx, TakeVecZnxDft, VecZnxAutomorphism, VecZnxAutomorphismInplace, VecZnxBigAddSmallInplace,
-        VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume,
-        VecZnxNormalize, VecZnxNormalizeTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+        ScratchAvailable, VecZnxAutomorphism, VecZnxAutomorphismInplace, VecZnxBigAddSmallInplace, VecZnxBigNormalize,
+        VecZnxBigNormalizeTmpBytes, VecZnxDftApply, VecZnxDftBytesOf, VecZnxIdftApplyConsume, VecZnxNormalize,
+        VecZnxNormalizeTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch, ZnxZero},
 };
 
-use crate::layouts::{GGLWEAutomorphismKey, GGLWEInfos, GLWECiphertext, prepared::GGLWEAutomorphismKeyPrepared};
+use crate::layouts::{AutomorphismKey, GGLWEInfos, GLWE, prepared::AutomorphismKeyPrepared};
 
-impl GGLWEAutomorphismKey<Vec<u8>> {
-    pub fn automorphism_scratch_space<B: Backend, OUT, IN, KEY>(
+impl AutomorphismKey<Vec<u8>> {
+    pub fn automorphism_tmp_bytes<B: Backend, OUT, IN, KEY>(
         module: &Module<B>,
         out_infos: &OUT,
         in_infos: &IN,
@@ -20,9 +20,9 @@ where
         OUT: GGLWEInfos,
         IN: GGLWEInfos,
         KEY: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
+        Module<B>: VecZnxDftBytesOf + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
     {
-        GLWECiphertext::keyswitch_scratch_space(
+        GLWE::keyswitch_tmp_bytes(
             module,
             &out_infos.glwe_layout(),
             &in_infos.glwe_layout(),
@@ -30,25 +30,25 @@ key_infos,
         )
     }
 
-    pub fn automorphism_inplace_scratch_space<B: Backend, OUT, KEY>(module: &Module<B>, out_infos: &OUT, key_infos: &KEY) -> usize
+    pub fn automorphism_inplace_tmp_bytes<B: Backend, OUT, KEY>(module: &Module<B>, out_infos: &OUT, key_infos: &KEY) -> usize
     where
         OUT: GGLWEInfos,
         KEY: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
+        Module<B>: VecZnxDftBytesOf + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
     {
-        GGLWEAutomorphismKey::automorphism_scratch_space(module, out_infos, out_infos, key_infos)
+        AutomorphismKey::automorphism_tmp_bytes(module, out_infos, out_infos, key_infos)
     }
 }
 
-impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
+impl<DataSelf: DataMut> AutomorphismKey<DataSelf> {
     pub fn automorphism<DataLhs: DataRef, DataRhs: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
-        lhs: &GGLWEAutomorphismKey<DataLhs>,
-        rhs: &GGLWEAutomorphismKeyPrepared<DataRhs, B>,
+        lhs: &AutomorphismKey<DataLhs>,
+        rhs: &AutomorphismKeyPrepared<DataRhs, B>,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxDftAllocBytes
+        Module<B>: VecZnxDftBytesOf
             + VmpApplyDftToDftTmpBytes
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
@@ -61,7 +61,7 @@ + VecZnxAutomorphism
             + VecZnxAutomorphismInplace<B>
             + VecZnxNormalize<B>
             + VecZnxNormalizeTmpBytes,
-        Scratch<B>: ScratchAvailable + TakeVecZnxDft<B> + TakeVecZnx,
+        Scratch<B>: ScratchAvailable,
     {
         #[cfg(debug_assertions)]
         {
@@ -103,8 +103,8 @@ let p_inv: i64 = module.galois_element_inv(p);
 
         (0..self.rank_in().into()).for_each(|col_i| {
             (0..self.dnum().into()).for_each(|row_j| {
-                let mut res_ct: GLWECiphertext<&mut [u8]> = self.at_mut(row_j, col_i);
-                let lhs_ct: GLWECiphertext<&[u8]> = lhs.at(row_j, col_i);
+                let mut res_ct: GLWE<&mut [u8]> = self.at_mut(row_j, col_i);
+                let lhs_ct: GLWE<&[u8]> = lhs.at(row_j, col_i);
 
                 // Reverts the automorphism X^{-k}: (-pi^{-1}_{k}(s)a + s, a) to (-sa + pi_{k}(s), a)
                 (0..cols_out).for_each(|i| {
@@ -133,10 +133,10 @@
     pub fn automorphism_inplace<DataRhs: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
-        rhs: &GGLWEAutomorphismKeyPrepared<DataRhs, B>,
+        rhs: &AutomorphismKeyPrepared<DataRhs, B>,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxDftAllocBytes
+        Module<B>: VecZnxDftBytesOf
             + VmpApplyDftToDftTmpBytes
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
@@ -149,7 +149,7 @@ + VecZnxAutomorphism
             + VecZnxAutomorphismInplace<B>
             + VecZnxNormalize<B>
             + VecZnxNormalizeTmpBytes,
-        Scratch<B>: ScratchAvailable + TakeVecZnxDft<B> + TakeVecZnx,
+        Scratch<B>: ScratchAvailable,
     {
         #[cfg(debug_assertions)]
         {
@@ -176,7 +176,7 @@ let p_inv = module.galois_element_inv(p);
 
         (0..self.rank_in().into()).for_each(|col_i| {
             (0..self.dnum().into()).for_each(|row_j| {
-                let mut res_ct: GLWECiphertext<&mut [u8]> = self.at_mut(row_j, col_i);
+                let mut res_ct: GLWE<&mut [u8]> = self.at_mut(row_j, col_i);
 
                 // Reverts the automorphism X^{-k}: (-pi^{-1}_{k}(s)a + s, a) to (-sa + pi_{k}(s), a)
                 (0..cols_out).for_each(|i| {

@@ -1,20 +1,20 @@
 use poulpy_hal::{
     api::{
-        ScratchAvailable, TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft, VecZnxAutomorphismInplace, VecZnxBigAddSmallInplace,
-        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxDftAddInplace, VecZnxDftAllocBytes,
-        VecZnxDftApply, VecZnxDftCopy, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA, VecZnxNormalize, VecZnxNormalizeTmpBytes,
-        VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+        ScratchAvailable, VecZnxAutomorphismInplace, VecZnxBigAddSmallInplace, VecZnxBigBytesOf, VecZnxBigNormalize,
+        VecZnxBigNormalizeTmpBytes, VecZnxDftAddInplace, VecZnxDftApply, VecZnxDftBytesOf, VecZnxDftCopy, VecZnxIdftApplyConsume,
+        VecZnxIdftApplyTmpA, VecZnxNormalize, VecZnxNormalizeTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd,
+        VmpApplyDftToDftTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch},
 };
 
 use crate::layouts::{
-    GGLWEInfos, GGSWCiphertext, GGSWInfos, GLWECiphertext,
-    prepared::{GGLWEAutomorphismKeyPrepared, GGLWETensorKeyPrepared},
+    GGLWEInfos, GGSW, GGSWInfos, GLWE,
+    prepared::{AutomorphismKeyPrepared, TensorKeyPrepared},
 };
 
-impl GGSWCiphertext<Vec<u8>> {
-    pub fn automorphism_scratch_space<B: Backend, OUT, IN, KEY, TSK>(
+impl GGSW<Vec<u8>> {
+    pub fn automorphism_tmp_bytes<B: Backend, OUT, IN, KEY, TSK>(
         module: &Module<B>,
         out_infos: &OUT,
         in_infos: &IN,
@@ -26,25 +26,22 @@ OUT: GGSWInfos,
         IN: GGSWInfos,
         KEY: GGLWEInfos,
         TSK: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxBigAllocBytes
-            + VecZnxNormalizeTmpBytes
-            + VecZnxBigNormalizeTmpBytes,
+        Module<B>:
+            VecZnxDftBytesOf + VmpApplyDftToDftTmpBytes + VecZnxBigBytesOf + VecZnxNormalizeTmpBytes + VecZnxBigNormalizeTmpBytes,
     {
         let out_size: usize = out_infos.size();
-        let ci_dft: usize = module.vec_znx_dft_alloc_bytes((key_infos.rank_out() + 1).into(), out_size);
-        let ks_internal: usize = GLWECiphertext::keyswitch_scratch_space(
+        let ci_dft: usize = module.bytes_of_vec_znx_dft((key_infos.rank_out() + 1).into(), out_size);
+        let ks_internal: usize = GLWE::keyswitch_tmp_bytes(
             module,
             &out_infos.glwe_layout(),
             &in_infos.glwe_layout(),
             key_infos,
         );
-        let expand: usize = GGSWCiphertext::expand_row_scratch_space(module, out_infos, tsk_infos);
+        let expand: usize = GGSW::expand_row_tmp_bytes(module, out_infos, tsk_infos);
         ci_dft + (ks_internal | expand)
     }
 
-    pub fn automorphism_inplace_scratch_space<B: Backend, OUT, KEY, TSK>(
+    pub fn automorphism_inplace_tmp_bytes<B: Backend, OUT, KEY, TSK>(
         module: &Module<B>,
         out_infos: &OUT,
         key_infos: &KEY,
@@ -54,26 +51,23 @@ where
         OUT: GGSWInfos,
         KEY: GGLWEInfos,
         TSK: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxBigAllocBytes
-            + VecZnxNormalizeTmpBytes
-            + VecZnxBigNormalizeTmpBytes,
+        Module<B>:
+            VecZnxDftBytesOf + VmpApplyDftToDftTmpBytes + VecZnxBigBytesOf + VecZnxNormalizeTmpBytes + VecZnxBigNormalizeTmpBytes,
     {
-        GGSWCiphertext::automorphism_scratch_space(module, out_infos, out_infos, key_infos, tsk_infos)
+        GGSW::automorphism_tmp_bytes(module, out_infos, out_infos, key_infos, tsk_infos)
     }
 }
 
-impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
+impl<DataSelf: DataMut> GGSW<DataSelf> {
     pub fn automorphism<DataLhs: DataRef, DataAk: DataRef, DataTsk: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
-        lhs: &GGSWCiphertext<DataLhs>,
-        auto_key: &GGLWEAutomorphismKeyPrepared<DataAk, B>,
-        tensor_key: &GGLWETensorKeyPrepared<DataTsk, B>,
+        lhs: &GGSW<DataLhs>,
+        auto_key: &AutomorphismKeyPrepared<DataAk, B>,
+        tensor_key: &TensorKeyPrepared<DataTsk, B>,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxDftAllocBytes
+        Module<B>: VecZnxDftBytesOf
             + VmpApplyDftToDftTmpBytes
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
@@ -83,13 +77,13 @@ + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
             + VecZnxAutomorphismInplace<B>
-            + VecZnxBigAllocBytes
+            + VecZnxBigBytesOf
             + VecZnxNormalizeTmpBytes
             + VecZnxDftCopy<B>
             + VecZnxDftAddInplace<B>
             + VecZnxIdftApplyTmpA<B>
             + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnxBig<B> + TakeVecZnx,
+        Scratch<B>: ScratchAvailable,
     {
         #[cfg(debug_assertions)]
         {
@@ -121,7 +115,7 @@ "ggsw_in rank: {} != tensor_key rank: {}",
                 self.rank(),
                 tensor_key.rank_out()
             );
-            assert!(scratch.available() >= GGSWCiphertext::automorphism_scratch_space(module, self, lhs, auto_key, tensor_key))
+            assert!(scratch.available() >= GGSW::automorphism_tmp_bytes(module, self, lhs, auto_key, tensor_key))
         };
 
         // Keyswitch the j-th row of the col 0
@@ -137,11 +131,11 @@
     pub fn automorphism_inplace<DataKsk: DataRef, DataTsk: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
-        auto_key: &GGLWEAutomorphismKeyPrepared<DataKsk, B>,
-        tensor_key: &GGLWETensorKeyPrepared<DataTsk, B>,
+        auto_key: &AutomorphismKeyPrepared<DataKsk, B>,
+        tensor_key: &TensorKeyPrepared<DataTsk, B>,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxDftAllocBytes
+        Module<B>: VecZnxDftBytesOf
             + VmpApplyDftToDftTmpBytes
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
@@ -151,13 +145,13 @@ + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
             + VecZnxAutomorphismInplace<B>
-            + VecZnxBigAllocBytes
+            + VecZnxBigBytesOf
             + VecZnxNormalizeTmpBytes
             + VecZnxDftCopy<B>
             + VecZnxDftAddInplace<B>
             + VecZnxIdftApplyTmpA<B>
             + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnxBig<B> + TakeVecZnx,
+        Scratch<B>: ScratchAvailable,
     {
         // Keyswitch the j-th row of the col 0
         (0..self.dnum().into()).for_each(|row_i| {

@@ -1,17 +1,17 @@
 use poulpy_hal::{
     api::{
-        ScratchAvailable, TakeVecZnx, TakeVecZnxDft, VecZnxAutomorphismInplace, VecZnxBigAddSmallInplace,
-        VecZnxBigAutomorphismInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxBigSubSmallInplace,
-        VecZnxBigSubSmallNegateInplace, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume, VecZnxNormalize,
-        VecZnxNormalizeTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+        ScratchAvailable, VecZnxAutomorphismInplace, VecZnxBigAddSmallInplace, VecZnxBigAutomorphismInplace, VecZnxBigNormalize,
+        VecZnxBigNormalizeTmpBytes, VecZnxBigSubSmallInplace, VecZnxBigSubSmallNegateInplace, VecZnxDftApply, VecZnxDftBytesOf,
+        VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd,
+        VmpApplyDftToDftTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch, VecZnxBig},
 };
 
-use crate::layouts::{GGLWEInfos, GLWECiphertext, GLWEInfos, LWEInfos, prepared::GGLWEAutomorphismKeyPrepared};
+use crate::layouts::{GGLWEInfos, GLWE, GLWEInfos, LWEInfos, prepared::AutomorphismKeyPrepared};
 
-impl GLWECiphertext<Vec<u8>> {
-    pub fn automorphism_scratch_space<B: Backend, OUT, IN, KEY>(
+impl GLWE<Vec<u8>> {
+    pub fn automorphism_tmp_bytes<B: Backend, OUT, IN, KEY>(
         module: &Module<B>,
         out_infos: &OUT,
         in_infos: &IN,
@@ -21,30 +21,30 @@ where
         OUT: GLWEInfos,
         IN: GLWEInfos,
         KEY: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
+        Module<B>: VecZnxDftBytesOf + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
     {
-        Self::keyswitch_scratch_space(module, out_infos, in_infos, key_infos)
+        Self::keyswitch_tmp_bytes(module, out_infos, in_infos, key_infos)
     }
 
-    pub fn automorphism_inplace_scratch_space<B: Backend, OUT, KEY>(module: &Module<B>, out_infos: &OUT, key_infos: &KEY) -> usize
+    pub fn automorphism_inplace_tmp_bytes<B: Backend, OUT, KEY>(module: &Module<B>, out_infos: &OUT, key_infos: &KEY) -> usize
     where
         OUT: GLWEInfos,
         KEY: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
+        Module<B>: VecZnxDftBytesOf + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
     {
-        Self::keyswitch_inplace_scratch_space(module, out_infos, key_infos)
+        Self::keyswitch_inplace_tmp_bytes(module, out_infos, key_infos)
     }
 }
 
-impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
+impl<DataSelf: DataMut> GLWE<DataSelf> {
     pub fn automorphism<DataLhs: DataRef, DataRhs: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
-        lhs: &GLWECiphertext<DataLhs>,
-        rhs: &GGLWEAutomorphismKeyPrepared<DataRhs, B>,
+        lhs: &GLWE<DataLhs>,
+        rhs: &AutomorphismKeyPrepared<DataRhs, B>,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxDftAllocBytes
+        Module<B>: VecZnxDftBytesOf
             + VmpApplyDftToDftTmpBytes
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
@@ -56,7 +56,7 @@ + VecZnxBigNormalize<B>
             + VecZnxAutomorphismInplace<B>
             + VecZnxNormalize<B>
             + VecZnxNormalizeTmpBytes,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+        Scratch<B>: ScratchAvailable,
     {
         self.keyswitch(module, lhs, &rhs.key, scratch);
         (0..(self.rank() + 1).into()).for_each(|i| {
@@ -67,10 +67,10 @@
     pub fn automorphism_inplace<DataRhs: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
-        rhs: &GGLWEAutomorphismKeyPrepared<DataRhs, B>,
+        rhs: &AutomorphismKeyPrepared<DataRhs, B>,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxDftAllocBytes
+        Module<B>: VecZnxDftBytesOf
             + VmpApplyDftToDftTmpBytes
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
@@ -82,7 +82,7 @@ + VecZnxBigNormalize<B>
             + VecZnxAutomorphismInplace<B>
             + VecZnxNormalize<B>
             + VecZnxNormalizeTmpBytes,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+        Scratch<B>: ScratchAvailable,
     {
         self.keyswitch_inplace(module, &rhs.key, scratch);
         (0..(self.rank() + 1).into()).for_each(|i| {
@@ -93,11 +93,11 @@
     pub fn automorphism_add<DataLhs: DataRef, DataRhs: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
-        lhs: &GLWECiphertext<DataLhs>,
-        rhs: &GGLWEAutomorphismKeyPrepared<DataRhs, B>,
+        lhs: &GLWE<DataLhs>,
+        rhs: &AutomorphismKeyPrepared<DataRhs, B>,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxDftAllocBytes
+        Module<B>: VecZnxDftBytesOf
             + VmpApplyDftToDftTmpBytes
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
@@ -109,7 +109,7 @@ + VecZnxBigNormalize<B>
             + VecZnxBigAutomorphismInplace<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+        Scratch<B>: ScratchAvailable,
     {
         #[cfg(debug_assertions)]
         {
@@ -135,10 +135,10 @@
     pub fn automorphism_add_inplace<DataRhs: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
-        rhs: &GGLWEAutomorphismKeyPrepared<DataRhs, B>,
+        rhs: &AutomorphismKeyPrepared<DataRhs, B>,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxDftAllocBytes
+        Module<B>: VecZnxDftBytesOf
             + VmpApplyDftToDftTmpBytes
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
@@ -150,7 +150,7 @@ + VecZnxBigNormalize<B>
             + VecZnxBigAutomorphismInplace<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+        Scratch<B>: ScratchAvailable,
     {
         #[cfg(debug_assertions)]
         {
@@ -176,11 +176,11 @@
     pub fn automorphism_sub_ab<DataLhs: DataRef, DataRhs: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
-        lhs: &GLWECiphertext<DataLhs>,
-        rhs: &GGLWEAutomorphismKeyPrepared<DataRhs, B>,
+        lhs: &GLWE<DataLhs>,
+        rhs: &AutomorphismKeyPrepared<DataRhs, B>,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxDftAllocBytes
+        Module<B>: VecZnxDftBytesOf
             + VmpApplyDftToDftTmpBytes
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
@@ -193,7 +193,7 @@ + VecZnxBigAutomorphismInplace<B>
             + VecZnxBigSubSmallInplace<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+        Scratch<B>: ScratchAvailable,
     {
         #[cfg(debug_assertions)]
         {
@@ -219,10 +219,10 @@
     pub fn automorphism_sub_inplace<DataRhs: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
-        rhs: &GGLWEAutomorphismKeyPrepared<DataRhs, B>,
+        rhs: &AutomorphismKeyPrepared<DataRhs, B>,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxDftAllocBytes
+        Module<B>: VecZnxDftBytesOf
             + VmpApplyDftToDftTmpBytes
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
@@ -235,7 +235,7 @@ + VecZnxBigAutomorphismInplace<B>
             + VecZnxBigSubSmallInplace<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+        Scratch<B>: ScratchAvailable,
     {
         #[cfg(debug_assertions)]
         {
@@ -261,11 +261,11 @@
     pub fn automorphism_sub_negate<DataLhs: DataRef, DataRhs: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
-        lhs: &GLWECiphertext<DataLhs>,
-        rhs: &GGLWEAutomorphismKeyPrepared<DataRhs, B>,
+        lhs: &GLWE<DataLhs>,
+        rhs: &AutomorphismKeyPrepared<DataRhs, B>,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxDftAllocBytes
+        Module<B>: VecZnxDftBytesOf
             + VmpApplyDftToDftTmpBytes
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
@@ -278,7 +278,7 @@ + VecZnxBigAutomorphismInplace<B>
             + VecZnxBigSubSmallNegateInplace<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+        Scratch<B>: ScratchAvailable,
     {
         #[cfg(debug_assertions)]
         {
@@ -304,10 +304,10 @@
     pub fn automorphism_sub_negate_inplace<DataRhs: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
-        rhs: &GGLWEAutomorphismKeyPrepared<DataRhs, B>,
+        rhs: &AutomorphismKeyPrepared<DataRhs, B>,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxDftAllocBytes
+        Module<B>: VecZnxDftBytesOf
             + VmpApplyDftToDftTmpBytes
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
@@ -320,7 +320,7 @@ + VecZnxBigAutomorphismInplace<B>
             + VecZnxBigSubSmallNegateInplace<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+        Scratch<B>: ScratchAvailable,
     {
         #[cfg(debug_assertions)]
         {

@@ -0,0 +1,279 @@
+use poulpy_hal::{
+    api::{
+        ModuleN, ScratchAvailable, ScratchTakeBasic, VecZnxBigBytesOf, VecZnxBigNormalize, VecZnxCopy, VecZnxDftAddInplace,
+        VecZnxDftApply, VecZnxDftBytesOf, VecZnxDftCopy, VecZnxIdftApplyTmpA, VecZnxNormalize, VecZnxNormalizeTmpBytes,
+        VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+    },
+    layouts::{Backend, DataMut, Module, Scratch, VmpPMat, ZnxInfos},
+};
+
+use crate::{
+    ScratchTakeCore,
+    layouts::{
+        GGLWE, GGLWEInfos, GGLWEToRef, GGSW, GGSWInfos, GGSWToMut, GLWEInfos, LWEInfos,
+        prepared::{TensorKeyPrepared, TensorKeyPreparedToRef},
+    },
+    operations::GLWEOperations,
+};
+
+impl GGLWE<Vec<u8>> {
+    pub fn from_gglw_tmp_bytes<R, A, M, BE: Backend>(module: &M, res_infos: &R, tsk_infos: &A) -> usize
+    where
+        M: GGSWFromGGLWE<BE>,
+        R: GGSWInfos,
+        A: GGLWEInfos,
+    {
+        module.ggsw_from_gglwe_tmp_bytes(res_infos, tsk_infos)
+    }
+}
+
+impl<D: DataMut> GGSW<D> {
+    pub fn from_gglwe<G, M, T, BE: Backend>(&mut self, module: &M, gglwe: &G, tsk: &T, scratch: &mut Scratch<BE>)
+    where
+        M: GGSWFromGGLWE<BE>,
+        G: GGLWEToRef,
+        T: TensorKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        module.ggsw_from_gglwe(self, gglwe, tsk, scratch);
+    }
+}
+
+impl<BE: Backend> GGSWFromGGLWE<BE> for Module<BE> where Self: GGSWExpandRows<BE> + VecZnxCopy {}
+
+pub trait GGSWFromGGLWE<BE: Backend>
+where
+    Self: GGSWExpandRows<BE> + VecZnxCopy,
+{
+    fn ggsw_from_gglwe_tmp_bytes<R, A>(&self, res_infos: &R, tsk_infos: &A) -> usize
+    where
+        R: GGSWInfos,
+        A: GGLWEInfos,
+    {
+        self.ggsw_expand_rows_tmp_bytes(res_infos, tsk_infos)
+    }
+
+    fn ggsw_from_gglwe<R, A, T>(&self, res: &mut R, a: &A, tsk: &T, scratch: &mut Scratch<BE>)
+    where
+        R: GGSWToMut,
+        A: GGLWEToRef,
+        T: TensorKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        let res: &mut GGSW<&mut [u8]> = &mut res.to_mut();
+        let a: &GGLWE<&[u8]> = &a.to_ref();
+        let tsk: &TensorKeyPrepared<&[u8], BE> = &tsk.to_ref();
+
+        assert_eq!(res.rank(), a.rank_out());
+        assert_eq!(res.dnum(), a.dnum());
+        assert_eq!(res.n(), self.n() as u32);
+        assert_eq!(a.n(), self.n() as u32);
+        assert_eq!(tsk.n(), self.n() as u32);
+
+        for row in 0..res.dnum().into() {
+            res.at_mut(row, 0).copy(self, &a.at(row, 0));
+        }
+
+        self.ggsw_expand_row(res, tsk, scratch);
+    }
+}
+
+impl<BE: Backend> GGSWExpandRows<BE> for Module<BE> where
+    Self: Sized
+        + ModuleN
+        + VecZnxDftBytesOf
+        + VmpApplyDftToDftTmpBytes
+        + VecZnxBigBytesOf
+        + VecZnxNormalizeTmpBytes
+        + VecZnxDftBytesOf
+        + VmpApplyDftToDftTmpBytes
+        + VecZnxBigBytesOf
+        + VecZnxNormalizeTmpBytes
+        + VecZnxDftApply<BE>
+        + VecZnxDftCopy<BE>
+        + VmpApplyDftToDft<BE>
+        + VmpApplyDftToDftAdd<BE>
+        + VecZnxDftAddInplace<BE>
+        + VecZnxBigNormalize<BE>
+        + VecZnxIdftApplyTmpA<BE>
+        + VecZnxNormalize<BE>
+{
+}
+
+pub(crate) trait GGSWExpandRows<BE: Backend>
+where
+    Self: Sized
+        + ModuleN
+        + VecZnxDftBytesOf
+        + VmpApplyDftToDftTmpBytes
+        + VecZnxBigBytesOf
+        + VecZnxNormalizeTmpBytes
+        + VecZnxDftBytesOf
+        + VmpApplyDftToDftTmpBytes
+        + VecZnxBigBytesOf
+        + VecZnxNormalizeTmpBytes
+        + VecZnxDftApply<BE>
+        + VecZnxDftCopy<BE>
+        + VmpApplyDftToDft<BE>
+        + VmpApplyDftToDftAdd<BE>
+        + VecZnxDftAddInplace<BE>
+        + VecZnxBigNormalize<BE>
+        + VecZnxIdftApplyTmpA<BE>
+        + VecZnxNormalize<BE>,
+{
+    fn ggsw_expand_rows_tmp_bytes<R, A>(&self, res_infos: &R, tsk_infos: &A) -> usize
+    where
+        R: GGSWInfos,
+        A: GGLWEInfos,
+    {
+        let tsk_size: usize = tsk_infos.k().div_ceil(tsk_infos.base2k()) as usize;
+        let size_in: usize = res_infos
+            .k()
+            .div_ceil(tsk_infos.base2k())
+            .div_ceil(tsk_infos.dsize().into()) as usize;
+
+        let tmp_dft_i: usize = self.bytes_of_vec_znx_dft((tsk_infos.rank_out() + 1).into(), tsk_size);
+        let tmp_a: usize = self.bytes_of_vec_znx_dft(1, size_in);
+        let vmp: usize = self.vmp_apply_dft_to_dft_tmp_bytes(
+            tsk_size,
+            size_in,
+            size_in,
+            (tsk_infos.rank_in()).into(),  // Verify if rank+1
+            (tsk_infos.rank_out()).into(), // Verify if rank+1
+            tsk_size,
+        );
+        let tmp_idft: usize = self.bytes_of_vec_znx_big(1, tsk_size);
+        let norm: usize = self.vec_znx_normalize_tmp_bytes();
+
+        tmp_dft_i + ((tmp_a + vmp) | (tmp_idft + norm))
+    }
+
+    fn ggsw_expand_row<R, T>(&self, res: &mut R, tsk: &T, scratch: &mut Scratch<BE>)
+    where
+        R: GGSWToMut,
+        T: TensorKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        let res: &mut GGSW<&mut [u8]> = &mut res.to_mut();
+        let tsk: &TensorKeyPrepared<&[u8], BE> = &tsk.to_ref();
+
+        let basek_in: usize = res.base2k().into();
+        let basek_tsk: usize = tsk.base2k().into();
+
+        assert!(scratch.available() >= self.ggsw_expand_rows_tmp_bytes(res, tsk));
+
+        let rank: usize = res.rank().into();
+        let cols: usize = rank + 1;
+
+        let a_size: usize = (res.size() * basek_in).div_ceil(basek_tsk);
+
+        // Keyswitch the j-th row of the col 0
+        for row_i in 0..res.dnum().into() {
+            let a = &res.at(row_i, 0).data;
+
+            // Pre-compute DFT of (a0, a1, a2)
+            let (mut ci_dft, scratch_1) = scratch.take_vec_znx_dft(self, cols, a_size);
+
+            if basek_in == basek_tsk {
+                for i in 0..cols {
+                    self.vec_znx_dft_apply(1, 0, &mut ci_dft, i, a, i);
+                }
+            } else {
+                let (mut a_conv, scratch_2) = scratch_1.take_vec_znx(self, 1, a_size);
+                for i in 0..cols {
+                    self.vec_znx_normalize(basek_tsk, &mut a_conv, 0, basek_in, a, i, scratch_2);
+                    self.vec_znx_dft_apply(1, 0, &mut ci_dft, i, &a_conv, 0);
+                }
+            }
+
+            for col_j in 1..cols {
+                // Example for rank 3:
+                //
+                // Note: M is a vector (m, Bm, B^2m, B^3m, ...), so each column is
+                // actually composed of that many dnum and we focus on a specific row here
+                // implicitely given ci_dft.
+                //
+                // # Input
+                //
+                // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0    , a1    , a2    )
+                // col 1: (0, 0, 0, 0)
+                // col 2: (0, 0, 0, 0)
+                // col 3: (0, 0, 0, 0)
+                //
+                // # Output
+                //
+                // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0       , a1       , a2       )
+                // col 1: (-(b0s0 + b1s1 + b2s2)       , b0 + M[i], b1       , b2       )
+                // col 2: (-(c0s0 + c1s1 + c2s2)       , c0       , c1 + M[i], c2       )
+                // col 3: (-(d0s0 + d1s1 + d2s2)       , d0       , d1       , d2 + M[i])
+
+                let dsize: usize = tsk.dsize().into();
+
+                let (mut tmp_dft_i, scratch_2) = scratch_1.take_vec_znx_dft(self, cols, tsk.size());
+                let (mut tmp_a, scratch_3) = scratch_2.take_vec_znx_dft(self, 1, ci_dft.size().div_ceil(dsize));
+
+                {
+                    // Performs a key-switch for each combination of s[i]*s[j], i.e. for a0, a1, a2
+                    //
+                    // # Example for col=1
+                    //
+                    // a0 * (-(f0s0 + f1s1 + f1s2) + s0^2, f0, f1, f2) = (-(a0f0s0 + a0f1s1 + a0f1s2) + a0s0^2, a0f0, a0f1, a0f2)
+                    // +
+                    // a1 * (-(g0s0 + g1s1 + g1s2) + s0s1, g0, g1, g2) = (-(a1g0s0 + a1g1s1 + a1g1s2) + a1s0s1, a1g0, a1g1, a1g2)
+                    // +
+                    // a2 * (-(h0s0 + h1s1 + h1s2) + s0s2, h0, h1, h2) = (-(a2h0s0 + a2h1s1 + a2h1s2) + a2s0s2, a2h0, a2h1, a2h2)
+                    // =
+                    // (-(x0s0 + x1s1 + x2s2) + s0(a0s0 + a1s1 + a2s2), x0, x1, x2)
+                    for col_i in 1..cols {
+                        let pmat: &VmpPMat<&[u8], BE> = &tsk.at(col_i - 1, col_j - 1).key.data; // Selects Enc(s[i]s[j])
+
+                        // Extracts a[i] and multipies with Enc(s[i]s[j])
+                        for di in 0..dsize {
+                            tmp_a.set_size((ci_dft.size() + di) / dsize);
+
+                            // Small optimization for dsize > 2
+                            // VMP produce some error e, and since we aggregate vmp * 2^{di * B}, then
+                            // we also aggregate ei * 2^{di * B}, with the largest error being ei * 2^{(dsize-1) * B}.
+                            // As such we can ignore the last dsize-2 limbs safely of the sum of vmp products.
+                            // It is possible to further ignore the last dsize-1 limbs, but this introduce
+                            // ~0.5 to 1 bit of additional noise, and thus not chosen here to ensure that the same
+                            // noise is kept with respect to the ideal functionality.
+                            tmp_dft_i.set_size(tsk.size() - ((dsize - di) as isize - 2).max(0) as usize);
+
+                            self.vec_znx_dft_copy(dsize, dsize - 1 - di, &mut tmp_a, 0, &ci_dft, col_i);
+                            if di == 0 && col_i == 1 {
+                                self.vmp_apply_dft_to_dft(&mut tmp_dft_i, &tmp_a, pmat, scratch_3);
+                            } else {
+                                self.vmp_apply_dft_to_dft_add(&mut tmp_dft_i, &tmp_a, pmat, di, scratch_3);
+                            }
+                        }
+                    }
+                }
+
+                // Adds -(sum a[i] * s[i]) + m)  on the i-th column of tmp_idft_i
+                //
+                // (-(x0s0 + x1s1 + x2s2) + a0s0s0 + a1s0s1 + a2s0s2, x0, x1, x2)
+                // +
+                // (0, -(a0s0 + a1s1 + a2s2) + M[i], 0, 0)
+                // =
+                // (-(x0s0 + x1s1 + x2s2) + s0(a0s0 + a1s1 + a2s2), x0 -(a0s0 + a1s1 + a2s2) + M[i], x1, x2)
+                // =
+                // (-(x0s0 + x1s1 + x2s2), x0 + M[i], x1, x2)
+                self.vec_znx_dft_add_inplace(&mut tmp_dft_i, col_j, &ci_dft, 0);
+                let (mut tmp_idft, scratch_3) = scratch_2.take_vec_znx_big(self, 1, tsk.size());
+                for i in 0..cols {
+                    self.vec_znx_idft_apply_tmpa(&mut tmp_idft, 0, &mut tmp_dft_i, i);
+                    self.vec_znx_big_normalize(
+                        basek_in,
+                        &mut res.at_mut(row_i, col_j).data,
+                        i,
+                        basek_tsk,
+                        &tmp_idft,
+                        0,
+                        scratch_3,
+                    );
+                }
+            }
+        }
+    }
+}

@@ -1,22 +1,16 @@
 use poulpy_hal::{
     api::{
-        ScratchAvailable, TakeVecZnx, TakeVecZnxDft, VecZnxBigAddSmallInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
-        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeTmpBytes, VmpApplyDftToDft,
-        VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+        VecZnxBigAddSmallInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxDftApply, VecZnxDftBytesOf,
+        VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd,
+        VmpApplyDftToDftTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch, ZnxView, ZnxViewMut, ZnxZero},
 };
 
-use crate::{
-    TakeGLWECt,
-    layouts::{
-        GGLWEInfos, GLWECiphertext, GLWECiphertextLayout, GLWEInfos, LWECiphertext, LWEInfos, Rank,
-        prepared::GLWEToLWESwitchingKeyPrepared,
-    },
-};
+use crate::layouts::{GGLWEInfos, GLWE, GLWEInfos, GLWELayout, LWE, LWEInfos, Rank, prepared::GLWEToLWESwitchingKeyPrepared};
 
-impl LWECiphertext<Vec<u8>> {
-    pub fn from_glwe_scratch_space<B: Backend, OUT, IN, KEY>(
+impl LWE<Vec<u8>> {
+    pub fn from_glwe_tmp_bytes<B: Backend, OUT, IN, KEY>(
         module: &Module<B>,
         lwe_infos: &OUT,
         glwe_infos: &IN,
@@ -26,26 +20,26 @@ where
         OUT: LWEInfos,
         IN: GLWEInfos,
         KEY: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
+        Module<B>: VecZnxDftBytesOf + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
     {
-        let glwe_layout: GLWECiphertextLayout = GLWECiphertextLayout {
+        let glwe_layout: GLWELayout = GLWELayout {
             n: module.n().into(),
             base2k: lwe_infos.base2k(),
             k: lwe_infos.k(),
             rank: Rank(1),
         };
 
-        GLWECiphertext::alloc_bytes_with(
+        GLWE::bytes_of(
             module.n().into(),
             lwe_infos.base2k(),
             lwe_infos.k(),
             1u32.into(),
-        ) + GLWECiphertext::keyswitch_scratch_space(module, &glwe_layout, glwe_infos, key_infos)
+        ) + GLWE::keyswitch_tmp_bytes(module, &glwe_layout, glwe_infos, key_infos)
     }
 }
 
-impl<DLwe: DataMut> LWECiphertext<DLwe> {
-    pub fn sample_extract<DGlwe: DataRef>(&mut self, a: &GLWECiphertext<DGlwe>) {
+impl<DLwe: DataMut> LWE<DLwe> {
+    pub fn sample_extract<DGlwe: DataRef>(&mut self, a: &GLWE<DGlwe>) {
         #[cfg(debug_assertions)]
         {
             assert!(self.n() <= a.n());
@@ -66,13 +60,13 @@
     pub fn from_glwe<DGlwe, DKs, B: Backend>(
         &mut self,
         module: &Module<B>,
-        a: &GLWECiphertext<DGlwe>,
+        a: &GLWE<DGlwe>,
         ks: &GLWEToLWESwitchingKeyPrepared<DKs, B>,
         scratch: &mut Scratch<B>,
     ) where
         DGlwe: DataRef,
         DKs: DataRef,
-        Module<B>: VecZnxDftAllocBytes
+        Module<B>: VecZnxDftBytesOf
             + VmpApplyDftToDftTmpBytes
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
@@ -83,7 +77,7 @@ + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
             + VecZnxNormalize<B>
             + VecZnxNormalizeTmpBytes,
-        Scratch<B>: ScratchAvailable + TakeVecZnxDft<B> + TakeGLWECt + TakeVecZnx,
+        Scratch<B>:,
     {
         #[cfg(debug_assertions)]
         {
@@ -92,7 +86,7 @@ assert_eq!(ks.n(), module.n() as u32);
             assert!(self.n() <= module.n() as u32);
         }
 
-        let glwe_layout: GLWECiphertextLayout = GLWECiphertextLayout {
+        let glwe_layout: GLWELayout = GLWELayout {
             n: module.n().into(),
             base2k: self.base2k(),
             k: self.k(),

@@ -1,22 +1,16 @@
 use poulpy_hal::{
     api::{
-        ScratchAvailable, TakeVecZnx, TakeVecZnxDft, VecZnxBigAddSmallInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
-        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeTmpBytes, VmpApplyDftToDft,
+        ScratchAvailable, VecZnxBigAddSmallInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxDftApply,
+        VecZnxDftBytesOf, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeTmpBytes, VmpApplyDftToDft,
         VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch, VecZnx, ZnxView, ZnxViewMut, ZnxZero},
 };
 
-use crate::{
-    TakeGLWECt,
-    layouts::{
-        GGLWEInfos, GLWECiphertext, GLWECiphertextLayout, GLWEInfos, LWECiphertext, LWEInfos,
-        prepared::LWEToGLWESwitchingKeyPrepared,
-    },
-};
+use crate::layouts::{GGLWEInfos, GLWE, GLWEInfos, GLWELayout, LWE, LWEInfos, prepared::LWEToGLWESwitchingKeyPrepared};
 
-impl GLWECiphertext<Vec<u8>> {
-    pub fn from_lwe_scratch_space<B: Backend, OUT, IN, KEY>(
+impl GLWE<Vec<u8>> {
+    pub fn from_lwe_tmp_bytes<B: Backend, OUT, IN, KEY>(
         module: &Module<B>,
         glwe_infos: &OUT,
         lwe_infos: &IN,
@@ -26,35 +20,35 @@ where
         OUT: GLWEInfos,
         IN: LWEInfos,
         KEY: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
+        Module<B>: VecZnxDftBytesOf + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
     {
-        let ct: usize = GLWECiphertext::alloc_bytes_with(
+        let ct: usize = GLWE::bytes_of(
             module.n().into(),
             key_infos.base2k(),
             lwe_infos.k().max(glwe_infos.k()),
             1u32.into(),
         );
-        let ks: usize = GLWECiphertext::keyswitch_inplace_scratch_space(module, glwe_infos, key_infos);
+        let ks: usize = GLWE::keyswitch_inplace_tmp_bytes(module, glwe_infos, key_infos);
         if lwe_infos.base2k() == key_infos.base2k() {
             ct + ks
         } else {
-            let a_conv = VecZnx::alloc_bytes(module.n(), 1, lwe_infos.size()) + module.vec_znx_normalize_tmp_bytes();
+            let a_conv = VecZnx::bytes_of(module.n(), 1, lwe_infos.size()) + module.vec_znx_normalize_tmp_bytes();
             ct + a_conv + ks
         }
     }
 }
 
-impl<D: DataMut> GLWECiphertext<D> {
+impl<D: DataMut> GLWE<D> {
     pub fn from_lwe<DLwe, DKsk, B: Backend>(
         &mut self,
         module: &Module<B>,
-        lwe: &LWECiphertext<DLwe>,
+        lwe: &LWE<DLwe>,
         ksk: &LWEToGLWESwitchingKeyPrepared<DKsk, B>,
         scratch: &mut Scratch<B>,
     ) where
         DLwe: DataRef,
         DKsk: DataRef,
-        Module<B>: VecZnxDftAllocBytes
+        Module<B>: VecZnxDftBytesOf
             + VmpApplyDftToDftTmpBytes
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
@@ -65,7 +59,7 @@ + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>
             + VecZnxNormalize<B>
             + VecZnxNormalizeTmpBytes,
-        Scratch<B>: ScratchAvailable + TakeVecZnxDft<B> + TakeGLWECt + TakeVecZnx,
+        Scratch<B>: ScratchAvailable,
     {
         #[cfg(debug_assertions)]
         {
@@ -74,7 +68,7 @@ assert_eq!(ksk.n(), module.n() as u32);
             assert!(lwe.n() <= module.n() as u32);
         }
 
-        let (mut glwe, scratch_1) = scratch.take_glwe_ct(&GLWECiphertextLayout {
+        let (mut glwe, scratch_1) = scratch.take_glwe_ct(&GLWELayout {
             n: ksk.n(),
             base2k: ksk.base2k(),
             k: lwe.k(),

@@ -1,2 +1,5 @@
+mod gglwe_to_ggsw;
 mod glwe_to_lwe;
 mod lwe_to_glwe;
+
+pub use gglwe_to_ggsw::*;

@@ -1,25 +1,25 @@
 use poulpy_hal::{
     api::{
-        SvpApplyDftToDftInplace, TakeVecZnxBig, TakeVecZnxDft, VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigNormalize,
-        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume, VecZnxNormalizeTmpBytes,
+        SvpApplyDftToDftInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigNormalize, VecZnxDftApply,
+        VecZnxDftBytesOf, VecZnxIdftApplyConsume, VecZnxNormalizeTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, DataViewMut, Module, Scratch},
 };
 
-use crate::layouts::{GLWECiphertext, GLWEInfos, GLWEPlaintext, LWEInfos, prepared::GLWESecretPrepared};
+use crate::layouts::{GLWE, GLWEInfos, GLWEPlaintext, LWEInfos, prepared::GLWESecretPrepared};
 
-impl GLWECiphertext<Vec<u8>> {
-    pub fn decrypt_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+impl GLWE<Vec<u8>> {
+    pub fn decrypt_tmp_bytes<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
     where
         A: GLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes,
+        Module<B>: VecZnxDftBytesOf + VecZnxNormalizeTmpBytes + VecZnxDftBytesOf,
     {
         let size: usize = infos.size();
-        (module.vec_znx_normalize_tmp_bytes() | module.vec_znx_dft_alloc_bytes(1, size)) + module.vec_znx_dft_alloc_bytes(1, size)
+        (module.vec_znx_normalize_tmp_bytes() | module.bytes_of_vec_znx_dft(1, size)) + module.bytes_of_vec_znx_dft(1, size)
     }
 }
 
-impl<DataSelf: DataRef> GLWECiphertext<DataSelf> {
+impl<DataSelf: DataRef> GLWE<DataSelf> {
     pub fn decrypt<DataPt: DataMut, DataSk: DataRef, B: Backend>(
         &self,
         module: &Module<B>,
@@ -33,7 +33,7 @@ + VecZnxIdftApplyConsume<B>
             + VecZnxBigAddInplace<B>
             + VecZnxBigAddSmallInplace<B>
             + VecZnxBigNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + TakeVecZnxBig<B>,
+        Scratch<B>:,
     {
         #[cfg(debug_assertions)]
         {

@@ -4,9 +4,9 @@ layouts::{Backend, DataMut, DataRef, Module, ScratchOwned, ZnxView, ZnxViewMut},
     oep::{ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl},
 };
 
-use crate::layouts::{LWECiphertext, LWEInfos, LWEPlaintext, LWESecret};
+use crate::layouts::{LWE, LWEInfos, LWEPlaintext, LWESecret};
 
-impl<DataSelf> LWECiphertext<DataSelf>
+impl<DataSelf> LWE<DataSelf>
 where
     DataSelf: DataRef,
 {

@@ -1,84 +1,81 @@
 use poulpy_hal::{
-    api::{
-        ScratchAvailable, SvpApplyDftToDftInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx, TakeVecZnxDft,
-        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism, VecZnxBigNormalize, VecZnxDftAllocBytes,
-        VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace,
-        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace, VecZnxSwitchRing,
-    },
+    api::{ScratchAvailable, SvpPPolBytesOf, VecZnxAutomorphism, VecZnxDftBytesOf, VecZnxNormalizeTmpBytes},
     layouts::{Backend, DataMut, DataRef, Module, Scratch},
     source::Source,
 };
 
 use crate::{
-    TakeGLWESecret, TakeGLWESecretPrepared,
+    encryption::compressed::gglwe_ksk::GGLWEKeyCompressedEncryptSk,
     layouts::{
-        GGLWEInfos, GLWEInfos, GLWESecret, LWEInfos,
-        compressed::{GGLWEAutomorphismKeyCompressed, GGLWESwitchingKeyCompressed},
+        GGLWEInfos, GLWEInfos, GLWESecret, GLWESecretToRef, LWEInfos,
+        compressed::{AutomorphismKeyCompressed, AutomorphismKeyCompressedToMut, GLWESwitchingKeyCompressed},
     },
 };
 
-impl GGLWEAutomorphismKeyCompressed<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+impl AutomorphismKeyCompressed<Vec<u8>> {
+    pub fn encrypt_sk_tmp_bytes<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
     where
         A: GGLWEInfos,
-        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes + VecZnxNormalizeTmpBytes + SvpPPolAllocBytes,
+        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftBytesOf + VecZnxNormalizeTmpBytes + SvpPPolBytesOf,
     {
         assert_eq!(module.n() as u32, infos.n());
-        GGLWESwitchingKeyCompressed::encrypt_sk_scratch_space(module, infos)
-            + GLWESecret::alloc_bytes_with(infos.n(), infos.rank_out())
+        GLWESwitchingKeyCompressed::encrypt_sk_tmp_bytes(module, infos) + GLWESecret::bytes_of(infos.n(), infos.rank_out())
     }
 }
 
-impl<DataSelf: DataMut> GGLWEAutomorphismKeyCompressed<DataSelf> {
-    #[allow(clippy::too_many_arguments)]
-    pub fn encrypt_sk<DataSk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
+pub trait GGLWEAutomorphismKeyCompressedEncryptSk<B: Backend> {
+    fn gglwe_automorphism_key_compressed_encrypt_sk<R, S>(
+        &self,
+        res: &mut R,
         p: i64,
-        sk: &GLWESecret<DataSk>,
+        sk: &S,
+        seed_xa: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        R: AutomorphismKeyCompressedToMut,
+        S: GLWESecretToRef;
+}
+
+impl<B: Backend> GGLWEAutomorphismKeyCompressedEncryptSk<B> for Module<B>
+where
+    Module<B>: GGLWEKeyCompressedEncryptSk<B> + VecZnxNormalizeTmpBytes + VecZnxDftBytesOf + SvpPPolBytesOf + VecZnxAutomorphism,
+    Scratch<B>: ScratchAvailable,
+{
+    fn gglwe_automorphism_key_compressed_encrypt_sk<R, S>(
+        &self,
+        res: &mut R,
+        p: i64,
+        sk: &S,
         seed_xa: [u8; 32],
         source_xe: &mut Source,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxAutomorphism
-            + SvpPrepare<B>
-            + SvpPPolAllocBytes
-            + VecZnxSwitchRing
-            + VecZnxDftAllocBytes
-            + VecZnxBigNormalize<B>
-            + VecZnxDftApply<B>
-            + SvpApplyDftToDftInplace<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxNormalizeTmpBytes
-            + VecZnxFillUniform
-            + VecZnxSubInplace
-            + VecZnxAddInplace
-            + VecZnxNormalizeInplace<B>
-            + VecZnxAddNormal
-            + VecZnxNormalize<B>
-            + VecZnxSub
-            + VecZnxAddScalarInplace,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx + TakeScalarZnx + TakeGLWESecretPrepared<B>,
+        R: AutomorphismKeyCompressedToMut,
+        S: GLWESecretToRef,
     {
+        let res: &mut AutomorphismKeyCompressed<&mut [u8]> = &mut res.to_mut();
+        let sk: &GLWESecret<&[u8]> = &sk.to_ref();
+
         #[cfg(debug_assertions)]
         {
-            assert_eq!(self.n(), sk.n());
-            assert_eq!(self.rank_out(), self.rank_in());
-            assert_eq!(sk.rank(), self.rank_out());
+            assert_eq!(res.n(), sk.n());
+            assert_eq!(res.rank_out(), res.rank_in());
+            assert_eq!(sk.rank(), res.rank_out());
             assert!(
-                scratch.available() >= GGLWEAutomorphismKeyCompressed::encrypt_sk_scratch_space(module, self),
-                "scratch.available(): {} < AutomorphismKey::encrypt_sk_scratch_space: {}",
+                scratch.available() >= AutomorphismKeyCompressed::encrypt_sk_tmp_bytes(self, res),
+                "scratch.available(): {} < AutomorphismKey::encrypt_sk_tmp_bytes: {}",
                 scratch.available(),
-                GGLWEAutomorphismKeyCompressed::encrypt_sk_scratch_space(module, self)
+                AutomorphismKeyCompressed::encrypt_sk_tmp_bytes(self, res)
             )
         }
 
         let (mut sk_out, scratch_1) = scratch.take_glwe_secret(sk.n(), sk.rank());
 
         {
-            (0..self.rank_out().into()).for_each(|i| {
-                module.vec_znx_automorphism(
-                    module.galois_element_inv(p),
+            (0..res.rank_out().into()).for_each(|i| {
+                self.vec_znx_automorphism(
+                    self.galois_element_inv(p),
                     &mut sk_out.data.as_vec_znx_mut(),
                     i,
                     &sk.data.as_vec_znx(),
@@ -87,9 +84,25 @@ );
             });
         }
 
-        self.key
-            .encrypt_sk(module, sk, &sk_out, seed_xa, source_xe, scratch_1);
+        self.gglwe_key_compressed_encrypt_sk(&mut res.key, sk, &sk_out, seed_xa, source_xe, scratch_1);
+
+        res.p = p;
+    }
+}
 
-        self.p = p;
+impl<DataSelf: DataMut> AutomorphismKeyCompressed<DataSelf> {
+    #[allow(clippy::too_many_arguments)]
+    pub fn encrypt_sk<DataSk: DataRef, B: Backend>(
+        &mut self,
+        module: &Module<B>,
+        p: i64,
+        sk: &GLWESecret<DataSk>,
+        seed_xa: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        Module<B>: GGLWEAutomorphismKeyCompressedEncryptSk<B>,
+    {
+        module.gglwe_automorphism_key_compressed_encrypt_sk(self, p, sk, seed_xa, source_xe, scratch);
     }
 }

@@ -1,117 +1,150 @@
 use poulpy_hal::{
     api::{
-        ScratchAvailable, SvpApplyDftToDftInplace, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal,
-        VecZnxAddScalarInplace, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform,
-        VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace,
+        ScratchAvailable, VecZnxAddScalarInplace, VecZnxDftBytesOf, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes,
+        ZnNormalizeInplace,
     },
-    layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, Scratch, ZnxZero},
+    layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, ScalarZnxToRef, Scratch, ZnxZero},
     source::Source,
 };
 
 use crate::{
-    TakeGLWEPt,
-    encryption::{SIGMA, glwe_encrypt_sk_internal},
-    layouts::{GGLWECiphertext, GGLWEInfos, LWEInfos, compressed::GGLWECiphertextCompressed, prepared::GLWESecretPrepared},
+    encryption::{SIGMA, glwe_ct::GLWEEncryptSkInternal},
+    layouts::{
+        GGLWE, GGLWEInfos, LWEInfos,
+        compressed::{GGLWECompressed, GGLWECompressedToMut},
+        prepared::{GLWESecretPrepared, GLWESecretPreparedToRef},
+    },
 };
 
-impl GGLWECiphertextCompressed<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+impl<D: DataMut> GGLWECompressed<D> {
+    #[allow(clippy::too_many_arguments)]
+    pub fn encrypt_sk<DataPt: DataRef, DataSk: DataRef, B: Backend>(
+        &mut self,
+        module: &Module<B>,
+        pt: &ScalarZnx<DataPt>,
+        sk: &GLWESecretPrepared<DataSk, B>,
+        seed: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        Module<B>: GGLWECompressedEncryptSk<B>,
+    {
+        module.gglwe_compressed_encrypt_sk(self, pt, sk, seed, source_xe, scratch);
+    }
+}
+
+impl GGLWECompressed<Vec<u8>> {
+    pub fn encrypt_sk_tmp_bytes<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
     where
         A: GGLWEInfos,
-        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes + VecZnxNormalizeTmpBytes,
+        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftBytesOf + VecZnxNormalizeTmpBytes,
     {
-        GGLWECiphertext::encrypt_sk_scratch_space(module, infos)
+        GGLWE::encrypt_sk_tmp_bytes(module, infos)
     }
 }
 
-impl<D: DataMut> GGLWECiphertextCompressed<D> {
-    #[allow(clippy::too_many_arguments)]
-    pub fn encrypt_sk<DataPt: DataRef, DataSk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        pt: &ScalarZnx<DataPt>,
-        sk: &GLWESecretPrepared<DataSk, B>,
+pub trait GGLWECompressedEncryptSk<B: Backend> {
+    fn gglwe_compressed_encrypt_sk<R, P, S>(
+        &self,
+        res: &mut R,
+        pt: &P,
+        sk: &S,
         seed: [u8; 32],
         source_xe: &mut Source,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxAddScalarInplace
-            + VecZnxDftAllocBytes
-            + VecZnxBigNormalize<B>
-            + VecZnxDftApply<B>
-            + SvpApplyDftToDftInplace<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxNormalizeTmpBytes
-            + VecZnxFillUniform
-            + VecZnxSubInplace
-            + VecZnxAddInplace
-            + VecZnxNormalizeInplace<B>
-            + VecZnxAddNormal
-            + VecZnxNormalize<B>
-            + VecZnxSub,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+        R: GGLWECompressedToMut,
+        P: ScalarZnxToRef,
+        S: GLWESecretPreparedToRef<B>;
+}
+
+impl<B: Backend> GGLWECompressedEncryptSk<B> for Module<B>
+where
+    Module<B>: GLWEEncryptSkInternal<B>
+        + VecZnxNormalizeInplace<B>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxDftBytesOf
+        + VecZnxAddScalarInplace
+        + ZnNormalizeInplace<B>,
+    Scratch<B>: ScratchAvailable,
+{
+    fn gglwe_compressed_encrypt_sk<R, P, S>(
+        &self,
+        res: &mut R,
+        pt: &P,
+        sk: &S,
+        seed: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        R: GGLWECompressedToMut,
+        P: ScalarZnxToRef,
+        S: GLWESecretPreparedToRef<B>,
     {
+        let res: &mut GGLWECompressed<&mut [u8]> = &mut res.to_mut();
+        let pt: &ScalarZnx<&[u8]> = &pt.to_ref();
+
         #[cfg(debug_assertions)]
         {
             use poulpy_hal::layouts::ZnxInfos;
+            let sk = &sk.to_ref();
 
             assert_eq!(
-                self.rank_in(),
+                res.rank_in(),
                 pt.cols() as u32,
-                "self.rank_in(): {} != pt.cols(): {}",
-                self.rank_in(),
+                "res.rank_in(): {} != pt.cols(): {}",
+                res.rank_in(),
                 pt.cols()
             );
             assert_eq!(
-                self.rank_out(),
+                res.rank_out(),
                 sk.rank(),
-                "self.rank_out(): {} != sk.rank(): {}",
-                self.rank_out(),
+                "res.rank_out(): {} != sk.rank(): {}",
+                res.rank_out(),
                 sk.rank()
             );
-            assert_eq!(self.n(), sk.n());
+            assert_eq!(res.n(), sk.n());
             assert_eq!(pt.n() as u32, sk.n());
             assert!(
-                scratch.available() >= GGLWECiphertextCompressed::encrypt_sk_scratch_space(module, self),
-                "scratch.available: {} < GGLWECiphertext::encrypt_sk_scratch_space: {}",
+                scratch.available() >= GGLWECompressed::encrypt_sk_tmp_bytes(self, res),
+                "scratch.available: {} < GGLWECiphertext::encrypt_sk_tmp_bytes: {}",
                 scratch.available(),
-                GGLWECiphertextCompressed::encrypt_sk_scratch_space(module, self)
+                GGLWECompressed::encrypt_sk_tmp_bytes(self, res)
             );
             assert!(
-                self.dnum().0 * self.dsize().0 * self.base2k().0 <= self.k().0,
-                "self.dnum() : {} * self.dsize() : {} * self.base2k() : {} = {} >= self.k() = {}",
-                self.dnum(),
-                self.dsize(),
-                self.base2k(),
-                self.dnum().0 * self.dsize().0 * self.base2k().0,
-                self.k()
+                res.dnum().0 * res.dsize().0 * res.base2k().0 <= res.k().0,
+                "res.dnum() : {} * res.dsize() : {} * res.base2k() : {} = {} >= res.k() = {}",
+                res.dnum(),
+                res.dsize(),
+                res.base2k(),
+                res.dnum().0 * res.dsize().0 * res.base2k().0,
+                res.k()
             );
         }
 
-        let dnum: usize = self.dnum().into();
-        let dsize: usize = self.dsize().into();
-        let base2k: usize = self.base2k().into();
-        let rank_in: usize = self.rank_in().into();
-        let cols: usize = (self.rank_out() + 1).into();
+        let dnum: usize = res.dnum().into();
+        let dsize: usize = res.dsize().into();
+        let base2k: usize = res.base2k().into();
+        let rank_in: usize = res.rank_in().into();
+        let cols: usize = (res.rank_out() + 1).into();
 
         let mut source_xa = Source::new(seed);
 
-        let (mut tmp_pt, scrach_1) = scratch.take_glwe_pt(self);
+        let (mut tmp_pt, scrach_1) = scratch.take_glwe_pt(res);
         (0..rank_in).for_each(|col_i| {
             (0..dnum).for_each(|d_i| {
                 // Adds the scalar_znx_pt to the i-th limb of the vec_znx_pt
                 tmp_pt.data.zero(); // zeroes for next iteration
-                module.vec_znx_add_scalar_inplace(&mut tmp_pt.data, 0, (dsize - 1) + d_i * dsize, pt, col_i);
-                module.vec_znx_normalize_inplace(base2k, &mut tmp_pt.data, 0, scrach_1);
+                self.vec_znx_add_scalar_inplace(&mut tmp_pt.data, 0, (dsize - 1) + d_i * dsize, pt, col_i);
+                self.vec_znx_normalize_inplace(base2k, &mut tmp_pt.data, 0, scrach_1);
 
                 let (seed, mut source_xa_tmp) = source_xa.branch();
-                self.seed[col_i * dnum + d_i] = seed;
+                res.seed[col_i * dnum + d_i] = seed;
 
-                glwe_encrypt_sk_internal(
-                    module,
-                    self.base2k().into(),
-                    self.k().into(),
-                    &mut self.at_mut(d_i, col_i).data,
+                self.glwe_encrypt_sk_internal(
+                    res.base2k().into(),
+                    res.k().into(),
+                    &mut res.at_mut(d_i, col_i).data,
                     cols,
                     true,
                     Some((&tmp_pt, 0)),

@@ -1,35 +1,31 @@
 use poulpy_hal::{
-    api::{
-        ScratchAvailable, SvpApplyDftToDftInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx, TakeVecZnxDft,
-        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply,
-        VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub,
-        VecZnxSubInplace, VecZnxSwitchRing,
-    },
+    api::{ScratchAvailable, SvpPPolBytesOf, SvpPrepare, VecZnxDftBytesOf, VecZnxNormalizeTmpBytes, VecZnxSwitchRing},
     layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, Scratch},
     source::Source,
 };
 
 use crate::{
-    TakeGLWESecretPrepared,
+    encryption::compressed::gglwe_ct::GGLWECompressedEncryptSk,
     layouts::{
-        Degree, GGLWECiphertext, GGLWEInfos, GLWEInfos, GLWESecret, LWEInfos, compressed::GGLWESwitchingKeyCompressed,
+        GGLWE, GGLWEInfos, GLWEInfos, GLWESecret, GLWESecretToRef, LWEInfos, RingDegree,
+        compressed::{GLWESwitchingKeyCompressed, GLWESwitchingKeyCompressedToMut},
         prepared::GLWESecretPrepared,
     },
 };
 
-impl GGLWESwitchingKeyCompressed<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+impl GLWESwitchingKeyCompressed<Vec<u8>> {
+    pub fn encrypt_sk_tmp_bytes<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
     where
         A: GGLWEInfos,
-        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes + VecZnxNormalizeTmpBytes + SvpPPolAllocBytes,
+        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftBytesOf + VecZnxNormalizeTmpBytes + SvpPPolBytesOf,
     {
-        (GGLWECiphertext::encrypt_sk_scratch_space(module, infos) | ScalarZnx::alloc_bytes(module.n(), 1))
-            + ScalarZnx::alloc_bytes(module.n(), infos.rank_in().into())
-            + GLWESecretPrepared::alloc_bytes_with(module, infos.rank_out())
+        (GGLWE::encrypt_sk_tmp_bytes(module, infos) | ScalarZnx::bytes_of(module.n(), 1))
+            + ScalarZnx::bytes_of(module.n(), infos.rank_in().into())
+            + GLWESecretPrepared::bytes_of(module, infos.rank_out())
     }
 }
 
-impl<DataSelf: DataMut> GGLWESwitchingKeyCompressed<DataSelf> {
+impl<DataSelf: DataMut> GLWESwitchingKeyCompressed<DataSelf> {
     #[allow(clippy::too_many_arguments)]
     pub fn encrypt_sk<DataSkIn: DataRef, DataSkOut: DataRef, B: Backend>(
         &mut self,
@@ -40,36 +36,65 @@ seed_xa: [u8; 32],
         source_xe: &mut Source,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: SvpPrepare<B>
-            + SvpPPolAllocBytes
-            + VecZnxSwitchRing
-            + VecZnxDftAllocBytes
-            + VecZnxBigNormalize<B>
-            + VecZnxDftApply<B>
-            + SvpApplyDftToDftInplace<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxNormalizeTmpBytes
-            + VecZnxFillUniform
-            + VecZnxSubInplace
-            + VecZnxAddInplace
-            + VecZnxNormalizeInplace<B>
-            + VecZnxAddNormal
-            + VecZnxNormalize<B>
-            + VecZnxSub
-            + VecZnxAddScalarInplace,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx + TakeScalarZnx + TakeGLWESecretPrepared<B>,
+        Module<B>: GGLWEKeyCompressedEncryptSk<B>,
+    {
+        module.gglwe_key_compressed_encrypt_sk(self, sk_in, sk_out, seed_xa, source_xe, scratch);
+    }
+}
+
+pub trait GGLWEKeyCompressedEncryptSk<B: Backend> {
+    fn gglwe_key_compressed_encrypt_sk<R, SI, SO>(
+        &self,
+        res: &mut R,
+        sk_in: &SI,
+        sk_out: &SO,
+        seed_xa: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        R: GLWESwitchingKeyCompressedToMut,
+        SI: GLWESecretToRef,
+        SO: GLWESecretToRef;
+}
+
+impl<B: Backend> GGLWEKeyCompressedEncryptSk<B> for Module<B>
+where
+    Module<B>: GGLWECompressedEncryptSk<B>
+        + SvpPPolBytesOf
+        + VecZnxNormalizeTmpBytes
+        + VecZnxDftBytesOf
+        + VecZnxSwitchRing
+        + SvpPrepare<B>,
+    Scratch<B>: ScratchAvailable,
+{
+    fn gglwe_key_compressed_encrypt_sk<R, SI, SO>(
+        &self,
+        res: &mut R,
+        sk_in: &SI,
+        sk_out: &SO,
+        seed_xa: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        R: GLWESwitchingKeyCompressedToMut,
+        SI: GLWESecretToRef,
+        SO: GLWESecretToRef,
     {
+        let res: &mut GLWESwitchingKeyCompressed<&mut [u8]> = &mut res.to_mut();
+        let sk_in: &GLWESecret<&[u8]> = &sk_in.to_ref();
+        let sk_out: &GLWESecret<&[u8]> = &sk_out.to_ref();
+
         #[cfg(debug_assertions)]
         {
-            use crate::layouts::GGLWESwitchingKey;
+            use crate::layouts::GLWESwitchingKey;
 
-            assert!(sk_in.n().0 <= module.n() as u32);
-            assert!(sk_out.n().0 <= module.n() as u32);
+            assert!(sk_in.n().0 <= self.n() as u32);
+            assert!(sk_out.n().0 <= self.n() as u32);
             assert!(
-                scratch.available() >= GGLWESwitchingKey::encrypt_sk_scratch_space(module, self),
-                "scratch.available()={} < GLWESwitchingKey::encrypt_sk_scratch_space={}",
+                scratch.available() >= GLWESwitchingKey::encrypt_sk_tmp_bytes(self, res),
+                "scratch.available()={} < GLWESwitchingKey::encrypt_sk_tmp_bytes={}",
                 scratch.available(),
-                GGLWESwitchingKey::encrypt_sk_scratch_space(module, self)
+                GLWESwitchingKey::encrypt_sk_tmp_bytes(self, res)
             )
         }
 
@@ -77,7 +102,7 @@ let n: usize = sk_in.n().max(sk_out.n()).into();
 
         let (mut sk_in_tmp, scratch_1) = scratch.take_scalar_znx(n, sk_in.rank().into());
         (0..sk_in.rank().into()).for_each(|i| {
-            module.vec_znx_switch_ring(
+            self.vec_znx_switch_ring(
                 &mut sk_in_tmp.as_vec_znx_mut(),
                 i,
                 &sk_in.data.as_vec_znx(),
@@ -85,24 +110,24 @@ i,
             );
         });
 
-        let (mut sk_out_tmp, scratch_2) = scratch_1.take_glwe_secret_prepared(Degree(n as u32), sk_out.rank());
+        let (mut sk_out_tmp, scratch_2) = scratch_1.take_glwe_secret_prepared(RingDegree(n as u32), sk_out.rank());
         {
             let (mut tmp, _) = scratch_2.take_scalar_znx(n, 1);
             (0..sk_out.rank().into()).for_each(|i| {
-                module.vec_znx_switch_ring(&mut tmp.as_vec_znx_mut(), 0, &sk_out.data.as_vec_znx(), i);
-                module.svp_prepare(&mut sk_out_tmp.data, i, &tmp, 0);
+                self.vec_znx_switch_ring(&mut tmp.as_vec_znx_mut(), 0, &sk_out.data.as_vec_znx(), i);
+                self.svp_prepare(&mut sk_out_tmp.data, i, &tmp, 0);
             });
         }
 
-        self.key.encrypt_sk(
-            module,
+        self.gglwe_compressed_encrypt_sk(
+            &mut res.key,
             &sk_in_tmp,
             &sk_out_tmp,
             seed_xa,
             source_xe,
             scratch_2,
         );
-        self.sk_in_n = sk_in.n().into();
-        self.sk_out_n = sk_out.n().into();
+        res.sk_in_n = sk_in.n().into();
+        res.sk_out_n = sk_out.n().into();
     }
 }

@@ -1,86 +1,83 @@
 use poulpy_hal::{
     api::{
-        ScratchAvailable, SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx,
-        TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAllocBytes,
-        VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA,
-        VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace, VecZnxSwitchRing,
+        SvpApplyDftToDft, SvpPPolBytesOf, SvpPrepare, VecZnxBigBytesOf, VecZnxBigNormalize, VecZnxDftApply, VecZnxDftBytesOf,
+        VecZnxIdftApplyTmpA, VecZnxNormalizeTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch},
     source::Source,
 };
 
 use crate::{
-    TakeGLWESecret, TakeGLWESecretPrepared,
+    encryption::compressed::gglwe_ksk::GGLWEKeyCompressedEncryptSk,
     layouts::{
-        GGLWEInfos, GGLWETensorKey, GLWEInfos, GLWESecret, LWEInfos, Rank, compressed::GGLWETensorKeyCompressed,
-        prepared::Prepare,
+        GGLWEInfos, GLWEInfos, GLWESecret, GLWESecretToRef, LWEInfos, Rank, TensorKey,
+        compressed::{TensorKeyCompressed, TensorKeyCompressedToMut},
     },
 };
 
-impl GGLWETensorKeyCompressed<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+impl TensorKeyCompressed<Vec<u8>> {
+    pub fn encrypt_sk_tmp_bytes<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
     where
         A: GGLWEInfos,
-        Module<B>:
-            SvpPPolAllocBytes + VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes + VecZnxNormalizeTmpBytes + VecZnxBigAllocBytes,
+        Module<B>: SvpPPolBytesOf + VecZnxNormalizeTmpBytes + VecZnxDftBytesOf + VecZnxNormalizeTmpBytes + VecZnxBigBytesOf,
     {
-        GGLWETensorKey::encrypt_sk_scratch_space(module, infos)
+        TensorKey::encrypt_sk_tmp_bytes(module, infos)
     }
 }
 
-impl<DataSelf: DataMut> GGLWETensorKeyCompressed<DataSelf> {
-    pub fn encrypt_sk<DataSk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        sk: &GLWESecret<DataSk>,
+pub trait GGLWETensorKeyCompressedEncryptSk<B: Backend> {
+    fn gglwe_tensor_key_encrypt_sk<R, S>(
+        &self,
+        res: &mut R,
+        sk: &S,
         seed_xa: [u8; 32],
         source_xe: &mut Source,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: SvpApplyDftToDft<B>
-            + VecZnxIdftApplyTmpA<B>
-            + VecZnxDftAllocBytes
-            + VecZnxBigNormalize<B>
-            + VecZnxDftApply<B>
-            + SvpApplyDftToDftInplace<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxNormalizeTmpBytes
-            + VecZnxFillUniform
-            + VecZnxSubInplace
-            + VecZnxAddInplace
-            + VecZnxNormalizeInplace<B>
-            + VecZnxAddNormal
-            + VecZnxNormalize<B>
-            + VecZnxSub
-            + VecZnxSwitchRing
-            + VecZnxAddScalarInplace
-            + SvpPrepare<B>
-            + SvpPPolAllocBytes
-            + SvpPPolAlloc<B>,
-        Scratch<B>: ScratchAvailable
-            + TakeScalarZnx
-            + TakeVecZnxDft<B>
-            + TakeGLWESecretPrepared<B>
-            + ScratchAvailable
-            + TakeVecZnx
-            + TakeVecZnxBig<B>,
+        R: TensorKeyCompressedToMut,
+        S: GLWESecretToRef;
+}
+
+impl<B: Backend> GGLWETensorKeyCompressedEncryptSk<B> for Module<B>
+where
+    Module<B>: GGLWEKeyCompressedEncryptSk<B>
+        + VecZnxDftApply<B>
+        + SvpApplyDftToDft<B>
+        + VecZnxIdftApplyTmpA<B>
+        + VecZnxBigNormalize<B>
+        + SvpPrepare<B>,
+    Scratch<B>:,
+{
+    fn gglwe_tensor_key_encrypt_sk<R, S>(
+        &self,
+        res: &mut R,
+        sk: &S,
+        seed_xa: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        R: TensorKeyCompressedToMut,
+        S: GLWESecretToRef,
     {
+        let res: &mut TensorKeyCompressed<&mut [u8]> = &mut res.to_mut();
+        let sk: &GLWESecret<&[u8]> = &sk.to_ref();
+
         #[cfg(debug_assertions)]
         {
-            assert_eq!(self.rank_out(), sk.rank());
-            assert_eq!(self.n(), sk.n());
+            assert_eq!(res.rank_out(), sk.rank());
+            assert_eq!(res.n(), sk.n());
         }
 
         let n: usize = sk.n().into();
-        let rank: usize = self.rank_out().into();
+        let rank: usize = res.rank_out().into();
 
-        let (mut sk_dft_prep, scratch_1) = scratch.take_glwe_secret_prepared(sk.n(), self.rank_out());
-        sk_dft_prep.prepare(module, sk, scratch_1);
+        let (mut sk_dft_prep, scratch_1) = scratch.take_glwe_secret_prepared(sk.n(), res.rank_out());
+        sk_dft_prep.prepare(self, sk, scratch_1);
 
         let (mut sk_dft, scratch_2) = scratch_1.take_vec_znx_dft(n, rank, 1);
 
         for i in 0..rank {
-            module.vec_znx_dft_apply(1, 0, &mut sk_dft, i, &sk.data.as_vec_znx(), i);
+            self.vec_znx_dft_apply(1, 0, &mut sk_dft, i, &sk.data.as_vec_znx(), i);
         }
 
         let (mut sk_ij_big, scratch_3) = scratch_2.take_vec_znx_big(n, 1, 1);
@@ -91,14 +88,14 @@ let mut source_xa: Source = Source::new(seed_xa);
 
         for i in 0..rank {
             for j in i..rank {
-                module.svp_apply_dft_to_dft(&mut sk_ij_dft, 0, &sk_dft_prep.data, j, &sk_dft, i);
+                self.svp_apply_dft_to_dft(&mut sk_ij_dft, 0, &sk_dft_prep.data, j, &sk_dft, i);
 
-                module.vec_znx_idft_apply_tmpa(&mut sk_ij_big, 0, &mut sk_ij_dft, 0);
-                module.vec_znx_big_normalize(
-                    self.base2k().into(),
+                self.vec_znx_idft_apply_tmpa(&mut sk_ij_big, 0, &mut sk_ij_dft, 0);
+                self.vec_znx_big_normalize(
+                    res.base2k().into(),
                     &mut sk_ij.data.as_vec_znx_mut(),
                     0,
-                    self.base2k().into(),
+                    res.base2k().into(),
                     &sk_ij_big,
                     0,
                     scratch_5,
@@ -106,9 +103,30 @@ );
 
                 let (seed_xa_tmp, _) = source_xa.branch();
 
-                self.at_mut(i, j)
-                    .encrypt_sk(module, &sk_ij, sk, seed_xa_tmp, source_xe, scratch_5);
+                self.gglwe_key_compressed_encrypt_sk(
+                    res.at_mut(i, j),
+                    &sk_ij,
+                    sk,
+                    seed_xa_tmp,
+                    source_xe,
+                    scratch_5,
+                );
             }
         }
     }
 }
+
+impl<DataSelf: DataMut> TensorKeyCompressed<DataSelf> {
+    pub fn encrypt_sk<DataSk: DataRef, B: Backend>(
+        &mut self,
+        module: &Module<B>,
+        sk: &GLWESecret<DataSk>,
+        seed_xa: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        Module<B>: GGLWETensorKeyCompressedEncryptSk<B>,
+    {
+        module.gglwe_tensor_key_encrypt_sk(self, sk, seed_xa, source_xe, scratch);
+    }
+}

@@ -1,97 +1,103 @@
 use poulpy_hal::{
-    api::{
-        ScratchAvailable, SvpApplyDftToDftInplace, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal,
-        VecZnxAddScalarInplace, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform,
-        VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace,
-    },
-    layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, Scratch, ZnxZero},
+    api::{VecZnxAddScalarInplace, VecZnxDftBytesOf, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes},
+    layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, ScalarZnxToRef, Scratch, ZnxZero},
     source::Source,
 };
 
 use crate::{
-    TakeGLWEPt,
-    encryption::{SIGMA, glwe_encrypt_sk_internal},
+    encryption::{SIGMA, glwe_ct::GLWEEncryptSkInternal},
     layouts::{
-        GGSWCiphertext, GGSWInfos, GLWEInfos, LWEInfos, compressed::GGSWCiphertextCompressed, prepared::GLWESecretPrepared,
+        GGSW, GGSWInfos, GLWEInfos, LWEInfos,
+        compressed::{GGSWCompressed, GGSWCompressedToMut},
+        prepared::{GLWESecretPrepared, GLWESecretPreparedToRef},
     },
 };
 
-impl GGSWCiphertextCompressed<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+impl GGSWCompressed<Vec<u8>> {
+    pub fn encrypt_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<DataSelf: DataMut> GGSWCiphertextCompressed<DataSelf> {
-    #[allow(clippy::too_many_arguments)]
-    pub fn encrypt_sk<DataPt: DataRef, DataSk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        pt: &ScalarZnx<DataPt>,
-        sk: &GLWESecretPrepared<DataSk, B>,
+pub trait GGSWCompressedEncryptSk<B: Backend> {
+    fn ggsw_compressed_encrypt_sk<R, P, S>(
+        &self,
+        res: &mut R,
+        pt: &P,
+        sk: &S,
         seed_xa: [u8; 32],
         source_xe: &mut Source,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxAddScalarInplace
-            + VecZnxDftAllocBytes
-            + VecZnxBigNormalize<B>
-            + VecZnxDftApply<B>
-            + SvpApplyDftToDftInplace<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxNormalizeTmpBytes
-            + VecZnxFillUniform
-            + VecZnxSubInplace
-            + VecZnxAddInplace
-            + VecZnxNormalizeInplace<B>
-            + VecZnxAddNormal
-            + VecZnxNormalize<B>
-            + VecZnxSub,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+        R: GGSWCompressedToMut,
+        P: ScalarZnxToRef,
+        S: GLWESecretPreparedToRef<B>;
+}
+
+impl<B: Backend> GGSWCompressedEncryptSk<B> for Module<B>
+where
+    Module<B>: GLWEEncryptSkInternal<B> + VecZnxAddScalarInplace + VecZnxNormalizeInplace<B>,
+    Scratch<B>:,
+{
+    fn ggsw_compressed_encrypt_sk<R, P, S>(
+        &self,
+        res: &mut R,
+        pt: &P,
+        sk: &S,
+        seed_xa: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        R: GGSWCompressedToMut,
+        P: ScalarZnxToRef,
+        S: GLWESecretPreparedToRef<B>,
     {
+        let res: &mut GGSWCompressed<&mut [u8]> = &mut res.to_mut();
+        let sk: &GLWESecretPrepared<&[u8], B> = &sk.to_ref();
+        let pt: &ScalarZnx<&[u8]> = &pt.to_ref();
+
         #[cfg(debug_assertions)]
         {
             use poulpy_hal::layouts::ZnxInfos;
 
-            assert_eq!(self.rank(), sk.rank());
-            assert_eq!(self.n(), sk.n());
+            assert_eq!(res.rank(), sk.rank());
+            assert_eq!(res.n(), sk.n());
             assert_eq!(pt.n() as u32, sk.n());
         }
 
-        let base2k: usize = self.base2k().into();
-        let rank: usize = self.rank().into();
+        let base2k: usize = res.base2k().into();
+        let rank: usize = res.rank().into();
         let cols: usize = rank + 1;
-        let dsize: usize = self.dsize().into();
+        let dsize: usize = res.dsize().into();
 
-        let (mut tmp_pt, scratch_1) = scratch.take_glwe_pt(&self.glwe_layout());
+        let (mut tmp_pt, scratch_1) = scratch.take_glwe_pt(&res.glwe_layout());
 
         let mut source = Source::new(seed_xa);
 
-        self.seed = vec![[0u8; 32]; self.dnum().0 as usize * cols];
+        res.seed = vec![[0u8; 32]; res.dnum().0 as usize * cols];
 
-        (0..self.dnum().into()).for_each(|row_i| {
+        for row_i in 0..res.dnum().into() {
             tmp_pt.data.zero();
 
             // Adds the scalar_znx_pt to the i-th limb of the vec_znx_pt
-            module.vec_znx_add_scalar_inplace(&mut tmp_pt.data, 0, (dsize - 1) + row_i * dsize, pt, 0);
-            module.vec_znx_normalize_inplace(base2k, &mut tmp_pt.data, 0, scratch_1);
+            self.vec_znx_add_scalar_inplace(&mut tmp_pt.data, 0, (dsize - 1) + row_i * dsize, pt, 0);
+            self.vec_znx_normalize_inplace(base2k, &mut tmp_pt.data, 0, scratch_1);
 
-            (0..rank + 1).for_each(|col_j| {
+            for col_j in 0..rank + 1 {
                 // rlwe encrypt of vec_znx_pt into vec_znx_ct
 
                 let (seed, mut source_xa_tmp) = source.branch();
 
-                self.seed[row_i * cols + col_j] = seed;
+                res.seed[row_i * cols + col_j] = seed;
 
-                glwe_encrypt_sk_internal(
-                    module,
-                    self.base2k().into(),
-                    self.k().into(),
-                    &mut self.at_mut(row_i, col_j).data,
+                self.glwe_encrypt_sk_internal(
+                    res.base2k().into(),
+                    res.k().into(),
+                    &mut res.at_mut(row_i, col_j).data,
                     cols,
                     true,
                     Some((&tmp_pt, col_j)),
@@ -101,7 +107,24 @@ source_xe,
                     SIGMA,
                     scratch_1,
                 );
-            });
-        });
+            }
+        }
+    }
+}
+
+impl<DataSelf: DataMut> GGSWCompressed<DataSelf> {
+    #[allow(clippy::too_many_arguments)]
+    pub fn encrypt_sk<DataPt: DataRef, DataSk: DataRef, B: Backend>(
+        &mut self,
+        module: &Module<B>,
+        pt: &ScalarZnx<DataPt>,
+        sk: &GLWESecretPrepared<DataSk, B>,
+        seed_xa: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        Module<B>: GGSWCompressedEncryptSk<B>,
+    {
+        module.ggsw_compressed_encrypt_sk(self, pt, sk, seed_xa, source_xe, scratch);
     }
 }

@@ -1,100 +1,95 @@
 use poulpy_hal::{
-    api::{
-        ScratchAvailable, SvpApplyDftToDftInplace, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal,
-        VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize,
-        VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace,
-    },
+    api::{VecZnxDftBytesOf, VecZnxNormalizeTmpBytes},
     layouts::{Backend, DataMut, DataRef, Module, Scratch},
     source::Source,
 };
 
 use crate::{
-    encryption::{SIGMA, glwe_ct::glwe_encrypt_sk_internal},
+    encryption::{SIGMA, glwe_ct::GLWEEncryptSkInternal},
     layouts::{
-        GLWECiphertext, GLWEInfos, GLWEPlaintext, LWEInfos, compressed::GLWECiphertextCompressed, prepared::GLWESecretPrepared,
+        GLWE, GLWEInfos, GLWEPlaintext, GLWEPlaintextToRef, LWEInfos,
+        compressed::{GLWECompressed, GLWECompressedToMut},
+        prepared::{GLWESecretPrepared, GLWESecretPreparedToRef},
     },
 };
 
-impl GLWECiphertextCompressed<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+impl GLWECompressed<Vec<u8>> {
+    pub fn encrypt_sk_tmp_bytes<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
     where
         A: GLWEInfos,
-        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes,
+        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftBytesOf,
     {
-        GLWECiphertext::encrypt_sk_scratch_space(module, infos)
+        GLWE::encrypt_sk_tmp_bytes(module, infos)
     }
 }
 
-impl<D: DataMut> GLWECiphertextCompressed<D> {
-    #[allow(clippy::too_many_arguments)]
-    pub fn encrypt_sk<DataPt: DataRef, DataSk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        pt: &GLWEPlaintext<DataPt>,
-        sk: &GLWESecretPrepared<DataSk, B>,
+pub trait GLWECompressedEncryptSk<B: Backend> {
+    fn glwe_compressed_encrypt_sk<R, P, S>(
+        &self,
+        res: &mut R,
+        pt: &P,
+        sk: &S,
         seed_xa: [u8; 32],
         source_xe: &mut Source,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VecZnxBigNormalize<B>
-            + VecZnxDftApply<B>
-            + SvpApplyDftToDftInplace<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxNormalizeTmpBytes
-            + VecZnxFillUniform
-            + VecZnxSubInplace
-            + VecZnxAddInplace
-            + VecZnxNormalizeInplace<B>
-            + VecZnxAddNormal
-            + VecZnxNormalize<B>
-            + VecZnxSub,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
-    {
-        self.encrypt_sk_internal(module, Some((pt, 0)), sk, seed_xa, source_xe, scratch);
-    }
+        R: GLWECompressedToMut,
+        P: GLWEPlaintextToRef,
+        S: GLWESecretPreparedToRef<B>;
+}
 
-    #[allow(clippy::too_many_arguments)]
-    pub(crate) fn encrypt_sk_internal<DataPt: DataRef, DataSk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        pt: Option<(&GLWEPlaintext<DataPt>, usize)>,
-        sk: &GLWESecretPrepared<DataSk, B>,
+impl<B: Backend> GLWECompressedEncryptSk<B> for Module<B>
+where
+    Module<B>: GLWEEncryptSkInternal<B>,
+{
+    fn glwe_compressed_encrypt_sk<R, P, S>(
+        &self,
+        res: &mut R,
+        pt: &P,
+        sk: &S,
         seed_xa: [u8; 32],
         source_xe: &mut Source,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VecZnxBigNormalize<B>
-            + VecZnxDftApply<B>
-            + SvpApplyDftToDftInplace<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxNormalizeTmpBytes
-            + VecZnxFillUniform
-            + VecZnxSubInplace
-            + VecZnxAddInplace
-            + VecZnxNormalizeInplace<B>
-            + VecZnxAddNormal
-            + VecZnxNormalize<B>
-            + VecZnxSub,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+        R: GLWECompressedToMut,
+        P: GLWEPlaintextToRef,
+        S: GLWESecretPreparedToRef<B>,
     {
-        let mut source_xa = Source::new(seed_xa);
-        let cols: usize = (self.rank() + 1).into();
-        glwe_encrypt_sk_internal(
-            module,
-            self.base2k().into(),
-            self.k().into(),
-            &mut self.data,
+        let res: &mut GLWECompressed<&mut [u8]> = &mut res.to_mut();
+        let mut source_xa: Source = Source::new(seed_xa);
+        let cols: usize = (res.rank() + 1).into();
+
+        self.glwe_encrypt_sk_internal(
+            res.base2k().into(),
+            res.k().into(),
+            &mut res.data,
             cols,
             true,
-            pt,
+            Some((pt, 0)),
             sk,
             &mut source_xa,
             source_xe,
             SIGMA,
             scratch,
         );
-        self.seed = seed_xa;
+
+        res.seed = seed_xa;
+    }
+}
+
+impl<D: DataMut> GLWECompressed<D> {
+    #[allow(clippy::too_many_arguments)]
+    pub fn encrypt_sk<DataPt: DataRef, DataSk: DataRef, B: Backend>(
+        &mut self,
+        module: &Module<B>,
+        pt: &GLWEPlaintext<DataPt>,
+        sk: &GLWESecretPrepared<DataSk, B>,
+        seed_xa: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        Module<B>: GLWECompressedEncryptSk<B>,
+    {
+        module.glwe_compressed_encrypt_sk(self, pt, sk, seed_xa, source_xe, scratch);
     }
 }

@@ -1,34 +1,33 @@
 use poulpy_hal::{
     api::{
-        ScratchAvailable, SvpApplyDftToDftInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx, TakeVecZnxDft,
-        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphism, VecZnxBigNormalize, VecZnxDftAllocBytes,
-        VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace,
-        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace, VecZnxSwitchRing,
+        ScratchAvailable, SvpApplyDftToDftInplace, SvpPPolBytesOf, SvpPrepare, VecZnxAddInplace, VecZnxAddNormal,
+        VecZnxAddScalarInplace, VecZnxAutomorphism, VecZnxBigNormalize, VecZnxDftApply, VecZnxDftBytesOf, VecZnxFillUniform,
+        VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace,
+        VecZnxSwitchRing,
     },
-    layouts::{Backend, DataMut, DataRef, Module, Scratch},
+    layouts::{Backend, DataMut, Module, Scratch},
     source::Source,
 };
 
-use crate::{
-    TakeGLWESecret, TakeGLWESecretPrepared,
-    layouts::{GGLWEAutomorphismKey, GGLWEInfos, GGLWESwitchingKey, GLWEInfos, GLWESecret, LWEInfos},
+use crate::layouts::{
+    AutomorphismKey, AutomorphismKeyToMut, GGLWEInfos, GLWEInfos, GLWESecret, GLWESecretToRef, GLWESwitchingKey, LWEInfos,
 };
 
-impl GGLWEAutomorphismKey<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+impl AutomorphismKey<Vec<u8>> {
+    pub fn encrypt_sk_tmp_bytes<BE: Backend, A>(module: &Module<BE>, infos: &A) -> usize
     where
         A: GGLWEInfos,
-        Module<B>: SvpPPolAllocBytes + VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes + VecZnxNormalizeTmpBytes,
+        Module<BE>: SvpPPolBytesOf + VecZnxNormalizeTmpBytes + VecZnxDftBytesOf + VecZnxNormalizeTmpBytes,
     {
         assert_eq!(
             infos.rank_in(),
             infos.rank_out(),
             "rank_in != rank_out is not supported for GGLWEAutomorphismKey"
         );
-        GGLWESwitchingKey::encrypt_sk_scratch_space(module, infos) + GLWESecret::alloc_bytes(&infos.glwe_layout())
+        GLWESwitchingKey::encrypt_sk_tmp_bytes(module, infos) + GLWESecret::bytes_of_from_infos(module, &infos.glwe_layout())
     }
 
-    pub fn encrypt_pk_scratch_space<B: Backend, A>(module: &Module<B>, _infos: &A) -> usize
+    pub fn encrypt_pk_tmp_bytes<BE: Backend, A>(module: &Module<BE>, _infos: &A) -> usize
     where
         A: GGLWEInfos,
     {
@@ -37,62 +36,102 @@ _infos.rank_in(),
             _infos.rank_out(),
             "rank_in != rank_out is not supported for GGLWEAutomorphismKey"
         );
-        GGLWESwitchingKey::encrypt_pk_scratch_space(module, _infos)
+        GLWESwitchingKey::encrypt_pk_tmp_bytes(module, _infos)
     }
 }
 
-impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
-    #[allow(clippy::too_many_arguments)]
-    pub fn encrypt_sk<DataSk: DataRef, B: Backend>(
+pub trait GGLWEAutomorphismKeyEncryptSk<BE: Backend> {
+    fn gglwe_automorphism_key_encrypt_sk<A, B>(
+        &self,
+        res: &mut A,
+        p: i64,
+        sk: &B,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        A: AutomorphismKeyToMut,
+        B: GLWESecretToRef;
+}
+
+impl<DM: DataMut> AutomorphismKey<DM>
+where
+    Self: AutomorphismKeyToMut,
+{
+    pub fn encrypt_sk<S, BE: Backend>(
         &mut self,
-        module: &Module<B>,
+        module: &Module<BE>,
+        p: i64,
+        sk: &S,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        S: GLWESecretToRef,
+        Module<BE>: GGLWEAutomorphismKeyEncryptSk<BE>,
+    {
+        module.gglwe_automorphism_key_encrypt_sk(self, p, sk, source_xa, source_xe, scratch);
+    }
+}
+
+impl<BE: Backend> GGLWEAutomorphismKeyEncryptSk<BE> for Module<BE>
+where
+    Module<BE>: VecZnxAddScalarInplace
+        + VecZnxDftBytesOf
+        + VecZnxBigNormalize<BE>
+        + VecZnxDftApply<BE>
+        + SvpApplyDftToDftInplace<BE>
+        + VecZnxIdftApplyConsume<BE>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<BE>
+        + VecZnxAddNormal
+        + VecZnxNormalize<BE>
+        + VecZnxSub
+        + SvpPrepare<BE>
+        + VecZnxSwitchRing
+        + SvpPPolBytesOf
+        + VecZnxAutomorphism,
+    Scratch<BE>: ScratchAvailable,
+{
+    fn gglwe_automorphism_key_encrypt_sk<A, B>(
+        &self,
+        res: &mut A,
         p: i64,
-        sk: &GLWESecret<DataSk>,
+        sk: &B,
         source_xa: &mut Source,
         source_xe: &mut Source,
-        scratch: &mut Scratch<B>,
+        scratch: &mut Scratch<BE>,
     ) where
-        Module<B>: VecZnxAddScalarInplace
-            + VecZnxDftAllocBytes
-            + VecZnxBigNormalize<B>
-            + VecZnxDftApply<B>
-            + SvpApplyDftToDftInplace<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxNormalizeTmpBytes
-            + VecZnxFillUniform
-            + VecZnxSubInplace
-            + VecZnxAddInplace
-            + VecZnxNormalizeInplace<B>
-            + VecZnxAddNormal
-            + VecZnxNormalize<B>
-            + VecZnxSub
-            + SvpPrepare<B>
-            + VecZnxSwitchRing
-            + SvpPPolAllocBytes
-            + VecZnxAutomorphism,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx + TakeScalarZnx + TakeGLWESecretPrepared<B>,
+        A: AutomorphismKeyToMut,
+        B: GLWESecretToRef,
     {
+        let res: &mut AutomorphismKey<&mut [u8]> = &mut res.to_mut();
+        let sk: &GLWESecret<&[u8]> = &sk.to_ref();
+
         #[cfg(debug_assertions)]
         {
             use crate::layouts::{GLWEInfos, LWEInfos};
 
-            assert_eq!(self.n(), sk.n());
-            assert_eq!(self.rank_out(), self.rank_in());
-            assert_eq!(sk.rank(), self.rank_out());
+            assert_eq!(res.n(), sk.n());
+            assert_eq!(res.rank_out(), res.rank_in());
+            assert_eq!(sk.rank(), res.rank_out());
             assert!(
-                scratch.available() >= GGLWEAutomorphismKey::encrypt_sk_scratch_space(module, self),
-                "scratch.available(): {} < AutomorphismKey::encrypt_sk_scratch_space: {:?}",
+                scratch.available() >= AutomorphismKey::encrypt_sk_tmp_bytes(self, res),
+                "scratch.available(): {} < AutomorphismKey::encrypt_sk_tmp_bytes: {:?}",
                 scratch.available(),
-                GGLWEAutomorphismKey::encrypt_sk_scratch_space(module, self)
+                AutomorphismKey::encrypt_sk_tmp_bytes(self, res)
             )
         }
 
         let (mut sk_out, scratch_1) = scratch.take_glwe_secret(sk.n(), sk.rank());
 
         {
-            (0..self.rank_out().into()).for_each(|i| {
-                module.vec_znx_automorphism(
-                    module.galois_element_inv(p),
+            (0..res.rank_out().into()).for_each(|i| {
+                self.vec_znx_automorphism(
+                    self.galois_element_inv(p),
                     &mut sk_out.data.as_vec_znx_mut(),
                     i,
                     &sk.data.as_vec_znx(),
@@ -101,9 +140,9 @@ );
             });
         }
 
-        self.key
-            .encrypt_sk(module, sk, &sk_out, source_xa, source_xe, scratch_1);
+        res.key
+            .encrypt_sk(self, sk, &sk_out, source_xa, source_xe, scratch_1);
 
-        self.p = p;
+        res.p = p;
     }
 }

@@ -1,29 +1,28 @@
 use poulpy_hal::{
-    api::{
-        ScratchAvailable, SvpApplyDftToDftInplace, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal,
-        VecZnxAddScalarInplace, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform,
-        VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace,
-    },
-    layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, Scratch, ZnxZero},
+    api::{ScratchAvailable, VecZnxAddScalarInplace, VecZnxDftBytesOf, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes},
+    layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, ScalarZnxToRef, Scratch, ZnxZero},
     source::Source,
 };
 
 use crate::{
-    TakeGLWEPt,
-    layouts::{GGLWECiphertext, GGLWEInfos, GLWECiphertext, GLWEPlaintext, LWEInfos, prepared::GLWESecretPrepared},
+    encryption::glwe_ct::GLWEEncryptSk,
+    layouts::{
+        GGLWE, GGLWEInfos, GGLWEToMut, GLWE, GLWEPlaintext, LWEInfos,
+        prepared::{GLWESecretPrepared, GLWESecretPreparedToRef},
+    },
 };
 
-impl GGLWECiphertext<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+impl GGLWE<Vec<u8>> {
+    pub fn encrypt_sk_tmp_bytes<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
     where
         A: GGLWEInfos,
-        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes + VecZnxNormalizeTmpBytes,
+        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftBytesOf + VecZnxNormalizeTmpBytes,
     {
-        GLWECiphertext::encrypt_sk_scratch_space(module, &infos.glwe_layout())
-            + (GLWEPlaintext::alloc_bytes(&infos.glwe_layout()) | module.vec_znx_normalize_tmp_bytes())
+        GLWE::encrypt_sk_tmp_bytes(module, &infos.glwe_layout())
+            + (GLWEPlaintext::bytes_of_from_infos(module, &infos.glwe_layout()) | module.vec_znx_normalize_tmp_bytes())
     }
 
-    pub fn encrypt_pk_scratch_space<B: Backend, A>(_module: &Module<B>, _infos: &A) -> usize
+    pub fn encrypt_pk_tmp_bytes<B: Backend, A>(_module: &Module<B>, _infos: &A) -> usize
     where
         A: GGLWEInfos,
     {
@@ -31,78 +30,88 @@ unimplemented!()
     }
 }
 
-impl<DataSelf: DataMut> GGLWECiphertext<DataSelf> {
-    #[allow(clippy::too_many_arguments)]
-    pub fn encrypt_sk<DataPt: DataRef, DataSk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        pt: &ScalarZnx<DataPt>,
-        sk: &GLWESecretPrepared<DataSk, B>,
+pub trait GGLWEEncryptSk<B: Backend> {
+    fn gglwe_encrypt_sk<R, P, S>(
+        &self,
+        res: &mut R,
+        pt: &P,
+        sk: &S,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        R: GGLWEToMut,
+        P: ScalarZnxToRef,
+        S: GLWESecretPreparedToRef<B>;
+}
+
+impl<B: Backend> GGLWEEncryptSk<B> for Module<B>
+where
+    Module<B>: GLWEEncryptSk<B> + VecZnxNormalizeTmpBytes + VecZnxDftBytesOf + VecZnxAddScalarInplace + VecZnxNormalizeInplace<B>,
+    Scratch<B>: ScratchAvailable,
+{
+    fn gglwe_encrypt_sk<R, P, S>(
+        &self,
+        res: &mut R,
+        pt: &P,
+        sk: &S,
         source_xa: &mut Source,
         source_xe: &mut Source,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxAddScalarInplace
-            + VecZnxDftAllocBytes
-            + VecZnxBigNormalize<B>
-            + VecZnxDftApply<B>
-            + SvpApplyDftToDftInplace<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxNormalizeTmpBytes
-            + VecZnxFillUniform
-            + VecZnxSubInplace
-            + VecZnxAddInplace
-            + VecZnxNormalizeInplace<B>
-            + VecZnxAddNormal
-            + VecZnxNormalize<B>
-            + VecZnxSub,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+        R: GGLWEToMut,
+        P: ScalarZnxToRef,
+        S: GLWESecretPreparedToRef<B>,
     {
+        let res: &mut GGLWE<&mut [u8]> = &mut res.to_mut();
+        let pt: &ScalarZnx<&[u8]> = &pt.to_ref();
+
         #[cfg(debug_assertions)]
         {
             use poulpy_hal::layouts::ZnxInfos;
+            let sk: GLWESecretPrepared<&[u8], B> = sk.to_ref();
 
             assert_eq!(
-                self.rank_in(),
+                res.rank_in(),
                 pt.cols() as u32,
-                "self.rank_in(): {} != pt.cols(): {}",
-                self.rank_in(),
+                "res.rank_in(): {} != pt.cols(): {}",
+                res.rank_in(),
                 pt.cols()
             );
             assert_eq!(
-                self.rank_out(),
+                res.rank_out(),
                 sk.rank(),
-                "self.rank_out(): {} != sk.rank(): {}",
-                self.rank_out(),
+                "res.rank_out(): {} != sk.rank(): {}",
+                res.rank_out(),
                 sk.rank()
             );
-            assert_eq!(self.n(), sk.n());
+            assert_eq!(res.n(), sk.n());
             assert_eq!(pt.n() as u32, sk.n());
             assert!(
-                scratch.available() >= GGLWECiphertext::encrypt_sk_scratch_space(module, self),
-                "scratch.available: {} < GGLWECiphertext::encrypt_sk_scratch_space(module, self.rank()={}, self.size()={}): {}",
+                scratch.available() >= GGLWE::encrypt_sk_tmp_bytes(self, res),
+                "scratch.available: {} < GGLWECiphertext::encrypt_sk_tmp_bytes(self, res.rank()={}, res.size()={}): {}",
                 scratch.available(),
-                self.rank_out(),
-                self.size(),
-                GGLWECiphertext::encrypt_sk_scratch_space(module, self)
+                res.rank_out(),
+                res.size(),
+                GGLWE::encrypt_sk_tmp_bytes(self, res)
             );
             assert!(
-                self.dnum().0 * self.dsize().0 * self.base2k().0 <= self.k().0,
-                "self.dnum() : {} * self.dsize() : {} * self.base2k() : {} = {} >= self.k() = {}",
-                self.dnum(),
-                self.dsize(),
-                self.base2k(),
-                self.dnum().0 * self.dsize().0 * self.base2k().0,
-                self.k()
+                res.dnum().0 * res.dsize().0 * res.base2k().0 <= res.k().0,
+                "res.dnum() : {} * res.dsize() : {} * res.base2k() : {} = {} >= res.k() = {}",
+                res.dnum(),
+                res.dsize(),
+                res.base2k(),
+                res.dnum().0 * res.dsize().0 * res.base2k().0,
+                res.k()
             );
         }
 
-        let dnum: usize = self.dnum().into();
-        let dsize: usize = self.dsize().into();
-        let base2k: usize = self.base2k().into();
-        let rank_in: usize = self.rank_in().into();
+        let dnum: usize = res.dnum().into();
+        let dsize: usize = res.dsize().into();
+        let base2k: usize = res.base2k().into();
+        let rank_in: usize = res.rank_in().into();
 
-        let (mut tmp_pt, scrach_1) = scratch.take_glwe_pt(self);
+        let (mut tmp_pt, scrach_1) = scratch.take_glwe_pt(res);
         // For each input column (i.e. rank) produces a GGLWE ciphertext of rank_out+1 columns
         //
         // Example for ksk rank 2 to rank 3:
@@ -114,17 +123,39 @@ // Example ksk rank 2 to rank 1
         //
         // (-(a*s) + s0, a)
         // (-(b*s) + s1, b)
-        (0..rank_in).for_each(|col_i| {
-            (0..dnum).for_each(|row_i| {
+
+        for col_i in 0..rank_in {
+            for row_i in 0..dnum {
                 // Adds the scalar_znx_pt to the i-th limb of the vec_znx_pt
                 tmp_pt.data.zero(); // zeroes for next iteration
-                module.vec_znx_add_scalar_inplace(&mut tmp_pt.data, 0, (dsize - 1) + row_i * dsize, pt, col_i);
-                module.vec_znx_normalize_inplace(base2k, &mut tmp_pt.data, 0, scrach_1);
+                self.vec_znx_add_scalar_inplace(&mut tmp_pt.data, 0, (dsize - 1) + row_i * dsize, pt, col_i);
+                self.vec_znx_normalize_inplace(base2k, &mut tmp_pt.data, 0, scrach_1);
+                self.glwe_encrypt_sk(
+                    &mut res.at_mut(row_i, col_i),
+                    &tmp_pt,
+                    sk,
+                    source_xa,
+                    source_xe,
+                    scrach_1,
+                );
+            }
+        }
+    }
+}
 
-                // rlwe encrypt of vec_znx_pt into vec_znx_ct
-                self.at_mut(row_i, col_i)
-                    .encrypt_sk(module, &tmp_pt, sk, source_xa, source_xe, scrach_1);
-            });
-        });
+impl<DataSelf: DataMut> GGLWE<DataSelf> {
+    #[allow(clippy::too_many_arguments)]
+    pub fn encrypt_sk<DataPt: DataRef, DataSk: DataRef, B: Backend>(
+        &mut self,
+        module: &Module<B>,
+        pt: &ScalarZnx<DataPt>,
+        sk: &GLWESecretPrepared<DataSk, B>,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        Module<B>: GGLWEEncryptSk<B>,
+    {
+        module.gglwe_encrypt_sk(self, pt, sk, source_xa, source_xe, scratch);
     }
 }

@@ -1,41 +1,37 @@
 use poulpy_hal::{
     api::{
-        ScratchAvailable, SvpApplyDftToDftInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx, TakeVecZnxDft,
-        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply,
-        VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub,
-        VecZnxSubInplace, VecZnxSwitchRing,
+        ScratchAvailable, SvpApplyDftToDftInplace, SvpPPolBytesOf, SvpPrepare, VecZnxAddInplace, VecZnxAddNormal,
+        VecZnxAddScalarInplace, VecZnxBigNormalize, VecZnxDftApply, VecZnxDftBytesOf, VecZnxFillUniform, VecZnxIdftApplyConsume,
+        VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace, VecZnxSwitchRing,
     },
     layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, Scratch},
     source::Source,
 };
 
-use crate::{
-    TakeGLWESecretPrepared,
-    layouts::{
-        Degree, GGLWECiphertext, GGLWEInfos, GGLWESwitchingKey, GLWEInfos, GLWESecret, LWEInfos, prepared::GLWESecretPrepared,
-    },
+use crate::layouts::{
+    GGLWE, GGLWEInfos, GLWEInfos, GLWESecret, GLWESwitchingKey, LWEInfos, RingDegree, prepared::GLWESecretPrepared,
 };
 
-impl GGLWESwitchingKey<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+impl GLWESwitchingKey<Vec<u8>> {
+    pub fn encrypt_sk_tmp_bytes<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
     where
         A: GGLWEInfos,
-        Module<B>: SvpPPolAllocBytes + VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes + VecZnxNormalizeTmpBytes,
+        Module<B>: SvpPPolBytesOf + VecZnxNormalizeTmpBytes + VecZnxDftBytesOf + VecZnxNormalizeTmpBytes,
     {
-        (GGLWECiphertext::encrypt_sk_scratch_space(module, infos) | ScalarZnx::alloc_bytes(module.n(), 1))
-            + ScalarZnx::alloc_bytes(module.n(), infos.rank_in().into())
-            + GLWESecretPrepared::alloc_bytes(module, &infos.glwe_layout())
+        (GGLWE::encrypt_sk_tmp_bytes(module, infos) | ScalarZnx::bytes_of(module.n(), 1))
+            + ScalarZnx::bytes_of(module.n(), infos.rank_in().into())
+            + GLWESecretPrepared::bytes_of_from_infos(module, &infos.glwe_layout())
     }
 
-    pub fn encrypt_pk_scratch_space<B: Backend, A>(module: &Module<B>, _infos: &A) -> usize
+    pub fn encrypt_pk_tmp_bytes<B: Backend, A>(module: &Module<B>, _infos: &A) -> usize
     where
         A: GGLWEInfos,
     {
-        GGLWECiphertext::encrypt_pk_scratch_space(module, _infos)
+        GGLWE::encrypt_pk_tmp_bytes(module, _infos)
     }
 }
 
-impl<DataSelf: DataMut> GGLWESwitchingKey<DataSelf> {
+impl<DataSelf: DataMut> GLWESwitchingKey<DataSelf> {
     #[allow(clippy::too_many_arguments)]
     pub fn encrypt_sk<DataSkIn: DataRef, DataSkOut: DataRef, B: Backend>(
         &mut self,
@@ -47,7 +43,7 @@ source_xe: &mut Source,
         scratch: &mut Scratch<B>,
     ) where
         Module<B>: VecZnxAddScalarInplace
-            + VecZnxDftAllocBytes
+            + VecZnxDftBytesOf
             + VecZnxBigNormalize<B>
             + VecZnxDftApply<B>
             + SvpApplyDftToDftInplace<B>
@@ -62,18 +58,18 @@ + VecZnxNormalize<B>
             + VecZnxSub
             + SvpPrepare<B>
             + VecZnxSwitchRing
-            + SvpPPolAllocBytes,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx + TakeScalarZnx + TakeGLWESecretPrepared<B>,
+            + SvpPPolBytesOf,
+        Scratch<B>: ScratchAvailable,
     {
         #[cfg(debug_assertions)]
         {
             assert!(sk_in.n().0 <= module.n() as u32);
             assert!(sk_out.n().0 <= module.n() as u32);
             assert!(
-                scratch.available() >= GGLWESwitchingKey::encrypt_sk_scratch_space(module, self),
-                "scratch.available()={} < GLWESwitchingKey::encrypt_sk_scratch_space={}",
+                scratch.available() >= GLWESwitchingKey::encrypt_sk_tmp_bytes(module, self),
+                "scratch.available()={} < GLWESwitchingKey::encrypt_sk_tmp_bytes={}",
                 scratch.available(),
-                GGLWESwitchingKey::encrypt_sk_scratch_space(module, self)
+                GLWESwitchingKey::encrypt_sk_tmp_bytes(module, self)
             )
         }
 
@@ -89,7 +85,7 @@ i,
             );
         });
 
-        let (mut sk_out_tmp, scratch_2) = scratch_1.take_glwe_secret_prepared(Degree(n as u32), sk_out.rank());
+        let (mut sk_out_tmp, scratch_2) = scratch_1.take_glwe_secret_prepared(RingDegree(n as u32), sk_out.rank());
         {
             let (mut tmp, _) = scratch_2.take_scalar_znx(n, 1);
             (0..sk_out.rank().into()).for_each(|i| {

@@ -1,39 +1,34 @@
 use poulpy_hal::{
     api::{
-        ScratchAvailable, SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx,
-        TakeVecZnxBig, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxBigAllocBytes,
-        VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA,
-        VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace, VecZnxSwitchRing,
+        SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolBytesOf, SvpPrepare, VecZnxAddInplace, VecZnxAddNormal,
+        VecZnxAddScalarInplace, VecZnxBigBytesOf, VecZnxBigNormalize, VecZnxDftApply, VecZnxDftBytesOf, VecZnxFillUniform,
+        VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub,
+        VecZnxSubInplace, VecZnxSwitchRing,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch},
     source::Source,
 };
 
-use crate::{
-    TakeGLWESecret, TakeGLWESecretPrepared,
-    layouts::{
-        Degree, GGLWEInfos, GGLWESwitchingKey, GGLWETensorKey, GLWEInfos, GLWESecret, LWEInfos, Rank,
-        prepared::{GLWESecretPrepared, Prepare},
-    },
+use crate::layouts::{
+    GGLWEInfos, GLWEInfos, GLWESecret, GLWESwitchingKey, LWEInfos, Rank, RingDegree, TensorKey, prepared::GLWESecretPrepared,
 };
 
-impl GGLWETensorKey<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+impl TensorKey<Vec<u8>> {
+    pub fn encrypt_sk_tmp_bytes<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
     where
         A: GGLWEInfos,
-        Module<B>:
-            SvpPPolAllocBytes + VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes + VecZnxNormalizeTmpBytes + VecZnxBigAllocBytes,
+        Module<B>: SvpPPolBytesOf + VecZnxNormalizeTmpBytes + VecZnxDftBytesOf + VecZnxNormalizeTmpBytes + VecZnxBigBytesOf,
     {
-        GLWESecretPrepared::alloc_bytes_with(module, infos.rank_out())
-            + module.vec_znx_dft_alloc_bytes(infos.rank_out().into(), 1)
-            + module.vec_znx_big_alloc_bytes(1, 1)
-            + module.vec_znx_dft_alloc_bytes(1, 1)
-            + GLWESecret::alloc_bytes_with(Degree(module.n() as u32), Rank(1))
-            + GGLWESwitchingKey::encrypt_sk_scratch_space(module, infos)
+        GLWESecretPrepared::bytes_of(module, infos.rank_out())
+            + module.bytes_of_vec_znx_dft(infos.rank_out().into(), 1)
+            + module.bytes_of_vec_znx_big(1, 1)
+            + module.bytes_of_vec_znx_dft(1, 1)
+            + GLWESecret::bytes_of(RingDegree(module.n() as u32), Rank(1))
+            + GLWESwitchingKey::encrypt_sk_tmp_bytes(module, infos)
     }
 }
 
-impl<DataSelf: DataMut> GGLWETensorKey<DataSelf> {
+impl<DataSelf: DataMut> TensorKey<DataSelf> {
     pub fn encrypt_sk<DataSk: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
@@ -45,7 +40,7 @@ ) where
         Module<B>: SvpApplyDftToDft<B>
             + VecZnxIdftApplyTmpA<B>
             + VecZnxAddScalarInplace
-            + VecZnxDftAllocBytes
+            + VecZnxDftBytesOf
             + VecZnxBigNormalize<B>
             + VecZnxDftApply<B>
             + SvpApplyDftToDftInplace<B>
@@ -60,9 +55,8 @@ + VecZnxNormalize<B>
             + VecZnxSub
             + SvpPrepare<B>
             + VecZnxSwitchRing
-            + SvpPPolAllocBytes,
-        Scratch<B>:
-            TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx + TakeScalarZnx + TakeGLWESecretPrepared<B> + TakeVecZnxBig<B>,
+            + SvpPPolBytesOf,
+        Scratch<B>:,
     {
         #[cfg(debug_assertions)]
         {
@@ -70,7 +64,7 @@ assert_eq!(self.rank_out(), sk.rank());
             assert_eq!(self.n(), sk.n());
         }
 
-        let n: Degree = sk.n();
+        let n: RingDegree = sk.n();
         let rank: Rank = self.rank_out();
 
         let (mut sk_dft_prep, scratch_1) = scratch.take_glwe_secret_prepared(n, rank);

@@ -1,93 +1,124 @@
 use poulpy_hal::{
-    api::{
-        ScratchAvailable, SvpApplyDftToDftInplace, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal,
-        VecZnxAddScalarInplace, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform,
-        VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace,
-    },
-    layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, Scratch, VecZnx, ZnxZero},
+    api::{VecZnxAddScalarInplace, VecZnxDftBytesOf, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes},
+    layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, ScalarZnxToRef, Scratch, VecZnx, ZnxZero},
     source::Source,
 };
 
 use crate::{
-    TakeGLWEPt,
-    layouts::{GGSWCiphertext, GGSWInfos, GLWECiphertext, GLWEInfos, LWEInfos, prepared::GLWESecretPrepared},
+    SIGMA,
+    encryption::glwe_ct::GLWEEncryptSkInternal,
+    layouts::{
+        GGSW, GGSWInfos, GGSWToMut, GLWE, GLWEInfos, LWEInfos,
+        prepared::{GLWESecretPrepared, GLWESecretPreparedToRef},
+    },
 };
 
-impl GGSWCiphertext<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+impl GGSW<Vec<u8>> {
+    pub fn encrypt_sk_tmp_bytes<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
     where
         A: GGSWInfos,
-        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes,
+        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftBytesOf,
     {
         let size = infos.size();
-        GLWECiphertext::encrypt_sk_scratch_space(module, &infos.glwe_layout())
-            + VecZnx::alloc_bytes(module.n(), (infos.rank() + 1).into(), size)
-            + VecZnx::alloc_bytes(module.n(), 1, size)
-            + module.vec_znx_dft_alloc_bytes((infos.rank() + 1).into(), size)
+        GLWE::encrypt_sk_tmp_bytes(module, &infos.glwe_layout())
+            + VecZnx::bytes_of(module.n(), (infos.rank() + 1).into(), size)
+            + VecZnx::bytes_of(module.n(), 1, size)
+            + module.bytes_of_vec_znx_dft((infos.rank() + 1).into(), size)
     }
 }
 
-impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
-    #[allow(clippy::too_many_arguments)]
-    pub fn encrypt_sk<DataPt: DataRef, DataSk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        pt: &ScalarZnx<DataPt>,
-        sk: &GLWESecretPrepared<DataSk, B>,
+pub trait GGSWEncryptSk<B: Backend> {
+    fn ggsw_encrypt_sk<R, P, S>(
+        &self,
+        res: &mut R,
+        pt: &P,
+        sk: &S,
         source_xa: &mut Source,
         source_xe: &mut Source,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxAddScalarInplace
-            + VecZnxDftAllocBytes
-            + VecZnxBigNormalize<B>
-            + VecZnxDftApply<B>
-            + SvpApplyDftToDftInplace<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxNormalizeTmpBytes
-            + VecZnxFillUniform
-            + VecZnxSubInplace
-            + VecZnxAddInplace
-            + VecZnxNormalizeInplace<B>
-            + VecZnxAddNormal
-            + VecZnxNormalize<B>
-            + VecZnxSub,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+        R: GGSWToMut,
+        P: ScalarZnxToRef,
+        S: GLWESecretPreparedToRef<B>;
+}
+
+impl<B: Backend> GGSWEncryptSk<B> for Module<B>
+where
+    Module<B>: GLWEEncryptSkInternal<B> + VecZnxAddScalarInplace + VecZnxNormalizeInplace<B>,
+    Scratch<B>:,
+{
+    fn ggsw_encrypt_sk<R, P, S>(
+        &self,
+        res: &mut R,
+        pt: &P,
+        sk: &S,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        R: GGSWToMut,
+        P: ScalarZnxToRef,
+        S: GLWESecretPreparedToRef<B>,
     {
+        let res: &mut GGSW<&mut [u8]> = &mut res.to_mut();
+        let pt: &ScalarZnx<&[u8]> = &pt.to_ref();
+        let sk: &GLWESecretPrepared<&[u8], B> = &sk.to_ref();
+
         #[cfg(debug_assertions)]
         {
             use poulpy_hal::layouts::ZnxInfos;
 
-            assert_eq!(self.rank(), sk.rank());
-            assert_eq!(self.n(), sk.n());
-            assert_eq!(pt.n() as u32, sk.n());
+            assert_eq!(res.rank(), sk.rank());
+            assert_eq!(res.n(), self.n() as u32);
+            assert_eq!(pt.n(), self.n());
+            assert_eq!(sk.n(), self.n() as u32);
         }
 
-        let base2k: usize = self.base2k().into();
-        let rank: usize = self.rank().into();
-        let dsize: usize = self.dsize().into();
+        let k: usize = res.k().into();
+        let base2k: usize = res.base2k().into();
+        let rank: usize = res.rank().into();
+        let dsize: usize = res.dsize().into();
+        let cols: usize = (rank + 1).into();
 
-        let (mut tmp_pt, scratch_1) = scratch.take_glwe_pt(&self.glwe_layout());
+        let (mut tmp_pt, scratch_1) = scratch.take_glwe_pt(&res.glwe_layout());
 
-        (0..self.dnum().into()).for_each(|row_i| {
+        for row_i in 0..res.dnum().into() {
             tmp_pt.data.zero();
-
             // Adds the scalar_znx_pt to the i-th limb of the vec_znx_pt
-            module.vec_znx_add_scalar_inplace(&mut tmp_pt.data, 0, (dsize - 1) + row_i * dsize, pt, 0);
-            module.vec_znx_normalize_inplace(base2k, &mut tmp_pt.data, 0, scratch_1);
-
-            (0..rank + 1).for_each(|col_j| {
-                // rlwe encrypt of vec_znx_pt into vec_znx_ct
-
-                self.at_mut(row_i, col_j).encrypt_sk_internal(
-                    module,
+            self.vec_znx_add_scalar_inplace(&mut tmp_pt.data, 0, (dsize - 1) + row_i * dsize, pt, 0);
+            self.vec_znx_normalize_inplace(base2k, &mut tmp_pt.data, 0, scratch_1);
+            for col_j in 0..rank + 1 {
+                self.glwe_encrypt_sk_internal(
+                    base2k,
+                    k,
+                    res.at_mut(row_i, col_j).data_mut(),
+                    cols,
+                    false,
                     Some((&tmp_pt, col_j)),
                     sk,
                     source_xa,
                     source_xe,
+                    SIGMA,
                     scratch_1,
                 );
-            });
-        });
+            }
+        }
+    }
+}
+
+impl<DataSelf: DataMut> GGSW<DataSelf> {
+    #[allow(clippy::too_many_arguments)]
+    pub fn encrypt_sk<DataPt: DataRef, DataSk: DataRef, B: Backend>(
+        &mut self,
+        module: &Module<B>,
+        pt: &ScalarZnx<DataPt>,
+        sk: &GLWESecretPrepared<DataSk, B>,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        Module<B>: GGSWEncryptSk<B>,
+    {
+        module.ggsw_encrypt_sk(self, pt, sk, source_xa, source_xe, scratch);
     }
 }

@@ -1,11 +1,11 @@
 use poulpy_hal::{
     api::{
-        ScratchAvailable, SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeSvpPPol,
-        TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal, VecZnxBigAddNormal, VecZnxBigAddSmallInplace,
-        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume,
-        VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace,
+        ScratchAvailable, SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolBytesOf, SvpPrepare, VecZnxAddInplace,
+        VecZnxAddNormal, VecZnxBigAddNormal, VecZnxBigAddSmallInplace, VecZnxBigBytesOf, VecZnxBigNormalize, VecZnxDftApply,
+        VecZnxDftBytesOf, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace,
+        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace,
     },
-    layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, Scratch, VecZnx, VecZnxBig, ZnxInfos, ZnxZero},
+    layouts::{Backend, DataMut, Module, ScalarZnx, Scratch, VecZnx, VecZnxBig, VecZnxToMut, ZnxInfos, ZnxZero},
     source::Source,
 };
 
@@ -13,157 +13,217 @@ use crate::{
     dist::Distribution,
     encryption::{SIGMA, SIGMA_BOUND},
     layouts::{
-        GLWECiphertext, GLWEInfos, GLWEPlaintext, LWEInfos,
-        prepared::{GLWEPublicKeyPrepared, GLWESecretPrepared},
+        GLWE, GLWEInfos, GLWEPlaintext, GLWEPlaintextToRef, GLWEToMut, LWEInfos,
+        prepared::{GLWEPublicKeyPrepared, GLWEPublicKeyPreparedToRef, GLWESecretPrepared, GLWESecretPreparedToRef},
     },
 };
 
-impl GLWECiphertext<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+impl GLWE<Vec<u8>> {
+    pub fn encrypt_sk_tmp_bytes<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
     where
         A: GLWEInfos,
-        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes,
+        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftBytesOf,
     {
         let size: usize = infos.size();
         assert_eq!(module.n() as u32, infos.n());
-        module.vec_znx_normalize_tmp_bytes()
-            + 2 * VecZnx::alloc_bytes(module.n(), 1, size)
-            + module.vec_znx_dft_alloc_bytes(1, size)
+        module.vec_znx_normalize_tmp_bytes() + 2 * VecZnx::bytes_of(module.n(), 1, size) + module.bytes_of_vec_znx_dft(1, size)
     }
-    pub fn encrypt_pk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+    pub fn encrypt_pk_tmp_bytes<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
     where
         A: GLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + SvpPPolAllocBytes + VecZnxBigAllocBytes + VecZnxNormalizeTmpBytes,
+        Module<B>: VecZnxDftBytesOf + SvpPPolBytesOf + VecZnxBigBytesOf + VecZnxNormalizeTmpBytes,
     {
         let size: usize = infos.size();
         assert_eq!(module.n() as u32, infos.n());
-        ((module.vec_znx_dft_alloc_bytes(1, size) + module.vec_znx_big_alloc_bytes(1, size))
-            | ScalarZnx::alloc_bytes(module.n(), 1))
-            + module.svp_ppol_alloc_bytes(1)
+        ((module.bytes_of_vec_znx_dft(1, size) + module.bytes_of_vec_znx_big(1, size)) | ScalarZnx::bytes_of(module.n(), 1))
+            + module.bytes_of_svp_ppol(1)
             + module.vec_znx_normalize_tmp_bytes()
     }
 }
 
-impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
-    #[allow(clippy::too_many_arguments)]
-    pub fn encrypt_sk<DataPt: DataRef, DataSk: DataRef, B: Backend>(
+impl<D: DataMut> GLWE<D> {
+    pub fn encrypt_sk<R, P, S, B: Backend>(
         &mut self,
         module: &Module<B>,
-        pt: &GLWEPlaintext<DataPt>,
-        sk: &GLWESecretPrepared<DataSk, B>,
+        pt: &P,
+        sk: &S,
         source_xa: &mut Source,
         source_xe: &mut Source,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VecZnxBigNormalize<B>
-            + VecZnxDftApply<B>
-            + SvpApplyDftToDftInplace<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxNormalizeTmpBytes
-            + VecZnxFillUniform
-            + VecZnxSubInplace
-            + VecZnxAddInplace
-            + VecZnxNormalizeInplace<B>
-            + VecZnxAddNormal
-            + VecZnxNormalize<B>
-            + VecZnxSub,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+        P: GLWEPlaintextToRef,
+        S: GLWESecretPreparedToRef<B>,
+        Module<B>: GLWEEncryptSk<B>,
     {
-        #[cfg(debug_assertions)]
-        {
-            assert_eq!(self.rank(), sk.rank());
-            assert_eq!(sk.n(), self.n());
-            assert_eq!(pt.n(), self.n());
-            assert!(
-                scratch.available() >= GLWECiphertext::encrypt_sk_scratch_space(module, self),
-                "scratch.available(): {} < GLWECiphertext::encrypt_sk_scratch_space: {}",
-                scratch.available(),
-                GLWECiphertext::encrypt_sk_scratch_space(module, self)
-            )
-        }
+        module.glwe_encrypt_sk(self, pt, sk, source_xa, source_xe, scratch);
+    }
 
-        self.encrypt_sk_internal(module, Some((pt, 0)), sk, source_xa, source_xe, scratch);
+    pub fn encrypt_zero_sk<S, B: Backend>(
+        &mut self,
+        module: &Module<B>,
+        sk: &S,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        S: GLWESecretPreparedToRef<B>,
+        Module<B>: GLWEEncryptZeroSk<B>,
+    {
+        module.glwe_encrypt_zero_sk(self, sk, source_xa, source_xe, scratch);
     }
 
-    pub fn encrypt_zero_sk<DataSk: DataRef, B: Backend>(
+    pub fn encrypt_pk<P, K, B: Backend>(
+        &mut self,
+        module: &Module<B>,
+        pt: &P,
+        pk: &K,
+        source_xu: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        P: GLWEPlaintextToRef,
+        K: GLWEPublicKeyPreparedToRef<B>,
+        Module<B>: GLWEEncryptPk<B>,
+    {
+        module.glwe_encrypt_pk(self, pt, pk, source_xu, source_xe, scratch);
+    }
+
+    pub fn encrypt_zero_pk<K, B: Backend>(
         &mut self,
         module: &Module<B>,
-        sk: &GLWESecretPrepared<DataSk, B>,
+        pk: &K,
+        source_xu: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        K: GLWEPublicKeyPreparedToRef<B>,
+        Module<B>: GLWEEncryptZeroPk<B>,
+    {
+        module.glwe_encrypt_zero_pk(self, pk, source_xu, source_xe, scratch);
+    }
+}
+
+pub trait GLWEEncryptSk<B: Backend> {
+    fn glwe_encrypt_sk<R, P, S>(
+        &self,
+        res: &mut R,
+        pt: &P,
+        sk: &S,
         source_xa: &mut Source,
         source_xe: &mut Source,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VecZnxBigNormalize<B>
-            + VecZnxDftApply<B>
-            + SvpApplyDftToDftInplace<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxNormalizeTmpBytes
-            + VecZnxFillUniform
-            + VecZnxSubInplace
-            + VecZnxAddInplace
-            + VecZnxNormalizeInplace<B>
-            + VecZnxAddNormal
-            + VecZnxNormalize<B>
-            + VecZnxSub,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+        R: GLWEToMut,
+        P: GLWEPlaintextToRef,
+        S: GLWESecretPreparedToRef<B>;
+}
+
+impl<B: Backend> GLWEEncryptSk<B> for Module<B>
+where
+    Module<B>: GLWEEncryptSkInternal<B> + VecZnxNormalizeTmpBytes + VecZnxDftBytesOf,
+    Scratch<B>: ScratchAvailable,
+{
+    fn glwe_encrypt_sk<R, P, S>(
+        &self,
+        res: &mut R,
+        pt: &P,
+        sk: &S,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        R: GLWEToMut,
+        P: GLWEPlaintextToRef,
+        S: GLWESecretPreparedToRef<B>,
     {
+        let mut res: GLWE<&mut [u8]> = res.to_mut();
+        let pt: GLWEPlaintext<&[u8]> = pt.to_ref();
+
         #[cfg(debug_assertions)]
         {
-            assert_eq!(self.rank(), sk.rank());
-            assert_eq!(sk.n(), self.n());
+            let sk: GLWESecretPrepared<&[u8], B> = sk.to_ref();
+            assert_eq!(res.rank(), sk.rank());
+            assert_eq!(res.n(), self.n() as u32);
+            assert_eq!(sk.n(), self.n() as u32);
+            assert_eq!(pt.n(), self.n() as u32);
             assert!(
-                scratch.available() >= GLWECiphertext::encrypt_sk_scratch_space(module, self),
-                "scratch.available(): {} < GLWECiphertext::encrypt_sk_scratch_space: {}",
+                scratch.available() >= GLWE::encrypt_sk_tmp_bytes(self, &res),
+                "scratch.available(): {} < GLWECiphertext::encrypt_sk_tmp_bytes: {}",
                 scratch.available(),
-                GLWECiphertext::encrypt_sk_scratch_space(module, self)
+                GLWE::encrypt_sk_tmp_bytes(self, &res)
             )
         }
-        self.encrypt_sk_internal(
-            module,
-            None::<(&GLWEPlaintext<Vec<u8>>, usize)>,
+
+        let cols: usize = (res.rank() + 1).into();
+        self.glwe_encrypt_sk_internal(
+            res.base2k().into(),
+            res.k().into(),
+            res.data_mut(),
+            cols,
+            false,
+            Some((&pt, 0)),
             sk,
             source_xa,
             source_xe,
+            SIGMA,
             scratch,
         );
     }
+}
 
-    #[allow(clippy::too_many_arguments)]
-    pub(crate) fn encrypt_sk_internal<DataPt: DataRef, DataSk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        pt: Option<(&GLWEPlaintext<DataPt>, usize)>,
-        sk: &GLWESecretPrepared<DataSk, B>,
+pub trait GLWEEncryptZeroSk<B: Backend> {
+    fn glwe_encrypt_zero_sk<R, S>(
+        &self,
+        res: &mut R,
+        sk: &S,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        R: GLWEToMut,
+        S: GLWESecretPreparedToRef<B>;
+}
+
+impl<B: Backend> GLWEEncryptZeroSk<B> for Module<B>
+where
+    Module<B>: GLWEEncryptSkInternal<B> + VecZnxNormalizeTmpBytes + VecZnxDftBytesOf,
+    Scratch<B>: ScratchAvailable,
+{
+    fn glwe_encrypt_zero_sk<R, S>(
+        &self,
+        res: &mut R,
+        sk: &S,
         source_xa: &mut Source,
         source_xe: &mut Source,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VecZnxBigNormalize<B>
-            + VecZnxDftApply<B>
-            + SvpApplyDftToDftInplace<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxNormalizeTmpBytes
-            + VecZnxFillUniform
-            + VecZnxSubInplace
-            + VecZnxAddInplace
-            + VecZnxNormalizeInplace<B>
-            + VecZnxAddNormal
-            + VecZnxNormalize<B>
-            + VecZnxSub,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+        R: GLWEToMut,
+        S: GLWESecretPreparedToRef<B>,
     {
-        let cols: usize = (self.rank() + 1).into();
-        glwe_encrypt_sk_internal(
-            module,
-            self.base2k().into(),
-            self.k().into(),
-            &mut self.data,
+        let mut res: GLWE<&mut [u8]> = res.to_mut();
+
+        #[cfg(debug_assertions)]
+        {
+            let sk: GLWESecretPrepared<&[u8], B> = sk.to_ref();
+            assert_eq!(res.rank(), sk.rank());
+            assert_eq!(res.n(), self.n() as u32);
+            assert_eq!(sk.n(), self.n() as u32);
+            assert!(
+                scratch.available() >= GLWE::encrypt_sk_tmp_bytes(self, &res),
+                "scratch.available(): {} < GLWECiphertext::encrypt_sk_tmp_bytes: {}",
+                scratch.available(),
+                GLWE::encrypt_sk_tmp_bytes(self, &res)
+            )
+        }
+
+        let cols: usize = (res.rank() + 1).into();
+        self.glwe_encrypt_sk_internal(
+            res.base2k().into(),
+            res.k().into(),
+            res.data_mut(),
             cols,
             false,
-            pt,
+            None::<(&GLWEPlaintext<Vec<u8>>, usize)>,
             sk,
             source_xa,
             source_xe,
@@ -171,46 +231,74 @@ SIGMA,
             scratch,
         );
     }
+}
 
-    #[allow(clippy::too_many_arguments)]
-    pub fn encrypt_pk<DataPt: DataRef, DataPk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        pt: &GLWEPlaintext<DataPt>,
-        pk: &GLWEPublicKeyPrepared<DataPk, B>,
+pub trait GLWEEncryptPk<B: Backend> {
+    fn glwe_encrypt_pk<R, P, K>(
+        &self,
+        res: &mut R,
+        pt: &P,
+        pk: &K,
         source_xu: &mut Source,
         source_xe: &mut Source,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: SvpPrepare<B>
-            + SvpApplyDftToDft<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxBigAddNormal<B>
-            + VecZnxBigAddSmallInplace<B>
-            + VecZnxBigNormalize<B>,
-        Scratch<B>: TakeSvpPPol<B> + TakeScalarZnx + TakeVecZnxDft<B>,
+        R: GLWEToMut,
+        P: GLWEPlaintextToRef,
+        K: GLWEPublicKeyPreparedToRef<B>;
+}
+
+impl<B: Backend> GLWEEncryptPk<B> for Module<B>
+where
+    Module<B>: GLWEEncryptPkInternal<B>,
+{
+    fn glwe_encrypt_pk<R, P, K>(
+        &self,
+        res: &mut R,
+        pt: &P,
+        pk: &K,
+        source_xu: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        R: GLWEToMut,
+        P: GLWEPlaintextToRef,
+        K: GLWEPublicKeyPreparedToRef<B>,
     {
-        self.encrypt_pk_internal::<DataPt, DataPk, B>(module, Some((pt, 0)), pk, source_xu, source_xe, scratch);
+        self.glwe_encrypt_pk_internal(res, Some((pt, 0)), pk, source_xu, source_xe, scratch);
     }
+}
 
-    pub fn encrypt_zero_pk<DataPk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        pk: &GLWEPublicKeyPrepared<DataPk, B>,
+pub trait GLWEEncryptZeroPk<B: Backend> {
+    fn glwe_encrypt_zero_pk<R, K>(
+        &self,
+        res: &mut R,
+        pk: &K,
         source_xu: &mut Source,
         source_xe: &mut Source,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: SvpPrepare<B>
-            + SvpApplyDftToDft<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxBigAddNormal<B>
-            + VecZnxBigAddSmallInplace<B>
-            + VecZnxBigNormalize<B>,
-        Scratch<B>: TakeSvpPPol<B> + TakeScalarZnx + TakeVecZnxDft<B>,
+        R: GLWEToMut,
+        K: GLWEPublicKeyPreparedToRef<B>;
+}
+
+impl<B: Backend> GLWEEncryptZeroPk<B> for Module<B>
+where
+    Module<B>: GLWEEncryptPkInternal<B>,
+{
+    fn glwe_encrypt_zero_pk<R, K>(
+        &self,
+        res: &mut R,
+        pk: &K,
+        source_xu: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        R: GLWEToMut,
+        K: GLWEPublicKeyPreparedToRef<B>,
     {
-        self.encrypt_pk_internal::<Vec<u8>, DataPk, B>(
-            module,
+        self.glwe_encrypt_pk_internal(
+            res,
             None::<(&GLWEPlaintext<Vec<u8>>, usize)>,
             pk,
             source_xu,
@@ -218,45 +306,69 @@ source_xe,
             scratch,
         );
     }
+}
 
-    #[allow(clippy::too_many_arguments)]
-    pub(crate) fn encrypt_pk_internal<DataPt: DataRef, DataPk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        pt: Option<(&GLWEPlaintext<DataPt>, usize)>,
-        pk: &GLWEPublicKeyPrepared<DataPk, B>,
+pub(crate) trait GLWEEncryptPkInternal<B: Backend> {
+    fn glwe_encrypt_pk_internal<R, P, K>(
+        &self,
+        res: &mut R,
+        pt: Option<(&P, usize)>,
+        pk: &K,
+        source_xu: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<B>,
+    ) where
+        R: GLWEToMut,
+        P: GLWEPlaintextToRef,
+        K: GLWEPublicKeyPreparedToRef<B>;
+}
+
+impl<B: Backend> GLWEEncryptPkInternal<B> for Module<B>
+where
+    Module<B>: SvpPrepare<B>
+        + SvpApplyDftToDft<B>
+        + VecZnxIdftApplyConsume<B>
+        + VecZnxBigAddNormal<B>
+        + VecZnxBigAddSmallInplace<B>
+        + VecZnxBigNormalize<B>,
+    Scratch<B>:,
+{
+    fn glwe_encrypt_pk_internal<R, P, K>(
+        &self,
+        res: &mut R,
+        pt: Option<(&P, usize)>,
+        pk: &K,
         source_xu: &mut Source,
         source_xe: &mut Source,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: SvpPrepare<B>
-            + SvpApplyDftToDft<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxBigAddNormal<B>
-            + VecZnxBigAddSmallInplace<B>
-            + VecZnxBigNormalize<B>,
-        Scratch<B>: TakeSvpPPol<B> + TakeScalarZnx + TakeVecZnxDft<B>,
+        R: GLWEToMut,
+        P: GLWEPlaintextToRef,
+        K: GLWEPublicKeyPreparedToRef<B>,
     {
+        let res: &mut GLWE<&mut [u8]> = &mut res.to_mut();
+        let pk: &GLWEPublicKeyPrepared<&[u8], B> = &pk.to_ref();
+
         #[cfg(debug_assertions)]
         {
-            assert_eq!(self.base2k(), pk.base2k());
-            assert_eq!(self.n(), pk.n());
-            assert_eq!(self.rank(), pk.rank());
+            assert_eq!(res.base2k(), pk.base2k());
+            assert_eq!(res.n(), pk.n());
+            assert_eq!(res.rank(), pk.rank());
             if let Some((pt, _)) = pt {
-                assert_eq!(pt.base2k(), pk.base2k());
-                assert_eq!(pt.n(), pk.n());
+                assert_eq!(pt.to_ref().base2k(), pk.base2k());
+                assert_eq!(pt.to_ref().n(), pk.n());
             }
         }
 
         let base2k: usize = pk.base2k().into();
         let size_pk: usize = pk.size();
-        let cols: usize = (self.rank() + 1).into();
+        let cols: usize = (res.rank() + 1).into();
 
         // Generates u according to the underlying secret distribution.
-        let (mut u_dft, scratch_1) = scratch.take_svp_ppol(self.n().into(), 1);
+        let (mut u_dft, scratch_1) = scratch.take_svp_ppol(res.n().into(), 1);
 
         {
-            let (mut u, _) = scratch_1.take_scalar_znx(self.n().into(), 1);
+            let (mut u, _) = scratch_1.take_scalar_znx(res.n().into(), 1);
             match pk.dist {
                 Distribution::NONE => panic!(
                     "invalid public key: SecretDistribution::NONE, ensure it has been correctly intialized through \
@@ -270,20 +382,20 @@ Distribution::BinaryBlock(block_size) => u.fill_binary_block(0, block_size, source_xu),
                 Distribution::ZERO => {}
             }
 
-            module.svp_prepare(&mut u_dft, 0, &u, 0);
+            self.svp_prepare(&mut u_dft, 0, &u, 0);
         }
 
         // ct[i] = pk[i] * u + ei (+ m if col = i)
         (0..cols).for_each(|i| {
-            let (mut ci_dft, scratch_2) = scratch_1.take_vec_znx_dft(self.n().into(), 1, size_pk);
+            let (mut ci_dft, scratch_2) = scratch_1.take_vec_znx_dft(res.n().into(), 1, size_pk);
             // ci_dft = DFT(u) * DFT(pk[i])
-            module.svp_apply_dft_to_dft(&mut ci_dft, 0, &u_dft, 0, &pk.data, i);
+            self.svp_apply_dft_to_dft(&mut ci_dft, 0, &u_dft, 0, &pk.data, i);
 
             // ci_big = u * p[i]
-            let mut ci_big = module.vec_znx_idft_apply_consume(ci_dft);
+            let mut ci_big = self.vec_znx_idft_apply_consume(ci_dft);
 
             // ci_big = u * pk[i] + e
-            module.vec_znx_big_add_normal(
+            self.vec_znx_big_add_normal(
                 base2k,
                 &mut ci_big,
                 0,
@@ -297,31 +409,38 @@ // ci_big = u * pk[i] + e + m (if col = i)
             if let Some((pt, col)) = pt
                 && col == i
             {
-                module.vec_znx_big_add_small_inplace(&mut ci_big, 0, &pt.data, 0);
+                self.vec_znx_big_add_small_inplace(&mut ci_big, 0, &pt.to_ref().data, 0);
             }
 
             // ct[i] = norm(ci_big)
-            module.vec_znx_big_normalize(base2k, &mut self.data, i, base2k, &ci_big, 0, scratch_2);
+            self.vec_znx_big_normalize(base2k, &mut res.data, i, base2k, &ci_big, 0, scratch_2);
         });
     }
 }
 
-#[allow(clippy::too_many_arguments)]
-pub(crate) fn glwe_encrypt_sk_internal<DataCt: DataMut, DataPt: DataRef, DataSk: DataRef, B: Backend>(
-    module: &Module<B>,
-    base2k: usize,
-    k: usize,
-    ct: &mut VecZnx<DataCt>,
-    cols: usize,
-    compressed: bool,
-    pt: Option<(&GLWEPlaintext<DataPt>, usize)>,
-    sk: &GLWESecretPrepared<DataSk, B>,
-    source_xa: &mut Source,
-    source_xe: &mut Source,
-    sigma: f64,
-    scratch: &mut Scratch<B>,
-) where
-    Module<B>: VecZnxDftAllocBytes
+pub(crate) trait GLWEEncryptSkInternal<B: Backend> {
+    fn glwe_encrypt_sk_internal<R, P, S>(
+        &self,
+        base2k: usize,
+        k: usize,
+        res: &mut R,
+        cols: usize,
+        compressed: bool,
+        pt: Option<(&P, usize)>,
+        sk: &S,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        sigma: f64,
+        scratch: &mut Scratch<B>,
+    ) where
+        R: VecZnxToMut,
+        P: GLWEPlaintextToRef,
+        S: GLWESecretPreparedToRef<B>;
+}
+
+impl<B: Backend> GLWEEncryptSkInternal<B> for Module<B>
+where
+    Module<B>: VecZnxDftBytesOf
         + VecZnxBigNormalize<B>
         + VecZnxDftApply<B>
         + SvpApplyDftToDftInplace<B>
@@ -334,74 +453,96 @@ + VecZnxNormalizeInplace<B>
         + VecZnxAddNormal
         + VecZnxNormalize<B>
         + VecZnxSub,
-    Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+    Scratch<B>: ScratchAvailable,
 {
-    #[cfg(debug_assertions)]
+    fn glwe_encrypt_sk_internal<R, P, S>(
+        &self,
+        base2k: usize,
+        k: usize,
+        res: &mut R,
+        cols: usize,
+        compressed: bool,
+        pt: Option<(&P, usize)>,
+        sk: &S,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        sigma: f64,
+        scratch: &mut Scratch<B>,
+    ) where
+        R: VecZnxToMut,
+        P: GLWEPlaintextToRef,
+        S: GLWESecretPreparedToRef<B>,
     {
-        if compressed {
-            assert_eq!(
-                ct.cols(),
-                1,
-                "invalid ciphertext: compressed tag=true but #cols={} != 1",
-                ct.cols()
-            )
+        let ct: &mut VecZnx<&mut [u8]> = &mut res.to_mut();
+        let sk: GLWESecretPrepared<&[u8], B> = sk.to_ref();
+
+        #[cfg(debug_assertions)]
+        {
+            if compressed {
+                assert_eq!(
+                    ct.cols(),
+                    1,
+                    "invalid ciphertext: compressed tag=true but #cols={} != 1",
+                    ct.cols()
+                )
+            }
         }
-    }
 
-    let size: usize = ct.size();
+        let size: usize = ct.size();
 
-    let (mut c0, scratch_1) = scratch.take_vec_znx(ct.n(), 1, size);
-    c0.zero();
+        let (mut c0, scratch_1) = scratch.take_vec_znx(ct.n(), 1, size);
+        c0.zero();
 
-    {
-        let (mut ci, scratch_2) = scratch_1.take_vec_znx(ct.n(), 1, size);
+        {
+            let (mut ci, scratch_2) = scratch_1.take_vec_znx(ct.n(), 1, size);
 
-        // ct[i] = uniform
-        // ct[0] -= c[i] * s[i],
-        (1..cols).for_each(|i| {
-            let col_ct: usize = if compressed { 0 } else { i };
+            // ct[i] = uniform
+            // ct[0] -= c[i] * s[i],
+            (1..cols).for_each(|i| {
+                let col_ct: usize = if compressed { 0 } else { i };
 
-            // ct[i] = uniform (+ pt)
-            module.vec_znx_fill_uniform(base2k, ct, col_ct, source_xa);
+                // ct[i] = uniform (+ pt)
+                self.vec_znx_fill_uniform(base2k, ct, col_ct, source_xa);
 
-            let (mut ci_dft, scratch_3) = scratch_2.take_vec_znx_dft(ct.n(), 1, size);
+                let (mut ci_dft, scratch_3) = scratch_2.take_vec_znx_dft(ct.n(), 1, size);
 
-            // ci = ct[i] - pt
-            // i.e. we act as we sample ct[i] already as uniform + pt
-            // and if there is a pt, then we subtract it before applying DFT
-            if let Some((pt, col)) = pt {
-                if i == col {
-                    module.vec_znx_sub(&mut ci, 0, ct, col_ct, &pt.data, 0);
-                    module.vec_znx_normalize_inplace(base2k, &mut ci, 0, scratch_3);
-                    module.vec_znx_dft_apply(1, 0, &mut ci_dft, 0, &ci, 0);
+                // ci = ct[i] - pt
+                // i.e. we act as we sample ct[i] already as uniform + pt
+                // and if there is a pt, then we subtract it before applying DFT
+                if let Some((pt, col)) = pt {
+                    if i == col {
+                        self.vec_znx_sub(&mut ci, 0, ct, col_ct, &pt.to_ref().data, 0);
+                        self.vec_znx_normalize_inplace(base2k, &mut ci, 0, scratch_3);
+                        self.vec_znx_dft_apply(1, 0, &mut ci_dft, 0, &ci, 0);
+                    } else {
+                        self.vec_znx_dft_apply(1, 0, &mut ci_dft, 0, ct, col_ct);
+                    }
                 } else {
-                    module.vec_znx_dft_apply(1, 0, &mut ci_dft, 0, ct, col_ct);
+                    self.vec_znx_dft_apply(1, 0, &mut ci_dft, 0, ct, col_ct);
                 }
-            } else {
-                module.vec_znx_dft_apply(1, 0, &mut ci_dft, 0, ct, col_ct);
-            }
+
+                self.svp_apply_dft_to_dft_inplace(&mut ci_dft, 0, &sk.data, i - 1);
+                let ci_big: VecZnxBig<&mut [u8], B> = self.vec_znx_idft_apply_consume(ci_dft);
 
-            module.svp_apply_dft_to_dft_inplace(&mut ci_dft, 0, &sk.data, i - 1);
-            let ci_big: VecZnxBig<&mut [u8], B> = module.vec_znx_idft_apply_consume(ci_dft);
+                // use c[0] as buffer, which is overwritten later by the normalization step
+                self.vec_znx_big_normalize(base2k, &mut ci, 0, base2k, &ci_big, 0, scratch_3);
 
-            // use c[0] as buffer, which is overwritten later by the normalization step
-            module.vec_znx_big_normalize(base2k, &mut ci, 0, base2k, &ci_big, 0, scratch_3);
+                // c0_tmp = -c[i] * s[i] (use c[0] as buffer)
+                self.vec_znx_sub_inplace(&mut c0, 0, &ci, 0);
+            });
+        }
 
-            // c0_tmp = -c[i] * s[i] (use c[0] as buffer)
-            module.vec_znx_sub_inplace(&mut c0, 0, &ci, 0);
-        });
-    }
+        // c[0] += e
+        self.vec_znx_add_normal(base2k, &mut c0, 0, k, source_xe, sigma, SIGMA_BOUND);
 
-    // c[0] += e
-    module.vec_znx_add_normal(base2k, &mut c0, 0, k, source_xe, sigma, SIGMA_BOUND);
+        // c[0] += m if col = 0
+        if let Some((pt, col)) = pt
+            && col == 0
+        {
+            self.vec_znx_add_inplace(&mut c0, 0, &pt.to_ref().data, 0);
+        }
 
-    // c[0] += m if col = 0
-    if let Some((pt, col)) = pt
-        && col == 0
-    {
-        module.vec_znx_add_inplace(&mut c0, 0, &pt.data, 0);
+        // c[0] = norm(c[0])
+        self.vec_znx_normalize(base2k, ct, 0, base2k, &c0, 0, scratch_1);
     }
-
-    // c[0] = norm(c[0])
-    module.vec_znx_normalize(base2k, ct, 0, base2k, &c0, 0, scratch_1);
 }

@@ -1,50 +1,43 @@
 use poulpy_hal::{
-    api::{
-        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDftInplace, VecZnxAddInplace, VecZnxAddNormal, VecZnxBigNormalize,
-        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace,
-        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace,
-    },
+    api::{ScratchOwnedAlloc, ScratchOwnedBorrow, VecZnxDftBytesOf, VecZnxNormalizeTmpBytes},
     layouts::{Backend, DataMut, DataRef, Module, ScratchOwned},
-    oep::{ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeVecZnxDftImpl, TakeVecZnxImpl},
     source::Source,
 };
 
-use crate::layouts::{GLWECiphertext, GLWEPublicKey, prepared::GLWESecretPrepared};
+use crate::{
+    encryption::glwe_ct::GLWEEncryptZeroSk,
+    layouts::{
+        GLWE, GLWEPublicKey, GLWEPublicKeyToMut,
+        prepared::{GLWESecretPrepared, GLWESecretPreparedToRef},
+    },
+};
 
-impl<D: DataMut> GLWEPublicKey<D> {
-    pub fn generate_from_sk<S: DataRef, B>(
-        &mut self,
-        module: &Module<B>,
-        sk: &GLWESecretPrepared<S, B>,
-        source_xa: &mut Source,
-        source_xe: &mut Source,
-    ) where
-        Module<B>:,
-        Module<B>: VecZnxDftAllocBytes
-            + VecZnxBigNormalize<B>
-            + VecZnxDftApply<B>
-            + SvpApplyDftToDftInplace<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxNormalizeTmpBytes
-            + VecZnxFillUniform
-            + VecZnxSubInplace
-            + VecZnxAddInplace
-            + VecZnxNormalizeInplace<B>
-            + VecZnxAddNormal
-            + VecZnxNormalize<B>
-            + VecZnxSub,
-        B: Backend
-            + ScratchOwnedAllocImpl<B>
-            + ScratchOwnedBorrowImpl<B>
-            + TakeVecZnxDftImpl<B>
-            + ScratchAvailableImpl<B>
-            + TakeVecZnxImpl<B>,
+pub trait GLWEPublicKeyGenerate<B: Backend> {
+    fn glwe_public_key_generate<R, S>(&self, res: &mut R, sk: &S, source_xa: &mut Source, source_xe: &mut Source)
+    where
+        R: GLWEPublicKeyToMut,
+        S: GLWESecretPreparedToRef<B>;
+}
+
+impl<B: Backend> GLWEPublicKeyGenerate<B> for Module<B>
+where
+    Module<B>: GLWEEncryptZeroSk<B> + VecZnxNormalizeTmpBytes + VecZnxDftBytesOf,
+    ScratchOwned<B>: ScratchOwnedAlloc<B> + ScratchOwnedBorrow<B>,
+{
+    fn glwe_public_key_generate<R, S>(&self, res: &mut R, sk: &S, source_xa: &mut Source, source_xe: &mut Source)
+    where
+        R: GLWEPublicKeyToMut,
+        S: GLWESecretPreparedToRef<B>,
     {
+        let res: &mut GLWEPublicKey<&mut [u8]> = &mut res.to_mut();
+        let sk: &GLWESecretPrepared<&[u8], B> = &sk.to_ref();
+
         #[cfg(debug_assertions)]
         {
             use crate::{Distribution, layouts::LWEInfos};
 
-            assert_eq!(self.n(), sk.n());
+            assert_eq!(res.n(), self.n() as u32);
+            assert_eq!(sk.n(), self.n() as u32);
 
             if sk.dist == Distribution::NONE {
                 panic!("invalid sk: SecretDistribution::NONE")
@@ -52,10 +45,25 @@ }
         }
 
         // Its ok to allocate scratch space here since pk is usually generated only once.
-        let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(GLWECiphertext::encrypt_sk_scratch_space(module, self));
+        let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(GLWE::encrypt_sk_tmp_bytes(self, res));
 
-        let mut tmp: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(self);
-        tmp.encrypt_zero_sk(module, sk, source_xa, source_xe, scratch.borrow());
-        self.dist = sk.dist;
+        let mut tmp: GLWE<Vec<u8>> = GLWE::alloc_from_infos(res);
+
+        tmp.encrypt_zero_sk(self, sk, source_xa, source_xe, scratch.borrow());
+        res.dist = sk.dist;
+    }
+}
+
+impl<D: DataMut> GLWEPublicKey<D> {
+    pub fn generate<S: DataRef, B: Backend>(
+        &mut self,
+        module: &Module<B>,
+        sk: &GLWESecretPrepared<S, B>,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+    ) where
+        Module<B>: GLWEPublicKeyGenerate<B>,
+    {
+        module.glwe_public_key_generate(self, sk, source_xa, source_xe);
     }
 }

@@ -1,32 +1,30 @@
 use poulpy_hal::{
     api::{
-        ScratchAvailable, SvpApplyDftToDftInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx, TakeVecZnxDft,
-        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphismInplace, VecZnxBigNormalize,
-        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace,
-        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace, VecZnxSwitchRing,
+        ScratchAvailable, SvpApplyDftToDftInplace, SvpPPolBytesOf, SvpPrepare, VecZnxAddInplace, VecZnxAddNormal,
+        VecZnxAddScalarInplace, VecZnxAutomorphismInplace, VecZnxBigNormalize, VecZnxDftApply, VecZnxDftBytesOf,
+        VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub,
+        VecZnxSubInplace, VecZnxSwitchRing,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch, ZnxView, ZnxViewMut, ZnxZero},
     source::Source,
 };
 
-use crate::{
-    TakeGLWESecret, TakeGLWESecretPrepared,
-    layouts::{GGLWEInfos, GGLWESwitchingKey, GLWESecret, GLWEToLWEKey, LWEInfos, LWESecret, Rank, prepared::GLWESecretPrepared},
+use crate::layouts::{
+    GGLWEInfos, GLWESecret, GLWESwitchingKey, GLWEToLWESwitchingKey, LWEInfos, LWESecret, Rank, prepared::GLWESecretPrepared,
 };
 
-impl GLWEToLWEKey<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+impl GLWEToLWESwitchingKey<Vec<u8>> {
+    pub fn encrypt_sk_tmp_bytes<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
     where
         A: GGLWEInfos,
-        Module<B>: SvpPPolAllocBytes + VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes + VecZnxNormalizeTmpBytes,
+        Module<B>: SvpPPolBytesOf + VecZnxNormalizeTmpBytes + VecZnxDftBytesOf + VecZnxNormalizeTmpBytes,
     {
-        GLWESecretPrepared::alloc_bytes_with(module, infos.rank_in())
-            + (GGLWESwitchingKey::encrypt_sk_scratch_space(module, infos)
-                | GLWESecret::alloc_bytes_with(infos.n(), infos.rank_in()))
+        GLWESecretPrepared::bytes_of(module, infos.rank_in())
+            + (GLWESwitchingKey::encrypt_sk_tmp_bytes(module, infos) | GLWESecret::bytes_of(infos.n(), infos.rank_in()))
     }
 }
 
-impl<D: DataMut> GLWEToLWEKey<D> {
+impl<D: DataMut> GLWEToLWESwitchingKey<D> {
     #[allow(clippy::too_many_arguments)]
     pub fn encrypt_sk<DLwe, DGlwe, B: Backend>(
         &mut self,
@@ -41,7 +39,7 @@ DLwe: DataRef,
         DGlwe: DataRef,
         Module<B>: VecZnxAutomorphismInplace<B>
             + VecZnxAddScalarInplace
-            + VecZnxDftAllocBytes
+            + VecZnxDftBytesOf
             + VecZnxBigNormalize<B>
             + VecZnxDftApply<B>
             + SvpApplyDftToDftInplace<B>
@@ -56,8 +54,8 @@ + VecZnxNormalize<B>
             + VecZnxSub
             + SvpPrepare<B>
             + VecZnxSwitchRing
-            + SvpPPolAllocBytes,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx + TakeScalarZnx + TakeGLWESecretPrepared<B>,
+            + SvpPPolBytesOf,
+        Scratch<B>: ScratchAvailable,
     {
         #[cfg(debug_assertions)]
         {

@@ -7,10 +7,10 @@ };
 
 use crate::{
     encryption::{SIGMA, SIGMA_BOUND},
-    layouts::{LWECiphertext, LWEInfos, LWEPlaintext, LWESecret},
+    layouts::{LWE, LWEInfos, LWEPlaintext, LWESecret},
 };
 
-impl<DataSelf: DataMut> LWECiphertext<DataSelf> {
+impl<DataSelf: DataMut> LWE<DataSelf> {
     pub fn encrypt_sk<DataPt, DataSk, B>(
         &mut self,
         module: &Module<B>,

@@ -1,27 +1,24 @@
 use poulpy_hal::{
     api::{
-        ScratchAvailable, SvpApplyDftToDftInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx, TakeVecZnxDft,
-        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphismInplace, VecZnxBigNormalize,
-        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace,
-        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace, VecZnxSwitchRing,
+        SvpApplyDftToDftInplace, SvpPPolBytesOf, SvpPrepare, VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace,
+        VecZnxAutomorphismInplace, VecZnxBigNormalize, VecZnxDftApply, VecZnxDftBytesOf, VecZnxFillUniform,
+        VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace,
+        VecZnxSwitchRing,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch, ZnxView, ZnxViewMut},
     source::Source,
 };
 
-use crate::{
-    TakeGLWESecret, TakeGLWESecretPrepared,
-    layouts::{
-        Degree, GGLWEInfos, GGLWESwitchingKey, GLWESecret, LWEInfos, LWESecret, LWESwitchingKey, Rank,
-        prepared::GLWESecretPrepared,
-    },
+use crate::layouts::{
+    GGLWEInfos, GLWESecret, GLWESwitchingKey, LWEInfos, LWESecret, LWESwitchingKey, Rank, RingDegree,
+    prepared::GLWESecretPrepared,
 };
 
 impl LWESwitchingKey<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+    pub fn encrypt_sk_tmp_bytes<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
     where
         A: GGLWEInfos,
-        Module<B>: SvpPPolAllocBytes + VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes + VecZnxNormalizeTmpBytes,
+        Module<B>: SvpPPolBytesOf + VecZnxNormalizeTmpBytes + VecZnxDftBytesOf + VecZnxNormalizeTmpBytes,
     {
         debug_assert_eq!(
             infos.dsize().0,
@@ -38,9 +35,9 @@ infos.rank_out().0,
             1,
             "rank_out > 1 is not supported for LWESwitchingKey"
         );
-        GLWESecret::alloc_bytes_with(Degree(module.n() as u32), Rank(1))
-            + GLWESecretPrepared::alloc_bytes_with(module, Rank(1))
-            + GGLWESwitchingKey::encrypt_sk_scratch_space(module, infos)
+        GLWESecret::bytes_of(RingDegree(module.n() as u32), Rank(1))
+            + GLWESecretPrepared::bytes_of(module, Rank(1))
+            + GLWESwitchingKey::encrypt_sk_tmp_bytes(module, infos)
     }
 }
 
@@ -59,7 +56,7 @@ DIn: DataRef,
         DOut: DataRef,
         Module<B>: VecZnxAutomorphismInplace<B>
             + VecZnxAddScalarInplace
-            + VecZnxDftAllocBytes
+            + VecZnxDftBytesOf
             + VecZnxBigNormalize<B>
             + VecZnxDftApply<B>
             + SvpApplyDftToDftInplace<B>
@@ -74,8 +71,8 @@ + VecZnxNormalize<B>
             + VecZnxSub
             + SvpPrepare<B>
             + VecZnxSwitchRing
-            + SvpPPolAllocBytes,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx + TakeScalarZnx + TakeGLWESecretPrepared<B>,
+            + SvpPPolBytesOf,
+        Scratch<B>:,
     {
         #[cfg(debug_assertions)]
         {

@@ -1,32 +1,29 @@
 use poulpy_hal::{
     api::{
-        ScratchAvailable, SvpApplyDftToDftInplace, SvpPPolAllocBytes, SvpPrepare, TakeScalarZnx, TakeVecZnx, TakeVecZnxDft,
-        VecZnxAddInplace, VecZnxAddNormal, VecZnxAddScalarInplace, VecZnxAutomorphismInplace, VecZnxBigNormalize,
-        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace,
-        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace, VecZnxSwitchRing,
+        ScratchAvailable, SvpApplyDftToDftInplace, SvpPPolBytesOf, SvpPrepare, VecZnxAddInplace, VecZnxAddNormal,
+        VecZnxAddScalarInplace, VecZnxAutomorphismInplace, VecZnxBigNormalize, VecZnxDftApply, VecZnxDftBytesOf,
+        VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub,
+        VecZnxSubInplace, VecZnxSwitchRing,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch, ZnxView, ZnxViewMut},
     source::Source,
 };
 
-use crate::{
-    TakeGLWESecret, TakeGLWESecretPrepared,
-    layouts::{Degree, GGLWEInfos, GGLWESwitchingKey, GLWESecret, LWEInfos, LWESecret, LWEToGLWESwitchingKey, Rank},
-};
+use crate::layouts::{GGLWEInfos, GLWESecret, GLWESwitchingKey, LWEInfos, LWESecret, LWEToGLWESwitchingKey, Rank, RingDegree};
 
 impl LWEToGLWESwitchingKey<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+    pub fn encrypt_sk_tmp_bytes<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
     where
         A: GGLWEInfos,
-        Module<B>: SvpPPolAllocBytes + VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes + VecZnxNormalizeTmpBytes,
+        Module<B>: SvpPPolBytesOf + VecZnxNormalizeTmpBytes + VecZnxDftBytesOf + VecZnxNormalizeTmpBytes,
     {
         debug_assert_eq!(
             infos.rank_in(),
             Rank(1),
             "rank_in != 1 is not supported for LWEToGLWESwitchingKey"
         );
-        GGLWESwitchingKey::encrypt_sk_scratch_space(module, infos)
-            + GLWESecret::alloc_bytes_with(Degree(module.n() as u32), infos.rank_in())
+        GLWESwitchingKey::encrypt_sk_tmp_bytes(module, infos)
+            + GLWESecret::bytes_of(RingDegree(module.n() as u32), infos.rank_in())
     }
 }
 
@@ -45,7 +42,7 @@ DLwe: DataRef,
         DGlwe: DataRef,
         Module<B>: VecZnxAutomorphismInplace<B>
             + VecZnxAddScalarInplace
-            + VecZnxDftAllocBytes
+            + VecZnxDftBytesOf
             + VecZnxBigNormalize<B>
             + VecZnxDftApply<B>
             + SvpApplyDftToDftInplace<B>
@@ -60,8 +57,8 @@ + VecZnxNormalize<B>
             + VecZnxSub
             + SvpPrepare<B>
             + VecZnxSwitchRing
-            + SvpPPolAllocBytes,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx + TakeScalarZnx + TakeGLWESecretPrepared<B>,
+            + SvpPPolBytesOf,
+        Scratch<B>: ScratchAvailable,
     {
         #[cfg(debug_assertions)]
         {

@@ -11,7 +11,5 @@ mod lwe_ct;
 mod lwe_ksk;
 mod lwe_to_glwe_ksk;
 
-pub(crate) use glwe_ct::glwe_encrypt_sk_internal;
-
 pub const SIGMA: f64 = 3.2;
 pub(crate) const SIGMA_BOUND: f64 = 6.0 * SIGMA;

@@ -1,83 +1,46 @@
-use poulpy_hal::{
-    api::{
-        ScratchAvailable, TakeVecZnx, TakeVecZnxDft, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply,
-        VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd,
-        VmpApplyDftToDftTmpBytes,
-    },
-    layouts::{Backend, DataMut, DataRef, Module, Scratch},
-};
+use poulpy_hal::layouts::{Backend, DataMut, Scratch};
 
-use crate::layouts::{GGLWEAutomorphismKey, GGLWEInfos, GGLWESwitchingKey, GGSWInfos, prepared::GGSWCiphertextPrepared};
+use crate::{
+    ScratchTakeCore,
+    external_product::gglwe_ksk::GGLWEExternalProduct,
+    layouts::{AutomorphismKey, AutomorphismKeyToRef, GGLWEInfos, GGSWInfos, prepared::GGSWPreparedToRef},
+};
 
-impl GGLWEAutomorphismKey<Vec<u8>> {
-    pub fn external_product_scratch_space<B: Backend, OUT, IN, GGSW>(
-        module: &Module<B>,
-        out_infos: &OUT,
-        in_infos: &IN,
-        ggsw_infos: &GGSW,
+impl AutomorphismKey<Vec<u8>> {
+    pub fn external_product_tmp_bytes<R, A, B, M, BE: Backend>(
+        &self,
+        module: &M,
+        res_infos: &R,
+        a_infos: &A,
+        b_infos: &B,
     ) -> usize
     where
-        OUT: GGLWEInfos,
-        IN: GGLWEInfos,
-        GGSW: GGSWInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxNormalizeTmpBytes,
+        R: GGLWEInfos,
+        A: GGLWEInfos,
+        B: GGSWInfos,
+        M: GGLWEExternalProduct<BE>,
     {
-        GGLWESwitchingKey::external_product_scratch_space(module, out_infos, in_infos, ggsw_infos)
+        module.gglwe_external_product_tmp_bytes(res_infos, a_infos, b_infos)
     }
+}
 
-    pub fn external_product_inplace_scratch_space<B: Backend, OUT, GGSW>(
-        module: &Module<B>,
-        out_infos: &OUT,
-        ggsw_infos: &GGSW,
-    ) -> usize
+impl<DataSelf: DataMut> AutomorphismKey<DataSelf> {
+    pub fn external_product<A, B, M, BE: Backend>(&mut self, module: &M, a: &A, b: &B, scratch: &mut Scratch<BE>)
     where
-        OUT: GGLWEInfos,
-        GGSW: GGSWInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxNormalizeTmpBytes,
-    {
-        GGLWESwitchingKey::external_product_inplace_scratch_space(module, out_infos, ggsw_infos)
-    }
-}
-
-impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
-    pub fn external_product<DataLhs: DataRef, DataRhs: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        lhs: &GGLWEAutomorphismKey<DataLhs>,
-        rhs: &GGSWCiphertextPrepared<DataRhs, B>,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxNormalizeTmpBytes
-            + VecZnxDftApply<B>
-            + VmpApplyDftToDft<B>
-            + VmpApplyDftToDftAdd<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxBigNormalize<B>
-            + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+        M: GGLWEExternalProduct<BE>,
+        A: AutomorphismKeyToRef,
+        B: GGSWPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        self.key.external_product(module, &lhs.key, rhs, scratch);
+        module.gglwe_external_product(&mut self.key.key, &a.to_ref().key.key, b, scratch);
     }
 
-    pub fn external_product_inplace<DataRhs: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        rhs: &GGSWCiphertextPrepared<DataRhs, B>,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxNormalizeTmpBytes
-            + VecZnxDftApply<B>
-            + VmpApplyDftToDft<B>
-            + VmpApplyDftToDftAdd<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxBigNormalize<B>
-            + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+    pub fn external_product_inplace<A, M, BE: Backend>(&mut self, module: &M, a: &A, scratch: &mut Scratch<BE>)
+    where
+        M: GGLWEExternalProduct<BE>,
+        A: GGSWPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        self.key.external_product_inplace(module, rhs, scratch);
+        module.gglwe_external_product_inplace(&mut self.key.key, a, scratch);
     }
 }

@@ -1,144 +1,134 @@
-use poulpy_hal::{
-    api::{
-        ScratchAvailable, TakeVecZnx, TakeVecZnxDft, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply,
-        VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd,
-        VmpApplyDftToDftTmpBytes,
+use poulpy_hal::layouts::{Backend, DataMut, Module, Scratch, ZnxZero};
+
+use crate::{
+    GLWEExternalProduct, ScratchTakeCore,
+    layouts::{
+        GGLWE, GGLWEInfos, GGLWEToMut, GGLWEToRef, GGSWInfos, GLWEInfos, GLWESwitchingKey, GLWESwitchingKeyToRef,
+        prepared::{GGSWPrepared, GGSWPreparedToRef},
     },
-    layouts::{Backend, DataMut, DataRef, Module, Scratch, ZnxZero},
 };
 
-use crate::layouts::{GGLWEInfos, GGLWESwitchingKey, GGSWInfos, GLWECiphertext, prepared::GGSWCiphertextPrepared};
-
-impl GGLWESwitchingKey<Vec<u8>> {
-    pub fn external_product_scratch_space<B: Backend, OUT, IN, GGSW>(
-        module: &Module<B>,
-        out_infos: &OUT,
-        in_infos: &IN,
-        ggsw_infos: &GGSW,
-    ) -> usize
+pub trait GGLWEExternalProduct<BE: Backend>
+where
+    Self: GLWEExternalProduct<BE>,
+{
+    fn gglwe_external_product_tmp_bytes<R, A, B>(&self, res_infos: &R, a_infos: &A, b_infos: &B) -> usize
     where
-        OUT: GGLWEInfos,
-        IN: GGLWEInfos,
-        GGSW: GGSWInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxNormalizeTmpBytes,
+        R: GGLWEInfos,
+        A: GGLWEInfos,
+        B: GGSWInfos,
     {
-        GLWECiphertext::external_product_scratch_space(
-            module,
-            &out_infos.glwe_layout(),
-            &in_infos.glwe_layout(),
-            ggsw_infos,
-        )
+        self.glwe_external_product_tmp_bytes(res_infos, a_infos, b_infos)
     }
 
-    pub fn external_product_inplace_scratch_space<B: Backend, OUT, GGSW>(
-        module: &Module<B>,
-        out_infos: &OUT,
-        ggsw_infos: &GGSW,
-    ) -> usize
+    fn gglwe_external_product<R, A, B>(&self, res: &mut R, a: &A, b: &B, scratch: &mut Scratch<BE>)
     where
-        OUT: GGLWEInfos,
-        GGSW: GGSWInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxNormalizeTmpBytes,
+        R: GGLWEToMut,
+        A: GGLWEToRef,
+        B: GGSWPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        GLWECiphertext::external_product_inplace_scratch_space(module, &out_infos.glwe_layout(), ggsw_infos)
+        let res: &mut GGLWE<&mut [u8]> = &mut res.to_mut();
+        let a: &GGLWE<&[u8]> = &a.to_ref();
+        let b: &GGSWPrepared<&[u8], BE> = &b.to_ref();
+
+        assert_eq!(
+            res.rank_in(),
+            a.rank_in(),
+            "res input rank_in: {} != a input rank_in: {}",
+            res.rank_in(),
+            a.rank_in()
+        );
+        assert_eq!(
+            a.rank_out(),
+            b.rank(),
+            "a output rank_out: {} != b rank: {}",
+            a.rank_out(),
+            b.rank()
+        );
+        assert_eq!(
+            res.rank_out(),
+            b.rank(),
+            "res output rank_out: {} != b rank: {}",
+            res.rank_out(),
+            b.rank()
+        );
+
+        for row in 0..res.dnum().into() {
+            for col in 0..res.rank_in().into() {
+                self.glwe_external_product(&mut res.at_mut(row, col), &a.at(row, col), b, scratch);
+            }
+        }
+
+        for row in res.dnum().min(a.dnum()).into()..res.dnum().into() {
+            for col in 0..res.rank_in().into() {
+                res.at_mut(row, col).data_mut().zero();
+            }
+        }
     }
-}
 
-impl<DataSelf: DataMut> GGLWESwitchingKey<DataSelf> {
-    pub fn external_product<DataLhs: DataRef, DataRhs: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        lhs: &GGLWESwitchingKey<DataLhs>,
-        rhs: &GGSWCiphertextPrepared<DataRhs, B>,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxNormalizeTmpBytes
-            + VecZnxDftApply<B>
-            + VmpApplyDftToDft<B>
-            + VmpApplyDftToDftAdd<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxBigNormalize<B>
-            + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+    fn gglwe_external_product_inplace<R, A>(&self, res: &mut R, a: &A, scratch: &mut Scratch<BE>)
+    where
+        R: GGLWEToMut,
+        A: GGSWPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        #[cfg(debug_assertions)]
-        {
-            use crate::layouts::GLWEInfos;
+        let res: &mut GGLWE<&mut [u8]> = &mut res.to_mut();
+        let a: &GGSWPrepared<&[u8], BE> = &a.to_ref();
 
-            assert_eq!(
-                self.rank_in(),
-                lhs.rank_in(),
-                "ksk_out input rank: {} != ksk_in input rank: {}",
-                self.rank_in(),
-                lhs.rank_in()
-            );
-            assert_eq!(
-                lhs.rank_out(),
-                rhs.rank(),
-                "ksk_in output rank: {} != ggsw rank: {}",
-                self.rank_out(),
-                rhs.rank()
-            );
-            assert_eq!(
-                self.rank_out(),
-                rhs.rank(),
-                "ksk_out output rank: {} != ggsw rank: {}",
-                self.rank_out(),
-                rhs.rank()
-            );
+        assert_eq!(
+            res.rank_out(),
+            a.rank(),
+            "res output rank: {} != a rank: {}",
+            res.rank_out(),
+            a.rank()
+        );
+
+        for row in 0..res.dnum().into() {
+            for col in 0..res.rank_in().into() {
+                self.glwe_external_product_inplace(&mut res.at_mut(row, col), a, scratch);
+            }
         }
+    }
+}
 
-        (0..self.rank_in().into()).for_each(|col_i| {
-            (0..self.dnum().into()).for_each(|row_j| {
-                self.at_mut(row_j, col_i)
-                    .external_product(module, &lhs.at(row_j, col_i), rhs, scratch);
-            });
-        });
+impl<BE: Backend> GGLWEExternalProduct<BE> for Module<BE> where Self: GLWEExternalProduct<BE> {}
 
-        (self.dnum().min(lhs.dnum()).into()..self.dnum().into()).for_each(|row_i| {
-            (0..self.rank_in().into()).for_each(|col_j| {
-                self.at_mut(row_i, col_j).data.zero();
-            });
-        });
+impl GLWESwitchingKey<Vec<u8>> {
+    pub fn external_product_tmp_bytes<R, A, B, M, BE: Backend>(
+        &self,
+        module: &M,
+        res_infos: &R,
+        a_infos: &A,
+        b_infos: &B,
+    ) -> usize
+    where
+        R: GGLWEInfos,
+        A: GGLWEInfos,
+        B: GGSWInfos,
+        M: GGLWEExternalProduct<BE>,
+    {
+        module.gglwe_external_product_tmp_bytes(res_infos, a_infos, b_infos)
     }
+}
 
-    pub fn external_product_inplace<DataRhs: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        rhs: &GGSWCiphertextPrepared<DataRhs, B>,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxNormalizeTmpBytes
-            + VecZnxDftApply<B>
-            + VmpApplyDftToDft<B>
-            + VmpApplyDftToDftAdd<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxBigNormalize<B>
-            + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+impl<DataSelf: DataMut> GLWESwitchingKey<DataSelf> {
+    pub fn external_product<A, B, M, BE: Backend>(&mut self, module: &M, a: &A, b: &B, scratch: &mut Scratch<BE>)
+    where
+        M: GGLWEExternalProduct<BE>,
+        A: GLWESwitchingKeyToRef,
+        B: GGSWPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        #[cfg(debug_assertions)]
-        {
-            use crate::layouts::GLWEInfos;
+        module.gglwe_external_product(&mut self.key, &a.to_ref().key, b, scratch);
+    }
 
-            assert_eq!(
-                self.rank_out(),
-                rhs.rank(),
-                "ksk_out output rank: {} != ggsw rank: {}",
-                self.rank_out(),
-                rhs.rank()
-            );
-        }
-
-        (0..self.rank_in().into()).for_each(|col_i| {
-            (0..self.dnum().into()).for_each(|row_j| {
-                self.at_mut(row_j, col_i)
-                    .external_product_inplace(module, rhs, scratch);
-            });
-        });
+    pub fn external_product_inplace<A, M, BE: Backend>(&mut self, module: &M, a: &A, scratch: &mut Scratch<BE>)
+    where
+        M: GGLWEExternalProduct<BE>,
+        A: GGSWPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        module.gglwe_external_product_inplace(&mut self.key, a, scratch);
     }
 }

@@ -1,143 +1,136 @@
 use poulpy_hal::{
-    api::{
-        ScratchAvailable, TakeVecZnx, TakeVecZnxDft, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply,
-        VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd,
-        VmpApplyDftToDftTmpBytes,
+    api::ScratchAvailable,
+    layouts::{Backend, DataMut, Module, Scratch, ZnxZero},
+};
+
+use crate::{
+    GLWEExternalProduct, ScratchTakeCore,
+    layouts::{
+        GGSW, GGSWInfos, GGSWToMut, GGSWToRef, GLWEInfos, LWEInfos,
+        prepared::{GGSWPrepared, GGSWPreparedToRef},
     },
-    layouts::{Backend, DataMut, DataRef, Module, Scratch, ZnxZero},
 };
 
-use crate::layouts::{GGSWCiphertext, GGSWInfos, GLWECiphertext, GLWEInfos, prepared::GGSWCiphertextPrepared};
-
-impl GGSWCiphertext<Vec<u8>> {
-    #[allow(clippy::too_many_arguments)]
-    pub fn external_product_scratch_space<B: Backend, OUT, IN, GGSW>(
-        module: &Module<B>,
-        out_infos: &OUT,
-        in_infos: &IN,
-        apply_infos: &GGSW,
-    ) -> usize
+pub trait GGSWExternalProduct<BE: Backend>
+where
+    Self: GLWEExternalProduct<BE>,
+{
+    fn ggsw_external_product_tmp_bytes<R, A, B>(&self, res_infos: &R, a_infos: &A, b_infos: &B) -> usize
     where
-        OUT: GGSWInfos,
-        IN: GGSWInfos,
-        GGSW: GGSWInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxNormalizeTmpBytes,
+        R: GGSWInfos,
+        A: GGSWInfos,
+        B: GGSWInfos,
     {
-        GLWECiphertext::external_product_scratch_space(
-            module,
-            &out_infos.glwe_layout(),
-            &in_infos.glwe_layout(),
-            apply_infos,
-        )
+        self.glwe_external_product_tmp_bytes(res_infos, a_infos, b_infos)
     }
 
-    pub fn external_product_inplace_scratch_space<B: Backend, OUT, GGSW>(
-        module: &Module<B>,
-        out_infos: &OUT,
-        apply_infos: &GGSW,
-    ) -> usize
+    fn ggsw_external_product<R, A, B>(&self, res: &mut R, a: &A, b: &B, scratch: &mut Scratch<BE>)
     where
-        OUT: GGSWInfos,
-        GGSW: GGSWInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxNormalizeTmpBytes,
+        R: GGSWToMut,
+        A: GGSWToRef,
+        B: GGSWPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        GLWECiphertext::external_product_inplace_scratch_space(module, &out_infos.glwe_layout(), apply_infos)
+        let res: &mut GGSW<&mut [u8]> = &mut res.to_mut();
+        let a: &GGSW<&[u8]> = &a.to_ref();
+        let b: &GGSWPrepared<&[u8], BE> = &b.to_ref();
+
+        assert_eq!(
+            res.rank(),
+            a.rank(),
+            "res rank: {} != a rank: {}",
+            res.rank(),
+            a.rank()
+        );
+        assert_eq!(
+            res.rank(),
+            b.rank(),
+            "res rank: {} != b rank: {}",
+            res.rank(),
+            b.rank()
+        );
+
+        assert!(scratch.available() >= self.ggsw_external_product_tmp_bytes(res, a, b));
+
+        let min_dnum: usize = res.dnum().min(a.dnum()).into();
+
+        for row in 0..min_dnum {
+            for col in 0..(res.rank() + 1).into() {
+                self.glwe_external_product(&mut res.at_mut(row, col), &a.at(row, col), b, scratch);
+            }
+        }
+
+        for row in min_dnum..res.dnum().into() {
+            for col in 0..(res.rank() + 1).into() {
+                res.at_mut(row, col).data.zero();
+            }
+        }
     }
-}
 
-impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
-    pub fn external_product<DataLhs: DataRef, DataRhs: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        lhs: &GGSWCiphertext<DataLhs>,
-        rhs: &GGSWCiphertextPrepared<DataRhs, B>,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxNormalizeTmpBytes
-            + VecZnxDftApply<B>
-            + VmpApplyDftToDft<B>
-            + VmpApplyDftToDftAdd<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxBigNormalize<B>
-            + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+    fn ggsw_external_product_inplace<R, A>(&self, res: &mut R, a: &A, scratch: &mut Scratch<BE>)
+    where
+        R: GGSWToMut,
+        A: GGSWPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        #[cfg(debug_assertions)]
-        {
-            use crate::layouts::LWEInfos;
+        let res: &mut GGSW<&mut [u8]> = &mut res.to_mut();
+        let a: &GGSWPrepared<&[u8], BE> = &a.to_ref();
 
-            assert_eq!(lhs.n(), self.n());
-            assert_eq!(rhs.n(), self.n());
-
-            assert_eq!(
-                self.rank(),
-                lhs.rank(),
-                "ggsw_out rank: {} != ggsw_in rank: {}",
-                self.rank(),
-                lhs.rank()
-            );
-            assert_eq!(
-                self.rank(),
-                rhs.rank(),
-                "ggsw_in rank: {} != ggsw_apply rank: {}",
-                self.rank(),
-                rhs.rank()
-            );
+        assert_eq!(res.n(), self.n() as u32);
+        assert_eq!(a.n(), self.n() as u32);
+        assert_eq!(
+            res.rank(),
+            a.rank(),
+            "res rank: {} != a rank: {}",
+            res.rank(),
+            a.rank()
+        );
 
-            assert!(scratch.available() >= GGSWCiphertext::external_product_scratch_space(module, self, lhs, rhs))
+        for row in 0..res.dnum().into() {
+            for col in 0..(res.rank() + 1).into() {
+                self.glwe_external_product_inplace(&mut res.at_mut(row, col), a, scratch);
+            }
         }
+    }
+}
 
-        let min_dnum: usize = self.dnum().min(lhs.dnum()).into();
+impl<BE: Backend> GGSWExternalProduct<BE> for Module<BE> where Self: GLWEExternalProduct<BE> {}
 
-        (0..(self.rank() + 1).into()).for_each(|col_i| {
-            (0..min_dnum).for_each(|row_j| {
-                self.at_mut(row_j, col_i)
-                    .external_product(module, &lhs.at(row_j, col_i), rhs, scratch);
-            });
-            (min_dnum..self.dnum().into()).for_each(|row_i| {
-                self.at_mut(row_i, col_i).data.zero();
-            });
-        });
+impl GGSW<Vec<u8>> {
+    pub fn external_product_tmp_bytes<R, A, B, M, BE: Backend>(
+        &self,
+        module: &M,
+        res_infos: &R,
+        a_infos: &A,
+        b_infos: &B,
+    ) -> usize
+    where
+        R: GGSWInfos,
+        A: GGSWInfos,
+        B: GGSWInfos,
+        M: GGSWExternalProduct<BE>,
+    {
+        module.ggsw_external_product_tmp_bytes(res_infos, a_infos, b_infos)
     }
+}
 
-    pub fn external_product_inplace<DataRhs: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        rhs: &GGSWCiphertextPrepared<DataRhs, B>,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxNormalizeTmpBytes
-            + VecZnxDftApply<B>
-            + VmpApplyDftToDft<B>
-            + VmpApplyDftToDftAdd<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxBigNormalize<B>
-            + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+impl<DataSelf: DataMut> GGSW<DataSelf> {
+    pub fn external_product<A, B, M, BE: Backend>(&mut self, module: &M, a: &A, b: &B, scratch: &mut Scratch<BE>)
+    where
+        M: GGSWExternalProduct<BE>,
+        A: GGSWToRef,
+        B: GGSWPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        #[cfg(debug_assertions)]
-        {
-            use crate::layouts::LWEInfos;
-
-            assert_eq!(rhs.n(), self.n());
-            assert_eq!(
-                self.rank(),
-                rhs.rank(),
-                "ggsw_out rank: {} != ggsw_apply: {}",
-                self.rank(),
-                rhs.rank()
-            );
-        }
+        module.ggsw_external_product(self, a, b, scratch);
+    }
 
-        (0..(self.rank() + 1).into()).for_each(|col_i| {
-            (0..self.dnum().into()).for_each(|row_j| {
-                self.at_mut(row_j, col_i)
-                    .external_product_inplace(module, rhs, scratch);
-            });
-        });
+    pub fn external_product_inplace<A, M, BE: Backend>(&mut self, module: &M, a: &A, scratch: &mut Scratch<BE>)
+    where
+        M: GGSWExternalProduct<BE>,
+        A: GGSWPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        module.ggsw_external_product_inplace(self, a, scratch);
     }
 }

@@ -1,102 +1,57 @@
 use poulpy_hal::{
     api::{
-        ScratchAvailable, TakeVecZnx, TakeVecZnxDft, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply,
-        VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd,
-        VmpApplyDftToDftTmpBytes,
+        ModuleN, ScratchTakeBasic, VecZnxBigNormalize, VecZnxDftApply, VecZnxDftBytesOf, VecZnxIdftApplyConsume, VecZnxNormalize,
+        VecZnxNormalizeTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
     },
-    layouts::{Backend, DataMut, DataRef, DataViewMut, Module, Scratch, VecZnx, VecZnxBig},
+    layouts::{Backend, DataMut, DataViewMut, Module, Scratch, VecZnx, VecZnxBig},
 };
 
 use crate::{
-    GLWEExternalProduct, GLWEExternalProductInplace,
+    ScratchTakeCore,
     layouts::{
-        GGSWInfos, GLWECiphertext, GLWECiphertextToMut, GLWECiphertextToRef, GLWEInfos, LWEInfos,
-        prepared::{GGSWCiphertextPrepared, GGSWCiphertextPreparedToRef},
+        GGSWInfos, GLWE, GLWEInfos, GLWEToMut, GLWEToRef, LWEInfos,
+        prepared::{GGSWPrepared, GGSWPreparedToRef},
     },
 };
 
-impl GLWECiphertext<Vec<u8>> {
-    #[allow(clippy::too_many_arguments)]
-    pub fn external_product_scratch_space<B: Backend, OUT, IN, GGSW>(
-        module: &Module<B>,
-        out_infos: &OUT,
-        in_infos: &IN,
-        apply_infos: &GGSW,
-    ) -> usize
+impl GLWE<Vec<u8>> {
+    pub fn external_product_tmp_bytes<R, A, B, M, BE: Backend>(module: &M, res_infos: &R, a_infos: &A, b_infos: &B) -> usize
     where
-        OUT: GLWEInfos,
-        IN: GLWEInfos,
-        GGSW: GGSWInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxNormalizeTmpBytes,
+        R: GLWEInfos,
+        A: GLWEInfos,
+        B: GGSWInfos,
+        M: GLWEExternalProduct<BE>,
     {
-        let in_size: usize = in_infos
-            .k()
-            .div_ceil(apply_infos.base2k())
-            .div_ceil(apply_infos.dsize().into()) as usize;
-        let out_size: usize = out_infos.size();
-        let ggsw_size: usize = apply_infos.size();
-        let res_dft: usize = module.vec_znx_dft_alloc_bytes((apply_infos.rank() + 1).into(), ggsw_size);
-        let a_dft: usize = module.vec_znx_dft_alloc_bytes((apply_infos.rank() + 1).into(), in_size);
-        let vmp: usize = module.vmp_apply_dft_to_dft_tmp_bytes(
-            out_size,
-            in_size,
-            in_size,                         // rows
-            (apply_infos.rank() + 1).into(), // cols in
-            (apply_infos.rank() + 1).into(), // cols out
-            ggsw_size,
-        );
-        let normalize_big: usize = module.vec_znx_normalize_tmp_bytes();
-
-        if in_infos.base2k() == apply_infos.base2k() {
-            res_dft + a_dft + (vmp | normalize_big)
-        } else {
-            let normalize_conv: usize = VecZnx::alloc_bytes(module.n(), (apply_infos.rank() + 1).into(), in_size);
-            res_dft + ((a_dft + normalize_conv + (module.vec_znx_normalize_tmp_bytes() | vmp)) | normalize_big)
-        }
+        module.glwe_external_product_tmp_bytes(res_infos, a_infos, b_infos)
     }
+}
 
-    pub fn external_product_inplace_scratch_space<B: Backend, OUT, GGSW>(
-        module: &Module<B>,
-        out_infos: &OUT,
-        apply_infos: &GGSW,
-    ) -> usize
+impl<DataSelf: DataMut> GLWE<DataSelf> {
+    pub fn external_product<A, B, M, BE: Backend>(&mut self, module: &M, a: &A, b: &B, scratch: &mut Scratch<BE>)
     where
-        OUT: GLWEInfos,
-        GGSW: GGSWInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxNormalizeTmpBytes,
+        A: GLWEToRef,
+        B: GGSWPreparedToRef<BE>,
+        M: GLWEExternalProduct<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        Self::external_product_scratch_space(module, out_infos, out_infos, apply_infos)
+        module.glwe_external_product(self, a, b, scratch);
     }
-}
 
-impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
-    pub fn external_product<DataLhs: DataRef, DataRhs: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        lhs: &GLWECiphertext<DataLhs>,
-        rhs: &GGSWCiphertextPrepared<DataRhs, B>,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: GLWEExternalProduct<B>,
+    pub fn external_product_inplace<A, M, BE: Backend>(&mut self, module: &M, a: &A, scratch: &mut Scratch<BE>)
+    where
+        A: GGSWPreparedToRef<BE>,
+        M: GLWEExternalProduct<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        module.external_product(self, lhs, rhs, scratch);
-    }
-
-    pub fn external_product_inplace<DataRhs: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        rhs: &GGSWCiphertextPrepared<DataRhs, B>,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: GLWEExternalProductInplace<B>,
-    {
-        module.external_product_inplace(self, rhs, scratch);
+        module.glwe_external_product_inplace(self, a, scratch);
     }
 }
 
-impl<BE: Backend> GLWEExternalProductInplace<BE> for Module<BE>
+pub trait GLWEExternalProduct<BE: Backend>
 where
-    Module<BE>: VecZnxDftAllocBytes
+    Self: Sized
+        + ModuleN
+        + VecZnxDftBytesOf
         + VmpApplyDftToDftTmpBytes
         + VecZnxNormalizeTmpBytes
         + VecZnxDftApply<BE>
@@ -105,15 +60,47 @@ + VmpApplyDftToDftAdd<BE>
         + VecZnxIdftApplyConsume<BE>
         + VecZnxBigNormalize<BE>
         + VecZnxNormalize<BE>,
-    Scratch<BE>: TakeVecZnxDft<BE> + ScratchAvailable + TakeVecZnx,
 {
-    fn external_product_inplace<R, D>(&self, res: &mut R, ggsw: &D, scratch: &mut Scratch<BE>)
+    fn glwe_external_product_tmp_bytes<R, A, B>(&self, res_infos: &R, a_infos: &A, b_infos: &B) -> usize
+    where
+        R: GLWEInfos,
+        A: GLWEInfos,
+        B: GGSWInfos,
+    {
+        let in_size: usize = a_infos
+            .k()
+            .div_ceil(b_infos.base2k())
+            .div_ceil(b_infos.dsize().into()) as usize;
+        let out_size: usize = res_infos.size();
+        let ggsw_size: usize = b_infos.size();
+        let res_dft: usize = self.bytes_of_vec_znx_dft((b_infos.rank() + 1).into(), ggsw_size);
+        let a_dft: usize = self.bytes_of_vec_znx_dft((b_infos.rank() + 1).into(), in_size);
+        let vmp: usize = self.vmp_apply_dft_to_dft_tmp_bytes(
+            out_size,
+            in_size,
+            in_size,                     // rows
+            (b_infos.rank() + 1).into(), // cols in
+            (b_infos.rank() + 1).into(), // cols out
+            ggsw_size,
+        );
+        let normalize_big: usize = self.vec_znx_normalize_tmp_bytes();
+
+        if a_infos.base2k() == b_infos.base2k() {
+            res_dft + a_dft + (vmp | normalize_big)
+        } else {
+            let normalize_conv: usize = VecZnx::bytes_of(self.n(), (b_infos.rank() + 1).into(), in_size);
+            res_dft + ((a_dft + normalize_conv + (self.vec_znx_normalize_tmp_bytes() | vmp)) | normalize_big)
+        }
+    }
+
+    fn glwe_external_product_inplace<R, D>(&self, res: &mut R, a: &D, scratch: &mut Scratch<BE>)
     where
-        R: GLWECiphertextToMut,
-        D: GGSWCiphertextPreparedToRef<BE>,
+        R: GLWEToMut,
+        D: GGSWPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        let res: &mut GLWECiphertext<&mut [u8]> = &mut res.to_mut();
-        let rhs: &GGSWCiphertextPrepared<&[u8], BE> = &ggsw.to_ref();
+        let res: &mut GLWE<&mut [u8]> = &mut res.to_mut();
+        let rhs: &GGSWPrepared<&[u8], BE> = &a.to_ref();
 
         let basek_in: usize = res.base2k().into();
         let basek_ggsw: usize = rhs.base2k().into();
@@ -124,15 +111,15 @@ use poulpy_hal::api::ScratchAvailable;
 
             assert_eq!(rhs.rank(), res.rank());
             assert_eq!(rhs.n(), res.n());
-            assert!(scratch.available() >= GLWECiphertext::external_product_inplace_scratch_space(self, res, rhs));
+            assert!(scratch.available() >= self.glwe_external_product_tmp_bytes(res, res, rhs));
         }
 
         let cols: usize = (rhs.rank() + 1).into();
         let dsize: usize = rhs.dsize().into();
         let a_size: usize = (res.size() * basek_in).div_ceil(basek_ggsw);
 
-        let (mut res_dft, scratch_1) = scratch.take_vec_znx_dft(res.n().into(), cols, rhs.size()); // Todo optimise
-        let (mut a_dft, scratch_2) = scratch_1.take_vec_znx_dft(res.n().into(), cols, a_size.div_ceil(dsize));
+        let (mut res_dft, scratch_1) = scratch.take_vec_znx_dft(self, cols, rhs.size()); // Todo optimise
+        let (mut a_dft, scratch_2) = scratch_1.take_vec_znx_dft(self, cols, a_size.div_ceil(dsize));
         a_dft.data_mut().fill(0);
 
         if basek_in == basek_ggsw {
@@ -160,7 +147,7 @@ self.vmp_apply_dft_to_dft_add(&mut res_dft, &a_dft, &rhs.data, di, scratch_2);
                 }
             }
         } else {
-            let (mut a_conv, scratch_3) = scratch_2.take_vec_znx(self.n(), cols, a_size);
+            let (mut a_conv, scratch_3) = scratch_2.take_vec_znx(self, cols, a_size);
 
             for j in 0..cols {
                 self.vec_znx_normalize(
@@ -213,31 +200,18 @@ scratch_1,
             );
         }
     }
-}
 
-impl<BE: Backend> GLWEExternalProduct<BE> for Module<BE>
-where
-    Module<BE>: VecZnxDftAllocBytes
-        + VmpApplyDftToDftTmpBytes
-        + VecZnxNormalizeTmpBytes
-        + VecZnxDftApply<BE>
-        + VmpApplyDftToDft<BE>
-        + VmpApplyDftToDftAdd<BE>
-        + VecZnxIdftApplyConsume<BE>
-        + VecZnxBigNormalize<BE>
-        + VecZnxNormalize<BE>,
-    Scratch<BE>: TakeVecZnxDft<BE> + ScratchAvailable + TakeVecZnx,
-{
-    fn external_product<R, A, D>(&self, res: &mut R, lhs: &A, rhs: &D, scratch: &mut Scratch<BE>)
+    fn glwe_external_product<R, A, D>(&self, res: &mut R, lhs: &A, rhs: &D, scratch: &mut Scratch<BE>)
     where
-        R: GLWECiphertextToMut,
-        A: GLWECiphertextToRef,
-        D: GGSWCiphertextPreparedToRef<BE>,
+        R: GLWEToMut,
+        A: GLWEToRef,
+        D: GGSWPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        let res: &mut GLWECiphertext<&mut [u8]> = &mut res.to_mut();
-        let lhs: &GLWECiphertext<&[u8]> = &lhs.to_ref();
+        let res: &mut GLWE<&mut [u8]> = &mut res.to_mut();
+        let lhs: &GLWE<&[u8]> = &lhs.to_ref();
 
-        let rhs: &GGSWCiphertextPrepared<&[u8], BE> = &rhs.to_ref();
+        let rhs: &GGSWPrepared<&[u8], BE> = &rhs.to_ref();
 
         let basek_in: usize = lhs.base2k().into();
         let basek_ggsw: usize = rhs.base2k().into();
@@ -251,7 +225,7 @@ assert_eq!(rhs.rank(), lhs.rank());
             assert_eq!(rhs.rank(), res.rank());
             assert_eq!(rhs.n(), res.n());
             assert_eq!(lhs.n(), res.n());
-            assert!(scratch.available() >= GLWECiphertext::external_product_scratch_space(self, res, lhs, rhs));
+            assert!(scratch.available() >= self.glwe_external_product_tmp_bytes(res, lhs, rhs));
         }
 
         let cols: usize = (rhs.rank() + 1).into();
@@ -259,8 +233,8 @@ let dsize: usize = rhs.dsize().into();
 
         let a_size: usize = (lhs.size() * basek_in).div_ceil(basek_ggsw);
 
-        let (mut res_dft, scratch_1) = scratch.take_vec_znx_dft(self.n(), cols, rhs.size()); // Todo optimise
-        let (mut a_dft, scratch_2) = scratch_1.take_vec_znx_dft(self.n(), cols, a_size.div_ceil(dsize));
+        let (mut res_dft, scratch_1) = scratch.take_vec_znx_dft(self, cols, rhs.size()); // Todo optimise
+        let (mut a_dft, scratch_2) = scratch_1.take_vec_znx_dft(self, cols, a_size.div_ceil(dsize));
         a_dft.data_mut().fill(0);
 
         if basek_in == basek_ggsw {
@@ -288,7 +262,7 @@ self.vmp_apply_dft_to_dft_add(&mut res_dft, &a_dft, &rhs.data, di, scratch_2);
                 }
             }
         } else {
-            let (mut a_conv, scratch_3) = scratch_2.take_vec_znx(self.n(), cols, a_size);
+            let (mut a_conv, scratch_3) = scratch_2.take_vec_znx(self, cols, a_size);
 
             for j in 0..cols {
                 self.vec_znx_normalize(
@@ -342,3 +316,20 @@ );
         });
     }
 }
+
+impl<BE: Backend> GLWEExternalProduct<BE> for Module<BE> where
+    Self: ModuleN
+        + VecZnxDftBytesOf
+        + VmpApplyDftToDftTmpBytes
+        + VecZnxNormalizeTmpBytes
+        + VecZnxDftApply<BE>
+        + VmpApplyDftToDft<BE>
+        + VmpApplyDftToDftAdd<BE>
+        + VecZnxIdftApplyConsume<BE>
+        + VecZnxBigNormalize<BE>
+        + VecZnxNormalize<BE>
+        + VecZnxDftBytesOf
+        + VmpApplyDftToDftTmpBytes
+        + VecZnxNormalizeTmpBytes
+{
+}

@@ -1,23 +1,8 @@
-use poulpy_hal::layouts::{Backend, Scratch};
-
-use crate::layouts::{GLWECiphertextToMut, GLWECiphertextToRef, prepared::GGSWCiphertextPreparedToRef};
-
 mod gglwe_atk;
 mod gglwe_ksk;
 mod ggsw_ct;
 mod glwe_ct;
 
-pub trait GLWEExternalProduct<BE: Backend> {
-    fn external_product<R, A, D>(&self, res: &mut R, a: &A, ggsw: &D, scratch: &mut Scratch<BE>)
-    where
-        R: GLWECiphertextToMut,
-        A: GLWECiphertextToRef,
-        D: GGSWCiphertextPreparedToRef<BE>;
-}
-
-pub trait GLWEExternalProductInplace<BE: Backend> {
-    fn external_product_inplace<R, D>(&self, res: &mut R, ggsw: &D, scratch: &mut Scratch<BE>)
-    where
-        R: GLWECiphertextToMut,
-        D: GGSWCiphertextPreparedToRef<BE>;
-}
+pub use gglwe_ksk::*;
+pub use ggsw_ct::*;
+pub use glwe_ct::*;

@@ -2,18 +2,18 @@ use std::collections::HashMap;
 
 use poulpy_hal::{
     api::{
-        ScratchAvailable, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAutomorphismInplace, VecZnxBigAddSmallInplace,
-        VecZnxBigAutomorphismInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxBigSubSmallNegateInplace, VecZnxCopy,
-        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxDftCopy, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA, VecZnxNegateInplace,
-        VecZnxNormalize, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxRotate, VecZnxRotateInplace, VecZnxRshInplace,
-        VecZnxSub, VecZnxSubInplace, VecZnxSwitchRing, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+        ScratchAvailable, VecZnxAddInplace, VecZnxAutomorphismInplace, VecZnxBigAddSmallInplace, VecZnxBigAutomorphismInplace,
+        VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxBigSubSmallNegateInplace, VecZnxCopy, VecZnxDftApply,
+        VecZnxDftBytesOf, VecZnxDftCopy, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA, VecZnxNegateInplace, VecZnxNormalize,
+        VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxRotate, VecZnxRotateInplace, VecZnxRshInplace, VecZnxSub,
+        VecZnxSubInplace, VecZnxSwitchRing, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch},
 };
 
 use crate::{
-    GLWEOperations, TakeGLWECt,
-    layouts::{GGLWEInfos, GLWECiphertext, GLWEInfos, LWEInfos, prepared::GGLWEAutomorphismKeyPrepared},
+    GLWEOperations,
+    layouts::{GGLWEInfos, GLWE, GLWEInfos, LWEInfos, prepared::AutomorphismKeyPrepared},
 };
 
 /// [GLWEPacker] enables only the fly GLWE packing
@@ -29,7 +29,7 @@
 /// [Accumulator] stores intermediate packing result.
 /// There are Log(N) such accumulators in a [GLWEPacker].
 struct Accumulator {
-    data: GLWECiphertext<Vec<u8>>,
+    data: GLWE<Vec<u8>>,
     value: bool,   // Implicit flag for zero ciphertext
     control: bool, // Can be combined with incoming value
 }
@@ -43,12 +43,12 @@ /// * `module`: static backend FFT tables.
     /// * `base2k`: base 2 logarithm of the GLWE ciphertext in memory digit representation.
     /// * `k`: base 2 precision of the GLWE ciphertext precision over the Torus.
     /// * `rank`: rank of the GLWE ciphertext.
-    pub fn alloc<A>(infos: &A) -> Self
+    pub fn alloc<A, B: Backend>(module: &Module<B>, infos: &A) -> Self
     where
         A: GLWEInfos,
     {
         Self {
-            data: GLWECiphertext::alloc(infos),
+            data: GLWE::alloc_from_infos(module, infos),
             value: false,
             control: false,
         }
@@ -66,13 +66,13 @@ ///   i.e. with `log_batch=0` only the constant coefficient is packed
     ///   and N GLWE ciphertext can be packed. With `log_batch=2` all coefficients
     ///   which are multiples of X^{N/4} are packed. Meaning that N/4 ciphertexts
     ///   can be packed.
-    pub fn new<A>(infos: &A, log_batch: usize) -> Self
+    pub fn new<A, B: Backend>(module: Module<B>, infos: &A, log_batch: usize) -> Self
     where
         A: GLWEInfos,
     {
         let mut accumulators: Vec<Accumulator> = Vec::<Accumulator>::new();
         let log_n: usize = infos.n().log2();
-        (0..log_n - log_batch).for_each(|_| accumulators.push(Accumulator::alloc(infos)));
+        (0..log_n - log_batch).for_each(|_| accumulators.push(Accumulator::alloc(module, infos)));
         Self {
             accumulators,
             log_batch,
@@ -90,17 +90,17 @@ self.counter = 0;
     }
 
     /// Number of scratch space bytes required to call [Self::add].
-    pub fn scratch_space<B: Backend, OUT, KEY>(module: &Module<B>, out_infos: &OUT, key_infos: &KEY) -> usize
+    pub fn tmp_bytes<B: Backend, OUT, KEY>(module: &Module<B>, out_infos: &OUT, key_infos: &KEY) -> usize
     where
         OUT: GLWEInfos,
         KEY: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
+        Module<B>: VecZnxDftBytesOf + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
     {
-        pack_core_scratch_space(module, out_infos, key_infos)
+        pack_core_tmp_bytes(module, out_infos, key_infos)
     }
 
     pub fn galois_elements<B: Backend>(module: &Module<B>) -> Vec<i64> {
-        GLWECiphertext::trace_galois_elements(module)
+        GLWE::trace_galois_elements(module)
     }
 
     /// Adds a GLWE ciphertext to the [GLWEPacker].
@@ -111,15 +111,15 @@ /// * `res`: space to append fully packed ciphertext. Only when the number
     ///   of packed ciphertexts reaches N/2^log_batch is a result written.
     /// * `a`: ciphertext to pack. Can optionally give None to pack a 0 ciphertext.
     /// * `auto_keys`: a [HashMap] containing the [AutomorphismKeyExec]s.
-    /// * `scratch`: scratch space of size at least [Self::scratch_space].
+    /// * `scratch`: scratch space of size at least [Self::tmp_bytes].
     pub fn add<DataA: DataRef, DataAK: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
-        a: Option<&GLWECiphertext<DataA>>,
-        auto_keys: &HashMap<i64, GGLWEAutomorphismKeyPrepared<DataAK, B>>,
+        a: Option<&GLWE<DataA>>,
+        auto_keys: &HashMap<i64, AutomorphismKeyPrepared<DataAK, B>>,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxDftAllocBytes
+        Module<B>: VecZnxDftBytesOf
             + VmpApplyDftToDftTmpBytes
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
@@ -142,7 +142,7 @@ + VecZnxBigSubSmallNegateInplace<B>
             + VecZnxBigAutomorphismInplace<B>
             + VecZnxNormalize<B>
             + VecZnxNormalizeTmpBytes,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+        Scratch<B>: ScratchAvailable,
     {
         assert!(
             (self.counter as u32) < self.accumulators[0].data.n(),
@@ -162,7 +162,7 @@ self.counter += 1 << self.log_batch;
     }
 
     /// Flush result to`res`.
-    pub fn flush<Data: DataMut, B: Backend>(&mut self, module: &Module<B>, res: &mut GLWECiphertext<Data>)
+    pub fn flush<Data: DataMut, B: Backend>(&mut self, module: &Module<B>, res: &mut GLWE<Data>)
     where
         Module<B>: VecZnxCopy,
     {
@@ -177,24 +177,24 @@ self.reset();
     }
 }
 
-fn pack_core_scratch_space<B: Backend, OUT, KEY>(module: &Module<B>, out_infos: &OUT, key_infos: &KEY) -> usize
+fn pack_core_tmp_bytes<B: Backend, OUT, KEY>(module: &Module<B>, out_infos: &OUT, key_infos: &KEY) -> usize
 where
     OUT: GLWEInfos,
     KEY: GGLWEInfos,
-    Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
+    Module<B>: VecZnxDftBytesOf + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
 {
-    combine_scratch_space(module, out_infos, key_infos)
+    combine_tmp_bytes(module, out_infos, key_infos)
 }
 
 fn pack_core<D: DataRef, DataAK: DataRef, B: Backend>(
     module: &Module<B>,
-    a: Option<&GLWECiphertext<D>>,
+    a: Option<&GLWE<D>>,
     accumulators: &mut [Accumulator],
     i: usize,
-    auto_keys: &HashMap<i64, GGLWEAutomorphismKeyPrepared<DataAK, B>>,
+    auto_keys: &HashMap<i64, AutomorphismKeyPrepared<DataAK, B>>,
     scratch: &mut Scratch<B>,
 ) where
-    Module<B>: VecZnxDftAllocBytes
+    Module<B>: VecZnxDftBytesOf
         + VmpApplyDftToDftTmpBytes
         + VecZnxBigNormalizeTmpBytes
         + VmpApplyDftToDft<B>
@@ -217,7 +217,7 @@ + VecZnxBigSubSmallNegateInplace<B>
         + VecZnxBigAutomorphismInplace<B>
         + VecZnxNormalize<B>
         + VecZnxNormalizeTmpBytes,
-    Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+    Scratch<B>: ScratchAvailable,
 {
     let log_n: usize = module.log_n();
 
@@ -258,7 +258,7 @@ );
         } else {
             pack_core(
                 module,
-                None::<&GLWECiphertext<Vec<u8>>>,
+                None::<&GLWE<Vec<u8>>>,
                 acc_next,
                 i + 1,
                 auto_keys,
@@ -268,27 +268,26 @@ }
     }
 }
 
-fn combine_scratch_space<B: Backend, OUT, KEY>(module: &Module<B>, out_infos: &OUT, key_infos: &KEY) -> usize
+fn combine_tmp_bytes<B: Backend, OUT, KEY>(module: &Module<B>, out_infos: &OUT, key_infos: &KEY) -> usize
 where
     OUT: GLWEInfos,
     KEY: GGLWEInfos,
-    Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
+    Module<B>: VecZnxDftBytesOf + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
 {
-    GLWECiphertext::alloc_bytes(out_infos)
-        + (GLWECiphertext::rsh_scratch_space(module.n())
-            | GLWECiphertext::automorphism_inplace_scratch_space(module, out_infos, key_infos))
+    GLWE::bytes_of_from_infos(module, out_infos)
+        + (GLWE::rsh_tmp_bytes(module.n()) | GLWE::automorphism_inplace_tmp_bytes(module, out_infos, key_infos))
 }
 
 /// [combine] merges two ciphertexts together.
 fn combine<D: DataRef, DataAK: DataRef, B: Backend>(
     module: &Module<B>,
     acc: &mut Accumulator,
-    b: Option<&GLWECiphertext<D>>,
+    b: Option<&GLWE<D>>,
     i: usize,
-    auto_keys: &HashMap<i64, GGLWEAutomorphismKeyPrepared<DataAK, B>>,
+    auto_keys: &HashMap<i64, AutomorphismKeyPrepared<DataAK, B>>,
     scratch: &mut Scratch<B>,
 ) where
-    Module<B>: VecZnxDftAllocBytes
+    Module<B>: VecZnxDftBytesOf
         + VmpApplyDftToDftTmpBytes
         + VecZnxBigNormalizeTmpBytes
         + VmpApplyDftToDft<B>
@@ -311,10 +310,10 @@ + VecZnxBigSubSmallNegateInplace<B>
         + VecZnxBigAutomorphismInplace<B>
         + VecZnxNormalize<B>
         + VecZnxNormalizeTmpBytes,
-    Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx + TakeGLWECt,
+    Scratch<B>: ScratchAvailable,
 {
     let log_n: usize = acc.data.n().log2();
-    let a: &mut GLWECiphertext<Vec<u8>> = &mut acc.data;
+    let a: &mut GLWE<Vec<u8>> = &mut acc.data;
 
     let gal_el: i64 = if i == 0 {
         -1
@@ -395,9 +394,9 @@ /// Packs [x_0: GLWE(m_0), x_1: GLWE(m_1), ..., x_i: GLWE(m_i)]
 /// to [0: GLWE(m_0 * X^x_0 + m_1 * X^x_1 + ... + m_i * X^x_i)]
 pub fn glwe_packing<D: DataMut, ATK, B: Backend>(
     module: &Module<B>,
-    cts: &mut HashMap<usize, &mut GLWECiphertext<D>>,
+    cts: &mut HashMap<usize, &mut GLWE<D>>,
     log_gap_out: usize,
-    auto_keys: &HashMap<i64, GGLWEAutomorphismKeyPrepared<ATK, B>>,
+    auto_keys: &HashMap<i64, AutomorphismKeyPrepared<ATK, B>>,
     scratch: &mut Scratch<B>,
 ) where
     ATK: DataRef,
@@ -414,7 +413,7 @@ + VecZnxAddInplace
         + VecZnxNegateInplace
         + VecZnxCopy
         + VecZnxSubInplace
-        + VecZnxDftAllocBytes
+        + VecZnxDftBytesOf
         + VmpApplyDftToDftTmpBytes
         + VecZnxBigNormalizeTmpBytes
         + VmpApplyDftToDft<B>
@@ -427,7 +426,7 @@ + VecZnxAutomorphismInplace<B>
         + VecZnxBigSubSmallNegateInplace<B>
         + VecZnxRotate
         + VecZnxNormalize<B>,
-    Scratch<B>: TakeVecZnx + TakeVecZnxDft<B> + ScratchAvailable,
+    Scratch<B>: ScratchAvailable,
 {
     #[cfg(debug_assertions)]
     {
@@ -439,15 +438,15 @@
     (0..log_n - log_gap_out).for_each(|i| {
         let t: usize = (1 << log_n).min(1 << (log_n - 1 - i));
 
-        let auto_key: &GGLWEAutomorphismKeyPrepared<ATK, B> = if i == 0 {
+        let auto_key: &AutomorphismKeyPrepared<ATK, B> = if i == 0 {
             auto_keys.get(&-1).unwrap()
         } else {
             auto_keys.get(&module.galois_element(1 << (i - 1))).unwrap()
         };
 
         (0..t).for_each(|j| {
-            let mut a: Option<&mut GLWECiphertext<D>> = cts.remove(&j);
-            let mut b: Option<&mut GLWECiphertext<D>> = cts.remove(&(j + t));
+            let mut a: Option<&mut GLWE<D>> = cts.remove(&j);
+            let mut b: Option<&mut GLWE<D>> = cts.remove(&(j + t));
 
             pack_internal(module, &mut a, &mut b, i, auto_key, scratch);
 
@@ -463,10 +462,10 @@
 #[allow(clippy::too_many_arguments)]
 fn pack_internal<A: DataMut, D: DataMut, DataAK: DataRef, B: Backend>(
     module: &Module<B>,
-    a: &mut Option<&mut GLWECiphertext<A>>,
-    b: &mut Option<&mut GLWECiphertext<D>>,
+    a: &mut Option<&mut GLWE<A>>,
+    b: &mut Option<&mut GLWE<D>>,
     i: usize,
-    auto_key: &GGLWEAutomorphismKeyPrepared<DataAK, B>,
+    auto_key: &AutomorphismKeyPrepared<DataAK, B>,
     scratch: &mut Scratch<B>,
 ) where
     Module<B>: VecZnxRotateInplace<B>
@@ -481,7 +480,7 @@ + VecZnxAddInplace
         + VecZnxNegateInplace
         + VecZnxCopy
         + VecZnxSubInplace
-        + VecZnxDftAllocBytes
+        + VecZnxDftBytesOf
         + VmpApplyDftToDftTmpBytes
         + VecZnxBigNormalizeTmpBytes
         + VmpApplyDftToDft<B>
@@ -494,7 +493,7 @@ + VecZnxAutomorphismInplace<B>
         + VecZnxBigSubSmallNegateInplace<B>
         + VecZnxRotate
         + VecZnxNormalize<B>,
-    Scratch<B>: TakeVecZnx + TakeVecZnxDft<B> + ScratchAvailable,
+    Scratch<B>: ScratchAvailable,
 {
     // Goal is to evaluate: a = a + b*X^t + phi(a - b*X^t))
     // We also use the identity: AUTO(a * X^t, g) = -X^t * AUTO(a, g)

@@ -2,22 +2,19 @@ use std::collections::HashMap;
 
 use poulpy_hal::{
     api::{
-        ScratchAvailable, TakeVecZnx, TakeVecZnxDft, VecZnxBigAddSmallInplace, VecZnxBigAutomorphismInplace, VecZnxBigNormalize,
-        VecZnxBigNormalizeTmpBytes, VecZnxCopy, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume, VecZnxNormalize,
-        VecZnxNormalizeTmpBytes, VecZnxRshInplace, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+        ScratchAvailable, VecZnxBigAddSmallInplace, VecZnxBigAutomorphismInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
+        VecZnxCopy, VecZnxDftApply, VecZnxDftBytesOf, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeTmpBytes,
+        VecZnxRshInplace, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
     },
     layouts::{Backend, DataMut, DataRef, Module, Scratch, VecZnx},
 };
 
 use crate::{
-    TakeGLWECt,
-    layouts::{
-        Base2K, GGLWEInfos, GLWECiphertext, GLWECiphertextLayout, GLWEInfos, LWEInfos, prepared::GGLWEAutomorphismKeyPrepared,
-    },
+    layouts::{Base2K, GGLWEInfos, GLWE, GLWEInfos, GLWELayout, LWEInfos, prepared::AutomorphismKeyPrepared},
     operations::GLWEOperations,
 };
 
-impl GLWECiphertext<Vec<u8>> {
+impl GLWE<Vec<u8>> {
     pub fn trace_galois_elements<B: Backend>(module: &Module<B>) -> Vec<i64> {
         let mut gal_els: Vec<i64> = Vec::new();
         (0..module.log_n()).for_each(|i| {
@@ -30,21 +27,16 @@ });
         gal_els
     }
 
-    pub fn trace_scratch_space<B: Backend, OUT, IN, KEY>(
-        module: &Module<B>,
-        out_infos: &OUT,
-        in_infos: &IN,
-        key_infos: &KEY,
-    ) -> usize
+    pub fn trace_tmp_bytes<B: Backend, OUT, IN, KEY>(module: &Module<B>, out_infos: &OUT, in_infos: &IN, key_infos: &KEY) -> usize
     where
         OUT: GLWEInfos,
         IN: GLWEInfos,
         KEY: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
+        Module<B>: VecZnxDftBytesOf + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
     {
-        let trace: usize = Self::automorphism_inplace_scratch_space(module, out_infos, key_infos);
+        let trace: usize = Self::automorphism_inplace_tmp_bytes(module, out_infos, key_infos);
         if in_infos.base2k() != key_infos.base2k() {
-            let glwe_conv: usize = VecZnx::alloc_bytes(
+            let glwe_conv: usize = VecZnx::bytes_of(
                 module.n(),
                 (key_infos.rank_out() + 1).into(),
                 out_infos.k().min(in_infos.k()).div_ceil(key_infos.base2k()) as usize,
@@ -55,27 +47,27 @@
         trace
     }
 
-    pub fn trace_inplace_scratch_space<B: Backend, OUT, KEY>(module: &Module<B>, out_infos: &OUT, key_infos: &KEY) -> usize
+    pub fn trace_inplace_tmp_bytes<B: Backend, OUT, KEY>(module: &Module<B>, out_infos: &OUT, key_infos: &KEY) -> usize
     where
         OUT: GLWEInfos,
         KEY: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
+        Module<B>: VecZnxDftBytesOf + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
     {
-        Self::trace_scratch_space(module, out_infos, out_infos, key_infos)
+        Self::trace_tmp_bytes(module, out_infos, out_infos, key_infos)
     }
 }
 
-impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
+impl<DataSelf: DataMut> GLWE<DataSelf> {
     pub fn trace<DataLhs: DataRef, DataAK: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
         start: usize,
         end: usize,
-        lhs: &GLWECiphertext<DataLhs>,
-        auto_keys: &HashMap<i64, GGLWEAutomorphismKeyPrepared<DataAK, B>>,
+        lhs: &GLWE<DataLhs>,
+        auto_keys: &HashMap<i64, AutomorphismKeyPrepared<DataAK, B>>,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxDftAllocBytes
+        Module<B>: VecZnxDftBytesOf
             + VmpApplyDftToDftTmpBytes
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
@@ -89,7 +81,7 @@ + VecZnxRshInplace<B>
             + VecZnxCopy
             + VecZnxNormalizeTmpBytes
             + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+        Scratch<B>: ScratchAvailable,
     {
         self.copy(module, lhs);
         self.trace_inplace(module, start, end, auto_keys, scratch);
@@ -100,10 +92,10 @@ &mut self,
         module: &Module<B>,
         start: usize,
         end: usize,
-        auto_keys: &HashMap<i64, GGLWEAutomorphismKeyPrepared<DataAK, B>>,
+        auto_keys: &HashMap<i64, AutomorphismKeyPrepared<DataAK, B>>,
         scratch: &mut Scratch<B>,
     ) where
-        Module<B>: VecZnxDftAllocBytes
+        Module<B>: VecZnxDftBytesOf
             + VmpApplyDftToDftTmpBytes
             + VecZnxBigNormalizeTmpBytes
             + VmpApplyDftToDft<B>
@@ -116,7 +108,7 @@ + VecZnxBigAutomorphismInplace<B>
             + VecZnxRshInplace<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+        Scratch<B>: ScratchAvailable,
     {
         let basek_ksk: Base2K = auto_keys
             .get(auto_keys.keys().next().unwrap())
@@ -137,7 +129,7 @@ }
         }
 
         if self.base2k() != basek_ksk {
-            let (mut self_conv, scratch_1) = scratch.take_glwe_ct(&GLWECiphertextLayout {
+            let (mut self_conv, scratch_1) = scratch.take_glwe_ct(&GLWELayout {
                 n: module.n().into(),
                 base2k: basek_ksk,
                 k: self.k(),

@@ -1,224 +1,205 @@
-use poulpy_hal::{
-    api::{
-        ScratchAvailable, TakeVecZnx, TakeVecZnxDft, VecZnxBigAddSmallInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
-        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeTmpBytes, VmpApplyDftToDft,
-        VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+use poulpy_hal::layouts::{Backend, DataMut, Module, Scratch};
+
+use crate::{
+    ScratchTakeCore,
+    keyswitching::glwe_ct::GLWEKeySwitch,
+    layouts::{
+        AutomorphismKey, AutomorphismKeyToRef, GGLWE, GGLWEInfos, GGLWEToMut, GGLWEToRef, GLWESwitchingKey,
+        GLWESwitchingKeyToRef,
+        prepared::{GLWESwitchingKeyPrepared, GLWESwitchingKeyPreparedToRef},
     },
-    layouts::{Backend, DataMut, DataRef, Module, Scratch, ZnxZero},
 };
 
-use crate::layouts::{
-    GGLWEAutomorphismKey, GGLWEInfos, GGLWESwitchingKey, GLWECiphertext, GLWEInfos,
-    prepared::{GGLWEAutomorphismKeyPrepared, GGLWESwitchingKeyPrepared},
-};
+impl AutomorphismKey<Vec<u8>> {
+    pub fn keyswitch_inplace_tmp_bytes<R, A, K, M, BE: Backend>(module: &M, res_infos: &R, a_infos: &A, key_infos: &K) -> usize
+    where
+        R: GGLWEInfos,
+        A: GGLWEInfos,
+        K: GGLWEInfos,
+        M: GGLWEKeySwitch<BE>,
+    {
+        module.glwe_keyswitch_tmp_bytes(res_infos, a_infos, key_infos)
+    }
+}
 
-impl GGLWEAutomorphismKey<Vec<u8>> {
-    pub fn keyswitch_scratch_space<B: Backend, OUT, IN, KEY>(
-        module: &Module<B>,
-        out_infos: &OUT,
-        in_infos: &IN,
-        key_infos: &KEY,
-    ) -> usize
+impl<DataSelf: DataMut> AutomorphismKey<DataSelf> {
+    pub fn keyswitch<A, B, M, BE: Backend>(&mut self, module: &M, a: &A, b: &B, scratch: &mut Scratch<BE>)
+    where
+        A: AutomorphismKeyToRef,
+        B: GLWESwitchingKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+        M: GGLWEKeySwitch<BE>,
+    {
+        module.gglwe_keyswitch(&mut self.key.key, &a.to_ref().key.key, b, scratch);
+    }
+
+    pub fn keyswitch_inplace<A, M, BE: Backend>(&mut self, module: &M, a: &A, scratch: &mut Scratch<BE>)
     where
-        OUT: GGLWEInfos,
-        IN: GGLWEInfos,
-        KEY: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
+        A: GLWESwitchingKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+        M: GGLWEKeySwitch<BE>,
     {
-        GGLWESwitchingKey::keyswitch_scratch_space(module, out_infos, in_infos, key_infos)
+        module.gglwe_keyswitch_inplace(&mut self.key.key, a, scratch);
     }
+}
 
-    pub fn keyswitch_inplace_scratch_space<B: Backend, OUT, KEY>(module: &Module<B>, out_infos: &OUT, key_infos: &KEY) -> usize
+impl GLWESwitchingKey<Vec<u8>> {
+    pub fn keyswitch_inplace_tmp_bytes<R, A, K, M, BE: Backend>(module: &M, res_infos: &R, a_infos: &A, key_infos: &K) -> usize
     where
-        OUT: GGLWEInfos,
-        KEY: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
+        R: GGLWEInfos,
+        A: GGLWEInfos,
+        K: GGLWEInfos,
+        M: GGLWEKeySwitch<BE>,
     {
-        GGLWESwitchingKey::keyswitch_inplace_scratch_space(module, out_infos, key_infos)
+        module.glwe_keyswitch_tmp_bytes(res_infos, a_infos, key_infos)
     }
 }
 
-impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
-    pub fn keyswitch<DataLhs: DataRef, DataRhs: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        lhs: &GGLWEAutomorphismKey<DataLhs>,
-        rhs: &GGLWESwitchingKeyPrepared<DataRhs, B>,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxBigNormalizeTmpBytes
-            + VmpApplyDftToDft<B>
-            + VmpApplyDftToDftAdd<B>
-            + VecZnxDftApply<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxBigAddSmallInplace<B>
-            + VecZnxBigNormalize<B>
-            + VecZnxNormalize<B>
-            + VecZnxNormalizeTmpBytes,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+impl<DataSelf: DataMut> GLWESwitchingKey<DataSelf> {
+    pub fn keyswitch<A, B, M, BE: Backend>(&mut self, module: &M, a: &A, b: &B, scratch: &mut Scratch<BE>)
+    where
+        A: GLWESwitchingKeyToRef,
+        B: GLWESwitchingKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+        M: GGLWEKeySwitch<BE>,
+    {
+        module.gglwe_keyswitch(&mut self.key, &a.to_ref().key, b, scratch);
+    }
+
+    pub fn keyswitch_inplace<A, M, BE: Backend>(&mut self, module: &M, a: &A, scratch: &mut Scratch<BE>)
+    where
+        A: GLWESwitchingKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+        M: GGLWEKeySwitch<BE>,
     {
-        self.key.keyswitch(module, &lhs.key, rhs, scratch);
+        module.gglwe_keyswitch_inplace(&mut self.key, a, scratch);
     }
+}
 
-    pub fn keyswitch_inplace<DataRhs: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        rhs: &GGLWEAutomorphismKeyPrepared<DataRhs, B>,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxBigNormalizeTmpBytes
-            + VmpApplyDftToDft<B>
-            + VmpApplyDftToDftAdd<B>
-            + VecZnxDftApply<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxBigAddSmallInplace<B>
-            + VecZnxBigNormalize<B>
-            + VecZnxNormalize<B>
-            + VecZnxNormalizeTmpBytes,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+impl GGLWE<Vec<u8>> {
+    pub fn keyswitch_inplace_tmp_bytes<R, A, K, M, BE: Backend>(module: &M, res_infos: &R, a_infos: &A, key_infos: &K) -> usize
+    where
+        R: GGLWEInfos,
+        A: GGLWEInfos,
+        K: GGLWEInfos,
+        M: GGLWEKeySwitch<BE>,
     {
-        self.key.keyswitch_inplace(module, &rhs.key, scratch);
+        module.glwe_keyswitch_tmp_bytes(res_infos, a_infos, key_infos)
     }
 }
 
-impl GGLWESwitchingKey<Vec<u8>> {
-    pub fn keyswitch_scratch_space<B: Backend, OUT, IN, KEY>(
-        module: &Module<B>,
-        out_infos: &OUT,
-        in_infos: &IN,
-        key_apply: &KEY,
-    ) -> usize
+impl<DataSelf: DataMut> GGLWE<DataSelf> {
+    pub fn keyswitch<A, B, M, BE: Backend>(&mut self, module: &M, a: &A, b: &B, scratch: &mut Scratch<BE>)
     where
-        OUT: GGLWEInfos,
-        IN: GGLWEInfos,
-        KEY: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
+        A: GGLWEToRef,
+        B: GLWESwitchingKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+        M: GGLWEKeySwitch<BE>,
     {
-        GLWECiphertext::keyswitch_scratch_space(module, out_infos, in_infos, key_apply)
+        module.gglwe_keyswitch(self, a, b, scratch);
     }
 
-    pub fn keyswitch_inplace_scratch_space<B: Backend, OUT, KEY>(module: &Module<B>, out_infos: &OUT, key_apply: &KEY) -> usize
+    pub fn keyswitch_inplace<A, M, BE: Backend>(&mut self, module: &M, a: &A, scratch: &mut Scratch<BE>)
     where
-        OUT: GGLWEInfos + GLWEInfos,
-        KEY: GGLWEInfos + GLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
+        A: GLWESwitchingKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+        M: GGLWEKeySwitch<BE>,
     {
-        GLWECiphertext::keyswitch_inplace_scratch_space(module, out_infos, key_apply)
+        module.gglwe_keyswitch_inplace(self, a, scratch);
     }
 }
 
-impl<DataSelf: DataMut> GGLWESwitchingKey<DataSelf> {
-    pub fn keyswitch<DataLhs: DataRef, DataRhs: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        lhs: &GGLWESwitchingKey<DataLhs>,
-        rhs: &GGLWESwitchingKeyPrepared<DataRhs, B>,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxBigNormalizeTmpBytes
-            + VmpApplyDftToDft<B>
-            + VmpApplyDftToDftAdd<B>
-            + VecZnxDftApply<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxBigAddSmallInplace<B>
-            + VecZnxBigNormalize<B>
-            + VecZnxNormalize<B>
-            + VecZnxNormalizeTmpBytes,
-        Scratch<B>: ScratchAvailable + TakeVecZnxDft<B> + TakeVecZnx,
+impl<BE: Backend> GGLWEKeySwitch<BE> for Module<BE> where Self: GLWEKeySwitch<BE> {}
+
+pub trait GGLWEKeySwitch<BE: Backend>
+where
+    Self: GLWEKeySwitch<BE>,
+{
+    fn gglwe_keyswitch_tmp_bytes<R, A, K>(&self, res_infos: &R, a_infos: &A, key_infos: &K) -> usize
+    where
+        R: GGLWEInfos,
+        A: GGLWEInfos,
+        K: GGLWEInfos,
     {
-        #[cfg(debug_assertions)]
-        {
-            assert_eq!(
-                self.rank_in(),
-                lhs.rank_in(),
-                "ksk_out input rank: {} != ksk_in input rank: {}",
-                self.rank_in(),
-                lhs.rank_in()
-            );
-            assert_eq!(
-                lhs.rank_out(),
-                rhs.rank_in(),
-                "ksk_in output rank: {} != ksk_apply input rank: {}",
-                self.rank_out(),
-                rhs.rank_in()
-            );
-            assert_eq!(
-                self.rank_out(),
-                rhs.rank_out(),
-                "ksk_out output rank: {} != ksk_apply output rank: {}",
-                self.rank_out(),
-                rhs.rank_out()
-            );
-            assert!(
-                self.dnum() <= lhs.dnum(),
-                "self.dnum()={} > lhs.dnum()={}",
-                self.dnum(),
-                lhs.dnum()
-            );
-            assert_eq!(
-                self.dsize(),
-                lhs.dsize(),
-                "ksk_out dsize: {} != ksk_in dsize: {}",
-                self.dsize(),
-                lhs.dsize()
-            )
-        }
+        self.glwe_keyswitch_tmp_bytes(res_infos, a_infos, key_infos)
+    }
 
-        (0..self.rank_in().into()).for_each(|col_i| {
-            (0..self.dnum().into()).for_each(|row_j| {
-                self.at_mut(row_j, col_i)
-                    .keyswitch(module, &lhs.at(row_j, col_i), rhs, scratch);
-            });
-        });
+    fn gglwe_keyswitch<R, A, B>(&self, res: &mut R, a: &A, b: &B, scratch: &mut Scratch<BE>)
+    where
+        R: GGLWEToMut,
+        A: GGLWEToRef,
+        B: GLWESwitchingKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        let res: &mut GGLWE<&mut [u8]> = &mut res.to_mut();
+        let a: &GGLWE<&[u8]> = &a.to_ref();
+        let b: &GLWESwitchingKeyPrepared<&[u8], BE> = &b.to_ref();
 
-        (self.dnum().min(lhs.dnum()).into()..self.dnum().into()).for_each(|row_i| {
-            (0..self.rank_in().into()).for_each(|col_j| {
-                self.at_mut(row_i, col_j).data.zero();
-            });
-        });
+        assert_eq!(
+            res.rank_in(),
+            a.rank_in(),
+            "res input rank: {} != a input rank: {}",
+            res.rank_in(),
+            a.rank_in()
+        );
+        assert_eq!(
+            a.rank_out(),
+            b.rank_in(),
+            "res output rank: {} != b input rank: {}",
+            a.rank_out(),
+            b.rank_in()
+        );
+        assert_eq!(
+            res.rank_out(),
+            b.rank_out(),
+            "res output rank: {} != b output rank: {}",
+            res.rank_out(),
+            b.rank_out()
+        );
+        assert!(
+            res.dnum() <= a.dnum(),
+            "res.dnum()={} > a.dnum()={}",
+            res.dnum(),
+            a.dnum()
+        );
+        assert_eq!(
+            res.dsize(),
+            a.dsize(),
+            "res dsize: {} != a dsize: {}",
+            res.dsize(),
+            a.dsize()
+        );
+
+        for row in 0..res.dnum().into() {
+            for col in 0..res.rank_in().into() {
+                self.glwe_keyswitch(&mut res.at_mut(row, col), &a.at(row, col), b, scratch);
+            }
+        }
     }
 
-    pub fn keyswitch_inplace<DataRhs: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        rhs: &GGLWESwitchingKeyPrepared<DataRhs, B>,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxBigNormalizeTmpBytes
-            + VmpApplyDftToDft<B>
-            + VmpApplyDftToDftAdd<B>
-            + VecZnxDftApply<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxBigAddSmallInplace<B>
-            + VecZnxBigNormalize<B>
-            + VecZnxNormalize<B>
-            + VecZnxNormalizeTmpBytes,
-        Scratch<B>: ScratchAvailable + TakeVecZnxDft<B> + TakeVecZnx,
+    fn gglwe_keyswitch_inplace<R, A>(&self, res: &mut R, a: &A, scratch: &mut Scratch<BE>)
+    where
+        R: GGLWEToMut,
+        A: GLWESwitchingKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        #[cfg(debug_assertions)]
-        {
-            assert_eq!(
-                self.rank_out(),
-                rhs.rank_out(),
-                "ksk_out output rank: {} != ksk_apply output rank: {}",
-                self.rank_out(),
-                rhs.rank_out()
-            );
-        }
+        let res: &mut GGLWE<&mut [u8]> = &mut res.to_mut();
+        let a: &GLWESwitchingKeyPrepared<&[u8], BE> = &a.to_ref();
 
-        (0..self.rank_in().into()).for_each(|col_i| {
-            (0..self.dnum().into()).for_each(|row_j| {
-                self.at_mut(row_j, col_i)
-                    .keyswitch_inplace(module, rhs, scratch)
-            });
-        });
+        assert_eq!(
+            res.rank_out(),
+            a.rank_out(),
+            "res output rank: {} != a output rank: {}",
+            res.rank_out(),
+            a.rank_out()
+        );
+
+        for row in 0..res.dnum().into() {
+            for col in 0..res.rank_in().into() {
+                self.glwe_keyswitch_inplace(&mut res.at_mut(row, col), a, scratch);
+            }
+        }
     }
 }
+
+impl<DataSelf: DataMut> GLWESwitchingKey<DataSelf> {}

@@ -1,366 +1,131 @@
-use poulpy_hal::{
-    api::{
-        ScratchAvailable, TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft, VecZnxBigAddSmallInplace, VecZnxBigAllocBytes,
-        VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxCopy, VecZnxDftAddInplace, VecZnxDftAllocBytes, VecZnxDftApply,
-        VecZnxDftCopy, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA, VecZnxNormalize, VecZnxNormalizeTmpBytes, VmpApplyDftToDft,
-        VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
-    },
-    layouts::{Backend, DataMut, DataRef, Module, Scratch, VecZnx, VmpPMat, ZnxInfos},
-};
+use poulpy_hal::layouts::{Backend, DataMut, Scratch, VecZnx};
 
 use crate::{
+    GGSWExpandRows, ScratchTakeCore,
+    keyswitching::glwe_ct::GLWEKeySwitch,
     layouts::{
-        GGLWECiphertext, GGLWEInfos, GGSWCiphertext, GGSWInfos, GLWECiphertext, GLWEInfos, LWEInfos,
-        prepared::{GGLWESwitchingKeyPrepared, GGLWETensorKeyPrepared},
+        GGLWEInfos, GGSW, GGSWInfos, GGSWToMut, GGSWToRef,
+        prepared::{GLWESwitchingKeyPreparedToRef, TensorKeyPreparedToRef},
     },
-    operations::GLWEOperations,
 };
 
-impl GGSWCiphertext<Vec<u8>> {
-    pub(crate) fn expand_row_scratch_space<B: Backend, OUT, TSK>(module: &Module<B>, out_infos: &OUT, tsk_infos: &TSK) -> usize
+impl GGSW<Vec<u8>> {
+    pub fn keyswitch_tmp_bytes<R, A, K, T, M, BE: Backend>(
+        module: &M,
+        res_infos: &R,
+        a_infos: &A,
+        key_infos: &K,
+        tsk_infos: &T,
+    ) -> usize
     where
-        OUT: GGSWInfos,
-        TSK: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigAllocBytes + VecZnxNormalizeTmpBytes,
+        R: GGSWInfos,
+        A: GGSWInfos,
+        K: GGLWEInfos,
+        T: GGLWEInfos,
+        M: GGSWKeySwitch<BE>,
     {
-        let tsk_size: usize = tsk_infos.k().div_ceil(tsk_infos.base2k()) as usize;
-        let size_in: usize = out_infos
-            .k()
-            .div_ceil(tsk_infos.base2k())
-            .div_ceil(tsk_infos.dsize().into()) as usize;
+        module.ggsw_keyswitch_tmp_bytes(res_infos, a_infos, key_infos, tsk_infos)
+    }
+}
 
-        let tmp_dft_i: usize = module.vec_znx_dft_alloc_bytes((tsk_infos.rank_out() + 1).into(), tsk_size);
-        let tmp_a: usize = module.vec_znx_dft_alloc_bytes(1, size_in);
-        let vmp: usize = module.vmp_apply_dft_to_dft_tmp_bytes(
-            tsk_size,
-            size_in,
-            size_in,
-            (tsk_infos.rank_in()).into(),  // Verify if rank+1
-            (tsk_infos.rank_out()).into(), // Verify if rank+1
-            tsk_size,
-        );
-        let tmp_idft: usize = module.vec_znx_big_alloc_bytes(1, tsk_size);
-        let norm: usize = module.vec_znx_normalize_tmp_bytes();
+impl<D: DataMut> GGSW<D> {
+    pub fn keyswitch<M, A, K, T, BE: Backend>(&mut self, module: &M, a: &A, key: &K, tsk: &T, scratch: &mut Scratch<BE>)
+    where
+        A: GGSWToRef,
+        K: GLWESwitchingKeyPreparedToRef<BE>,
+        T: TensorKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+        M: GGSWKeySwitch<BE>,
+    {
+        module.ggsw_keyswitch(self, a, key, tsk, scratch);
+    }
 
-        tmp_dft_i + ((tmp_a + vmp) | (tmp_idft + norm))
+    pub fn keyswitch_inplace<M, K, T, BE: Backend>(&mut self, module: &M, key: &K, tsk: &T, scratch: &mut Scratch<BE>)
+    where
+        K: GLWESwitchingKeyPreparedToRef<BE>,
+        T: TensorKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+        M: GGSWKeySwitch<BE>,
+    {
+        module.ggsw_keyswitch_inplace(self, key, tsk, scratch);
     }
+}
 
-    #[allow(clippy::too_many_arguments)]
-    pub fn keyswitch_scratch_space<B: Backend, OUT, IN, KEY, TSK>(
-        module: &Module<B>,
-        out_infos: &OUT,
-        in_infos: &IN,
-        apply_infos: &KEY,
-        tsk_infos: &TSK,
-    ) -> usize
+pub trait GGSWKeySwitch<BE: Backend>
+where
+    Self: GLWEKeySwitch<BE> + GGSWExpandRows<BE>,
+{
+    fn ggsw_keyswitch_tmp_bytes<R, A, K, T>(&self, res_infos: &R, a_infos: &A, key_infos: &K, tsk_infos: &T) -> usize
     where
-        OUT: GGSWInfos,
-        IN: GGSWInfos,
-        KEY: GGLWEInfos,
-        TSK: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxBigAllocBytes
-            + VecZnxNormalizeTmpBytes
-            + VecZnxBigNormalizeTmpBytes,
+        R: GGSWInfos,
+        A: GGSWInfos,
+        K: GGLWEInfos,
+        T: GGLWEInfos,
     {
-        #[cfg(debug_assertions)]
-        {
-            assert_eq!(apply_infos.rank_in(), apply_infos.rank_out());
-            assert_eq!(tsk_infos.rank_in(), tsk_infos.rank_out());
-            assert_eq!(apply_infos.rank_in(), tsk_infos.rank_in());
-        }
+        assert_eq!(key_infos.rank_in(), key_infos.rank_out());
+        assert_eq!(tsk_infos.rank_in(), tsk_infos.rank_out());
+        assert_eq!(key_infos.rank_in(), tsk_infos.rank_in());
 
-        let rank: usize = apply_infos.rank_out().into();
+        let rank: usize = key_infos.rank_out().into();
 
-        let size_out: usize = out_infos.k().div_ceil(out_infos.base2k()) as usize;
-        let res_znx: usize = VecZnx::alloc_bytes(module.n(), rank + 1, size_out);
-        let ci_dft: usize = module.vec_znx_dft_alloc_bytes(rank + 1, size_out);
-        let ks: usize = GLWECiphertext::keyswitch_scratch_space(module, out_infos, in_infos, apply_infos);
-        let expand_rows: usize = GGSWCiphertext::expand_row_scratch_space(module, out_infos, tsk_infos);
-        let res_dft: usize = module.vec_znx_dft_alloc_bytes(rank + 1, size_out);
+        let size_out: usize = res_infos.k().div_ceil(res_infos.base2k()) as usize;
+        let res_znx: usize = VecZnx::bytes_of(self.n(), rank + 1, size_out);
+        let ci_dft: usize = self.bytes_of_vec_znx_dft(rank + 1, size_out);
+        let ks: usize = self.glwe_keyswitch_tmp_bytes(res_infos, a_infos, key_infos);
+        let expand_rows: usize = self.ggsw_expand_rows_tmp_bytes(res_infos, tsk_infos);
+        let res_dft: usize = self.bytes_of_vec_znx_dft(rank + 1, size_out);
 
-        if in_infos.base2k() == tsk_infos.base2k() {
+        if a_infos.base2k() == tsk_infos.base2k() {
             res_znx + ci_dft + (ks | expand_rows | res_dft)
         } else {
-            let a_conv: usize = VecZnx::alloc_bytes(
-                module.n(),
+            let a_conv: usize = VecZnx::bytes_of(
+                self.n(),
                 1,
-                out_infos.k().div_ceil(tsk_infos.base2k()) as usize,
-            ) + module.vec_znx_normalize_tmp_bytes();
+                res_infos.k().div_ceil(tsk_infos.base2k()) as usize,
+            ) + self.vec_znx_normalize_tmp_bytes();
             res_znx + ci_dft + (a_conv | ks | expand_rows | res_dft)
         }
     }
 
-    #[allow(clippy::too_many_arguments)]
-    pub fn keyswitch_inplace_scratch_space<B: Backend, OUT, KEY, TSK>(
-        module: &Module<B>,
-        out_infos: &OUT,
-        apply_infos: &KEY,
-        tsk_infos: &TSK,
-    ) -> usize
+    fn ggsw_keyswitch<R, A, K, T>(&self, res: &mut R, a: &A, key: &K, tsk: &T, scratch: &mut Scratch<BE>)
     where
-        OUT: GGSWInfos,
-        KEY: GGLWEInfos,
-        TSK: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxBigAllocBytes
-            + VecZnxNormalizeTmpBytes
-            + VecZnxBigNormalizeTmpBytes,
+        R: GGSWToMut,
+        A: GGSWToRef,
+        K: GLWESwitchingKeyPreparedToRef<BE>,
+        T: TensorKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        GGSWCiphertext::keyswitch_scratch_space(module, out_infos, out_infos, apply_infos, tsk_infos)
-    }
-}
+        let res: &mut GGSW<&mut [u8]> = &mut res.to_mut();
+        let a: &GGSW<&[u8]> = &a.to_ref();
 
-impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
-    pub fn from_gglwe<DataA, DataTsk, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        a: &GGLWECiphertext<DataA>,
-        tsk: &GGLWETensorKeyPrepared<DataTsk, B>,
-        scratch: &mut Scratch<B>,
-    ) where
-        DataA: DataRef,
-        DataTsk: DataRef,
-        Module<B>: VecZnxCopy
-            + VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxBigAllocBytes
-            + VecZnxNormalizeTmpBytes
-            + VecZnxDftApply<B>
-            + VecZnxDftCopy<B>
-            + VmpApplyDftToDft<B>
-            + VmpApplyDftToDftAdd<B>
-            + VecZnxDftAddInplace<B>
-            + VecZnxBigNormalize<B>
-            + VecZnxIdftApplyTmpA<B>
-            + VecZnxNormalize<B>,
-        Scratch<B>: ScratchAvailable + TakeVecZnxDft<B> + TakeVecZnxBig<B> + TakeVecZnx,
-    {
-        #[cfg(debug_assertions)]
-        {
-            use crate::layouts::{GLWEInfos, LWEInfos};
+        assert_eq!(res.ggsw_layout(), a.ggsw_layout());
 
-            assert_eq!(self.rank(), a.rank_out());
-            assert_eq!(self.dnum(), a.dnum());
-            assert_eq!(self.n(), module.n() as u32);
-            assert_eq!(a.n(), module.n() as u32);
-            assert_eq!(tsk.n(), module.n() as u32);
+        for row in 0..a.dnum().into() {
+            // Key-switch column 0, i.e.
+            // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0, a1, a2) -> (-(a0s0' + a1s1' + a2s2') + M[i], a0, a1, a2)
+            self.glwe_keyswitch(&mut res.at_mut(row, 0), &a.at(row, 0), key, scratch);
         }
-        (0..self.dnum().into()).for_each(|row_i| {
-            self.at_mut(row_i, 0).copy(module, &a.at(row_i, 0));
-        });
-        self.expand_row(module, tsk, scratch);
+
+        self.ggsw_expand_row(res, tsk, scratch);
     }
 
-    pub fn keyswitch<DataLhs: DataRef, DataKsk: DataRef, DataTsk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        lhs: &GGSWCiphertext<DataLhs>,
-        ksk: &GGLWESwitchingKeyPrepared<DataKsk, B>,
-        tsk: &GGLWETensorKeyPrepared<DataTsk, B>,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxBigNormalizeTmpBytes
-            + VmpApplyDftToDft<B>
-            + VmpApplyDftToDftAdd<B>
-            + VecZnxDftApply<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxBigAddSmallInplace<B>
-            + VecZnxBigNormalize<B>
-            + VecZnxDftAllocBytes
-            + VecZnxBigAllocBytes
-            + VecZnxNormalizeTmpBytes
-            + VecZnxDftCopy<B>
-            + VecZnxDftAddInplace<B>
-            + VecZnxIdftApplyTmpA<B>
-            + VecZnxNormalize<B>,
-        Scratch<B>: ScratchAvailable + TakeVecZnxDft<B> + TakeVecZnxBig<B> + TakeVecZnx,
+    fn ggsw_keyswitch_inplace<R, K, T>(&self, res: &mut R, key: &K, tsk: &T, scratch: &mut Scratch<BE>)
+    where
+        R: GGSWToMut,
+        K: GLWESwitchingKeyPreparedToRef<BE>,
+        T: TensorKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        (0..lhs.dnum().into()).for_each(|row_i| {
-            // Key-switch column 0, i.e.
-            // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0, a1, a2) -> (-(a0s0' + a1s1' + a2s2') + M[i], a0, a1, a2)
-            self.at_mut(row_i, 0)
-                .keyswitch(module, &lhs.at(row_i, 0), ksk, scratch);
-        });
-        self.expand_row(module, tsk, scratch);
-    }
+        let res: &mut GGSW<&mut [u8]> = &mut res.to_mut();
 
-    pub fn keyswitch_inplace<DataKsk: DataRef, DataTsk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        ksk: &GGLWESwitchingKeyPrepared<DataKsk, B>,
-        tsk: &GGLWETensorKeyPrepared<DataTsk, B>,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxBigNormalizeTmpBytes
-            + VmpApplyDftToDft<B>
-            + VmpApplyDftToDftAdd<B>
-            + VecZnxDftApply<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxBigAddSmallInplace<B>
-            + VecZnxBigNormalize<B>
-            + VecZnxDftAllocBytes
-            + VecZnxBigAllocBytes
-            + VecZnxNormalizeTmpBytes
-            + VecZnxDftCopy<B>
-            + VecZnxDftAddInplace<B>
-            + VecZnxIdftApplyTmpA<B>
-            + VecZnxNormalize<B>,
-        Scratch<B>: ScratchAvailable + TakeVecZnxDft<B> + TakeVecZnxBig<B> + TakeVecZnx,
-    {
-        (0..self.dnum().into()).for_each(|row_i| {
+        for row in 0..res.dnum().into() {
             // Key-switch column 0, i.e.
             // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0, a1, a2) -> (-(a0s0' + a1s1' + a2s2') + M[i], a0, a1, a2)
-            self.at_mut(row_i, 0)
-                .keyswitch_inplace(module, ksk, scratch);
-        });
-        self.expand_row(module, tsk, scratch);
-    }
-
-    pub fn expand_row<DataTsk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        tsk: &GGLWETensorKeyPrepared<DataTsk, B>,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxBigAllocBytes
-            + VecZnxNormalizeTmpBytes
-            + VecZnxDftApply<B>
-            + VecZnxDftCopy<B>
-            + VmpApplyDftToDft<B>
-            + VmpApplyDftToDftAdd<B>
-            + VecZnxDftAddInplace<B>
-            + VecZnxBigNormalize<B>
-            + VecZnxIdftApplyTmpA<B>
-            + VecZnxNormalize<B>,
-        Scratch<B>: ScratchAvailable + TakeVecZnxDft<B> + TakeVecZnxBig<B> + TakeVecZnx,
-    {
-        let basek_in: usize = self.base2k().into();
-        let basek_tsk: usize = tsk.base2k().into();
-
-        assert!(scratch.available() >= GGSWCiphertext::expand_row_scratch_space(module, self, tsk));
-
-        let n: usize = self.n().into();
-        let rank: usize = self.rank().into();
-        let cols: usize = rank + 1;
-
-        let a_size: usize = (self.size() * basek_in).div_ceil(basek_tsk);
-
-        // Keyswitch the j-th row of the col 0
-        for row_i in 0..self.dnum().into() {
-            let a = &self.at(row_i, 0).data;
-
-            // Pre-compute DFT of (a0, a1, a2)
-            let (mut ci_dft, scratch_1) = scratch.take_vec_znx_dft(n, cols, a_size);
-
-            if basek_in == basek_tsk {
-                for i in 0..cols {
-                    module.vec_znx_dft_apply(1, 0, &mut ci_dft, i, a, i);
-                }
-            } else {
-                let (mut a_conv, scratch_2) = scratch_1.take_vec_znx(n, 1, a_size);
-                for i in 0..cols {
-                    module.vec_znx_normalize(basek_tsk, &mut a_conv, 0, basek_in, a, i, scratch_2);
-                    module.vec_znx_dft_apply(1, 0, &mut ci_dft, i, &a_conv, 0);
-                }
-            }
+            self.glwe_keyswitch_inplace(&mut res.at_mut(row, 0), key, scratch);
+        }
 
-            for col_j in 1..cols {
-                // Example for rank 3:
-                //
-                // Note: M is a vector (m, Bm, B^2m, B^3m, ...), so each column is
-                // actually composed of that many dnum and we focus on a specific row here
-                // implicitely given ci_dft.
-                //
-                // # Input
-                //
-                // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0    , a1    , a2    )
-                // col 1: (0, 0, 0, 0)
-                // col 2: (0, 0, 0, 0)
-                // col 3: (0, 0, 0, 0)
-                //
-                // # Output
-                //
-                // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0       , a1       , a2       )
-                // col 1: (-(b0s0 + b1s1 + b2s2)       , b0 + M[i], b1       , b2       )
-                // col 2: (-(c0s0 + c1s1 + c2s2)       , c0       , c1 + M[i], c2       )
-                // col 3: (-(d0s0 + d1s1 + d2s2)       , d0       , d1       , d2 + M[i])
-
-                let dsize: usize = tsk.dsize().into();
-
-                let (mut tmp_dft_i, scratch_2) = scratch_1.take_vec_znx_dft(n, cols, tsk.size());
-                let (mut tmp_a, scratch_3) = scratch_2.take_vec_znx_dft(n, 1, ci_dft.size().div_ceil(dsize));
-
-                {
-                    // Performs a key-switch for each combination of s[i]*s[j], i.e. for a0, a1, a2
-                    //
-                    // # Example for col=1
-                    //
-                    // a0 * (-(f0s0 + f1s1 + f1s2) + s0^2, f0, f1, f2) = (-(a0f0s0 + a0f1s1 + a0f1s2) + a0s0^2, a0f0, a0f1, a0f2)
-                    // +
-                    // a1 * (-(g0s0 + g1s1 + g1s2) + s0s1, g0, g1, g2) = (-(a1g0s0 + a1g1s1 + a1g1s2) + a1s0s1, a1g0, a1g1, a1g2)
-                    // +
-                    // a2 * (-(h0s0 + h1s1 + h1s2) + s0s2, h0, h1, h2) = (-(a2h0s0 + a2h1s1 + a2h1s2) + a2s0s2, a2h0, a2h1, a2h2)
-                    // =
-                    // (-(x0s0 + x1s1 + x2s2) + s0(a0s0 + a1s1 + a2s2), x0, x1, x2)
-                    for col_i in 1..cols {
-                        let pmat: &VmpPMat<DataTsk, B> = &tsk.at(col_i - 1, col_j - 1).key.data; // Selects Enc(s[i]s[j])
-
-                        // Extracts a[i] and multipies with Enc(s[i]s[j])
-                        for di in 0..dsize {
-                            tmp_a.set_size((ci_dft.size() + di) / dsize);
-
-                            // Small optimization for dsize > 2
-                            // VMP produce some error e, and since we aggregate vmp * 2^{di * B}, then
-                            // we also aggregate ei * 2^{di * B}, with the largest error being ei * 2^{(dsize-1) * B}.
-                            // As such we can ignore the last dsize-2 limbs safely of the sum of vmp products.
-                            // It is possible to further ignore the last dsize-1 limbs, but this introduce
-                            // ~0.5 to 1 bit of additional noise, and thus not chosen here to ensure that the same
-                            // noise is kept with respect to the ideal functionality.
-                            tmp_dft_i.set_size(tsk.size() - ((dsize - di) as isize - 2).max(0) as usize);
-
-                            module.vec_znx_dft_copy(dsize, dsize - 1 - di, &mut tmp_a, 0, &ci_dft, col_i);
-                            if di == 0 && col_i == 1 {
-                                module.vmp_apply_dft_to_dft(&mut tmp_dft_i, &tmp_a, pmat, scratch_3);
-                            } else {
-                                module.vmp_apply_dft_to_dft_add(&mut tmp_dft_i, &tmp_a, pmat, di, scratch_3);
-                            }
-                        }
-                    }
-                }
-
-                // Adds -(sum a[i] * s[i]) + m)  on the i-th column of tmp_idft_i
-                //
-                // (-(x0s0 + x1s1 + x2s2) + a0s0s0 + a1s0s1 + a2s0s2, x0, x1, x2)
-                // +
-                // (0, -(a0s0 + a1s1 + a2s2) + M[i], 0, 0)
-                // =
-                // (-(x0s0 + x1s1 + x2s2) + s0(a0s0 + a1s1 + a2s2), x0 -(a0s0 + a1s1 + a2s2) + M[i], x1, x2)
-                // =
-                // (-(x0s0 + x1s1 + x2s2), x0 + M[i], x1, x2)
-                module.vec_znx_dft_add_inplace(&mut tmp_dft_i, col_j, &ci_dft, 0);
-                let (mut tmp_idft, scratch_3) = scratch_2.take_vec_znx_big(n, 1, tsk.size());
-                for i in 0..cols {
-                    module.vec_znx_idft_apply_tmpa(&mut tmp_idft, 0, &mut tmp_dft_i, i);
-                    module.vec_znx_big_normalize(
-                        basek_in,
-                        &mut self.at_mut(row_i, col_j).data,
-                        i,
-                        basek_tsk,
-                        &tmp_idft,
-                        0,
-                        scratch_3,
-                    );
-                }
-            }
-        }
+        self.ggsw_expand_row(res, tsk, scratch);
     }
 }
+
+impl<DataSelf: DataMut> GGSW<DataSelf> {}