@@ -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, Degree, Dnum, Dsize, GGSW, GGSWLayout, GLWE, GLWELayout, GLWESecret, Rank, TorusPrecision,
+    prepared::{GGSWPrepared, GLWESecretPrepared},
 };
 use std::hint::black_box;
 
@@ -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,38 +47,40 @@ 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());
+
+        let mut sk_dft: GLWESecretPrepared<Vec<u8>, FFT64Spqlios> = GLWESecretPrepared::alloc(&module, rank);
+        sk_dft.prepare(&module, &sk);
 
         ct_ggsw.encrypt_sk(
             &module,
@@ -98,7 +99,8 @@ &mut source_xe,
             scratch.borrow(),
         );
 
-        let ggsw_prepared: GGSWCiphertextPrepared<Vec<u8>, FFT64Spqlios> = ct_ggsw.prepare_alloc(&module, scratch.borrow());
+        let mut ggsw_prepared: GGSWPrepared<Vec<u8>, FFT64Spqlios> = GGSWPrepared::alloc_from_infos(&module, &ct_ggsw);
+        ggsw_prepared.prepare(&module, &ct_ggsw, scratch.borrow());
 
         move || {
             ct_glwe_out.external_product(&module, &ct_glwe_in, &ggsw_prepared, scratch.borrow());
@@ -147,7 +149,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,30 +158,32 @@ 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_tmp_bytes(&module, &glwe_layout, &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());
+
+        let mut sk_dft: GLWESecretPrepared<Vec<u8>, FFT64Spqlios> = GLWESecretPrepared::alloc(&module, rank);
+        sk_dft.prepare(&module, &sk);
 
         ct_ggsw.encrypt_sk(
             &module,
@@ -198,8 +202,8 @@ &mut source_xe,
             scratch.borrow(),
         );
 
-        let ggsw_prepared: GGSWCiphertextPrepared<Vec<u8>, FFT64Spqlios> = ct_ggsw.prepare_alloc(&module, scratch.borrow());
-
+        let mut ggsw_prepared: GGSWPrepared<Vec<u8>, FFT64Spqlios> = GGSWPrepared::alloc_from_infos(&module, &ct_ggsw);
+        ggsw_prepared.prepare(&module, &ct_ggsw, scratch.borrow());
         move || {
             let scratch_borrow = scratch.borrow();
             ct_glwe.external_product_inplace(&module, &ggsw_prepared, 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},
+    Base2K, Degree, Dnum, Dsize, GLWE, GLWEAutomorphismKey, GLWEAutomorphismKeyLayout, GLWELayout, GLWESecret, GLWESwitchingKey,
+    GLWESwitchingKeyLayout, GLWESwitchingKeyPrepared, Rank, TorusPrecision,
+    prepared::{GLWEAutomorphismKeyPrepared, GLWESecretPrepared},
 };
 use std::{hint::black_box, time::Duration};
 
@@ -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: GLWEAutomorphismKeyLayout = GLWEAutomorphismKeyLayout {
             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: GLWEAutomorphismKey<Vec<u8>> = GLWEAutomorphismKey::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,9 +81,11 @@ 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());
+
+        let mut sk_in_dft: GLWESecretPrepared<Vec<u8>, FFT64Spqlios> = GLWESecretPrepared::alloc(&module, rank);
+        sk_in_dft.prepare(&module, &sk_in);
 
         ksk.encrypt_sk(
             &module,
@@ -102,7 +104,9 @@ &mut source_xe,
             scratch.borrow(),
         );
 
-        let ksk_prepared: GGLWEAutomorphismKeyPrepared<Vec<u8>, _> = ksk.prepare_alloc(&module, scratch.borrow());
+        let mut ksk_prepared: GLWEAutomorphismKeyPrepared<Vec<u8>, _> =
+            GLWEAutomorphismKeyPrepared::alloc_from_infos(&module, &ksk);
+        ksk_prepared.prepare(&module, &ksk, scratch.borrow());
 
         move || {
             ct_out.automorphism(&module, &ct_in, &ksk_prepared, scratch.borrow());
@@ -157,7 +161,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 +171,33 @@ 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_tmp_bytes(&module, &glwe_layout, &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_in_dft: GLWESecretPrepared<Vec<u8>, FFT64Spqlios> = GLWESecretPrepared::alloc(&module, rank);
+        sk_in_dft.prepare(&module, &sk_in);
 
-        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 +217,8 @@ &mut source_xe,
             scratch.borrow(),
         );
 
-        let ksk_prepared: GGLWESwitchingKeyPrepared<Vec<u8>, FFT64Spqlios> = ksk.prepare_alloc(&module, scratch.borrow());
+        let mut ksk_prepared: GLWESwitchingKeyPrepared<Vec<u8>, _> = GLWESwitchingKeyPrepared::alloc_from_infos(&module, &ksk);
+        ksk_prepared.prepare(&module, &ksk, scratch.borrow());
 
         move || {
             ct.keyswitch_inplace(&module, &ksk_prepared, scratch.borrow());

@@ -1,10 +1,9 @@
 use poulpy_backend::cpu_spqlios::FFT64Spqlios;
 use poulpy_core::{
-    GLWEOperations, SIGMA,
+    GLWESub, SIGMA,
     layouts::{
-        Base2K, Degree, GLWECiphertext, GLWECiphertextLayout, GLWEPlaintext, GLWEPlaintextLayout, GLWESecret, LWEInfos, Rank,
-        TorusPrecision,
-        prepared::{GLWESecretPrepared, PrepareAlloc},
+        Base2K, Degree, GLWE, GLWELayout, GLWEPlaintext, GLWEPlaintextLayout, GLWESecret, LWEInfos, Rank, TorusPrecision,
+        prepared::GLWESecretPrepared,
     },
 };
 use poulpy_hal::{
@@ -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,16 +54,16 @@ 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
-    let sk_prepared: GLWESecretPrepared<Vec<u8>, FFT64Spqlios> = sk.prepare_alloc(&module, scratch.borrow());
+    let mut sk_prepared: GLWESecretPrepared<Vec<u8>, FFT64Spqlios> = GLWESecretPrepared::alloc(&module, rank);
+    sk_prepared.prepare(&module, &sk);
 
     // Uniform plaintext
     module.vec_znx_fill_uniform(base2k.into(), &mut pt_want.data, 0, &mut source_xa);
@@ -83,7 +82,7 @@ // Decryption
     ct.decrypt(&module, &mut pt_have, &sk_prepared, scratch.borrow());
 
     // Diff between pt - Dec(Enc(pt))
-    pt_want.sub_inplace_ab(&module, &pt_have);
+    module.glwe_sub_inplace(&mut pt_want, &pt_have);
 
     // Ideal vs. actual noise
     let noise_have: f64 = pt_want.data.std(base2k.into(), 0) * (ct.k().as_u32() as f64).exp2();

@@ -1,198 +1,165 @@
 use poulpy_hal::{
-    api::{
-        ScratchAvailable, TakeVecZnx, TakeVecZnxDft, VecZnxAutomorphism, VecZnxAutomorphismInplace, VecZnxBigAddSmallInplace,
-        VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume,
-        VecZnxNormalize, VecZnxNormalizeTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+    api::VecZnxAutomorphism,
+    layouts::{Backend, DataMut, GaloisElement, Module, Scratch},
+};
+
+use crate::{
+    ScratchTakeCore,
+    automorphism::glwe_ct::GLWEAutomorphism,
+    layouts::{
+        GGLWE, GGLWEInfos, GGLWEPreparedToRef, GGLWEToMut, GGLWEToRef, GLWE, GLWEAutomorphismKey, GetGaloisElement,
+        SetGaloisElement,
     },
-    layouts::{Backend, DataMut, DataRef, Module, Scratch, ZnxZero},
 };
 
-use crate::layouts::{GGLWEAutomorphismKey, GGLWEInfos, GLWECiphertext, prepared::GGLWEAutomorphismKeyPrepared};
+impl GLWEAutomorphismKey<Vec<u8>> {
+    pub fn automorphism_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: GLWEAutomorphismKeyAutomorphism<BE>,
+    {
+        module.glwe_automorphism_key_automorphism_tmp_bytes(res_infos, a_infos, key_infos)
+    }
+}
 
-impl GGLWEAutomorphismKey<Vec<u8>> {
-    pub fn automorphism_scratch_space<B: Backend, OUT, IN, KEY>(
-        module: &Module<B>,
-        out_infos: &OUT,
-        in_infos: &IN,
-        key_infos: &KEY,
-    ) -> usize
+impl<DataSelf: DataMut> GLWEAutomorphismKey<DataSelf> {
+    pub fn automorphism<A, K, M, BE: Backend>(&mut self, module: &M, a: &A, key: &K, scratch: &mut Scratch<BE>)
     where
-        OUT: GGLWEInfos,
-        IN: GGLWEInfos,
-        KEY: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
+        A: GGLWEToRef + GetGaloisElement + GGLWEInfos,
+        K: GGLWEPreparedToRef<BE> + GetGaloisElement + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
+        M: GLWEAutomorphismKeyAutomorphism<BE>,
     {
-        GLWECiphertext::keyswitch_scratch_space(
-            module,
-            &out_infos.glwe_layout(),
-            &in_infos.glwe_layout(),
-            key_infos,
-        )
+        module.glwe_automorphism_key_automorphism(self, a, key, scratch);
     }
 
-    pub fn automorphism_inplace_scratch_space<B: Backend, OUT, KEY>(module: &Module<B>, out_infos: &OUT, key_infos: &KEY) -> usize
+    pub fn automorphism_inplace<K, M, BE: Backend>(&mut self, module: &M, key: &K, scratch: &mut Scratch<BE>)
     where
-        OUT: GGLWEInfos,
-        KEY: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
+        K: GGLWEPreparedToRef<BE> + GetGaloisElement + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
+        M: GLWEAutomorphismKeyAutomorphism<BE>,
     {
-        GGLWEAutomorphismKey::automorphism_scratch_space(module, out_infos, out_infos, key_infos)
+        module.glwe_automorphism_key_automorphism_inplace(self, key, scratch);
     }
 }
 
-impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
-    pub fn automorphism<DataLhs: DataRef, DataRhs: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        lhs: &GGLWEAutomorphismKey<DataLhs>,
-        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>
-            + VecZnxAutomorphism
-            + VecZnxAutomorphismInplace<B>
-            + VecZnxNormalize<B>
-            + VecZnxNormalizeTmpBytes,
-        Scratch<B>: ScratchAvailable + TakeVecZnxDft<B> + TakeVecZnx,
+impl<BE: Backend> GLWEAutomorphismKeyAutomorphism<BE> for Module<BE> where
+    Self: GaloisElement + GLWEAutomorphism<BE> + VecZnxAutomorphism
+{
+}
+
+pub trait GLWEAutomorphismKeyAutomorphism<BE: Backend>
+where
+    Self: GaloisElement + GLWEAutomorphism<BE> + VecZnxAutomorphism,
+{
+    fn glwe_automorphism_key_automorphism_tmp_bytes<R, A, K>(&self, res_infos: &R, a_infos: &A, key_infos: &K) -> usize
+    where
+        R: GGLWEInfos,
+        A: GGLWEInfos,
+        K: GGLWEInfos,
+    {
+        self.glwe_keyswitch_tmp_bytes(res_infos, a_infos, key_infos)
+    }
+
+    fn glwe_automorphism_key_automorphism<R, A, K>(&self, res: &mut R, a: &A, key: &K, scratch: &mut Scratch<BE>)
+    where
+        R: GGLWEToMut + SetGaloisElement + GGLWEInfos,
+        A: GGLWEToRef + GetGaloisElement + GGLWEInfos,
+        K: GGLWEPreparedToRef<BE> + GetGaloisElement + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        #[cfg(debug_assertions)]
-        {
-            use crate::layouts::LWEInfos;
+        assert!(
+            res.dnum().as_u32() <= a.dnum().as_u32(),
+            "res dnum: {} > a dnum: {}",
+            res.dnum(),
+            a.dnum()
+        );
 
-            assert_eq!(
-                self.rank_in(),
-                lhs.rank_in(),
-                "ksk_out input rank: {} != ksk_in input rank: {}",
-                self.rank_in(),
-                lhs.rank_in()
-            );
-            assert_eq!(
-                self.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.k() <= lhs.k(),
-                "output k={} cannot be greater than input k={}",
-                self.k(),
-                lhs.k()
-            )
-        }
+        assert_eq!(
+            res.dsize(),
+            a.dsize(),
+            "res dnum: {} != a dnum: {}",
+            res.dsize(),
+            a.dsize()
+        );
 
-        let cols_out: usize = (rhs.rank_out() + 1).into();
+        let cols_out: usize = (key.rank_out() + 1).into();
+        let cols_in: usize = key.rank_in().into();
 
-        let p: i64 = lhs.p();
-        let p_inv: i64 = module.galois_element_inv(p);
+        let p: i64 = a.p();
+        let p_inv: i64 = self.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 res: &mut GGLWE<&mut [u8]> = &mut res.to_mut();
+            let a: &GGLWE<&[u8]> = &a.to_ref();
 
-                // Reverts the automorphism X^{-k}: (-pi^{-1}_{k}(s)a + s, a) to (-sa + pi_{k}(s), a)
-                (0..cols_out).for_each(|i| {
-                    module.vec_znx_automorphism(lhs.p(), &mut res_ct.data, i, &lhs_ct.data, i);
-                });
+            for row in 0..res.dnum().as_usize() {
+                for col in 0..cols_in {
+                    let mut res_tmp: GLWE<&mut [u8]> = res.at_mut(row, col);
+                    let a_ct: GLWE<&[u8]> = a.at(row, col);
 
-                // Key-switch (-sa + pi_{k}(s), a) to (-pi^{-1}_{k'}(s)a + pi_{k}(s), a)
-                res_ct.keyswitch_inplace(module, &rhs.key, scratch);
+                    // Reverts the automorphism X^{-k}: (-pi^{-1}_{k}(s)a + s, a) to (-sa + pi_{k}(s), a)
+                    for i in 0..cols_out {
+                        self.vec_znx_automorphism(p, res_tmp.data_mut(), i, &a_ct.data, i);
+                    }
 
-                // Applies back the automorphism X^{-k}: (-pi^{-1}_{k'}(s)a + pi_{k}(s), a) to (-pi^{-1}_{k'+k}(s)a + s, a)
-                (0..cols_out).for_each(|i| {
-                    module.vec_znx_automorphism_inplace(p_inv, &mut res_ct.data, i, scratch);
-                });
-            });
-        });
+                    // Key-switch (-sa + pi_{k}(s), a) to (-pi^{-1}_{k'}(s)a + pi_{k}(s), a)
+                    self.glwe_keyswitch_inplace(&mut res_tmp, key, scratch);
 
-        (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();
-            });
-        });
+                    // Applies back the automorphism X^{-k}: (-pi^{-1}_{k'}(s)a + pi_{k}(s), a) to (-pi^{-1}_{k'+k}(s)a + s, a)
+                    (0..cols_out).for_each(|i| {
+                        self.vec_znx_automorphism_inplace(p_inv, res_tmp.data_mut(), i, scratch);
+                    });
+                }
+            }
+        }
 
-        self.p = (lhs.p * rhs.p) % (module.cyclotomic_order() as i64);
+        res.set_p((p * key.p()) % self.cyclotomic_order());
     }
 
-    pub fn automorphism_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>
-            + VecZnxAutomorphism
-            + VecZnxAutomorphismInplace<B>
-            + VecZnxNormalize<B>
-            + VecZnxNormalizeTmpBytes,
-        Scratch<B>: ScratchAvailable + TakeVecZnxDft<B> + TakeVecZnx,
+    fn glwe_automorphism_key_automorphism_inplace<R, K>(&self, res: &mut R, key: &K, scratch: &mut Scratch<BE>)
+    where
+        R: GGLWEToMut + SetGaloisElement + GetGaloisElement + GGLWEInfos,
+        K: GGLWEPreparedToRef<BE> + GetGaloisElement + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        #[cfg(debug_assertions)]
-        {
-            assert_eq!(
-                self.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_eq!(
+            res.rank(),
+            key.rank(),
+            "key rank: {} != key rank: {}",
+            res.rank(),
+            key.rank()
+        );
 
-        let cols_out: usize = (rhs.rank_out() + 1).into();
+        let cols_out: usize = (key.rank_out() + 1).into();
+        let cols_in: usize = key.rank_in().into();
+        let p: i64 = res.p();
+        let p_inv: i64 = self.galois_element_inv(p);
 
-        let p: i64 = self.p();
-        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 res: &mut GGLWE<&mut [u8]> = &mut res.to_mut();
+            for row in 0..res.dnum().as_usize() {
+                for col in 0..cols_in {
+                    let mut res_tmp: GLWE<&mut [u8]> = res.at_mut(row, col);
 
-                // Reverts the automorphism X^{-k}: (-pi^{-1}_{k}(s)a + s, a) to (-sa + pi_{k}(s), a)
-                (0..cols_out).for_each(|i| {
-                    module.vec_znx_automorphism_inplace(p_inv, &mut res_ct.data, i, scratch);
-                });
+                    // Reverts the automorphism X^{-k}: (-pi^{-1}_{k}(s)a + s, a) to (-sa + pi_{k}(s), a)
+                    for i in 0..cols_out {
+                        self.vec_znx_automorphism_inplace(p, res_tmp.data_mut(), i, scratch);
+                    }
 
-                // Key-switch (-sa + pi_{k}(s), a) to (-pi^{-1}_{k'}(s)a + pi_{k}(s), a)
-                res_ct.keyswitch_inplace(module, &rhs.key, scratch);
+                    // Key-switch (-sa + pi_{k}(s), a) to (-pi^{-1}_{k'}(s)a + pi_{k}(s), a)
+                    self.glwe_keyswitch_inplace(&mut res_tmp, key, scratch);
 
-                // Applies back the automorphism X^{-k}: (-pi^{-1}_{k'}(s)a + pi_{k}(s), a) to (-pi^{-1}_{k'+k}(s)a + s, a)
-                (0..cols_out).for_each(|i| {
-                    module.vec_znx_automorphism_inplace(p_inv, &mut res_ct.data, i, scratch);
-                });
-            });
-        });
+                    // Applies back the automorphism X^{-k}: (-pi^{-1}_{k'}(s)a + pi_{k}(s), a) to (-pi^{-1}_{k'+k}(s)a + s, a)
+                    for i in 0..cols_out {
+                        self.vec_znx_automorphism_inplace(p_inv, res_tmp.data_mut(), i, scratch);
+                    }
+                }
+            }
+        }
 
-        self.p = (self.p * rhs.p) % (module.cyclotomic_order() as i64);
+        res.set_p((res.p() * key.p()) % self.cyclotomic_order());
     }
 }

@@ -1,171 +1,124 @@
 use poulpy_hal::{
-    api::{
-        ScratchAvailable, TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft, VecZnxAutomorphismInplace, VecZnxBigAddSmallInplace,
-        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxDftAddInplace, VecZnxDftAllocBytes,
-        VecZnxDftApply, VecZnxDftCopy, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA, VecZnxNormalize, VecZnxNormalizeTmpBytes,
-        VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
-    },
-    layouts::{Backend, DataMut, DataRef, Module, Scratch},
+    api::ScratchAvailable,
+    layouts::{Backend, DataMut, Module, Scratch},
 };
 
-use crate::layouts::{
-    GGLWEInfos, GGSWCiphertext, GGSWInfos, GLWECiphertext,
-    prepared::{GGLWEAutomorphismKeyPrepared, GGLWETensorKeyPrepared},
+use crate::{
+    GGSWExpandRows, ScratchTakeCore,
+    automorphism::glwe_ct::GLWEAutomorphism,
+    layouts::{
+        GGLWEInfos, GGLWEPreparedToRef, GGSW, GGSWInfos, GGSWToMut, GGSWToRef, GetGaloisElement,
+        prepared::{GLWETensorKeyPrepared, GLWETensorKeyPreparedToRef},
+    },
 };
 
-impl GGSWCiphertext<Vec<u8>> {
-    pub fn automorphism_scratch_space<B: Backend, OUT, IN, KEY, TSK>(
-        module: &Module<B>,
-        out_infos: &OUT,
-        in_infos: &IN,
-        key_infos: &KEY,
-        tsk_infos: &TSK,
+impl GGSW<Vec<u8>> {
+    pub fn automorphism_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,
-        IN: GGSWInfos,
-        KEY: GGLWEInfos,
-        TSK: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxBigAllocBytes
-            + VecZnxNormalizeTmpBytes
-            + VecZnxBigNormalizeTmpBytes,
+        R: GGSWInfos,
+        A: GGSWInfos,
+        K: GGLWEInfos,
+        T: GGLWEInfos,
+        M: GGSWAutomorphism<BE>,
     {
-        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(
-            module,
-            &out_infos.glwe_layout(),
-            &in_infos.glwe_layout(),
-            key_infos,
-        );
-        let expand: usize = GGSWCiphertext::expand_row_scratch_space(module, out_infos, tsk_infos);
-        ci_dft + (ks_internal | expand)
+        module.ggsw_automorphism_tmp_bytes(res_infos, a_infos, key_infos, tsk_infos)
     }
+}
 
-    pub fn automorphism_inplace_scratch_space<B: Backend, OUT, KEY, TSK>(
-        module: &Module<B>,
-        out_infos: &OUT,
-        key_infos: &KEY,
-        tsk_infos: &TSK,
-    ) -> usize
+impl<D: DataMut> GGSW<D> {
+    pub fn automorphism<A, K, T, M, BE: Backend>(&mut self, module: &M, a: &A, key: &K, tsk: &T, scratch: &mut Scratch<BE>)
     where
-        OUT: GGSWInfos,
-        KEY: GGLWEInfos,
-        TSK: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxBigAllocBytes
-            + VecZnxNormalizeTmpBytes
-            + VecZnxBigNormalizeTmpBytes,
+        A: GGSWToRef,
+        K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos,
+        T: GLWETensorKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+        M: GGSWAutomorphism<BE>,
+    {
+        module.ggsw_automorphism(self, a, key, tsk, scratch);
+    }
+
+    pub fn automorphism_inplace<K, T, M, BE: Backend>(&mut self, module: &M, key: &K, tsk: &T, scratch: &mut Scratch<BE>)
+    where
+        K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos,
+        T: GLWETensorKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+        M: GGSWAutomorphism<BE>,
     {
-        GGSWCiphertext::automorphism_scratch_space(module, out_infos, out_infos, key_infos, tsk_infos)
+        module.ggsw_automorphism_inplace(self, key, tsk, scratch);
     }
 }
 
-impl<DataSelf: DataMut> GGSWCiphertext<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>,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxBigNormalizeTmpBytes
-            + VmpApplyDftToDft<B>
-            + VmpApplyDftToDftAdd<B>
-            + VecZnxDftApply<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxBigAddSmallInplace<B>
-            + VecZnxBigNormalize<B>
-            + VecZnxAutomorphismInplace<B>
-            + VecZnxBigAllocBytes
-            + VecZnxNormalizeTmpBytes
-            + VecZnxDftCopy<B>
-            + VecZnxDftAddInplace<B>
-            + VecZnxIdftApplyTmpA<B>
-            + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnxBig<B> + TakeVecZnx,
+impl<BE: Backend> GGSWAutomorphism<BE> for Module<BE> where Self: GLWEAutomorphism<BE> + GGSWExpandRows<BE> {}
+
+pub trait GGSWAutomorphism<BE: Backend>
+where
+    Self: GLWEAutomorphism<BE> + GGSWExpandRows<BE>,
+{
+    fn ggsw_automorphism_tmp_bytes<R, A, K, T>(&self, res_infos: &R, a_infos: &A, key_infos: &K, tsk_infos: &T) -> usize
+    where
+        R: GGSWInfos,
+        A: GGSWInfos,
+        K: GGLWEInfos,
+        T: GGLWEInfos,
     {
-        #[cfg(debug_assertions)]
-        {
-            use crate::layouts::{GLWEInfos, LWEInfos};
+        let out_size: usize = res_infos.size();
+        let ci_dft: usize = self.bytes_of_vec_znx_dft((key_infos.rank_out() + 1).into(), out_size);
+        let ks_internal: usize = self.glwe_automorphism_tmp_bytes(res_infos, a_infos, key_infos);
+        let expand: usize = self.ggsw_expand_rows_tmp_bytes(res_infos, tsk_infos);
+        ci_dft + (ks_internal.max(expand))
+    }
 
-            assert_eq!(self.n(), module.n() as u32);
-            assert_eq!(lhs.n(), module.n() as u32);
-            assert_eq!(auto_key.n(), module.n() as u32);
-            assert_eq!(tensor_key.n(), module.n() as u32);
+    fn ggsw_automorphism<R, A, K, T>(&self, res: &mut R, a: &A, key: &K, tsk: &T, scratch: &mut Scratch<BE>)
+    where
+        R: GGSWToMut,
+        A: GGSWToRef,
+        K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos,
+        T: GLWETensorKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        let res: &mut GGSW<&mut [u8]> = &mut res.to_mut();
+        let a: &GGSW<&[u8]> = &a.to_ref();
+        let tsk: &GLWETensorKeyPrepared<&[u8], BE> = &tsk.to_ref();
 
-            assert_eq!(
-                self.rank(),
-                lhs.rank(),
-                "ggsw_out rank: {} != ggsw_in rank: {}",
-                self.rank(),
-                lhs.rank()
-            );
-            assert_eq!(
-                self.rank(),
-                auto_key.rank_out(),
-                "ggsw_in rank: {} != auto_key rank: {}",
-                self.rank(),
-                auto_key.rank_out()
-            );
-            assert_eq!(
-                self.rank(),
-                tensor_key.rank_out(),
-                "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_eq!(res.dsize(), a.dsize());
+        assert!(res.dnum() <= a.dnum());
+        assert!(scratch.available() >= self.ggsw_automorphism_tmp_bytes(res, a, key, tsk));
 
         // Keyswitch the j-th row of the col 0
-        (0..lhs.dnum().into()).for_each(|row_i| {
+        for row in 0..res.dnum().as_usize() {
             // Key-switch column 0, i.e.
             // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0, a1, a2) -> (-(a0pi^-1(s0) + a1pi^-1(s1) + a2pi^-1(s2)) + M[i], a0, a1, a2)
-            self.at_mut(row_i, 0)
-                .automorphism(module, &lhs.at(row_i, 0), auto_key, scratch);
-        });
-        self.expand_row(module, tensor_key, scratch);
+            self.glwe_automorphism(&mut res.at_mut(row, 0), &a.at(row, 0), key, scratch);
+        }
+
+        self.ggsw_expand_row(res, tsk, scratch);
     }
 
-    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>,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: VecZnxDftAllocBytes
-            + VmpApplyDftToDftTmpBytes
-            + VecZnxBigNormalizeTmpBytes
-            + VmpApplyDftToDft<B>
-            + VmpApplyDftToDftAdd<B>
-            + VecZnxDftApply<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxBigAddSmallInplace<B>
-            + VecZnxBigNormalize<B>
-            + VecZnxAutomorphismInplace<B>
-            + VecZnxBigAllocBytes
-            + VecZnxNormalizeTmpBytes
-            + VecZnxDftCopy<B>
-            + VecZnxDftAddInplace<B>
-            + VecZnxIdftApplyTmpA<B>
-            + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnxBig<B> + TakeVecZnx,
+    fn ggsw_automorphism_inplace<R, K, T>(&self, res: &mut R, key: &K, tsk: &T, scratch: &mut Scratch<BE>)
+    where
+        R: GGSWToMut,
+        K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos,
+        T: GLWETensorKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
+        let res: &mut GGSW<&mut [u8]> = &mut res.to_mut();
+        let tsk: &GLWETensorKeyPrepared<&[u8], BE> = &tsk.to_ref();
+
         // Keyswitch the j-th row of the col 0
-        (0..self.dnum().into()).for_each(|row_i| {
+        for row in 0..res.dnum().as_usize() {
             // Key-switch column 0, i.e.
             // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0, a1, a2) -> (-(a0pi^-1(s0) + a1pi^-1(s1) + a2pi^-1(s2)) + M[i], a0, a1, a2)
-            self.at_mut(row_i, 0)
-                .automorphism_inplace(module, auto_key, scratch);
-        });
-        self.expand_row(module, tensor_key, scratch);
+            self.glwe_automorphism_inplace(&mut res.at_mut(row, 0), key, scratch);
+        }
+
+        self.ggsw_expand_row(res, tsk, scratch);
     }
 }
+
+impl<DataSelf: DataMut> GGSW<DataSelf> {}

@@ -1,345 +1,322 @@
 use poulpy_hal::{
     api::{
-        ScratchAvailable, TakeVecZnx, TakeVecZnxDft, VecZnxAutomorphismInplace, VecZnxBigAddSmallInplace,
-        VecZnxBigAutomorphismInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxBigSubSmallInplace,
-        VecZnxBigSubSmallNegateInplace, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume, VecZnxNormalize,
-        VecZnxNormalizeTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+        ScratchTakeBasic, VecZnxAutomorphismInplace, VecZnxBigAutomorphismInplace, VecZnxBigSubSmallInplace,
+        VecZnxBigSubSmallNegateInplace,
     },
-    layouts::{Backend, DataMut, DataRef, Module, Scratch, VecZnxBig},
+    layouts::{Backend, DataMut, Module, Scratch, VecZnxBig},
 };
 
-use crate::layouts::{GGLWEInfos, GLWECiphertext, GLWEInfos, LWEInfos, prepared::GGLWEAutomorphismKeyPrepared};
+use crate::{
+    GLWEKeyswitch, ScratchTakeCore, keyswitch_internal,
+    layouts::{GGLWEInfos, GGLWEPreparedToRef, GLWE, GLWEInfos, GLWEToMut, GLWEToRef, GetGaloisElement, LWEInfos},
+};
 
-impl GLWECiphertext<Vec<u8>> {
-    pub fn automorphism_scratch_space<B: Backend, OUT, IN, KEY>(
-        module: &Module<B>,
-        out_infos: &OUT,
-        in_infos: &IN,
-        key_infos: &KEY,
-    ) -> usize
+impl GLWE<Vec<u8>> {
+    pub fn automorphism_tmp_bytes<M, R, A, K, BE: Backend>(module: &M, res_infos: &R, a_infos: &A, key_infos: &K) -> usize
     where
-        OUT: GLWEInfos,
-        IN: GLWEInfos,
-        KEY: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
+        R: GLWEInfos,
+        A: GLWEInfos,
+        K: GGLWEInfos,
+        M: GLWEAutomorphism<BE>,
     {
-        Self::keyswitch_scratch_space(module, out_infos, in_infos, key_infos)
+        module.glwe_automorphism_tmp_bytes(res_infos, a_infos, key_infos)
     }
+}
 
-    pub fn automorphism_inplace_scratch_space<B: Backend, OUT, KEY>(module: &Module<B>, out_infos: &OUT, key_infos: &KEY) -> usize
+impl<DataSelf: DataMut> GLWE<DataSelf> {
+    pub fn automorphism<M, A, K, BE: Backend>(&mut self, module: &M, a: &A, key: &K, scratch: &mut Scratch<BE>)
+    where
+        M: GLWEAutomorphism<BE>,
+        A: GLWEToRef,
+        K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        module.glwe_automorphism(self, a, key, scratch);
+    }
+
+    pub fn automorphism_add<M, A, K, BE: Backend>(&mut self, module: &M, a: &A, key: &K, scratch: &mut Scratch<BE>)
+    where
+        M: GLWEAutomorphism<BE>,
+        A: GLWEToRef,
+        K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        module.glwe_automorphism_add(self, a, key, scratch);
+    }
+
+    pub fn automorphism_sub<M, A, K, BE: Backend>(&mut self, module: &M, a: &A, key: &K, scratch: &mut Scratch<BE>)
     where
-        OUT: GLWEInfos,
-        KEY: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
+        M: GLWEAutomorphism<BE>,
+        A: GLWEToRef,
+        K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        Self::keyswitch_inplace_scratch_space(module, out_infos, key_infos)
+        module.glwe_automorphism_sub(self, a, key, scratch);
+    }
+
+    pub fn automorphism_sub_negate<M, A, K, BE: Backend>(&mut self, module: &M, a: &A, key: &K, scratch: &mut Scratch<BE>)
+    where
+        M: GLWEAutomorphism<BE>,
+        A: GLWEToRef,
+        K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        module.glwe_automorphism_sub_negate(self, a, key, scratch);
+    }
+
+    pub fn automorphism_inplace<M, K, BE: Backend>(&mut self, module: &M, key: &K, scratch: &mut Scratch<BE>)
+    where
+        M: GLWEAutomorphism<BE>,
+        K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        module.glwe_automorphism_inplace(self, key, scratch);
+    }
+
+    pub fn automorphism_add_inplace<M, K, BE: Backend>(&mut self, module: &M, key: &K, scratch: &mut Scratch<BE>)
+    where
+        M: GLWEAutomorphism<BE>,
+        K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        module.glwe_automorphism_add_inplace(self, key, scratch);
+    }
+
+    pub fn automorphism_sub_inplace<M, K, BE: Backend>(&mut self, module: &M, key: &K, scratch: &mut Scratch<BE>)
+    where
+        M: GLWEAutomorphism<BE>,
+        K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        module.glwe_automorphism_sub_inplace(self, key, scratch);
+    }
+
+    pub fn automorphism_sub_negate_inplace<M, K, BE: Backend>(&mut self, module: &M, key: &K, scratch: &mut Scratch<BE>)
+    where
+        M: GLWEAutomorphism<BE>,
+        K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        module.glwe_automorphism_sub_negate_inplace(self, key, scratch);
     }
 }
 
-impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
-    pub fn automorphism<DataLhs: DataRef, DataRhs: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        lhs: &GLWECiphertext<DataLhs>,
-        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>
-            + VecZnxAutomorphismInplace<B>
-            + VecZnxNormalize<B>
-            + VecZnxNormalizeTmpBytes,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+pub trait GLWEAutomorphism<BE: Backend>
+where
+    Self: GLWEKeyswitch<BE>
+        + VecZnxAutomorphismInplace<BE>
+        + VecZnxBigAutomorphismInplace<BE>
+        + VecZnxBigSubSmallInplace<BE>
+        + VecZnxBigSubSmallNegateInplace<BE>,
+{
+    fn glwe_automorphism_tmp_bytes<R, A, K>(&self, res_infos: &R, a_infos: &A, key_infos: &K) -> usize
+    where
+        R: GLWEInfos,
+        A: GLWEInfos,
+        K: GGLWEInfos,
     {
-        self.keyswitch(module, lhs, &rhs.key, scratch);
-        (0..(self.rank() + 1).into()).for_each(|i| {
-            module.vec_znx_automorphism_inplace(rhs.p(), &mut self.data, i, scratch);
-        })
+        self.glwe_keyswitch_tmp_bytes(res_infos, a_infos, key_infos)
     }
 
-    pub fn automorphism_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>
-            + VecZnxAutomorphismInplace<B>
-            + VecZnxNormalize<B>
-            + VecZnxNormalizeTmpBytes,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+    fn glwe_automorphism<R, A, K>(&self, res: &mut R, a: &A, key: &K, scratch: &mut Scratch<BE>)
+    where
+        R: GLWEToMut,
+        A: GLWEToRef,
+        K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        self.keyswitch_inplace(module, &rhs.key, scratch);
-        (0..(self.rank() + 1).into()).for_each(|i| {
-            module.vec_znx_automorphism_inplace(rhs.p(), &mut self.data, i, scratch);
-        })
+        self.glwe_keyswitch(res, a, key, scratch);
+
+        let res: &mut GLWE<&mut [u8]> = &mut res.to_mut();
+
+        for i in 0..res.rank().as_usize() + 1 {
+            self.vec_znx_automorphism_inplace(key.p(), res.data_mut(), i, scratch);
+        }
     }
 
-    pub fn automorphism_add<DataLhs: DataRef, DataRhs: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        lhs: &GLWECiphertext<DataLhs>,
-        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>
-            + VecZnxBigAutomorphismInplace<B>
-            + VecZnxNormalizeTmpBytes
-            + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+    fn glwe_automorphism_inplace<R, K>(&self, res: &mut R, key: &K, scratch: &mut Scratch<BE>)
+    where
+        R: GLWEToMut,
+        K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        #[cfg(debug_assertions)]
-        {
-            self.assert_keyswitch(module, lhs, &rhs.key, scratch);
+        self.glwe_keyswitch_inplace(res, key, scratch);
+
+        let res: &mut GLWE<&mut [u8]> = &mut res.to_mut();
+
+        for i in 0..res.rank().as_usize() + 1 {
+            self.vec_znx_automorphism_inplace(key.p(), res.data_mut(), i, scratch);
         }
-        let (res_dft, scratch_1) = scratch.take_vec_znx_dft(self.n().into(), (self.rank() + 1).into(), rhs.size()); // TODO: optimise size
-        let mut res_big: VecZnxBig<_, B> = lhs.keyswitch_internal(module, res_dft, &rhs.key, scratch_1);
-        (0..(self.rank() + 1).into()).for_each(|i| {
-            module.vec_znx_big_automorphism_inplace(rhs.p(), &mut res_big, i, scratch_1);
-            module.vec_znx_big_add_small_inplace(&mut res_big, i, &lhs.data, i);
-            module.vec_znx_big_normalize(
-                self.base2k().into(),
-                &mut self.data,
+    }
+
+    fn glwe_automorphism_add<R, A, K>(&self, res: &mut R, a: &A, key: &K, scratch: &mut Scratch<BE>)
+    where
+        R: GLWEToMut,
+        A: GLWEToRef,
+        K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        let res: &mut GLWE<&mut [u8]> = &mut res.to_mut();
+        let a: &GLWE<&[u8]> = &a.to_ref();
+
+        let (res_dft, scratch_1) = scratch.take_vec_znx_dft(self, (res.rank() + 1).into(), key.size()); // TODO: optimise size
+        let mut res_big: VecZnxBig<_, BE> = keyswitch_internal(self, res_dft, a, key, scratch_1);
+
+        for i in 0..res.rank().as_usize() + 1 {
+            self.vec_znx_big_automorphism_inplace(key.p(), &mut res_big, i, scratch_1);
+            self.vec_znx_big_add_small_inplace(&mut res_big, i, a.data(), i);
+            self.vec_znx_big_normalize(
+                res.base2k().into(),
+                res.data_mut(),
                 i,
-                rhs.base2k().into(),
+                key.base2k().into(),
                 &res_big,
                 i,
                 scratch_1,
             );
-        })
+        }
     }
 
-    pub fn automorphism_add_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>
-            + VecZnxBigAutomorphismInplace<B>
-            + VecZnxNormalizeTmpBytes
-            + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+    fn glwe_automorphism_add_inplace<R, K>(&self, res: &mut R, key: &K, scratch: &mut Scratch<BE>)
+    where
+        R: GLWEToMut,
+        K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        #[cfg(debug_assertions)]
-        {
-            self.assert_keyswitch_inplace(module, &rhs.key, scratch);
-        }
-        let (res_dft, scratch_1) = scratch.take_vec_znx_dft(self.n().into(), (self.rank() + 1).into(), rhs.size()); // TODO: optimise size
-        let mut res_big: VecZnxBig<_, B> = self.keyswitch_internal(module, res_dft, &rhs.key, scratch_1);
-        (0..(self.rank() + 1).into()).for_each(|i| {
-            module.vec_znx_big_automorphism_inplace(rhs.p(), &mut res_big, i, scratch_1);
-            module.vec_znx_big_add_small_inplace(&mut res_big, i, &self.data, i);
-            module.vec_znx_big_normalize(
-                self.base2k().into(),
-                &mut self.data,
+        let res: &mut GLWE<&mut [u8]> = &mut res.to_mut();
+
+        let (res_dft, scratch_1) = scratch.take_vec_znx_dft(self, (res.rank() + 1).into(), key.size()); // TODO: optimise size
+        let mut res_big: VecZnxBig<_, BE> = keyswitch_internal(self, res_dft, res, key, scratch_1);
+
+        for i in 0..res.rank().as_usize() + 1 {
+            self.vec_znx_big_automorphism_inplace(key.p(), &mut res_big, i, scratch_1);
+            self.vec_znx_big_add_small_inplace(&mut res_big, i, res.data(), i);
+            self.vec_znx_big_normalize(
+                res.base2k().into(),
+                res.data_mut(),
                 i,
-                rhs.base2k().into(),
+                key.base2k().into(),
                 &res_big,
                 i,
                 scratch_1,
             );
-        })
+        }
     }
 
-    pub fn automorphism_sub_ab<DataLhs: DataRef, DataRhs: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        lhs: &GLWECiphertext<DataLhs>,
-        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>
-            + VecZnxBigAutomorphismInplace<B>
-            + VecZnxBigSubSmallInplace<B>
-            + VecZnxNormalizeTmpBytes
-            + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+    fn glwe_automorphism_sub<R, A, K>(&self, res: &mut R, a: &A, key: &K, scratch: &mut Scratch<BE>)
+    where
+        R: GLWEToMut,
+        A: GLWEToRef,
+        K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        #[cfg(debug_assertions)]
-        {
-            self.assert_keyswitch(module, lhs, &rhs.key, scratch);
-        }
-        let (res_dft, scratch_1) = scratch.take_vec_znx_dft(self.n().into(), (self.rank() + 1).into(), rhs.size()); // TODO: optimise size
-        let mut res_big: VecZnxBig<_, B> = lhs.keyswitch_internal(module, res_dft, &rhs.key, scratch_1);
-        (0..(self.rank() + 1).into()).for_each(|i| {
-            module.vec_znx_big_automorphism_inplace(rhs.p(), &mut res_big, i, scratch_1);
-            module.vec_znx_big_sub_small_inplace(&mut res_big, i, &lhs.data, i);
-            module.vec_znx_big_normalize(
-                self.base2k().into(),
-                &mut self.data,
+        let res: &mut GLWE<&mut [u8]> = &mut res.to_mut();
+        let a: &GLWE<&[u8]> = &a.to_ref();
+
+        let (res_dft, scratch_1) = scratch.take_vec_znx_dft(self, (res.rank() + 1).into(), key.size()); // TODO: optimise size
+        let mut res_big: VecZnxBig<_, BE> = keyswitch_internal(self, res_dft, a, key, scratch_1);
+
+        for i in 0..res.rank().as_usize() + 1 {
+            self.vec_znx_big_automorphism_inplace(key.p(), &mut res_big, i, scratch_1);
+            self.vec_znx_big_sub_small_inplace(&mut res_big, i, a.data(), i);
+            self.vec_znx_big_normalize(
+                res.base2k().into(),
+                res.data_mut(),
                 i,
-                rhs.base2k().into(),
+                key.base2k().into(),
                 &res_big,
                 i,
                 scratch_1,
             );
-        })
+        }
     }
 
-    pub fn automorphism_sub_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>
-            + VecZnxBigAutomorphismInplace<B>
-            + VecZnxBigSubSmallInplace<B>
-            + VecZnxNormalizeTmpBytes
-            + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+    fn glwe_automorphism_sub_negate<R, A, K>(&self, res: &mut R, a: &A, key: &K, scratch: &mut Scratch<BE>)
+    where
+        R: GLWEToMut,
+        A: GLWEToRef,
+        K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        #[cfg(debug_assertions)]
-        {
-            self.assert_keyswitch_inplace(module, &rhs.key, scratch);
-        }
-        let (res_dft, scratch_1) = scratch.take_vec_znx_dft(self.n().into(), (self.rank() + 1).into(), rhs.size()); // TODO: optimise size
-        let mut res_big: VecZnxBig<_, B> = self.keyswitch_internal(module, res_dft, &rhs.key, scratch_1);
-        (0..(self.rank() + 1).into()).for_each(|i| {
-            module.vec_znx_big_automorphism_inplace(rhs.p(), &mut res_big, i, scratch_1);
-            module.vec_znx_big_sub_small_inplace(&mut res_big, i, &self.data, i);
-            module.vec_znx_big_normalize(
-                self.base2k().into(),
-                &mut self.data,
+        let res: &mut GLWE<&mut [u8]> = &mut res.to_mut();
+        let a: &GLWE<&[u8]> = &a.to_ref();
+
+        let (res_dft, scratch_1) = scratch.take_vec_znx_dft(self, (res.rank() + 1).into(), key.size()); // TODO: optimise size
+        let mut res_big: VecZnxBig<_, BE> = keyswitch_internal(self, res_dft, a, key, scratch_1);
+
+        for i in 0..res.rank().as_usize() + 1 {
+            self.vec_znx_big_automorphism_inplace(key.p(), &mut res_big, i, scratch_1);
+            self.vec_znx_big_sub_small_negate_inplace(&mut res_big, i, a.data(), i);
+            self.vec_znx_big_normalize(
+                res.base2k().into(),
+                res.data_mut(),
                 i,
-                rhs.base2k().into(),
+                key.base2k().into(),
                 &res_big,
                 i,
                 scratch_1,
             );
-        })
+        }
     }
 
-    pub fn automorphism_sub_negate<DataLhs: DataRef, DataRhs: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        lhs: &GLWECiphertext<DataLhs>,
-        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>
-            + VecZnxBigAutomorphismInplace<B>
-            + VecZnxBigSubSmallNegateInplace<B>
-            + VecZnxNormalizeTmpBytes
-            + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+    fn glwe_automorphism_sub_inplace<R, K>(&self, res: &mut R, key: &K, scratch: &mut Scratch<BE>)
+    where
+        R: GLWEToMut,
+        K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        #[cfg(debug_assertions)]
-        {
-            self.assert_keyswitch(module, lhs, &rhs.key, scratch);
-        }
-        let (res_dft, scratch_1) = scratch.take_vec_znx_dft(self.n().into(), (self.rank() + 1).into(), rhs.size()); // TODO: optimise size
-        let mut res_big: VecZnxBig<_, B> = lhs.keyswitch_internal(module, res_dft, &rhs.key, scratch_1);
-        (0..(self.rank() + 1).into()).for_each(|i| {
-            module.vec_znx_big_automorphism_inplace(rhs.p(), &mut res_big, i, scratch_1);
-            module.vec_znx_big_sub_small_negate_inplace(&mut res_big, i, &lhs.data, i);
-            module.vec_znx_big_normalize(
-                self.base2k().into(),
-                &mut self.data,
+        let res: &mut GLWE<&mut [u8]> = &mut res.to_mut();
+
+        let (res_dft, scratch_1) = scratch.take_vec_znx_dft(self, (res.rank() + 1).into(), key.size()); // TODO: optimise size
+        let mut res_big: VecZnxBig<_, BE> = keyswitch_internal(self, res_dft, res, key, scratch_1);
+
+        for i in 0..res.rank().as_usize() + 1 {
+            self.vec_znx_big_automorphism_inplace(key.p(), &mut res_big, i, scratch_1);
+            self.vec_znx_big_sub_small_inplace(&mut res_big, i, res.data(), i);
+            self.vec_znx_big_normalize(
+                res.base2k().into(),
+                res.data_mut(),
                 i,
-                rhs.base2k().into(),
+                key.base2k().into(),
                 &res_big,
                 i,
                 scratch_1,
             );
-        })
+        }
     }
 
-    pub fn automorphism_sub_negate_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>
-            + VecZnxBigAutomorphismInplace<B>
-            + VecZnxBigSubSmallNegateInplace<B>
-            + VecZnxNormalizeTmpBytes
-            + VecZnxNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
+    fn glwe_automorphism_sub_negate_inplace<R, K>(&self, res: &mut R, key: &K, scratch: &mut Scratch<BE>)
+    where
+        R: GLWEToMut,
+        K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        #[cfg(debug_assertions)]
-        {
-            self.assert_keyswitch_inplace(module, &rhs.key, scratch);
-        }
-        let (res_dft, scratch_1) = scratch.take_vec_znx_dft(self.n().into(), (self.rank() + 1).into(), rhs.size()); // TODO: optimise size
-        let mut res_big: VecZnxBig<_, B> = self.keyswitch_internal(module, res_dft, &rhs.key, scratch_1);
-        (0..(self.rank() + 1).into()).for_each(|i| {
-            module.vec_znx_big_automorphism_inplace(rhs.p(), &mut res_big, i, scratch_1);
-            module.vec_znx_big_sub_small_negate_inplace(&mut res_big, i, &self.data, i);
-            module.vec_znx_big_normalize(
-                self.base2k().into(),
-                &mut self.data,
+        let res: &mut GLWE<&mut [u8]> = &mut res.to_mut();
+
+        let (res_dft, scratch_1) = scratch.take_vec_znx_dft(self, (res.rank() + 1).into(), key.size()); // TODO: optimise size
+        let mut res_big: VecZnxBig<_, BE> = keyswitch_internal(self, res_dft, res, key, scratch_1);
+
+        for i in 0..res.rank().as_usize() + 1 {
+            self.vec_znx_big_automorphism_inplace(key.p(), &mut res_big, i, scratch_1);
+            self.vec_znx_big_sub_small_negate_inplace(&mut res_big, i, res.data(), i);
+            self.vec_znx_big_normalize(
+                res.base2k().into(),
+                res.data_mut(),
                 i,
-                rhs.base2k().into(),
+                key.base2k().into(),
                 &res_big,
                 i,
                 scratch_1,
             );
-        })
+        }
     }
 }
+
+impl<BE: Backend> GLWEAutomorphism<BE> for Module<BE> where
+    Self: GLWEKeyswitch<BE>
+        + VecZnxAutomorphismInplace<BE>
+        + VecZnxBigAutomorphismInplace<BE>
+        + VecZnxBigSubSmallInplace<BE>
+        + VecZnxBigSubSmallNegateInplace<BE>
+{
+}

@@ -1,3 +1,7 @@
 mod gglwe_atk;
 mod ggsw_ct;
 mod glwe_ct;
+
+pub use gglwe_atk::*;
+pub use ggsw_ct::*;
+pub use glwe_ct::*;

@@ -0,0 +1,286 @@
+use poulpy_hal::{
+    api::{
+        ModuleN, ScratchAvailable, ScratchTakeBasic, VecZnxBigBytesOf, VecZnxBigNormalize, VecZnxDftAddInplace, VecZnxDftApply,
+        VecZnxDftBytesOf, VecZnxDftCopy, VecZnxIdftApplyTmpA, VecZnxNormalize, VecZnxNormalizeTmpBytes, VmpApplyDftToDft,
+        VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
+    },
+    layouts::{Backend, DataMut, Module, Scratch, VmpPMat, ZnxInfos},
+};
+
+use crate::{
+    GLWECopy, ScratchTakeCore,
+    layouts::{
+        GGLWE, GGLWEInfos, GGLWEToRef, GGSW, GGSWInfos, GGSWToMut, GLWEInfos, LWEInfos,
+        prepared::{GLWETensorKeyPrepared, GLWETensorKeyPreparedToRef},
+    },
+};
+
+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: GLWETensorKeyPreparedToRef<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> + GLWECopy,
+{
+    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: GLWETensorKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        let res: &mut GGSW<&mut [u8]> = &mut res.to_mut();
+        let a: &GGLWE<&[u8]> = &a.to_ref();
+        let tsk: &GLWETensorKeyPrepared<&[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() {
+            self.glwe_copy(&mut res.at_mut(row, 0), &a.at(row, 0));
+        }
+
+        self.ggsw_expand_row(res, tsk, scratch);
+    }
+}
+
+pub trait GGSWFromGGLWE<BE: Backend> {
+    fn ggsw_from_gglwe_tmp_bytes<R, A>(&self, res_infos: &R, tsk_infos: &A) -> usize
+    where
+        R: GGSWInfos,
+        A: GGLWEInfos;
+
+    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: GLWETensorKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>;
+}
+
+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 trait GGSWExpandRows<BE: Backend>
+where
+    Self: Sized
+        + ModuleN
+        + 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: GLWETensorKeyPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        let res: &mut GGSW<&mut [u8]> = &mut res.to_mut();
+        let tsk: &GLWETensorKeyPrepared<&[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.n(), 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).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,106 +1,124 @@
 use poulpy_hal::{
-    api::{
-        ScratchAvailable, TakeVecZnx, TakeVecZnxDft, VecZnxBigAddSmallInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
-        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeTmpBytes, VmpApplyDftToDft,
-        VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
-    },
-    layouts::{Backend, DataMut, DataRef, Module, Scratch, ZnxView, ZnxViewMut, ZnxZero},
+    api::ModuleN,
+    layouts::{Backend, DataMut, Module, Scratch, ZnxView, ZnxViewMut, ZnxZero},
 };
 
 use crate::{
-    TakeGLWECt,
-    layouts::{
-        GGLWEInfos, GLWECiphertext, GLWECiphertextLayout, GLWEInfos, LWECiphertext, LWEInfos, Rank,
-        prepared::GLWEToLWESwitchingKeyPrepared,
-    },
+    GLWEKeyswitch, ScratchTakeCore,
+    layouts::{GGLWEInfos, GGLWEPreparedToRef, GLWE, GLWEInfos, GLWELayout, GLWEToRef, LWE, LWEInfos, LWEToMut, Rank},
 };
 
-impl LWECiphertext<Vec<u8>> {
-    pub fn from_glwe_scratch_space<B: Backend, OUT, IN, KEY>(
-        module: &Module<B>,
-        lwe_infos: &OUT,
-        glwe_infos: &IN,
-        key_infos: &KEY,
-    ) -> usize
+pub trait LWESampleExtract
+where
+    Self: ModuleN,
+{
+    fn lwe_sample_extract<R, A>(&self, res: &mut R, a: &A)
     where
-        OUT: LWEInfos,
-        IN: GLWEInfos,
-        KEY: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
+        R: LWEToMut,
+        A: GLWEToRef,
     {
-        let glwe_layout: GLWECiphertextLayout = GLWECiphertextLayout {
-            n: module.n().into(),
+        let res: &mut LWE<&mut [u8]> = &mut res.to_mut();
+        let a: &GLWE<&[u8]> = &a.to_ref();
+
+        assert!(res.n() <= a.n());
+        assert_eq!(a.n(), self.n() as u32);
+        assert!(res.base2k() == a.base2k());
+
+        let min_size: usize = res.size().min(a.size());
+        let n: usize = res.n().into();
+
+        res.data.zero();
+        (0..min_size).for_each(|i| {
+            let data_lwe: &mut [i64] = res.data.at_mut(0, i);
+            data_lwe[0] = a.data.at(0, i)[0];
+            data_lwe[1..].copy_from_slice(&a.data.at(1, i)[..n]);
+        });
+    }
+}
+
+impl<BE: Backend> LWESampleExtract for Module<BE> where Self: ModuleN {}
+impl<BE: Backend> LWEFromGLWE<BE> for Module<BE> where Self: GLWEKeyswitch<BE> + LWESampleExtract {}
+
+pub trait LWEFromGLWE<BE: Backend>
+where
+    Self: GLWEKeyswitch<BE> + LWESampleExtract,
+{
+    fn lwe_from_glwe_tmp_bytes<R, A, K>(&self, lwe_infos: &R, glwe_infos: &A, key_infos: &K) -> usize
+    where
+        R: LWEInfos,
+        A: GLWEInfos,
+        K: GGLWEInfos,
+    {
+        let res_infos: GLWELayout = GLWELayout {
+            n: self.n().into(),
             base2k: lwe_infos.base2k(),
             k: lwe_infos.k(),
             rank: Rank(1),
         };
 
-        GLWECiphertext::alloc_bytes_with(
-            module.n().into(),
+        GLWE::bytes_of(
+            self.n().into(),
             lwe_infos.base2k(),
             lwe_infos.k(),
             1u32.into(),
-        ) + GLWECiphertext::keyswitch_scratch_space(module, &glwe_layout, glwe_infos, key_infos)
+        ) + self.glwe_keyswitch_tmp_bytes(&res_infos, glwe_infos, key_infos)
     }
-}
 
-impl<DLwe: DataMut> LWECiphertext<DLwe> {
-    pub fn sample_extract<DGlwe: DataRef>(&mut self, a: &GLWECiphertext<DGlwe>) {
-        #[cfg(debug_assertions)]
-        {
-            assert!(self.n() <= a.n());
-            assert!(self.base2k() == a.base2k());
-        }
+    fn lwe_from_glwe<R, A, K>(&self, res: &mut R, a: &A, key: &K, scratch: &mut Scratch<BE>)
+    where
+        R: LWEToMut,
+        A: GLWEToRef,
+        K: GGLWEPreparedToRef<BE> + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        let res: &mut LWE<&mut [u8]> = &mut res.to_mut();
+        let a: &GLWE<&[u8]> = &a.to_ref();
 
-        let min_size: usize = self.size().min(a.size());
-        let n: usize = self.n().into();
+        assert_eq!(a.n(), self.n() as u32);
+        assert_eq!(key.n(), self.n() as u32);
+        assert!(res.n() <= self.n() as u32);
 
-        self.data.zero();
-        (0..min_size).for_each(|i| {
-            let data_lwe: &mut [i64] = self.data.at_mut(0, i);
-            data_lwe[0] = a.data.at(0, i)[0];
-            data_lwe[1..].copy_from_slice(&a.data.at(1, i)[..n]);
-        });
+        let glwe_layout: GLWELayout = GLWELayout {
+            n: self.n().into(),
+            base2k: res.base2k(),
+            k: res.k(),
+            rank: Rank(1),
+        };
+
+        let (mut tmp_glwe, scratch_1) = scratch.take_glwe(&glwe_layout);
+        self.glwe_keyswitch(&mut tmp_glwe, a, key, scratch_1);
+        self.lwe_sample_extract(res, &tmp_glwe);
     }
+}
 
-    pub fn from_glwe<DGlwe, DKs, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        a: &GLWECiphertext<DGlwe>,
-        ks: &GLWEToLWESwitchingKeyPrepared<DKs, B>,
-        scratch: &mut Scratch<B>,
-    ) where
-        DGlwe: DataRef,
-        DKs: DataRef,
-        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> + TakeGLWECt + TakeVecZnx,
+impl LWE<Vec<u8>> {
+    pub fn from_glwe_tmp_bytes<R, A, K, M, BE: Backend>(module: &M, lwe_infos: &R, glwe_infos: &A, key_infos: &K) -> usize
+    where
+        R: LWEInfos,
+        A: GLWEInfos,
+        K: GGLWEInfos,
+        M: LWEFromGLWE<BE>,
     {
-        #[cfg(debug_assertions)]
-        {
-            assert_eq!(a.n(), module.n() as u32);
-            assert_eq!(ks.n(), module.n() as u32);
-            assert!(self.n() <= module.n() as u32);
-        }
+        module.lwe_from_glwe_tmp_bytes(lwe_infos, glwe_infos, key_infos)
+    }
+}
 
-        let glwe_layout: GLWECiphertextLayout = GLWECiphertextLayout {
-            n: module.n().into(),
-            base2k: self.base2k(),
-            k: self.k(),
-            rank: Rank(1),
-        };
+impl<D: DataMut> LWE<D> {
+    pub fn sample_extract<A, M>(&mut self, module: &M, a: &A)
+    where
+        A: GLWEToRef,
+        M: LWESampleExtract,
+    {
+        module.lwe_sample_extract(self, a);
+    }
 
-        let (mut tmp_glwe, scratch_1) = scratch.take_glwe_ct(&glwe_layout);
-        tmp_glwe.keyswitch(module, a, &ks.0, scratch_1);
-        self.sample_extract(&tmp_glwe);
+    pub fn from_glwe<A, K, M, BE: Backend>(&mut self, module: &M, a: &A, key: &K, scratch: &mut Scratch<BE>)
+    where
+        A: GLWEToRef,
+        K: GGLWEPreparedToRef<BE> + GGLWEInfos,
+        M: LWEFromGLWE<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        module.lwe_from_glwe(self, a, key, scratch);
     }
 }

@@ -1,80 +1,56 @@
 use poulpy_hal::{
-    api::{
-        ScratchAvailable, TakeVecZnx, TakeVecZnxDft, VecZnxBigAddSmallInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
-        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeTmpBytes, VmpApplyDftToDft,
-        VmpApplyDftToDftAdd, VmpApplyDftToDftTmpBytes,
-    },
-    layouts::{Backend, DataMut, DataRef, Module, Scratch, VecZnx, ZnxView, ZnxViewMut, ZnxZero},
+    api::ScratchTakeBasic,
+    layouts::{Backend, DataMut, Module, Scratch, VecZnx, ZnxView, ZnxViewMut, ZnxZero},
 };
 
 use crate::{
-    TakeGLWECt,
-    layouts::{
-        GGLWEInfos, GLWECiphertext, GLWECiphertextLayout, GLWEInfos, LWECiphertext, LWEInfos,
-        prepared::LWEToGLWESwitchingKeyPrepared,
-    },
+    GLWEKeyswitch, ScratchTakeCore,
+    layouts::{GGLWEInfos, GGLWEPreparedToRef, GLWE, GLWEInfos, GLWELayout, GLWEToMut, LWE, LWEInfos, LWEToRef},
 };
 
-impl GLWECiphertext<Vec<u8>> {
-    pub fn from_lwe_scratch_space<B: Backend, OUT, IN, KEY>(
-        module: &Module<B>,
-        glwe_infos: &OUT,
-        lwe_infos: &IN,
-        key_infos: &KEY,
-    ) -> usize
+impl<BE: Backend> GLWEFromLWE<BE> for Module<BE> where Self: GLWEKeyswitch<BE> {}
+
+pub trait GLWEFromLWE<BE: Backend>
+where
+    Self: GLWEKeyswitch<BE>,
+{
+    fn glwe_from_lwe_tmp_bytes<R, A, K>(&self, glwe_infos: &R, lwe_infos: &A, key_infos: &K) -> usize
     where
-        OUT: GLWEInfos,
-        IN: LWEInfos,
-        KEY: GGLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VmpApplyDftToDftTmpBytes + VecZnxBigNormalizeTmpBytes + VecZnxNormalizeTmpBytes,
+        R: GLWEInfos,
+        A: LWEInfos,
+        K: GGLWEInfos,
     {
-        let ct: usize = GLWECiphertext::alloc_bytes_with(
-            module.n().into(),
+        let ct: usize = GLWE::bytes_of(
+            self.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 = self.glwe_keyswitch_tmp_bytes(glwe_infos, 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(self.n(), 1, lwe_infos.size()) + self.vec_znx_normalize_tmp_bytes();
             ct + a_conv + ks
         }
     }
-}
 
-impl<D: DataMut> GLWECiphertext<D> {
-    pub fn from_lwe<DLwe, DKsk, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        lwe: &LWECiphertext<DLwe>,
-        ksk: &LWEToGLWESwitchingKeyPrepared<DKsk, B>,
-        scratch: &mut Scratch<B>,
-    ) where
-        DLwe: DataRef,
-        DKsk: DataRef,
-        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> + TakeGLWECt + TakeVecZnx,
+    fn glwe_from_lwe<R, A, K>(&self, res: &mut R, lwe: &A, ksk: &K, scratch: &mut Scratch<BE>)
+    where
+        R: GLWEToMut,
+        A: LWEToRef,
+        K: GGLWEPreparedToRef<BE> + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
     {
-        #[cfg(debug_assertions)]
-        {
-            assert_eq!(self.n(), module.n() as u32);
-            assert_eq!(ksk.n(), module.n() as u32);
-            assert!(lwe.n() <= module.n() as u32);
-        }
+        let res: &mut GLWE<&mut [u8]> = &mut res.to_mut();
+        let lwe: &LWE<&[u8]> = &lwe.to_ref();
+
+        assert_eq!(res.n(), self.n() as u32);
+        assert_eq!(ksk.n(), self.n() as u32);
+        assert!(lwe.n() <= self.n() as u32);
 
-        let (mut glwe, scratch_1) = scratch.take_glwe_ct(&GLWECiphertextLayout {
+        let (mut glwe, scratch_1) = scratch.take_glwe(&GLWELayout {
             n: ksk.n(),
             base2k: ksk.base2k(),
             k: lwe.k(),
@@ -91,14 +67,14 @@ glwe.data.at_mut(0, i)[0] = data_lwe[0];
                 glwe.data.at_mut(1, i)[..n_lwe].copy_from_slice(&data_lwe[1..]);
             }
         } else {
-            let (mut a_conv, scratch_2) = scratch_1.take_vec_znx(module.n(), 1, lwe.size());
+            let (mut a_conv, scratch_2) = scratch_1.take_vec_znx(self.n(), 1, lwe.size());
             a_conv.zero();
             for j in 0..lwe.size() {
                 let data_lwe: &[i64] = lwe.data.at(0, j);
                 a_conv.at_mut(0, j)[0] = data_lwe[0]
             }
 
-            module.vec_znx_normalize(
+            self.vec_znx_normalize(
                 ksk.base2k().into(),
                 &mut glwe.data,
                 0,
@@ -114,7 +90,7 @@ let data_lwe: &[i64] = lwe.data.at(0, j);
                 a_conv.at_mut(0, j)[..n_lwe].copy_from_slice(&data_lwe[1..]);
             }
 
-            module.vec_znx_normalize(
+            self.vec_znx_normalize(
                 ksk.base2k().into(),
                 &mut glwe.data,
                 1,
@@ -125,6 +101,30 @@ scratch_2,
             );
         }
 
-        self.keyswitch(module, &glwe, &ksk.0, scratch_1);
+        self.glwe_keyswitch(res, &glwe, ksk, scratch_1);
+    }
+}
+
+impl GLWE<Vec<u8>> {
+    pub fn from_lwe_tmp_bytes<R, A, K, M, BE: Backend>(module: &M, glwe_infos: &R, lwe_infos: &A, key_infos: &K) -> usize
+    where
+        R: GLWEInfos,
+        A: LWEInfos,
+        K: GGLWEInfos,
+        M: GLWEFromLWE<BE>,
+    {
+        module.glwe_from_lwe_tmp_bytes(glwe_infos, lwe_infos, key_infos)
+    }
+}
+
+impl<D: DataMut> GLWE<D> {
+    pub fn from_lwe<A, K, M, BE: Backend>(&mut self, module: &M, lwe: &A, ksk: &K, scratch: &mut Scratch<BE>)
+    where
+        M: GLWEFromLWE<BE>,
+        A: LWEToRef,
+        K: GGLWEPreparedToRef<BE> + GGLWEInfos,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        module.glwe_from_lwe(self, lwe, ksk, scratch);
     }
 }

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

@@ -0,0 +1,125 @@
+use poulpy_hal::{
+    api::{
+        ModuleN, ScratchTakeBasic, SvpApplyDftToDftInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigBytesOf,
+        VecZnxBigNormalize, VecZnxDftApply, VecZnxDftBytesOf, VecZnxIdftApplyConsume, VecZnxNormalizeTmpBytes,
+    },
+    layouts::{Backend, DataRef, DataViewMut, Module, Scratch},
+};
+
+use crate::layouts::{
+    GLWE, GLWEInfos, GLWEPlaintext, GLWEPlaintextToMut, GLWEToRef, LWEInfos,
+    prepared::{GLWESecretPrepared, GLWESecretPreparedToRef},
+};
+
+impl GLWE<Vec<u8>> {
+    pub fn decrypt_tmp_bytes<A, M, BE: Backend>(module: &M, a_infos: &A) -> usize
+    where
+        A: GLWEInfos,
+        M: GLWEDecrypt<BE>,
+    {
+        module.glwe_decrypt_tmp_bytes(a_infos)
+    }
+}
+
+impl<DataSelf: DataRef> GLWE<DataSelf> {
+    pub fn decrypt<P, S, M, BE: Backend>(&self, module: &M, pt: &mut P, sk: &S, scratch: &mut Scratch<BE>)
+    where
+        P: GLWEPlaintextToMut,
+        S: GLWESecretPreparedToRef<BE>,
+        M: GLWEDecrypt<BE>,
+        Scratch<BE>: ScratchTakeBasic,
+    {
+        module.glwe_decrypt(self, pt, sk, scratch);
+    }
+}
+
+pub trait GLWEDecrypt<BE: Backend>
+where
+    Self: Sized
+        + ModuleN
+        + VecZnxDftBytesOf
+        + VecZnxNormalizeTmpBytes
+        + VecZnxBigBytesOf
+        + VecZnxDftApply<BE>
+        + SvpApplyDftToDftInplace<BE>
+        + VecZnxIdftApplyConsume<BE>
+        + VecZnxBigAddInplace<BE>
+        + VecZnxBigAddSmallInplace<BE>
+        + VecZnxBigNormalize<BE>,
+{
+    fn glwe_decrypt_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GLWEInfos,
+    {
+        let size: usize = infos.size();
+        (self.vec_znx_normalize_tmp_bytes() | self.bytes_of_vec_znx_dft(1, size)) + self.bytes_of_vec_znx_dft(1, size)
+    }
+
+    fn glwe_decrypt<R, P, S>(&self, res: &R, pt: &mut P, sk: &S, scratch: &mut Scratch<BE>)
+    where
+        R: GLWEToRef,
+        P: GLWEPlaintextToMut,
+        S: GLWESecretPreparedToRef<BE>,
+        Scratch<BE>: ScratchTakeBasic,
+    {
+        let res: &GLWE<&[u8]> = &res.to_ref();
+        let pt: &mut GLWEPlaintext<&mut [u8]> = &mut pt.to_ref();
+        let sk: &GLWESecretPrepared<&[u8], BE> = &sk.to_ref();
+
+        #[cfg(debug_assertions)]
+        {
+            assert_eq!(res.rank(), sk.rank());
+            assert_eq!(res.n(), sk.n());
+            assert_eq!(pt.n(), sk.n());
+        }
+
+        let cols: usize = (res.rank() + 1).into();
+
+        let (mut c0_big, scratch_1) = scratch.take_vec_znx_big(self, 1, res.size()); // TODO optimize size when pt << ct
+        c0_big.data_mut().fill(0);
+
+        {
+            (1..cols).for_each(|i| {
+                // ci_dft = DFT(a[i]) * DFT(s[i])
+                let (mut ci_dft, _) = scratch_1.take_vec_znx_dft(self, 1, res.size()); // TODO optimize size when pt << ct
+                self.vec_znx_dft_apply(1, 0, &mut ci_dft, 0, &res.data, i);
+                self.svp_apply_dft_to_dft_inplace(&mut ci_dft, 0, &sk.data, i - 1);
+                let ci_big = self.vec_znx_idft_apply_consume(ci_dft);
+
+                // c0_big += a[i] * s[i]
+                self.vec_znx_big_add_inplace(&mut c0_big, 0, &ci_big, 0);
+            });
+        }
+
+        // c0_big = (a * s) + (-a * s + m + e) = BIG(m + e)
+        self.vec_znx_big_add_small_inplace(&mut c0_big, 0, &res.data, 0);
+
+        // pt = norm(BIG(m + e))
+        self.vec_znx_big_normalize(
+            res.base2k().into(),
+            &mut pt.data,
+            0,
+            res.base2k().into(),
+            &c0_big,
+            0,
+            scratch_1,
+        );
+
+        pt.base2k = res.base2k();
+        pt.k = pt.k().min(res.k());
+    }
+}
+
+impl<BE: Backend> GLWEDecrypt<BE> for Module<BE> where
+    Self: ModuleN
+        + VecZnxDftBytesOf
+        + VecZnxNormalizeTmpBytes
+        + VecZnxBigBytesOf
+        + VecZnxDftApply<BE>
+        + SvpApplyDftToDftInplace<BE>
+        + VecZnxIdftApplyConsume<BE>
+        + VecZnxBigAddInplace<BE>
+        + VecZnxBigAddSmallInplace<BE>
+        + VecZnxBigNormalize<BE>
+{
+}

@@ -1,80 +0,0 @@
-use poulpy_hal::{
-    api::{
-        SvpApplyDftToDftInplace, TakeVecZnxBig, TakeVecZnxDft, VecZnxBigAddInplace, VecZnxBigAddSmallInplace, VecZnxBigNormalize,
-        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxIdftApplyConsume, VecZnxNormalizeTmpBytes,
-    },
-    layouts::{Backend, DataMut, DataRef, DataViewMut, Module, Scratch},
-};
-
-use crate::layouts::{GLWECiphertext, GLWEInfos, GLWEPlaintext, LWEInfos, prepared::GLWESecretPrepared};
-
-impl GLWECiphertext<Vec<u8>> {
-    pub fn decrypt_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
-    where
-        A: GLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes,
-    {
-        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)
-    }
-}
-
-impl<DataSelf: DataRef> GLWECiphertext<DataSelf> {
-    pub fn decrypt<DataPt: DataMut, DataSk: DataRef, B: Backend>(
-        &self,
-        module: &Module<B>,
-        pt: &mut GLWEPlaintext<DataPt>,
-        sk: &GLWESecretPrepared<DataSk, B>,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: VecZnxDftApply<B>
-            + SvpApplyDftToDftInplace<B>
-            + VecZnxIdftApplyConsume<B>
-            + VecZnxBigAddInplace<B>
-            + VecZnxBigAddSmallInplace<B>
-            + VecZnxBigNormalize<B>,
-        Scratch<B>: TakeVecZnxDft<B> + TakeVecZnxBig<B>,
-    {
-        #[cfg(debug_assertions)]
-        {
-            assert_eq!(self.rank(), sk.rank());
-            assert_eq!(self.n(), sk.n());
-            assert_eq!(pt.n(), sk.n());
-        }
-
-        let cols: usize = (self.rank() + 1).into();
-
-        let (mut c0_big, scratch_1) = scratch.take_vec_znx_big(self.n().into(), 1, self.size()); // TODO optimize size when pt << ct
-        c0_big.data_mut().fill(0);
-
-        {
-            (1..cols).for_each(|i| {
-                // ci_dft = DFT(a[i]) * DFT(s[i])
-                let (mut ci_dft, _) = scratch_1.take_vec_znx_dft(self.n().into(), 1, self.size()); // TODO optimize size when pt << ct
-                module.vec_znx_dft_apply(1, 0, &mut ci_dft, 0, &self.data, i);
-                module.svp_apply_dft_to_dft_inplace(&mut ci_dft, 0, &sk.data, i - 1);
-                let ci_big = module.vec_znx_idft_apply_consume(ci_dft);
-
-                // c0_big += a[i] * s[i]
-                module.vec_znx_big_add_inplace(&mut c0_big, 0, &ci_big, 0);
-            });
-        }
-
-        // c0_big = (a * s) + (-a * s + m + e) = BIG(m + e)
-        module.vec_znx_big_add_small_inplace(&mut c0_big, 0, &self.data, 0);
-
-        // pt = norm(BIG(m + e))
-        module.vec_znx_big_normalize(
-            self.base2k().into(),
-            &mut pt.data,
-            0,
-            self.base2k().into(),
-            &c0_big,
-            0,
-            scratch_1,
-        );
-
-        pt.base2k = self.base2k();
-        pt.k = pt.k().min(self.k());
-    }
-}

@@ -0,0 +1,65 @@
+use poulpy_hal::{
+    api::{ScratchOwnedAlloc, ScratchOwnedBorrow, ZnNormalizeInplace},
+    layouts::{Backend, DataMut, DataRef, Module, ScratchOwned, ZnxView, ZnxViewMut},
+};
+
+use crate::layouts::{LWE, LWEInfos, LWEPlaintext, LWEPlaintextToMut, LWESecret, LWESecretToRef, LWEToMut};
+
+impl<DataSelf: DataRef + DataMut> LWE<DataSelf> {
+    pub fn decrypt<P, S, M, B: Backend>(&mut self, module: &M, pt: &mut P, sk: &S)
+    where
+        P: LWEPlaintextToMut,
+        S: LWESecretToRef,
+        M: LWEDecrypt<B>,
+    {
+        module.lwe_decrypt(self, pt, sk);
+    }
+}
+
+pub trait LWEDecrypt<BE: Backend> {
+    fn lwe_decrypt<R, P, S>(&self, res: &mut R, pt: &mut P, sk: &S)
+    where
+        R: LWEToMut,
+        P: LWEPlaintextToMut,
+        S: LWESecretToRef;
+}
+
+impl<BE: Backend> LWEDecrypt<BE> for Module<BE>
+where
+    Self: Sized + ZnNormalizeInplace<BE>,
+    ScratchOwned<BE>: ScratchOwnedAlloc<BE> + ScratchOwnedBorrow<BE>,
+{
+    fn lwe_decrypt<R, P, S>(&self, res: &mut R, pt: &mut P, sk: &S)
+    where
+        R: LWEToMut,
+        P: LWEPlaintextToMut,
+        S: LWESecretToRef,
+    {
+        let res: &mut LWE<&mut [u8]> = &mut res.to_mut();
+        let pt: &mut LWEPlaintext<&mut [u8]> = &mut pt.to_mut();
+        let sk: LWESecret<&[u8]> = sk.to_ref();
+
+        #[cfg(debug_assertions)]
+        {
+            assert_eq!(res.n(), sk.n());
+        }
+
+        (0..pt.size().min(res.size())).for_each(|i| {
+            pt.data.at_mut(0, i)[0] = res.data.at(0, i)[0]
+                + res.data.at(0, i)[1..]
+                    .iter()
+                    .zip(sk.data.at(0, 0))
+                    .map(|(x, y)| x * y)
+                    .sum::<i64>();
+        });
+        self.zn_normalize_inplace(
+            1,
+            res.base2k().into(),
+            &mut pt.data,
+            0,
+            ScratchOwned::alloc(size_of::<i64>()).borrow(),
+        );
+        pt.base2k = res.base2k();
+        pt.k = crate::layouts::TorusPrecision(res.k().0.min(pt.size() as u32 * res.base2k().0));
+    }
+}

@@ -1,43 +0,0 @@
-use poulpy_hal::{
-    api::{ScratchOwnedAlloc, ScratchOwnedBorrow, ZnNormalizeInplace},
-    layouts::{Backend, DataMut, DataRef, Module, ScratchOwned, ZnxView, ZnxViewMut},
-    oep::{ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl},
-};
-
-use crate::layouts::{LWECiphertext, LWEInfos, LWEPlaintext, LWESecret};
-
-impl<DataSelf> LWECiphertext<DataSelf>
-where
-    DataSelf: DataRef,
-{
-    pub fn decrypt<DataPt, DataSk, B>(&self, module: &Module<B>, pt: &mut LWEPlaintext<DataPt>, sk: &LWESecret<DataSk>)
-    where
-        DataPt: DataMut,
-        DataSk: DataRef,
-        Module<B>: ZnNormalizeInplace<B>,
-        B: Backend + ScratchOwnedAllocImpl<B> + ScratchOwnedBorrowImpl<B>,
-    {
-        #[cfg(debug_assertions)]
-        {
-            assert_eq!(self.n(), sk.n());
-        }
-
-        (0..pt.size().min(self.size())).for_each(|i| {
-            pt.data.at_mut(0, i)[0] = self.data.at(0, i)[0]
-                + self.data.at(0, i)[1..]
-                    .iter()
-                    .zip(sk.data.at(0, 0))
-                    .map(|(x, y)| x * y)
-                    .sum::<i64>();
-        });
-        module.zn_normalize_inplace(
-            1,
-            self.base2k().into(),
-            &mut pt.data,
-            0,
-            ScratchOwned::alloc(size_of::<i64>()).borrow(),
-        );
-        pt.base2k = self.base2k();
-        pt.k = crate::layouts::TorusPrecision(self.k().0.min(pt.size() as u32 * self.base2k().0));
-    }
-}

@@ -1,2 +1,5 @@
-mod glwe_ct;
-mod lwe_ct;
+mod glwe;
+mod lwe;
+
+pub use glwe::*;
+pub use lwe::*;

@@ -1,5 +1,13 @@
 use std::io::{Read, Result, Write};
 
+pub trait GetDistribution {
+    fn dist(&self) -> &Distribution;
+}
+
+pub trait GetDistributionMut {
+    fn dist_mut(&mut self) -> &mut Distribution;
+}
+
 #[derive(Clone, Copy, Debug)]
 pub enum Distribution {
     TernaryFixed(usize), // Ternary with fixed Hamming weight

@@ -0,0 +1,175 @@
+use poulpy_hal::{
+    api::{ModuleN, ScratchAvailable, VecZnxAddScalarInplace, VecZnxDftBytesOf, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes},
+    layouts::{Backend, DataMut, Module, ScalarZnx, ScalarZnxToRef, Scratch, ZnxInfos, ZnxZero},
+    source::Source,
+};
+
+use crate::{
+    ScratchTakeCore,
+    encryption::{GLWEEncryptSk, GLWEEncryptSkInternal, SIGMA},
+    layouts::{
+        GGLWECompressedSeedMut, GGLWEInfos, GLWEPlaintext, GLWESecretPrepared, LWEInfos,
+        compressed::{GGLWECompressed, GGLWECompressedToMut},
+        prepared::GLWESecretPreparedToRef,
+    },
+};
+
+impl<D: DataMut> GGLWECompressed<D> {
+    #[allow(clippy::too_many_arguments)]
+    pub fn encrypt_sk<M, P, S, BE: Backend>(
+        &mut self,
+        module: &M,
+        pt: &P,
+        sk: &S,
+        seed: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        P: ScalarZnxToRef,
+        S: GLWESecretPreparedToRef<BE>,
+        M: GGLWECompressedEncryptSk<BE>,
+    {
+        module.gglwe_compressed_encrypt_sk(self, pt, sk, seed, source_xe, scratch);
+    }
+}
+
+impl GGLWECompressed<Vec<u8>> {
+    pub fn encrypt_sk_tmp_bytes<M, BE: Backend, A>(module: &M, infos: &A) -> usize
+    where
+        A: GGLWEInfos,
+        M: GGLWECompressedEncryptSk<BE>,
+    {
+        module.gglwe_compressed_encrypt_sk_tmp_bytes(infos)
+    }
+}
+
+pub trait GGLWECompressedEncryptSk<BE: Backend> {
+    fn gglwe_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GGLWEInfos;
+
+    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<BE>,
+    ) where
+        R: GGLWECompressedToMut + GGLWECompressedSeedMut,
+        P: ScalarZnxToRef,
+        S: GLWESecretPreparedToRef<BE>;
+}
+
+impl<BE: Backend> GGLWECompressedEncryptSk<BE> for Module<BE>
+where
+    Self: ModuleN
+        + GLWEEncryptSkInternal<BE>
+        + GLWEEncryptSk<BE>
+        + VecZnxDftBytesOf
+        + VecZnxNormalizeInplace<BE>
+        + VecZnxAddScalarInplace
+        + VecZnxNormalizeTmpBytes,
+    Scratch<BE>: ScratchTakeCore<BE>,
+{
+    fn gglwe_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GGLWEInfos,
+    {
+        self.glwe_encrypt_sk_tmp_bytes(infos)
+            .max(self.vec_znx_normalize_tmp_bytes())
+            + GLWEPlaintext::bytes_of_from_infos(infos)
+    }
+
+    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<BE>,
+    ) where
+        R: GGLWECompressedToMut + GGLWECompressedSeedMut,
+        P: ScalarZnxToRef,
+        S: GLWESecretPreparedToRef<BE>,
+    {
+        let mut seeds: Vec<[u8; 32]> = vec![[0u8; 32]; res.seed_mut().len()];
+
+        {
+            let res: &mut GGLWECompressed<&mut [u8]> = &mut res.to_mut();
+            let pt: &ScalarZnx<&[u8]> = &pt.to_ref();
+            let sk: &GLWESecretPrepared<&[u8], BE> = &sk.to_ref();
+
+            assert_eq!(
+                res.rank_in(),
+                pt.cols() as u32,
+                "res.rank_in(): {} != pt.cols(): {}",
+                res.rank_in(),
+                pt.cols()
+            );
+            assert_eq!(
+                res.rank_out(),
+                sk.rank(),
+                "res.rank_out(): {} != sk.rank(): {}",
+                res.rank_out(),
+                sk.rank()
+            );
+            assert_eq!(res.n(), sk.n());
+            assert_eq!(pt.n() as u32, sk.n());
+            assert!(
+                scratch.available() >= GGLWECompressed::encrypt_sk_tmp_bytes(self, res),
+                "scratch.available: {} < GGLWECiphertext::encrypt_sk_tmp_bytes: {}",
+                scratch.available(),
+                GGLWECompressed::encrypt_sk_tmp_bytes(self, res)
+            );
+            assert!(
+                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 = 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_plaintext(res);
+            for col_i in 0..rank_in {
+                for d_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
+                    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();
+                    seeds[col_i * dnum + d_i] = seed;
+
+                    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)),
+                        sk,
+                        &mut source_xa_tmp,
+                        source_xe,
+                        SIGMA,
+                        scrach_1,
+                    );
+                }
+            }
+        }
+
+        res.seed_mut().copy_from_slice(&seeds);
+    }
+}

@@ -1,95 +0,0 @@
-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,
-    },
-    layouts::{Backend, DataMut, DataRef, Module, Scratch},
-    source::Source,
-};
-
-use crate::{
-    TakeGLWESecret, TakeGLWESecretPrepared,
-    layouts::{
-        GGLWEInfos, GLWEInfos, GLWESecret, LWEInfos,
-        compressed::{GGLWEAutomorphismKeyCompressed, GGLWESwitchingKeyCompressed},
-    },
-};
-
-impl GGLWEAutomorphismKeyCompressed<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
-    where
-        A: GGLWEInfos,
-        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes + VecZnxNormalizeTmpBytes + SvpPPolAllocBytes,
-    {
-        assert_eq!(module.n() as u32, infos.n());
-        GGLWESwitchingKeyCompressed::encrypt_sk_scratch_space(module, infos)
-            + GLWESecret::alloc_bytes_with(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>,
-        p: i64,
-        sk: &GLWESecret<DataSk>,
-        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>,
-    {
-        #[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!(
-                scratch.available() >= GGLWEAutomorphismKeyCompressed::encrypt_sk_scratch_space(module, self),
-                "scratch.available(): {} < AutomorphismKey::encrypt_sk_scratch_space: {}",
-                scratch.available(),
-                GGLWEAutomorphismKeyCompressed::encrypt_sk_scratch_space(module, self)
-            )
-        }
-
-        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),
-                    &mut sk_out.data.as_vec_znx_mut(),
-                    i,
-                    &sk.data.as_vec_znx(),
-                    i,
-                );
-            });
-        }
-
-        self.key
-            .encrypt_sk(module, sk, &sk_out, seed_xa, source_xe, scratch_1);
-
-        self.p = p;
-    }
-}

@@ -1,127 +0,0 @@
-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},
-    source::Source,
-};
-
-use crate::{
-    TakeGLWEPt,
-    encryption::{SIGMA, glwe_encrypt_sk_internal},
-    layouts::{GGLWECiphertext, GGLWEInfos, LWEInfos, compressed::GGLWECiphertextCompressed, prepared::GLWESecretPrepared},
-};
-
-impl GGLWECiphertextCompressed<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
-    where
-        A: GGLWEInfos,
-        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes + VecZnxNormalizeTmpBytes,
-    {
-        GGLWECiphertext::encrypt_sk_scratch_space(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>,
-        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,
-    {
-        #[cfg(debug_assertions)]
-        {
-            use poulpy_hal::layouts::ZnxInfos;
-
-            assert_eq!(
-                self.rank_in(),
-                pt.cols() as u32,
-                "self.rank_in(): {} != pt.cols(): {}",
-                self.rank_in(),
-                pt.cols()
-            );
-            assert_eq!(
-                self.rank_out(),
-                sk.rank(),
-                "self.rank_out(): {} != sk.rank(): {}",
-                self.rank_out(),
-                sk.rank()
-            );
-            assert_eq!(self.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(),
-                GGLWECiphertextCompressed::encrypt_sk_scratch_space(module, self)
-            );
-            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()
-            );
-        }
-
-        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 mut source_xa = Source::new(seed);
-
-        let (mut tmp_pt, scrach_1) = scratch.take_glwe_pt(self);
-        (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);
-
-                let (seed, mut source_xa_tmp) = source_xa.branch();
-                self.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,
-                    cols,
-                    true,
-                    Some((&tmp_pt, 0)),
-                    sk,
-                    &mut source_xa_tmp,
-                    source_xe,
-                    SIGMA,
-                    scrach_1,
-                );
-            });
-        });
-    }
-}

@@ -1,108 +0,0 @@
-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,
-    },
-    layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, Scratch},
-    source::Source,
-};
-
-use crate::{
-    TakeGLWESecretPrepared,
-    layouts::{
-        Degree, GGLWECiphertext, GGLWEInfos, GLWEInfos, GLWESecret, LWEInfos, compressed::GGLWESwitchingKeyCompressed,
-        prepared::GLWESecretPrepared,
-    },
-};
-
-impl GGLWESwitchingKeyCompressed<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
-    where
-        A: GGLWEInfos,
-        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes + VecZnxNormalizeTmpBytes + SvpPPolAllocBytes,
-    {
-        (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())
-    }
-}
-
-impl<DataSelf: DataMut> GGLWESwitchingKeyCompressed<DataSelf> {
-    #[allow(clippy::too_many_arguments)]
-    pub fn encrypt_sk<DataSkIn: DataRef, DataSkOut: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        sk_in: &GLWESecret<DataSkIn>,
-        sk_out: &GLWESecret<DataSkOut>,
-        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>,
-    {
-        #[cfg(debug_assertions)]
-        {
-            use crate::layouts::GGLWESwitchingKey;
-
-            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(),
-                GGLWESwitchingKey::encrypt_sk_scratch_space(module, self)
-            )
-        }
-
-        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(
-                &mut sk_in_tmp.as_vec_znx_mut(),
-                i,
-                &sk_in.data.as_vec_znx(),
-                i,
-            );
-        });
-
-        let (mut sk_out_tmp, scratch_2) = scratch_1.take_glwe_secret_prepared(Degree(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.key.encrypt_sk(
-            module,
-            &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();
-    }
-}

@@ -1,114 +0,0 @@
-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,
-    },
-    layouts::{Backend, DataMut, DataRef, Module, Scratch},
-    source::Source,
-};
-
-use crate::{
-    TakeGLWESecret, TakeGLWESecretPrepared,
-    layouts::{
-        GGLWEInfos, GGLWETensorKey, GLWEInfos, GLWESecret, LWEInfos, Rank, compressed::GGLWETensorKeyCompressed,
-        prepared::Prepare,
-    },
-};
-
-impl GGLWETensorKeyCompressed<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
-    where
-        A: GGLWEInfos,
-        Module<B>:
-            SvpPPolAllocBytes + VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes + VecZnxNormalizeTmpBytes + VecZnxBigAllocBytes,
-    {
-        GGLWETensorKey::encrypt_sk_scratch_space(module, infos)
-    }
-}
-
-impl<DataSelf: DataMut> GGLWETensorKeyCompressed<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>: 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>,
-    {
-        #[cfg(debug_assertions)]
-        {
-            assert_eq!(self.rank_out(), sk.rank());
-            assert_eq!(self.n(), sk.n());
-        }
-
-        let n: usize = sk.n().into();
-        let rank: usize = self.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, 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);
-        }
-
-        let (mut sk_ij_big, scratch_3) = scratch_2.take_vec_znx_big(n, 1, 1);
-        let (mut sk_ij, scratch_4) = scratch_3.take_glwe_secret(sk.n(), Rank(1));
-        let (mut sk_ij_dft, scratch_5) = scratch_4.take_vec_znx_dft(n, 1, 1);
-
-        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);
-
-                module.vec_znx_idft_apply_tmpa(&mut sk_ij_big, 0, &mut sk_ij_dft, 0);
-                module.vec_znx_big_normalize(
-                    self.base2k().into(),
-                    &mut sk_ij.data.as_vec_znx_mut(),
-                    0,
-                    self.base2k().into(),
-                    &sk_ij_big,
-                    0,
-                    scratch_5,
-                );
-
-                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);
-            }
-        }
-    }
-}

@@ -0,0 +1,147 @@
+use poulpy_hal::{
+    api::{ModuleN, VecZnxAddScalarInplace, VecZnxNormalizeInplace},
+    layouts::{Backend, DataMut, Module, ScalarZnx, ScalarZnxToRef, Scratch, ZnxInfos, ZnxZero},
+    source::Source,
+};
+
+use crate::{
+    ScratchTakeCore,
+    encryption::{GGSWEncryptSk, GLWEEncryptSkInternal, SIGMA},
+    layouts::{
+        GGSWCompressedSeedMut, GGSWInfos, LWEInfos,
+        compressed::{GGSWCompressed, GGSWCompressedToMut},
+        prepared::{GLWESecretPrepared, GLWESecretPreparedToRef},
+    },
+};
+
+impl GGSWCompressed<Vec<u8>> {
+    pub fn encrypt_sk_tmp_bytes<M, A, BE: Backend>(module: &M, infos: &A) -> usize
+    where
+        A: GGSWInfos,
+        M: GGSWCompressedEncryptSk<BE>,
+    {
+        module.ggsw_compressed_encrypt_sk_tmp_bytes(infos)
+    }
+}
+
+impl<DataSelf: DataMut> GGSWCompressed<DataSelf> {
+    #[allow(clippy::too_many_arguments)]
+    pub fn encrypt_sk<P, S, M, BE: Backend>(
+        &mut self,
+        module: &M,
+        pt: &P,
+        sk: &S,
+        seed_xa: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        P: ScalarZnxToRef,
+        S: GLWESecretPreparedToRef<BE>,
+        M: GGSWCompressedEncryptSk<BE>,
+    {
+        module.ggsw_compressed_encrypt_sk(self, pt, sk, seed_xa, source_xe, scratch);
+    }
+}
+
+pub trait GGSWCompressedEncryptSk<BE: Backend> {
+    fn ggsw_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GGSWInfos;
+
+    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<BE>,
+    ) where
+        R: GGSWCompressedToMut + GGSWCompressedSeedMut + GGSWInfos,
+        P: ScalarZnxToRef,
+        S: GLWESecretPreparedToRef<BE>;
+}
+
+impl<BE: Backend> GGSWCompressedEncryptSk<BE> for Module<BE>
+where
+    Self: ModuleN + GLWEEncryptSkInternal<BE> + GGSWEncryptSk<BE> + VecZnxAddScalarInplace + VecZnxNormalizeInplace<BE>,
+    Scratch<BE>: ScratchTakeCore<BE>,
+{
+    fn ggsw_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GGSWInfos,
+    {
+        self.ggsw_encrypt_sk_tmp_bytes(infos)
+    }
+
+    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<BE>,
+    ) where
+        R: GGSWCompressedToMut + GGSWCompressedSeedMut + GGSWInfos,
+        P: ScalarZnxToRef,
+        S: GLWESecretPreparedToRef<BE>,
+    {
+        let base2k: usize = res.base2k().into();
+        let rank: usize = res.rank().into();
+        let cols: usize = rank + 1;
+        let dsize: usize = res.dsize().into();
+
+        let sk: &GLWESecretPrepared<&[u8], BE> = &sk.to_ref();
+        let pt: &ScalarZnx<&[u8]> = &pt.to_ref();
+
+        assert_eq!(res.rank(), sk.rank());
+        assert_eq!(pt.n(), self.n());
+        assert_eq!(res.n(), self.n() as u32);
+        assert_eq!(sk.n(), self.n() as u32);
+
+        let mut seeds: Vec<[u8; 32]> = vec![[0u8; 32]; res.dnum().as_usize() * (res.rank().as_usize() + 1)];
+
+        {
+            let res: &mut GGSWCompressed<&mut [u8]> = &mut res.to_mut();
+
+            println!("res.seed: {:?}", res.seed);
+
+            let (mut tmp_pt, scratch_1) = scratch.take_glwe_plaintext(res);
+
+            let mut source = Source::new(seed_xa);
+
+            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
+                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 {
+                    // rlwe encrypt of vec_znx_pt into vec_znx_ct
+
+                    let (seed, mut source_xa_tmp) = source.branch();
+
+                    seeds[row_i * cols + col_j] = seed;
+
+                    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)),
+                        sk,
+                        &mut source_xa_tmp,
+                        source_xe,
+                        SIGMA,
+                        scratch_1,
+                    );
+                }
+            }
+        }
+
+        res.seed_mut().copy_from_slice(&seeds);
+    }
+}

@@ -1,107 +0,0 @@
-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},
-    source::Source,
-};
-
-use crate::{
-    TakeGLWEPt,
-    encryption::{SIGMA, glwe_encrypt_sk_internal},
-    layouts::{
-        GGSWCiphertext, GGSWInfos, GLWEInfos, LWEInfos, compressed::GGSWCiphertextCompressed, prepared::GLWESecretPrepared,
-    },
-};
-
-impl GGSWCiphertextCompressed<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
-    where
-        A: GGSWInfos,
-        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes,
-    {
-        GGSWCiphertext::encrypt_sk_scratch_space(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>,
-        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,
-    {
-        #[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());
-        }
-
-        let base2k: usize = self.base2k().into();
-        let rank: usize = self.rank().into();
-        let cols: usize = rank + 1;
-        let dsize: usize = self.dsize().into();
-
-        let (mut tmp_pt, scratch_1) = scratch.take_glwe_pt(&self.glwe_layout());
-
-        let mut source = Source::new(seed_xa);
-
-        self.seed = vec![[0u8; 32]; self.dnum().0 as usize * cols];
-
-        (0..self.dnum().into()).for_each(|row_i| {
-            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
-
-                let (seed, mut source_xa_tmp) = source.branch();
-
-                self.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,
-                    cols,
-                    true,
-                    Some((&tmp_pt, col_j)),
-                    sk,
-                    &mut source_xa_tmp,
-                    source_xe,
-                    SIGMA,
-                    scratch_1,
-                );
-            });
-        });
-    }
-}

@@ -0,0 +1,126 @@
+use poulpy_hal::{
+    api::{ModuleN, ScratchAvailable, VecZnxAutomorphism},
+    layouts::{Backend, DataMut, GaloisElement, Module, Scratch},
+    source::Source,
+};
+
+use crate::{
+    GGLWECompressedEncryptSk, ScratchTakeCore,
+    layouts::{
+        GGLWECompressedSeedMut, GGLWECompressedToMut, GGLWEInfos, GLWEInfos, GLWESecret, GLWESecretPrepared,
+        GLWESecretPreparedFactory, GLWESecretToRef, LWEInfos, SetGaloisElement, compressed::GLWEAutomorphismKeyCompressed,
+    },
+};
+
+impl GLWEAutomorphismKeyCompressed<Vec<u8>> {
+    pub fn encrypt_sk_tmp_bytes<M, BE: Backend, A>(module: &M, infos: &A) -> usize
+    where
+        A: GGLWEInfos,
+        M: GLWEAutomorphismKeyCompressedEncryptSk<BE>,
+    {
+        module.glwe_automorphism_key_compressed_encrypt_sk_tmp_bytes(infos)
+    }
+}
+
+impl<DataSelf: DataMut> GLWEAutomorphismKeyCompressed<DataSelf> {
+    #[allow(clippy::too_many_arguments)]
+    pub fn encrypt_sk<M, S, BE: Backend>(
+        &mut self,
+        module: &M,
+        p: i64,
+        sk: &S,
+        seed_xa: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        S: GLWESecretToRef + GLWEInfos,
+        M: GLWEAutomorphismKeyCompressedEncryptSk<BE>,
+    {
+        module.glwe_automorphism_key_compressed_encrypt_sk(self, p, sk, seed_xa, source_xe, scratch);
+    }
+}
+
+pub trait GLWEAutomorphismKeyCompressedEncryptSk<BE: Backend> {
+    fn glwe_automorphism_key_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GGLWEInfos;
+
+    fn glwe_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<BE>,
+    ) where
+        R: GGLWECompressedToMut + GGLWECompressedSeedMut + SetGaloisElement + GGLWEInfos,
+        S: GLWESecretToRef + GLWEInfos;
+}
+
+impl<BE: Backend> GLWEAutomorphismKeyCompressedEncryptSk<BE> for Module<BE>
+where
+    Self: ModuleN + GaloisElement + VecZnxAutomorphism + GGLWECompressedEncryptSk<BE> + GLWESecretPreparedFactory<BE>,
+    Scratch<BE>: ScratchTakeCore<BE>,
+{
+    fn glwe_automorphism_key_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GGLWEInfos,
+    {
+        assert_eq!(self.n() as u32, infos.n());
+        self.gglwe_compressed_encrypt_sk_tmp_bytes(infos)
+            .max(GLWESecret::bytes_of_from_infos(infos))
+            + GLWESecretPrepared::bytes_of_from_infos(self, infos)
+    }
+
+    fn glwe_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<BE>,
+    ) where
+        R: GGLWECompressedToMut + GGLWECompressedSeedMut + SetGaloisElement + GGLWEInfos,
+        S: GLWESecretToRef + GLWEInfos,
+    {
+        let sk: &GLWESecret<&[u8]> = &sk.to_ref();
+        assert_eq!(res.n(), sk.n());
+        assert_eq!(res.rank_out(), res.rank_in());
+        assert_eq!(sk.rank(), res.rank_out());
+        assert!(
+            scratch.available() >= GLWEAutomorphismKeyCompressed::encrypt_sk_tmp_bytes(self, res),
+            "scratch.available(): {} < AutomorphismKey::encrypt_sk_tmp_bytes: {}",
+            scratch.available(),
+            GLWEAutomorphismKeyCompressed::encrypt_sk_tmp_bytes(self, res)
+        );
+
+        let (mut sk_out_prepared, scratch_1) = scratch.take_glwe_secret_prepared(self, sk.rank());
+        {
+            let (mut sk_out, _) = scratch_1.take_glwe_secret(self.n().into(), sk.rank());
+            sk_out.dist = sk.dist;
+            for i in 0..sk.rank().into() {
+                self.vec_znx_automorphism(
+                    self.galois_element_inv(p),
+                    &mut sk_out.data.as_vec_znx_mut(),
+                    i,
+                    &sk.data.as_vec_znx(),
+                    i,
+                );
+            }
+            sk_out_prepared.prepare(self, &sk_out);
+        }
+
+        self.gglwe_compressed_encrypt_sk(
+            res,
+            &sk.data,
+            &sk_out_prepared,
+            seed_xa,
+            source_xe,
+            scratch_1,
+        );
+
+        res.set_p(p);
+    }
+}

@@ -1,100 +1,109 @@
 use poulpy_hal::{
-    api::{
-        ScratchAvailable, SvpApplyDftToDftInplace, TakeVecZnx, TakeVecZnxDft, VecZnxAddInplace, VecZnxAddNormal,
-        VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize,
-        VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace,
-    },
-    layouts::{Backend, DataMut, DataRef, Module, Scratch},
+    layouts::{Backend, DataMut, Module, Scratch},
     source::Source,
 };
 
 use crate::{
-    encryption::{SIGMA, glwe_ct::glwe_encrypt_sk_internal},
+    encryption::{GLWEEncryptSk, GLWEEncryptSkInternal, SIGMA},
     layouts::{
-        GLWECiphertext, GLWEInfos, GLWEPlaintext, LWEInfos, compressed::GLWECiphertextCompressed, prepared::GLWESecretPrepared,
+        GLWECompressedSeedMut, GLWEInfos, GLWEPlaintextToRef, LWEInfos,
+        compressed::{GLWECompressed, GLWECompressedToMut},
+        prepared::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<M, A, BE: Backend>(module: &M, infos: &A) -> usize
     where
         A: GLWEInfos,
-        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes,
+        M: GLWECompressedEncryptSk<BE>,
     {
-        GLWECiphertext::encrypt_sk_scratch_space(module, infos)
+        module.glwe_compressed_encrypt_sk_tmp_bytes(infos)
     }
 }
 
-impl<D: DataMut> GLWECiphertextCompressed<D> {
+impl<D: DataMut> GLWECompressed<D> {
     #[allow(clippy::too_many_arguments)]
-    pub fn encrypt_sk<DataPt: DataRef, DataSk: DataRef, B: Backend>(
+    pub fn encrypt_sk<M, P, S, BE: Backend>(
         &mut self,
-        module: &Module<B>,
-        pt: &GLWEPlaintext<DataPt>,
-        sk: &GLWESecretPrepared<DataSk, B>,
+        module: &M,
+        pt: &P,
+        sk: &S,
         seed_xa: [u8; 32],
         source_xe: &mut Source,
-        scratch: &mut Scratch<B>,
+        scratch: &mut Scratch<BE>,
     ) 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,
+        M: GLWECompressedEncryptSk<BE>,
+        P: GLWEPlaintextToRef,
+        S: GLWESecretPreparedToRef<BE>,
+    {
+        module.glwe_compressed_encrypt_sk(self, pt, sk, seed_xa, source_xe, scratch);
+    }
+}
+
+pub trait GLWECompressedEncryptSk<BE: Backend> {
+    fn glwe_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GLWEInfos;
+
+    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<BE>,
+    ) where
+        R: GLWECompressedToMut + GLWECompressedSeedMut,
+        P: GLWEPlaintextToRef,
+        S: GLWESecretPreparedToRef<BE>;
+}
+
+impl<BE: Backend> GLWECompressedEncryptSk<BE> for Module<BE>
+where
+    Self: GLWEEncryptSkInternal<BE> + GLWEEncryptSk<BE>,
+{
+    fn glwe_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GLWEInfos,
     {
-        self.encrypt_sk_internal(module, Some((pt, 0)), sk, seed_xa, source_xe, scratch);
+        self.glwe_encrypt_sk_tmp_bytes(infos)
     }
 
-    #[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>,
+    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>,
+        scratch: &mut Scratch<BE>,
     ) 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 + GLWECompressedSeedMut,
+        P: GLWEPlaintextToRef,
+        S: GLWESecretPreparedToRef<BE>,
     {
-        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,
-            cols,
-            true,
-            pt,
-            sk,
-            &mut source_xa,
-            source_xe,
-            SIGMA,
-            scratch,
-        );
-        self.seed = seed_xa;
+        {
+            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,
+                Some((pt, 0)),
+                sk,
+                &mut source_xa,
+                source_xe,
+                SIGMA,
+                scratch,
+            );
+        }
+
+        res.seed_mut().copy_from_slice(&seed_xa);
     }
 }

@@ -0,0 +1,131 @@
+use poulpy_hal::{
+    api::{ModuleN, ScratchAvailable, ScratchTakeBasic, SvpPrepare, VecZnxSwitchRing},
+    layouts::{Backend, DataMut, Module, ScalarZnx, Scratch},
+    source::Source,
+};
+
+use crate::{
+    GGLWECompressedEncryptSk, ScratchTakeCore,
+    layouts::{
+        GGLWECompressedSeedMut, GGLWECompressedToMut, GGLWEInfos, GLWEInfos, GLWESecret, GLWESecretToRef,
+        GLWESwitchingKeyDegreesMut, LWEInfos,
+        compressed::GLWESwitchingKeyCompressed,
+        prepared::{GLWESecretPrepared, GLWESecretPreparedFactory},
+    },
+};
+
+impl GLWESwitchingKeyCompressed<Vec<u8>> {
+    pub fn encrypt_sk_tmp_bytes<M, A, BE: Backend>(module: &M, infos: &A) -> usize
+    where
+        A: GGLWEInfos,
+        M: GLWESwitchingKeyCompressedEncryptSk<BE>,
+    {
+        module.glwe_switching_key_compressed_encrypt_sk_tmp_bytes(infos)
+    }
+}
+
+impl<D: DataMut> GLWESwitchingKeyCompressed<D> {
+    #[allow(clippy::too_many_arguments)]
+    pub fn encrypt_sk<M, S1, S2, BE: Backend>(
+        &mut self,
+        module: &M,
+        sk_in: &S1,
+        sk_out: &S2,
+        seed_xa: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        S1: GLWESecretToRef,
+        S2: GLWESecretToRef,
+        M: GLWESwitchingKeyCompressedEncryptSk<BE>,
+    {
+        module.glwe_switching_key_compressed_encrypt_sk(self, sk_in, sk_out, seed_xa, source_xe, scratch);
+    }
+}
+
+pub trait GLWESwitchingKeyCompressedEncryptSk<BE: Backend> {
+    fn glwe_switching_key_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GGLWEInfos;
+
+    fn glwe_switching_key_compressed_encrypt_sk<R, S1, S2>(
+        &self,
+        res: &mut R,
+        sk_in: &S1,
+        sk_out: &S2,
+        seed_xa: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        R: GGLWECompressedToMut + GGLWECompressedSeedMut + GLWESwitchingKeyDegreesMut + GGLWEInfos,
+        S1: GLWESecretToRef,
+        S2: GLWESecretToRef;
+}
+
+impl<BE: Backend> GLWESwitchingKeyCompressedEncryptSk<BE> for Module<BE>
+where
+    Self: ModuleN + GGLWECompressedEncryptSk<BE> + GLWESecretPreparedFactory<BE> + VecZnxSwitchRing,
+    Scratch<BE>: ScratchTakeCore<BE>,
+{
+    fn glwe_switching_key_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GGLWEInfos,
+    {
+        self.gglwe_compressed_encrypt_sk_tmp_bytes(infos)
+            .max(ScalarZnx::bytes_of(self.n(), 1))
+            + ScalarZnx::bytes_of(self.n(), infos.rank_in().into())
+            + GLWESecretPrepared::bytes_of(self, infos.rank_out())
+    }
+
+    fn glwe_switching_key_compressed_encrypt_sk<R, S1, S2>(
+        &self,
+        res: &mut R,
+        sk_in: &S1,
+        sk_out: &S2,
+        seed_xa: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        R: GGLWECompressedToMut + GGLWECompressedSeedMut + GLWESwitchingKeyDegreesMut + GGLWEInfos,
+        S1: GLWESecretToRef,
+        S2: GLWESecretToRef,
+    {
+        let sk_in: &GLWESecret<&[u8]> = &sk_in.to_ref();
+        let sk_out: &GLWESecret<&[u8]> = &sk_out.to_ref();
+
+        assert!(sk_in.n().0 <= self.n() as u32);
+        assert!(sk_out.n().0 <= self.n() as u32);
+        assert!(
+            scratch.available() >= self.gglwe_compressed_encrypt_sk_tmp_bytes(res),
+            "scratch.available()={} < GLWESwitchingKey::encrypt_sk_tmp_bytes={}",
+            scratch.available(),
+            self.gglwe_compressed_encrypt_sk_tmp_bytes(res)
+        );
+
+        let (mut sk_in_tmp, scratch_1) = scratch.take_scalar_znx(self.n(), sk_in.rank().into());
+        for i in 0..sk_in.rank().into() {
+            self.vec_znx_switch_ring(
+                &mut sk_in_tmp.as_vec_znx_mut(),
+                i,
+                &sk_in.data.as_vec_znx(),
+                i,
+            );
+        }
+
+        let (mut sk_out_tmp, scratch_2) = scratch_1.take_glwe_secret_prepared(self, sk_out.rank());
+        {
+            let (mut tmp, _) = scratch_2.take_scalar_znx(self.n(), 1);
+            for i in 0..sk_out.rank().into() {
+                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);
+            }
+        }
+
+        sk_out_tmp.dist = sk_out.dist;
+
+        self.gglwe_compressed_encrypt_sk(res, &sk_in_tmp, &sk_out_tmp, seed_xa, source_xe, scratch_2);
+
+        *res.input_degree() = sk_in.n();
+        *res.output_degree() = sk_out.n();
+    }
+}

@@ -0,0 +1,156 @@
+use poulpy_hal::{
+    api::{
+        ModuleN, ScratchTakeBasic, SvpApplyDftToDft, SvpPPolBytesOf, SvpPrepare, VecZnxBigBytesOf, VecZnxBigNormalize,
+        VecZnxDftApply, VecZnxDftBytesOf, VecZnxIdftApplyTmpA,
+    },
+    layouts::{Backend, DataMut, Module, Scratch},
+    source::Source,
+};
+
+use crate::{
+    GGLWECompressedEncryptSk, GLWETensorKeyEncryptSk, GetDistribution, ScratchTakeCore,
+    layouts::{
+        GGLWEInfos, GLWEInfos, GLWESecret, GLWESecretPrepared, GLWESecretPreparedFactory, GLWESecretToRef,
+        GLWETensorKeyCompressedAtMut, LWEInfos, Rank, compressed::GLWETensorKeyCompressed,
+    },
+};
+
+impl GLWETensorKeyCompressed<Vec<u8>> {
+    pub fn encrypt_sk_tmp_bytes<M, A, BE: Backend>(module: &M, infos: &A) -> usize
+    where
+        A: GGLWEInfos,
+        M: GLWETensorKeyCompressedEncryptSk<BE>,
+    {
+        module.glwe_tensor_key_compressed_encrypt_sk_tmp_bytes(infos)
+    }
+}
+
+impl<DataSelf: DataMut> GLWETensorKeyCompressed<DataSelf> {
+    pub fn encrypt_sk<S, M, BE: Backend>(
+        &mut self,
+        module: &M,
+        sk: &S,
+        seed_xa: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        S: GLWESecretToRef + GetDistribution,
+        M: GLWETensorKeyCompressedEncryptSk<BE>,
+    {
+        module.glwe_tensor_key_compressed_encrypt_sk(self, sk, seed_xa, source_xe, scratch);
+    }
+}
+
+pub trait GLWETensorKeyCompressedEncryptSk<BE: Backend> {
+    fn glwe_tensor_key_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GGLWEInfos;
+
+    fn glwe_tensor_key_compressed_encrypt_sk<R, S, D>(
+        &self,
+        res: &mut R,
+        sk: &S,
+        seed_xa: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        D: DataMut,
+        R: GLWETensorKeyCompressedAtMut<D> + GGLWEInfos,
+        S: GLWESecretToRef + GetDistribution;
+}
+
+impl<BE: Backend> GLWETensorKeyCompressedEncryptSk<BE> for Module<BE>
+where
+    Self: ModuleN
+        + GGLWECompressedEncryptSk<BE>
+        + GLWETensorKeyEncryptSk<BE>
+        + VecZnxDftApply<BE>
+        + SvpApplyDftToDft<BE>
+        + VecZnxIdftApplyTmpA<BE>
+        + VecZnxBigNormalize<BE>
+        + SvpPrepare<BE>
+        + SvpPPolBytesOf
+        + VecZnxDftBytesOf
+        + VecZnxBigBytesOf
+        + GLWESecretPreparedFactory<BE>,
+    Scratch<BE>: ScratchTakeBasic + ScratchTakeCore<BE>,
+{
+    fn glwe_tensor_key_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GGLWEInfos,
+    {
+        GLWESecretPrepared::bytes_of(self, infos.rank_out())
+            + self.bytes_of_vec_znx_dft(infos.rank_out().into(), 1)
+            + self.bytes_of_vec_znx_big(1, 1)
+            + self.bytes_of_vec_znx_dft(1, 1)
+            + GLWESecret::bytes_of(self.n().into(), Rank(1))
+            + self.gglwe_compressed_encrypt_sk_tmp_bytes(infos)
+    }
+
+    fn glwe_tensor_key_compressed_encrypt_sk<R, S, D>(
+        &self,
+        res: &mut R,
+        sk: &S,
+        seed_xa: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        D: DataMut,
+        R: GGLWEInfos + GLWETensorKeyCompressedAtMut<D>,
+        S: GLWESecretToRef + GetDistribution,
+    {
+        let (mut sk_dft_prep, scratch_1) = scratch.take_glwe_secret_prepared(self, res.rank());
+        sk_dft_prep.prepare(self, sk);
+
+        let sk: &GLWESecret<&[u8]> = &sk.to_ref();
+
+        #[cfg(debug_assertions)]
+        {
+            assert_eq!(res.rank_out(), sk.rank());
+            assert_eq!(res.n(), sk.n());
+        }
+
+        // let n: usize = sk.n().into();
+        let rank: usize = res.rank_out().into();
+
+        let (mut sk_dft, scratch_2) = scratch_1.take_vec_znx_dft(self, rank, 1);
+
+        for i in 0..rank {
+            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(self, 1, 1);
+        let (mut sk_ij, scratch_4) = scratch_3.take_glwe_secret(self.n().into(), Rank(1));
+        let (mut sk_ij_dft, scratch_5) = scratch_4.take_vec_znx_dft(self, 1, 1);
+
+        let mut source_xa: Source = Source::new(seed_xa);
+
+        for i in 0..rank {
+            for j in i..rank {
+                self.svp_apply_dft_to_dft(&mut sk_ij_dft, 0, &sk_dft_prep.data, j, &sk_dft, i);
+
+                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,
+                    res.base2k().into(),
+                    &sk_ij_big,
+                    0,
+                    scratch_5,
+                );
+
+                let (seed_xa_tmp, _) = source_xa.branch();
+
+                self.gglwe_compressed_encrypt_sk(
+                    res.at_mut(i, j),
+                    &sk_ij.data,
+                    &sk_dft_prep,
+                    seed_xa_tmp,
+                    source_xe,
+                    scratch_5,
+                );
+            }
+        }
+    }
+}

@@ -1,6 +1,13 @@
-mod gglwe_atk;
-mod gglwe_ct;
-mod gglwe_ksk;
-mod gglwe_tsk;
-mod ggsw_ct;
+mod gglwe;
+mod ggsw;
+mod glwe_automorphism_key;
 mod glwe_ct;
+mod glwe_switching_key;
+mod glwe_tensor_key;
+
+pub use gglwe::*;
+pub use ggsw::*;
+pub use glwe_automorphism_key::*;
+pub use glwe_ct::*;
+pub use glwe_switching_key::*;
+pub use glwe_tensor_key::*;

@@ -0,0 +1,174 @@
+use poulpy_hal::{
+    api::{ModuleN, ScratchAvailable, VecZnxAddScalarInplace, VecZnxDftBytesOf, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes},
+    layouts::{Backend, DataMut, Module, ScalarZnx, ScalarZnxToRef, Scratch, ZnxInfos, ZnxZero},
+    source::Source,
+};
+
+use crate::{
+    GLWEEncryptSk, ScratchTakeCore,
+    layouts::{
+        GGLWE, GGLWEInfos, GGLWEToMut, GLWEPlaintext, LWEInfos,
+        prepared::{GLWESecretPrepared, GLWESecretPreparedToRef},
+    },
+};
+
+impl GGLWE<Vec<u8>> {
+    pub fn encrypt_sk_tmp_bytes<M, A, BE: Backend>(module: &M, infos: &A) -> usize
+    where
+        A: GGLWEInfos,
+        M: GGLWEEncryptSk<BE>,
+    {
+        module.gglwe_encrypt_sk_tmp_bytes(infos)
+    }
+
+    pub fn encrypt_pk_tmp_bytes<M, A, BE: Backend>(module: &M, infos: &A) -> usize
+    where
+        A: GGLWEInfos,
+        M: GGLWEEncryptSk<BE>,
+    {
+        module.gglwe_encrypt_sk_tmp_bytes(infos)
+    }
+}
+
+impl<D: DataMut> GGLWE<D> {
+    #[allow(clippy::too_many_arguments)]
+    pub fn encrypt_sk<P, S, M, BE: Backend>(
+        &mut self,
+        module: &M,
+        pt: &P,
+        sk: &S,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        P: ScalarZnxToRef,
+        S: GLWESecretPreparedToRef<BE>,
+        M: GGLWEEncryptSk<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        module.gglwe_encrypt_sk(self, pt, sk, source_xa, source_xe, scratch);
+    }
+}
+
+pub trait GGLWEEncryptSk<BE: Backend> {
+    fn gglwe_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GGLWEInfos;
+
+    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<BE>,
+    ) where
+        R: GGLWEToMut,
+        P: ScalarZnxToRef,
+        S: GLWESecretPreparedToRef<BE>;
+}
+
+impl<BE: Backend> GGLWEEncryptSk<BE> for Module<BE>
+where
+    Self: ModuleN
+        + GLWEEncryptSk<BE>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxDftBytesOf
+        + VecZnxAddScalarInplace
+        + VecZnxNormalizeInplace<BE>,
+    Scratch<BE>: ScratchTakeCore<BE>,
+{
+    fn gglwe_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GGLWEInfos,
+    {
+        self.glwe_encrypt_sk_tmp_bytes(infos) + GLWEPlaintext::bytes_of_from_infos(infos).max(self.vec_znx_normalize_tmp_bytes())
+    }
+
+    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<BE>,
+    ) where
+        R: GGLWEToMut,
+        P: ScalarZnxToRef,
+        S: GLWESecretPreparedToRef<BE>,
+    {
+        let res: &mut GGLWE<&mut [u8]> = &mut res.to_mut();
+        let pt: &ScalarZnx<&[u8]> = &pt.to_ref();
+        let sk: &GLWESecretPrepared<&[u8], BE> = &sk.to_ref();
+
+        assert_eq!(
+            res.rank_in(),
+            pt.cols() as u32,
+            "res.rank_in(): {} != pt.cols(): {}",
+            res.rank_in(),
+            pt.cols()
+        );
+        assert_eq!(
+            res.rank_out(),
+            sk.rank(),
+            "res.rank_out(): {} != sk.rank(): {}",
+            res.rank_out(),
+            sk.rank()
+        );
+        assert_eq!(res.n(), sk.n());
+        assert_eq!(pt.n() as u32, sk.n());
+        assert!(
+            scratch.available() >= self.gglwe_encrypt_sk_tmp_bytes(res),
+            "scratch.available: {} < GGLWE::encrypt_sk_tmp_bytes(self, res.rank()={}, res.size()={}): {}",
+            scratch.available(),
+            res.rank_out(),
+            res.size(),
+            self.gglwe_encrypt_sk_tmp_bytes(res)
+        );
+        assert!(
+            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 = 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_plaintext(res);
+        // For each input column (i.e. rank) produces a GGLWE of rank_out+1 columns
+        //
+        // Example for ksk rank 2 to rank 3:
+        //
+        // (-(a0*s0 + a1*s1 + a2*s2) + s0', a0, a1, a2)
+        // (-(b0*s0 + b1*s1 + b2*s2) + s0', b0, b1, b2)
+        //
+        // Example ksk rank 2 to rank 1
+        //
+        // (-(a*s) + s0, a)
+        // (-(b*s) + s1, b)
+        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
+                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,
+                );
+            }
+        }
+    }
+}

@@ -1,109 +0,0 @@
-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,
-    },
-    layouts::{Backend, DataMut, DataRef, Module, Scratch},
-    source::Source,
-};
-
-use crate::{
-    TakeGLWESecret, TakeGLWESecretPrepared,
-    layouts::{GGLWEAutomorphismKey, GGLWEInfos, GGLWESwitchingKey, GLWEInfos, GLWESecret, LWEInfos},
-};
-
-impl GGLWEAutomorphismKey<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
-    where
-        A: GGLWEInfos,
-        Module<B>: SvpPPolAllocBytes + VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes + 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())
-    }
-
-    pub fn encrypt_pk_scratch_space<B: Backend, A>(module: &Module<B>, _infos: &A) -> usize
-    where
-        A: GGLWEInfos,
-    {
-        assert_eq!(
-            _infos.rank_in(),
-            _infos.rank_out(),
-            "rank_in != rank_out is not supported for GGLWEAutomorphismKey"
-        );
-        GGLWESwitchingKey::encrypt_pk_scratch_space(module, _infos)
-    }
-}
-
-impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
-    #[allow(clippy::too_many_arguments)]
-    pub fn encrypt_sk<DataSk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        p: i64,
-        sk: &GLWESecret<DataSk>,
-        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
-            + SvpPrepare<B>
-            + VecZnxSwitchRing
-            + SvpPPolAllocBytes
-            + VecZnxAutomorphism,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx + TakeScalarZnx + TakeGLWESecretPrepared<B>,
-    {
-        #[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!(
-                scratch.available() >= GGLWEAutomorphismKey::encrypt_sk_scratch_space(module, self),
-                "scratch.available(): {} < AutomorphismKey::encrypt_sk_scratch_space: {:?}",
-                scratch.available(),
-                GGLWEAutomorphismKey::encrypt_sk_scratch_space(module, self)
-            )
-        }
-
-        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),
-                    &mut sk_out.data.as_vec_znx_mut(),
-                    i,
-                    &sk.data.as_vec_znx(),
-                    i,
-                );
-            });
-        }
-
-        self.key
-            .encrypt_sk(module, sk, &sk_out, source_xa, source_xe, scratch_1);
-
-        self.p = p;
-    }
-}

@@ -1,130 +0,0 @@
-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},
-    source::Source,
-};
-
-use crate::{
-    TakeGLWEPt,
-    layouts::{GGLWECiphertext, GGLWEInfos, GLWECiphertext, GLWEPlaintext, LWEInfos, prepared::GLWESecretPrepared},
-};
-
-impl GGLWECiphertext<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
-    where
-        A: GGLWEInfos,
-        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes + VecZnxNormalizeTmpBytes,
-    {
-        GLWECiphertext::encrypt_sk_scratch_space(module, &infos.glwe_layout())
-            + (GLWEPlaintext::alloc_bytes(&infos.glwe_layout()) | module.vec_znx_normalize_tmp_bytes())
-    }
-
-    pub fn encrypt_pk_scratch_space<B: Backend, A>(_module: &Module<B>, _infos: &A) -> usize
-    where
-        A: GGLWEInfos,
-    {
-        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>,
-        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,
-    {
-        #[cfg(debug_assertions)]
-        {
-            use poulpy_hal::layouts::ZnxInfos;
-
-            assert_eq!(
-                self.rank_in(),
-                pt.cols() as u32,
-                "self.rank_in(): {} != pt.cols(): {}",
-                self.rank_in(),
-                pt.cols()
-            );
-            assert_eq!(
-                self.rank_out(),
-                sk.rank(),
-                "self.rank_out(): {} != sk.rank(): {}",
-                self.rank_out(),
-                sk.rank()
-            );
-            assert_eq!(self.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(),
-                self.rank_out(),
-                self.size(),
-                GGLWECiphertext::encrypt_sk_scratch_space(module, self)
-            );
-            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()
-            );
-        }
-
-        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 (mut tmp_pt, scrach_1) = scratch.take_glwe_pt(self);
-        // For each input column (i.e. rank) produces a GGLWE ciphertext of rank_out+1 columns
-        //
-        // Example for ksk rank 2 to rank 3:
-        //
-        // (-(a0*s0 + a1*s1 + a2*s2) + s0', a0, a1, a2)
-        // (-(b0*s0 + b1*s1 + b2*s2) + s0', b0, b1, b2)
-        //
-        // 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| {
-                // 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);
-
-                // 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);
-            });
-        });
-    }
-}

@@ -1,112 +0,0 @@
-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,
-    },
-    layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, Scratch},
-    source::Source,
-};
-
-use crate::{
-    TakeGLWESecretPrepared,
-    layouts::{
-        Degree, GGLWECiphertext, GGLWEInfos, GGLWESwitchingKey, GLWEInfos, GLWESecret, LWEInfos, prepared::GLWESecretPrepared,
-    },
-};
-
-impl GGLWESwitchingKey<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
-    where
-        A: GGLWEInfos,
-        Module<B>: SvpPPolAllocBytes + VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes + 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())
-    }
-
-    pub fn encrypt_pk_scratch_space<B: Backend, A>(module: &Module<B>, _infos: &A) -> usize
-    where
-        A: GGLWEInfos,
-    {
-        GGLWECiphertext::encrypt_pk_scratch_space(module, _infos)
-    }
-}
-
-impl<DataSelf: DataMut> GGLWESwitchingKey<DataSelf> {
-    #[allow(clippy::too_many_arguments)]
-    pub fn encrypt_sk<DataSkIn: DataRef, DataSkOut: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        sk_in: &GLWESecret<DataSkIn>,
-        sk_out: &GLWESecret<DataSkOut>,
-        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
-            + SvpPrepare<B>
-            + VecZnxSwitchRing
-            + SvpPPolAllocBytes,
-        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx + TakeScalarZnx + TakeGLWESecretPrepared<B>,
-    {
-        #[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(),
-                GGLWESwitchingKey::encrypt_sk_scratch_space(module, self)
-            )
-        }
-
-        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(
-                &mut sk_in_tmp.as_vec_znx_mut(),
-                i,
-                &sk_in.data.as_vec_znx(),
-                i,
-            );
-        });
-
-        let (mut sk_out_tmp, scratch_2) = scratch_1.take_glwe_secret_prepared(Degree(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.key.encrypt_sk(
-            module,
-            &sk_in_tmp,
-            &sk_out_tmp,
-            source_xa,
-            source_xe,
-            scratch_2,
-        );
-        self.sk_in_n = sk_in.n().into();
-        self.sk_out_n = sk_out.n().into();
-    }
-}

@@ -1,109 +0,0 @@
-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,
-    },
-    layouts::{Backend, DataMut, DataRef, Module, Scratch},
-    source::Source,
-};
-
-use crate::{
-    TakeGLWESecret, TakeGLWESecretPrepared,
-    layouts::{
-        Degree, GGLWEInfos, GGLWESwitchingKey, GGLWETensorKey, GLWEInfos, GLWESecret, LWEInfos, Rank,
-        prepared::{GLWESecretPrepared, Prepare},
-    },
-};
-
-impl GGLWETensorKey<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
-    where
-        A: GGLWEInfos,
-        Module<B>:
-            SvpPPolAllocBytes + VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes + VecZnxNormalizeTmpBytes + VecZnxBigAllocBytes,
-    {
-        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)
-    }
-}
-
-impl<DataSelf: DataMut> GGLWETensorKey<DataSelf> {
-    pub fn encrypt_sk<DataSk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        sk: &GLWESecret<DataSk>,
-        source_xa: &mut Source,
-        source_xe: &mut Source,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: SvpApplyDftToDft<B>
-            + VecZnxIdftApplyTmpA<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,
-        Scratch<B>:
-            TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx + TakeScalarZnx + TakeGLWESecretPrepared<B> + TakeVecZnxBig<B>,
-    {
-        #[cfg(debug_assertions)]
-        {
-            assert_eq!(self.rank_out(), sk.rank());
-            assert_eq!(self.n(), sk.n());
-        }
-
-        let n: Degree = sk.n();
-        let rank: Rank = self.rank_out();
-
-        let (mut sk_dft_prep, scratch_1) = scratch.take_glwe_secret_prepared(n, rank);
-        sk_dft_prep.prepare(module, sk, scratch_1);
-
-        let (mut sk_dft, scratch_2) = scratch_1.take_vec_znx_dft(n.into(), rank.into(), 1);
-
-        (0..rank.into()).for_each(|i| {
-            module.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.into(), 1, 1);
-        let (mut sk_ij, scratch_4) = scratch_3.take_glwe_secret(n, Rank(1));
-        let (mut sk_ij_dft, scratch_5) = scratch_4.take_vec_znx_dft(n.into(), 1, 1);
-
-        (0..rank.into()).for_each(|i| {
-            (i..rank.into()).for_each(|j| {
-                module.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(),
-                    &mut sk_ij.data.as_vec_znx_mut(),
-                    0,
-                    self.base2k().into(),
-                    &sk_ij_big,
-                    0,
-                    scratch_5,
-                );
-
-                self.at_mut(i, j)
-                    .encrypt_sk(module, &sk_ij, sk, source_xa, source_xe, scratch_5);
-            });
-        })
-    }
-}

@@ -0,0 +1,136 @@
+use poulpy_hal::{
+    api::{ModuleN, VecZnxAddScalarInplace, VecZnxDftBytesOf, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes},
+    layouts::{Backend, DataMut, Module, ScalarZnx, ScalarZnxToRef, Scratch, ZnxInfos, ZnxZero},
+    source::Source,
+};
+
+use crate::{
+    GLWEEncryptSk, GLWEEncryptSkInternal, SIGMA, ScratchTakeCore,
+    layouts::{
+        GGSW, GGSWInfos, GGSWToMut, GLWEInfos, GLWEPlaintext, LWEInfos,
+        prepared::{GLWESecretPrepared, GLWESecretPreparedToRef},
+    },
+};
+
+impl GGSW<Vec<u8>> {
+    pub fn encrypt_sk_tmp_bytes<M, A, BE: Backend>(module: &M, infos: &A) -> usize
+    where
+        A: GGSWInfos,
+        M: GGSWEncryptSk<BE>,
+    {
+        module.ggsw_encrypt_sk_tmp_bytes(infos)
+    }
+}
+
+impl<D: DataMut> GGSW<D> {
+    #[allow(clippy::too_many_arguments)]
+    pub fn encrypt_sk<P, S, M, BE: Backend>(
+        &mut self,
+        module: &M,
+        pt: &P,
+        sk: &S,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        P: ScalarZnxToRef,
+        S: GLWESecretPreparedToRef<BE>,
+        M: GGSWEncryptSk<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        module.ggsw_encrypt_sk(self, pt, sk, source_xa, source_xe, scratch);
+    }
+}
+
+pub trait GGSWEncryptSk<BE: Backend> {
+    fn ggsw_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GGSWInfos;
+
+    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<BE>,
+    ) where
+        R: GGSWToMut,
+        P: ScalarZnxToRef,
+        S: GLWESecretPreparedToRef<BE>;
+}
+
+impl<BE: Backend> GGSWEncryptSk<BE> for Module<BE>
+where
+    Self: ModuleN
+        + GLWEEncryptSkInternal<BE>
+        + GLWEEncryptSk<BE>
+        + VecZnxDftBytesOf
+        + VecZnxNormalizeInplace<BE>
+        + VecZnxAddScalarInplace
+        + VecZnxNormalizeTmpBytes,
+    Scratch<BE>: ScratchTakeCore<BE>,
+{
+    fn ggsw_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GGSWInfos,
+    {
+        self.glwe_encrypt_sk_tmp_bytes(infos)
+            .max(self.vec_znx_normalize_tmp_bytes())
+            + GLWEPlaintext::bytes_of_from_infos(infos)
+    }
+
+    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<BE>,
+    ) where
+        R: GGSWToMut,
+        P: ScalarZnxToRef,
+        S: GLWESecretPreparedToRef<BE>,
+    {
+        let res: &mut GGSW<&mut [u8]> = &mut res.to_mut();
+        let pt: &ScalarZnx<&[u8]> = &pt.to_ref();
+        let sk: &GLWESecretPrepared<&[u8], BE> = &sk.to_ref();
+
+        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 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;
+
+        let (mut tmp_pt, scratch_1) = scratch.take_glwe_plaintext(res);
+
+        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
+            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,
+                );
+            }
+        }
+    }
+}

@@ -1,93 +0,0 @@
-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},
-    source::Source,
-};
-
-use crate::{
-    TakeGLWEPt,
-    layouts::{GGSWCiphertext, GGSWInfos, GLWECiphertext, GLWEInfos, LWEInfos, prepared::GLWESecretPrepared},
-};
-
-impl GGSWCiphertext<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
-    where
-        A: GGSWInfos,
-        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes,
-    {
-        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)
-    }
-}
-
-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>,
-        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,
-    {
-        #[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());
-        }
-
-        let base2k: usize = self.base2k().into();
-        let rank: usize = self.rank().into();
-        let dsize: usize = self.dsize().into();
-
-        let (mut tmp_pt, scratch_1) = scratch.take_glwe_pt(&self.glwe_layout());
-
-        (0..self.dnum().into()).for_each(|row_i| {
-            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,
-                    Some((&tmp_pt, col_j)),
-                    sk,
-                    source_xa,
-                    source_xe,
-                    scratch_1,
-                );
-            });
-        });
-    }
-}

@@ -0,0 +1,562 @@
+use poulpy_hal::{
+    api::{
+        ModuleN, ScratchAvailable, ScratchTakeBasic, SvpApplyDftToDft, SvpApplyDftToDftInplace, SvpPPolBytesOf, SvpPrepare,
+        VecZnxAddInplace, VecZnxAddNormal, VecZnxBigAddNormal, VecZnxBigAddSmallInplace, VecZnxBigBytesOf, VecZnxBigNormalize,
+        VecZnxDftApply, VecZnxDftBytesOf, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace,
+        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace,
+    },
+    layouts::{Backend, DataMut, Module, ScalarZnx, Scratch, VecZnx, VecZnxBig, VecZnxToMut, ZnxInfos, ZnxZero},
+    source::Source,
+};
+
+use crate::{
+    GetDistribution, ScratchTakeCore,
+    dist::Distribution,
+    encryption::{SIGMA, SIGMA_BOUND},
+    layouts::{
+        GLWE, GLWEInfos, GLWEPlaintext, GLWEPlaintextToRef, GLWEPrepared, GLWEPreparedToRef, GLWEToMut, LWEInfos,
+        prepared::{GLWESecretPrepared, GLWESecretPreparedToRef},
+    },
+};
+
+impl GLWE<Vec<u8>> {
+    pub fn encrypt_sk_tmp_bytes<M, A, BE: Backend>(module: &M, infos: &A) -> usize
+    where
+        A: GLWEInfos,
+        M: GLWEEncryptSk<BE>,
+    {
+        module.glwe_encrypt_sk_tmp_bytes(infos)
+    }
+
+    pub fn encrypt_pk_tmp_bytes<M, A, BE: Backend>(module: &M, infos: &A) -> usize
+    where
+        A: GLWEInfos,
+        M: GLWEEncryptPk<BE>,
+    {
+        module.glwe_encrypt_pk_tmp_bytes(infos)
+    }
+}
+
+impl<D: DataMut> GLWE<D> {
+    pub fn encrypt_sk<P, S, M, BE: Backend>(
+        &mut self,
+        module: &M,
+        pt: &P,
+        sk: &S,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        P: GLWEPlaintextToRef,
+        S: GLWESecretPreparedToRef<BE>,
+        M: GLWEEncryptSk<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        module.glwe_encrypt_sk(self, pt, sk, source_xa, source_xe, scratch);
+    }
+
+    pub fn encrypt_zero_sk<S, M, BE: Backend>(
+        &mut self,
+        module: &M,
+        sk: &S,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        S: GLWESecretPreparedToRef<BE>,
+        M: GLWEEncryptSk<BE>,
+        Scratch<BE>: ScratchTakeCore<BE>,
+    {
+        module.glwe_encrypt_zero_sk(self, sk, source_xa, source_xe, scratch);
+    }
+
+    pub fn encrypt_pk<P, K, M, BE: Backend>(
+        &mut self,
+        module: &M,
+        pt: &P,
+        pk: &K,
+        source_xu: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        P: GLWEPlaintextToRef + GLWEInfos,
+        K: GLWEPreparedToRef<BE> + GetDistribution + GLWEInfos,
+        M: GLWEEncryptPk<BE>,
+    {
+        module.glwe_encrypt_pk(self, pt, pk, source_xu, source_xe, scratch);
+    }
+
+    pub fn encrypt_zero_pk<K, M, BE: Backend>(
+        &mut self,
+        module: &M,
+        pk: &K,
+        source_xu: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        K: GLWEPreparedToRef<BE> + GetDistribution + GLWEInfos,
+        M: GLWEEncryptPk<BE>,
+    {
+        module.glwe_encrypt_zero_pk(self, pk, source_xu, source_xe, scratch);
+    }
+}
+
+pub trait GLWEEncryptSk<BE: Backend> {
+    fn glwe_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GLWEInfos;
+
+    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<BE>,
+    ) where
+        R: GLWEToMut,
+        P: GLWEPlaintextToRef,
+        S: GLWESecretPreparedToRef<BE>;
+
+    fn glwe_encrypt_zero_sk<R, S>(
+        &self,
+        res: &mut R,
+        sk: &S,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        R: GLWEToMut,
+        S: GLWESecretPreparedToRef<BE>;
+}
+
+impl<BE: Backend> GLWEEncryptSk<BE> for Module<BE>
+where
+    Self: Sized + ModuleN + VecZnxNormalizeTmpBytes + VecZnxDftBytesOf + GLWEEncryptSkInternal<BE>,
+    Scratch<BE>: ScratchAvailable,
+{
+    fn glwe_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GLWEInfos,
+    {
+        let size: usize = infos.size();
+        assert_eq!(self.n() as u32, infos.n());
+        self.vec_znx_normalize_tmp_bytes() + 2 * VecZnx::bytes_of(self.n(), 1, size) + self.bytes_of_vec_znx_dft(1, size)
+    }
+
+    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<BE>,
+    ) where
+        R: GLWEToMut,
+        P: GLWEPlaintextToRef,
+        S: GLWESecretPreparedToRef<BE>,
+    {
+        let res: &mut GLWE<&mut [u8]> = &mut res.to_mut();
+        let pt: &GLWEPlaintext<&[u8]> = &pt.to_ref();
+        let sk: &GLWESecretPrepared<&[u8], BE> = &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() >= self.glwe_encrypt_sk_tmp_bytes(res),
+            "scratch.available(): {} < GLWE::encrypt_sk_tmp_bytes: {}",
+            scratch.available(),
+            self.glwe_encrypt_sk_tmp_bytes(res)
+        );
+
+        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,
+        );
+    }
+
+    fn glwe_encrypt_zero_sk<R, S>(
+        &self,
+        res: &mut R,
+        sk: &S,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        R: GLWEToMut,
+        S: GLWESecretPreparedToRef<BE>,
+    {
+        let res: &mut GLWE<&mut [u8]> = &mut res.to_mut();
+        let sk: &GLWESecretPrepared<&[u8], BE> = &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() >= self.glwe_encrypt_sk_tmp_bytes(res),
+            "scratch.available(): {} < GLWE::encrypt_sk_tmp_bytes: {}",
+            scratch.available(),
+            self.glwe_encrypt_sk_tmp_bytes(res)
+        );
+
+        let cols: usize = (res.rank() + 1).into();
+        self.glwe_encrypt_sk_internal(
+            res.base2k().into(),
+            res.k().into(),
+            res.data_mut(),
+            cols,
+            false,
+            None::<(&GLWEPlaintext<Vec<u8>>, usize)>,
+            sk,
+            source_xa,
+            source_xe,
+            SIGMA,
+            scratch,
+        );
+    }
+}
+
+pub trait GLWEEncryptPk<BE: Backend> {
+    fn glwe_encrypt_pk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GLWEInfos;
+
+    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<BE>,
+    ) where
+        R: GLWEToMut,
+        P: GLWEPlaintextToRef + GLWEInfos,
+        K: GLWEPreparedToRef<BE> + GetDistribution + GLWEInfos;
+
+    fn glwe_encrypt_zero_pk<R, K>(
+        &self,
+        res: &mut R,
+        pk: &K,
+        source_xu: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        R: GLWEToMut,
+        K: GLWEPreparedToRef<BE> + GetDistribution + GLWEInfos;
+}
+
+impl<BE: Backend> GLWEEncryptPk<BE> for Module<BE>
+where
+    Self: GLWEEncryptPkInternal<BE> + VecZnxDftBytesOf + SvpPPolBytesOf + VecZnxBigBytesOf + VecZnxNormalizeTmpBytes,
+{
+    fn glwe_encrypt_pk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GLWEInfos,
+    {
+        let size: usize = infos.size();
+        assert_eq!(self.n() as u32, infos.n());
+        ((self.bytes_of_vec_znx_dft(1, size) + self.bytes_of_vec_znx_big(1, size)).max(ScalarZnx::bytes_of(self.n(), 1)))
+            + self.bytes_of_svp_ppol(1)
+            + self.vec_znx_normalize_tmp_bytes()
+    }
+
+    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<BE>,
+    ) where
+        R: GLWEToMut,
+        P: GLWEPlaintextToRef + GLWEInfos,
+        K: GLWEPreparedToRef<BE> + GetDistribution + GLWEInfos,
+    {
+        self.glwe_encrypt_pk_internal(res, Some((pt, 0)), pk, source_xu, source_xe, scratch);
+    }
+
+    fn glwe_encrypt_zero_pk<R, K>(
+        &self,
+        res: &mut R,
+        pk: &K,
+        source_xu: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        R: GLWEToMut,
+        K: GLWEPreparedToRef<BE> + GetDistribution + GLWEInfos,
+    {
+        self.glwe_encrypt_pk_internal(
+            res,
+            None::<(&GLWEPlaintext<Vec<u8>>, usize)>,
+            pk,
+            source_xu,
+            source_xe,
+            scratch,
+        );
+    }
+}
+
+pub(crate) trait GLWEEncryptPkInternal<BE: 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<BE>,
+    ) where
+        R: GLWEToMut,
+        P: GLWEPlaintextToRef + GLWEInfos,
+        K: GLWEPreparedToRef<BE> + GetDistribution + GLWEInfos;
+}
+
+impl<BE: Backend> GLWEEncryptPkInternal<BE> for Module<BE>
+where
+    Self: SvpPrepare<BE>
+        + SvpApplyDftToDft<BE>
+        + VecZnxIdftApplyConsume<BE>
+        + VecZnxBigAddNormal<BE>
+        + VecZnxBigAddSmallInplace<BE>
+        + VecZnxBigNormalize<BE>
+        + SvpPPolBytesOf
+        + ModuleN
+        + VecZnxDftBytesOf,
+    Scratch<BE>: ScratchTakeBasic,
+{
+    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<BE>,
+    ) where
+        R: GLWEToMut,
+        P: GLWEPlaintextToRef + GLWEInfos,
+        K: GLWEPreparedToRef<BE> + GetDistribution + GLWEInfos,
+    {
+        let res: &mut GLWE<&mut [u8]> = &mut res.to_mut();
+
+        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());
+        }
+
+        let base2k: usize = pk.base2k().into();
+        let size_pk: usize = pk.size();
+        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, 1);
+
+        {
+            let (mut u, _) = scratch_1.take_scalar_znx(self.n(), 1);
+            match pk.dist() {
+                Distribution::NONE => panic!(
+                    "invalid public key: SecretDistribution::NONE, ensure it has been correctly intialized through \
+                     Self::generate"
+                ),
+                Distribution::TernaryFixed(hw) => u.fill_ternary_hw(0, *hw, source_xu),
+                Distribution::TernaryProb(prob) => u.fill_ternary_prob(0, *prob, source_xu),
+                Distribution::BinaryFixed(hw) => u.fill_binary_hw(0, *hw, source_xu),
+                Distribution::BinaryProb(prob) => u.fill_binary_prob(0, *prob, source_xu),
+                Distribution::BinaryBlock(block_size) => u.fill_binary_block(0, *block_size, source_xu),
+                Distribution::ZERO => {}
+            }
+
+            self.svp_prepare(&mut u_dft, 0, &u, 0);
+        }
+
+        {
+            let pk: &GLWEPrepared<&[u8], BE> = &pk.to_ref();
+
+            // ct[i] = pk[i] * u + ei (+ m if col = i)
+            for i in 0..cols {
+                let (mut ci_dft, scratch_2) = scratch_1.take_vec_znx_dft(self, 1, size_pk);
+                // ci_dft = DFT(u) * DFT(pk[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 = self.vec_znx_idft_apply_consume(ci_dft);
+
+                // ci_big = u * pk[i] + e
+                self.vec_znx_big_add_normal(
+                    base2k,
+                    &mut ci_big,
+                    0,
+                    pk.k().into(),
+                    source_xe,
+                    SIGMA,
+                    SIGMA_BOUND,
+                );
+
+                // ci_big = u * pk[i] + e + m (if col = i)
+                if let Some((pt, col)) = pt
+                    && col == i
+                {
+                    self.vec_znx_big_add_small_inplace(&mut ci_big, 0, &pt.to_ref().data, 0);
+                }
+
+                // ct[i] = norm(ci_big)
+                self.vec_znx_big_normalize(base2k, &mut res.data, i, base2k, &ci_big, 0, scratch_2);
+            }
+        }
+    }
+}
+
+pub(crate) trait GLWEEncryptSkInternal<BE: Backend> {
+    #[allow(clippy::too_many_arguments)]
+    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<BE>,
+    ) where
+        R: VecZnxToMut,
+        P: GLWEPlaintextToRef,
+        S: GLWESecretPreparedToRef<BE>;
+}
+
+impl<BE: Backend> GLWEEncryptSkInternal<BE> for Module<BE>
+where
+    Self: ModuleN
+        + VecZnxDftBytesOf
+        + VecZnxBigNormalize<BE>
+        + VecZnxDftApply<BE>
+        + SvpApplyDftToDftInplace<BE>
+        + VecZnxIdftApplyConsume<BE>
+        + VecZnxNormalizeTmpBytes
+        + VecZnxFillUniform
+        + VecZnxSubInplace
+        + VecZnxAddInplace
+        + VecZnxNormalizeInplace<BE>
+        + VecZnxAddNormal
+        + VecZnxNormalize<BE>
+        + VecZnxSub,
+    Scratch<BE>: ScratchTakeBasic,
+{
+    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<BE>,
+    ) where
+        R: VecZnxToMut,
+        P: GLWEPlaintextToRef,
+        S: GLWESecretPreparedToRef<BE>,
+    {
+        let ct: &mut VecZnx<&mut [u8]> = &mut res.to_mut();
+        let sk: GLWESecretPrepared<&[u8], BE> = sk.to_ref();
+
+        if compressed {
+            assert_eq!(
+                ct.cols(),
+                1,
+                "invalid glwe: compressed tag=true but #cols={} != 1",
+                ct.cols()
+            )
+        }
+
+        assert!(
+            sk.dist != Distribution::NONE,
+            "glwe secret distribution is NONE (have you prepared the key?)"
+        );
+
+        let size: usize = ct.size();
+
+        let (mut c0, scratch_1) = scratch.take_vec_znx(self.n(), 1, size);
+        c0.zero();
+
+        {
+            let (mut ci, scratch_2) = scratch_1.take_vec_znx(self.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 (+ pt)
+                self.vec_znx_fill_uniform(base2k, ct, col_ct, source_xa);
+
+                // println!("vec_znx_fill_uniform: {}", ct);
+
+                let (mut ci_dft, scratch_3) = scratch_2.take_vec_znx_dft(self, 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 {
+                        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 {
+                    self.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], BE> = self.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);
+
+                // c0_tmp = -c[i] * s[i] (use c[0] as buffer)
+                self.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] += 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] = norm(c[0])
+        self.vec_znx_normalize(base2k, ct, 0, base2k, &c0, 0, scratch_1);
+    }
+}

@@ -0,0 +1,163 @@
+use poulpy_hal::{
+    api::{ScratchAvailable, SvpPPolBytesOf, VecZnxAutomorphism},
+    layouts::{Backend, DataMut, GaloisElement, Module, Scratch},
+    source::Source,
+};
+
+use crate::{
+    GGLWEEncryptSk, ScratchTakeCore,
+    layouts::{
+        GGLWEInfos, GGLWEToMut, GGLWEToRef, GLWEAutomorphismKey, GLWEInfos, GLWESecret, GLWESecretPrepared,
+        GLWESecretPreparedFactory, GLWESecretToRef, LWEInfos, SetGaloisElement,
+    },
+};
+
+impl GLWEAutomorphismKey<Vec<u8>> {
+    pub fn encrypt_sk_tmp_bytes<M, A, BE: Backend>(module: &M, infos: &A) -> usize
+    where
+        A: GGLWEInfos,
+        M: GLWEAutomorphismKeyEncryptSk<BE>,
+    {
+        module.glwe_automorphism_key_encrypt_sk_tmp_bytes(infos)
+    }
+
+    pub fn encrypt_pk_tmp_bytes<M, A, BE: Backend>(module: &M, infos: &A) -> usize
+    where
+        A: GGLWEInfos,
+        M: GLWEAutomorphismKeyEncryptPk<BE>,
+    {
+        module.glwe_automorphism_key_encrypt_pk_tmp_bytes(infos)
+    }
+}
+
+impl<DM: DataMut> GLWEAutomorphismKey<DM>
+where
+    Self: GGLWEToRef,
+{
+    pub fn encrypt_sk<S, M, BE: Backend>(
+        &mut self,
+        module: &M,
+        p: i64,
+        sk: &S,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        S: GLWESecretToRef,
+        M: GLWEAutomorphismKeyEncryptSk<BE>,
+    {
+        module.glwe_automorphism_key_encrypt_sk(self, p, sk, source_xa, source_xe, scratch);
+    }
+}
+
+pub trait GLWEAutomorphismKeyEncryptSk<BE: Backend> {
+    fn glwe_automorphism_key_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GGLWEInfos;
+
+    fn glwe_automorphism_key_encrypt_sk<R, S>(
+        &self,
+        res: &mut R,
+        p: i64,
+        sk: &S,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        R: GGLWEToMut + SetGaloisElement + GGLWEInfos,
+        S: GLWESecretToRef;
+}
+
+impl<BE: Backend> GLWEAutomorphismKeyEncryptSk<BE> for Module<BE>
+where
+    Self: GGLWEEncryptSk<BE> + VecZnxAutomorphism + GaloisElement + SvpPPolBytesOf + GLWESecretPreparedFactory<BE>,
+    Scratch<BE>: ScratchTakeCore<BE>,
+{
+    fn glwe_automorphism_key_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GGLWEInfos,
+    {
+        assert_eq!(
+            infos.rank_in(),
+            infos.rank_out(),
+            "rank_in != rank_out is not supported for GGLWEAutomorphismKey"
+        );
+        GLWESecretPrepared::bytes_of_from_infos(self, infos)
+            + self
+                .gglwe_encrypt_sk_tmp_bytes(infos)
+                .max(GLWESecret::bytes_of_from_infos(infos))
+    }
+
+    fn glwe_automorphism_key_encrypt_sk<R, S>(
+        &self,
+        res: &mut R,
+        p: i64,
+        sk: &S,
+        source_xa: &mut Source,
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        R: GGLWEToMut + SetGaloisElement + GGLWEInfos,
+        S: GLWESecretToRef,
+    {
+        let sk: &GLWESecret<&[u8]> = &sk.to_ref();
+
+        assert_eq!(res.n(), sk.n());
+        assert_eq!(res.rank_out(), res.rank_in());
+        assert_eq!(sk.rank(), res.rank_out());
+        assert!(
+            scratch.available() >= self.glwe_automorphism_key_encrypt_sk_tmp_bytes(res),
+            "scratch.available(): {} < AutomorphismKey::encrypt_sk_tmp_bytes: {:?}",
+            scratch.available(),
+            self.glwe_automorphism_key_encrypt_sk_tmp_bytes(res)
+        );
+
+        let (mut sk_out_prepared, scratch_1) = scratch.take_glwe_secret_prepared(self, sk.rank());
+
+        {
+            let (mut sk_out, _) = scratch_1.take_glwe_secret(sk.n(), sk.rank());
+            sk_out.dist = sk.dist;
+
+            for i in 0..sk.rank().into() {
+                self.vec_znx_automorphism(
+                    self.galois_element_inv(p),
+                    &mut sk_out.data.as_vec_znx_mut(),
+                    i,
+                    &sk.data.as_vec_znx(),
+                    i,
+                );
+            }
+            sk_out_prepared.prepare(self, &sk_out);
+        }
+
+        self.gglwe_encrypt_sk(
+            res,
+            &sk.data,
+            &sk_out_prepared,
+            source_xa,
+            source_xe,
+            scratch_1,
+        );
+
+        res.set_p(p);
+    }
+}
+
+pub trait GLWEAutomorphismKeyEncryptPk<BE: Backend> {
+    fn glwe_automorphism_key_encrypt_pk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GGLWEInfos;
+}
+
+impl<BE: Backend> GLWEAutomorphismKeyEncryptPk<BE> for Module<BE>
+where
+    Self:,
+    Scratch<BE>: ScratchTakeCore<BE>,
+{
+    fn glwe_automorphism_key_encrypt_pk_tmp_bytes<A>(&self, _infos: &A) -> usize
+    where
+        A: GGLWEInfos,
+    {
+        unimplemented!()
+    }
+}

@@ -1,407 +0,0 @@
-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,
-    },
-    layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, Scratch, VecZnx, VecZnxBig, ZnxInfos, ZnxZero},
-    source::Source,
-};
-
-use crate::{
-    dist::Distribution,
-    encryption::{SIGMA, SIGMA_BOUND},
-    layouts::{
-        GLWECiphertext, GLWEInfos, GLWEPlaintext, LWEInfos,
-        prepared::{GLWEPublicKeyPrepared, GLWESecretPrepared},
-    },
-};
-
-impl GLWECiphertext<Vec<u8>> {
-    pub fn encrypt_sk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
-    where
-        A: GLWEInfos,
-        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftAllocBytes,
-    {
-        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)
-    }
-    pub fn encrypt_pk_scratch_space<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
-    where
-        A: GLWEInfos,
-        Module<B>: VecZnxDftAllocBytes + SvpPPolAllocBytes + VecZnxBigAllocBytes + 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.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>(
-        &mut self,
-        module: &Module<B>,
-        pt: &GLWEPlaintext<DataPt>,
-        sk: &GLWESecretPrepared<DataSk, B>,
-        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,
-    {
-        #[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)
-            )
-        }
-
-        self.encrypt_sk_internal(module, Some((pt, 0)), sk, source_xa, source_xe, scratch);
-    }
-
-    pub fn encrypt_zero_sk<DataSk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        sk: &GLWESecretPrepared<DataSk, B>,
-        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,
-    {
-        #[cfg(debug_assertions)]
-        {
-            assert_eq!(self.rank(), sk.rank());
-            assert_eq!(sk.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)
-            )
-        }
-        self.encrypt_sk_internal(
-            module,
-            None::<(&GLWEPlaintext<Vec<u8>>, usize)>,
-            sk,
-            source_xa,
-            source_xe,
-            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>,
-        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,
-    {
-        let cols: usize = (self.rank() + 1).into();
-        glwe_encrypt_sk_internal(
-            module,
-            self.base2k().into(),
-            self.k().into(),
-            &mut self.data,
-            cols,
-            false,
-            pt,
-            sk,
-            source_xa,
-            source_xe,
-            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>,
-        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>,
-    {
-        self.encrypt_pk_internal::<DataPt, DataPk, B>(module, 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>,
-        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>,
-    {
-        self.encrypt_pk_internal::<Vec<u8>, DataPk, B>(
-            module,
-            None::<(&GLWEPlaintext<Vec<u8>>, usize)>,
-            pk,
-            source_xu,
-            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>,
-        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>,
-    {
-        #[cfg(debug_assertions)]
-        {
-            assert_eq!(self.base2k(), pk.base2k());
-            assert_eq!(self.n(), pk.n());
-            assert_eq!(self.rank(), pk.rank());
-            if let Some((pt, _)) = pt {
-                assert_eq!(pt.base2k(), pk.base2k());
-                assert_eq!(pt.n(), pk.n());
-            }
-        }
-
-        let base2k: usize = pk.base2k().into();
-        let size_pk: usize = pk.size();
-        let cols: usize = (self.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, _) = scratch_1.take_scalar_znx(self.n().into(), 1);
-            match pk.dist {
-                Distribution::NONE => panic!(
-                    "invalid public key: SecretDistribution::NONE, ensure it has been correctly intialized through \
-                     Self::generate"
-                ),
-                Distribution::TernaryFixed(hw) => u.fill_ternary_hw(0, hw, source_xu),
-                Distribution::TernaryProb(prob) => u.fill_ternary_prob(0, prob, source_xu),
-                Distribution::BinaryFixed(hw) => u.fill_binary_hw(0, hw, source_xu),
-                Distribution::BinaryProb(prob) => u.fill_binary_prob(0, prob, source_xu),
-                Distribution::BinaryBlock(block_size) => u.fill_binary_block(0, block_size, source_xu),
-                Distribution::ZERO => {}
-            }
-
-            module.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);
-            // ci_dft = DFT(u) * DFT(pk[i])
-            module.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);
-
-            // ci_big = u * pk[i] + e
-            module.vec_znx_big_add_normal(
-                base2k,
-                &mut ci_big,
-                0,
-                pk.k().into(),
-                source_xe,
-                SIGMA,
-                SIGMA_BOUND,
-            );
-
-            // 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);
-            }
-
-            // ct[i] = norm(ci_big)
-            module.vec_znx_big_normalize(base2k, &mut self.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
-        + VecZnxBigNormalize<B>
-        + VecZnxDftApply<B>
-        + SvpApplyDftToDftInplace<B>
-        + VecZnxIdftApplyConsume<B>
-        + VecZnxNormalizeTmpBytes
-        + VecZnxFillUniform
-        + VecZnxSubInplace
-        + VecZnxAddInplace
-        + VecZnxNormalizeInplace<B>
-        + VecZnxAddNormal
-        + VecZnxNormalize<B>
-        + VecZnxSub,
-    Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
-{
-    #[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 (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);
-
-        // 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);
-
-            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);
-                } else {
-                    module.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);
-            }
-
-            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
-            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)
-            module.vec_znx_sub_inplace(&mut c0, 0, &ci, 0);
-        });
-    }
-
-    // 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
-    {
-        module.vec_znx_add_inplace(&mut c0, 0, &pt.data, 0);
-    }
-
-    // c[0] = norm(c[0])
-    module.vec_znx_normalize(base2k, ct, 0, base2k, &c0, 0, scratch_1);
-}

@@ -1,61 +0,0 @@
-use poulpy_hal::{
-    api::{
-        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyDftToDftInplace, VecZnxAddInplace, VecZnxAddNormal, VecZnxBigNormalize,
-        VecZnxDftAllocBytes, VecZnxDftApply, VecZnxFillUniform, VecZnxIdftApplyConsume, VecZnxNormalize, VecZnxNormalizeInplace,
-        VecZnxNormalizeTmpBytes, VecZnxSub, VecZnxSubInplace,
-    },
-    layouts::{Backend, DataMut, DataRef, Module, ScratchOwned},
-    oep::{ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeVecZnxDftImpl, TakeVecZnxImpl},
-    source::Source,
-};
-
-use crate::layouts::{GLWECiphertext, GLWEPublicKey, prepared::GLWESecretPrepared};
-
-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>,
-    {
-        #[cfg(debug_assertions)]
-        {
-            use crate::{Distribution, layouts::LWEInfos};
-
-            assert_eq!(self.n(), sk.n());
-
-            if sk.dist == Distribution::NONE {
-                panic!("invalid sk: SecretDistribution::NONE")
-            }
-        }
-
-        // 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 tmp: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(self);
-        tmp.encrypt_zero_sk(module, sk, source_xa, source_xe, scratch.borrow());
-        self.dist = sk.dist;
-    }
-}

@@ -0,0 +1,62 @@
+use poulpy_hal::{
+    api::{ScratchOwnedAlloc, ScratchOwnedBorrow},
+    layouts::{Backend, DataMut, Module, Scratch, ScratchOwned},
+    source::Source,
+};
+
+use crate::{
+    Distribution, GLWEEncryptSk, GetDistribution, GetDistributionMut, ScratchTakeCore,
+    layouts::{
+        GLWE, GLWEInfos, GLWEPublicKey, GLWEToMut,
+        prepared::{GLWESecretPrepared, GLWESecretPreparedToRef},
+    },
+};
+
+impl<D: DataMut> GLWEPublicKey<D> {
+    pub fn generate<S, M, BE: Backend>(&mut self, module: &M, sk: &S, source_xa: &mut Source, source_xe: &mut Source)
+    where
+        S: GLWESecretPreparedToRef<BE> + GetDistribution,
+        M: GLWEPublicKeyGenerate<BE>,
+    {
+        module.glwe_public_key_generate(self, sk, source_xa, source_xe);
+    }
+}
+
+pub trait GLWEPublicKeyGenerate<BE: Backend> {
+    fn glwe_public_key_generate<R, S>(&self, res: &mut R, sk: &S, source_xa: &mut Source, source_xe: &mut Source)
+    where
+        R: GLWEToMut + GetDistributionMut + GLWEInfos,
+        S: GLWESecretPreparedToRef<BE> + GetDistribution;
+}
+
+impl<BE: Backend> GLWEPublicKeyGenerate<BE> for Module<BE>
+where
+    Self: GLWEEncryptSk<BE>,
+    ScratchOwned<BE>: ScratchOwnedAlloc<BE> + ScratchOwnedBorrow<BE>,
+    Scratch<BE>: ScratchTakeCore<BE>,
+{
+    fn glwe_public_key_generate<R, S>(&self, res: &mut R, sk: &S, source_xa: &mut Source, source_xe: &mut Source)
+    where
+        R: GLWEToMut + GetDistributionMut + GLWEInfos,
+        S: GLWESecretPreparedToRef<BE> + GetDistribution,
+    {
+        {
+            let sk: &GLWESecretPrepared<&[u8], BE> = &sk.to_ref();
+
+            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")
+            }
+
+            // Its ok to allocate scratch space here since pk is usually generated only once.
+            let mut scratch: ScratchOwned<BE> = ScratchOwned::alloc(self.glwe_encrypt_sk_tmp_bytes(res));
+
+            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_mut() = *sk.dist();
+    }
+}