Clippy check & update CI (#73)

* updated CI workflow with clippy & fmt

.github/workflows/ci.yml

@@ -18,6 +18,8 @@ jobs:
 
     - name: Install Rust nightly
       uses: dtolnay/rust-toolchain@nightly
+      with:
+        components: clippy, rustfmt
 
     - name: Cache cargo dependencies
       uses: actions/cache@v4
@@ -33,5 +35,11 @@ jobs:
     - name: Build
       run: cargo build --all-targets
 
+    - name: Clippy (deny warnings)
+      run: cargo clippy --workspace --all-targets --all-features -- -D warnings
+
+    - name: rustfmt (check only)
+      run: cargo fmt --all --check
+
     - name: Run tests
       run: cargo test --all

backend/src/hal/api/module.rs

@@ -1,6 +1,6 @@
-use crate::hal::layouts::{Backend, Module};
+use crate::hal::layouts::Backend;
 
 /// Instantiate a new [crate::hal::layouts::Module].
 pub trait ModuleNew<B: Backend> {
-    fn new(n: u64) -> Module<B>;
+    fn new(n: u64) -> Self;
 }

backend/src/hal/api/vec_znx.rs

@@ -164,7 +164,7 @@ pub trait VecZnxSplit<B: Backend> {
     ///
     /// This method requires that all [crate::hal::layouts::VecZnx] of b have the same ring degree
     /// and that b.n() * b.len() <= a.n()
-    fn vec_znx_split<R, A>(&self, res: &mut Vec<R>, res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch<B>)
+    fn vec_znx_split<R, A>(&self, res: &mut [R], res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch<B>)
     where
         R: VecZnxToMut,
         A: VecZnxToRef;
@@ -177,7 +177,7 @@ pub trait VecZnxMerge {
     ///
     /// This method requires that all [crate::hal::layouts::VecZnx] of a have the same ring degree
     /// and that a.n() * a.len() <= b.n()
-    fn vec_znx_merge<R, A>(&self, res: &mut R, res_col: usize, a: Vec<A>, a_col: usize)
+    fn vec_znx_merge<R, A>(&self, res: &mut R, res_col: usize, a: &[A], a_col: usize)
     where
         R: VecZnxToMut,
         A: VecZnxToRef;
@@ -204,6 +204,7 @@ pub trait VecZnxFillUniform {
         R: VecZnxToMut;
 }
 
+#[allow(clippy::too_many_arguments)]
 pub trait VecZnxFillDistF64 {
     fn vec_znx_fill_dist_f64<R, D: Distribution<f64>>(
         &self,
@@ -218,6 +219,7 @@ pub trait VecZnxFillDistF64 {
         R: VecZnxToMut;
 }
 
+#[allow(clippy::too_many_arguments)]
 pub trait VecZnxAddDistF64 {
     /// Adds vector sampled according to the provided distribution, scaled by 2^{-k} and bounded to \[-bound, bound\].
     fn vec_znx_add_dist_f64<R, D: Distribution<f64>>(
@@ -233,6 +235,7 @@ pub trait VecZnxAddDistF64 {
         R: VecZnxToMut;
 }
 
+#[allow(clippy::too_many_arguments)]
 pub trait VecZnxFillNormal {
     fn vec_znx_fill_normal<R>(
         &self,
@@ -247,6 +250,7 @@ pub trait VecZnxFillNormal {
         R: VecZnxToMut;
 }
 
+#[allow(clippy::too_many_arguments)]
 pub trait VecZnxAddNormal {
     /// Adds a discrete normal vector scaled by 2^{-k} with the provided standard deviation and bounded to \[-bound, bound\].
     fn vec_znx_add_normal<R>(

backend/src/hal/api/vec_znx_big.rs

@@ -19,6 +19,7 @@ pub trait VecZnxBigFromBytes<B: Backend> {
     fn vec_znx_big_from_bytes(&self, n: usize, cols: usize, size: usize, bytes: Vec<u8>) -> VecZnxBigOwned<B>;
 }
 
+#[allow(clippy::too_many_arguments)]
 /// Add a discrete normal distribution on res.
 ///
 /// # Arguments
@@ -42,6 +43,7 @@ pub trait VecZnxBigAddNormal<B: Backend> {
     );
 }
 
+#[allow(clippy::too_many_arguments)]
 pub trait VecZnxBigFillNormal<B: Backend> {
     fn vec_znx_big_fill_normal<R: VecZnxBigToMut<B>>(
         &self,
@@ -55,6 +57,7 @@ pub trait VecZnxBigFillNormal<B: Backend> {
     );
 }
 
+#[allow(clippy::too_many_arguments)]
 pub trait VecZnxBigFillDistF64<B: Backend> {
     fn vec_znx_big_fill_dist_f64<R: VecZnxBigToMut<B>, D: Distribution<f64>>(
         &self,
@@ -68,6 +71,7 @@ pub trait VecZnxBigFillDistF64<B: Backend> {
     );
 }
 
+#[allow(clippy::too_many_arguments)]
 pub trait VecZnxBigAddDistF64<B: Backend> {
     fn vec_znx_big_add_dist_f64<R: VecZnxBigToMut<B>, D: Distribution<f64>>(
         &self,

backend/src/hal/api/vmp_pmat.rs

@@ -33,6 +33,7 @@ pub trait VmpPrepare<B: Backend> {
         A: MatZnxToRef;
 }
 
+#[allow(clippy::too_many_arguments)]
 pub trait VmpApplyTmpBytes {
     fn vmp_apply_tmp_bytes(
         &self,
@@ -78,6 +79,7 @@ pub trait VmpApply<B: Backend> {
         C: VmpPMatToRef<B>;
 }
 
+#[allow(clippy::too_many_arguments)]
 pub trait VmpApplyAddTmpBytes {
     fn vmp_apply_add_tmp_bytes(
         &self,

backend/src/hal/delegates/vec_znx.rs

@@ -274,7 +274,7 @@ impl<B> VecZnxSplit<B> for Module<B>
 where
     B: Backend + VecZnxSplitImpl<B>,
 {
-    fn vec_znx_split<R, A>(&self, res: &mut Vec<R>, res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch<B>)
+    fn vec_znx_split<R, A>(&self, res: &mut [R], res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch<B>)
     where
         R: VecZnxToMut,
         A: VecZnxToRef,
@@ -287,7 +287,7 @@ impl<B> VecZnxMerge for Module<B>
 where
     B: Backend + VecZnxMergeImpl<B>,
 {
-    fn vec_znx_merge<R, A>(&self, res: &mut R, res_col: usize, a: Vec<A>, a_col: usize)
+    fn vec_znx_merge<R, A>(&self, res: &mut R, res_col: usize, a: &[A], a_col: usize)
     where
         R: VecZnxToMut,
         A: VecZnxToRef,

backend/src/hal/layouts/encoding.rs

@@ -15,7 +15,7 @@ impl<D: DataMut> VecZnx<D> {
             let a: VecZnx<&mut [u8]> = self.to_mut();
             assert!(
                 size <= a.size(),
-                "invalid argument k: k.div_ceil(basek)={} > a.size()={}",
+                "invalid argument k.div_ceil(basek)={} > a.size()={}",
                 size,
                 a.size()
             );
@@ -69,7 +69,7 @@ impl<D: DataMut> VecZnx<D> {
             assert!(idx < a.n());
             assert!(
                 size <= a.size(),
-                "invalid argument k: k.div_ceil(basek)={} > a.size()={}",
+                "invalid argument k.div_ceil(basek)={} > a.size()={}",
                 size,
                 a.size()
             );

backend/src/hal/layouts/mat_znx.rs

@@ -2,7 +2,7 @@ use crate::{
     alloc_aligned,
     hal::{
         api::{DataView, DataViewMut, FillUniform, Reset, ZnxInfos, ZnxSliceSize, ZnxView, ZnxViewMut, ZnxZero},
-        layouts::{Data, DataMut, DataRef, ReaderFrom, VecZnx, WriterTo},
+        layouts::{Data, DataMut, DataRef, ReaderFrom, ToOwnedDeep, VecZnx, WriterTo},
     },
 };
 use std::fmt;
@@ -21,6 +21,20 @@ pub struct MatZnx<D: Data> {
     cols_out: usize,
 }
 
+impl<D: DataRef> ToOwnedDeep for MatZnx<D> {
+    type Owned = MatZnx<Vec<u8>>;
+    fn to_owned_deep(&self) -> Self::Owned {
+        MatZnx {
+            data: self.data.as_ref().to_vec(),
+            n: self.n,
+            size: self.size,
+            rows: self.rows,
+            cols_in: self.cols_in,
+            cols_out: self.cols_out,
+        }
+    }
+}
+
 impl<D: DataRef> fmt::Debug for MatZnx<D> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self)
@@ -86,7 +100,7 @@ impl MatZnx<Vec<u8>> {
     pub fn alloc(n: usize, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> Self {
         let data: Vec<u8> = alloc_aligned(Self::alloc_bytes(n, rows, cols_in, cols_out, size));
         Self {
-            data: data.into(),
+            data,
             n,
             size,
             rows,
@@ -99,7 +113,7 @@ impl MatZnx<Vec<u8>> {
         let data: Vec<u8> = bytes.into();
         assert!(data.len() == Self::alloc_bytes(n, rows, cols_in, cols_out, size));
         Self {
-            data: data.into(),
+            data,
             n,
             size,
             rows,

backend/src/hal/layouts/mod.rs

@@ -25,3 +25,8 @@ pub use vmp_pmat::*;
 pub trait Data = PartialEq + Eq + Sized;
 pub trait DataRef = Data + AsRef<[u8]>;
 pub trait DataMut = DataRef + AsMut<[u8]>;
+
+pub trait ToOwnedDeep {
+    type Owned;
+    fn to_owned_deep(&self) -> Self::Owned;
+}

backend/src/hal/layouts/module.rs

@@ -2,6 +2,7 @@ use std::{marker::PhantomData, ptr::NonNull};
 
 use crate::GALOISGENERATOR;
 
+#[allow(clippy::missing_safety_doc)]
 pub trait Backend: Sized {
     type Handle: 'static;
     unsafe fn destroy(handle: NonNull<Self::Handle>);
@@ -17,6 +18,7 @@ impl<B: Backend> Module<B> {
     /// Construct from a raw pointer managed elsewhere.
     /// SAFETY: `ptr` must be non-null and remain valid for the lifetime of this Module.
     #[inline]
+    #[allow(clippy::missing_safety_doc)]
     pub unsafe fn from_raw_parts(ptr: *mut B::Handle, n: u64) -> Self {
         Self {
             ptr: NonNull::new(ptr).expect("null module ptr"),
@@ -25,6 +27,7 @@ impl<B: Backend> Module<B> {
         }
     }
 
+    #[allow(clippy::missing_safety_doc)]
     #[inline]
     pub unsafe fn ptr(&self) -> *mut <B as Backend>::Handle {
         self.ptr.as_ptr()
@@ -55,7 +58,8 @@ impl<B: Backend> Module<B> {
         if generator == 0 {
             return 1;
         }
-        ((mod_exp_u64(GALOISGENERATOR, generator.abs() as usize) & (self.cyclotomic_order() - 1)) as i64) * generator.signum()
+        ((mod_exp_u64(GALOISGENERATOR, generator.unsigned_abs() as usize) & (self.cyclotomic_order() - 1)) as i64)
+            * generator.signum()
     }
 
     // Returns gen^-1
@@ -64,7 +68,10 @@ impl<B: Backend> Module<B> {
         if gal_el == 0 {
             panic!("cannot invert 0")
         }
-        ((mod_exp_u64(gal_el.abs() as u64, (self.cyclotomic_order() - 1) as usize) & (self.cyclotomic_order() - 1)) as i64)
+        ((mod_exp_u64(
+            gal_el.unsigned_abs(),
+            (self.cyclotomic_order() - 1) as usize,
+        ) & (self.cyclotomic_order() - 1)) as i64)
             * gal_el.signum()
     }
 }

backend/src/hal/layouts/scalar_znx.rs

@@ -7,7 +7,7 @@ use crate::{
     alloc_aligned,
     hal::{
         api::{DataView, DataViewMut, FillUniform, Reset, ZnxInfos, ZnxSliceSize, ZnxView, ZnxViewMut, ZnxZero},
-        layouts::{Data, DataMut, DataRef, ReaderFrom, VecZnx, WriterTo},
+        layouts::{Data, DataMut, DataRef, ReaderFrom, ToOwnedDeep, VecZnx, WriterTo},
     },
 };
 
@@ -18,6 +18,17 @@ pub struct ScalarZnx<D: Data> {
     pub(crate) cols: usize,
 }
 
+impl<D: DataRef> ToOwnedDeep for ScalarZnx<D> {
+    type Owned = ScalarZnx<Vec<u8>>;
+    fn to_owned_deep(&self) -> Self::Owned {
+        ScalarZnx {
+            data: self.data.as_ref().to_vec(),
+            n: self.n,
+            cols: self.cols,
+        }
+    }
+}
+
 impl<D: Data> ZnxInfos for ScalarZnx<D> {
     fn cols(&self) -> usize {
         self.cols
@@ -63,7 +74,7 @@ impl<D: DataMut> ScalarZnx<D> {
     pub fn fill_ternary_prob(&mut self, col: usize, prob: f64, source: &mut Source) {
         let choices: [i64; 3] = [-1, 0, 1];
         let weights: [f64; 3] = [prob / 2.0, 1.0 - prob, prob / 2.0];
-        let dist: WeightedIndex<f64> = WeightedIndex::new(&weights).unwrap();
+        let dist: WeightedIndex<f64> = WeightedIndex::new(weights).unwrap();
         self.at_mut(col, 0)
             .iter_mut()
             .for_each(|x: &mut i64| *x = choices[dist.sample(source)]);
@@ -80,7 +91,7 @@ impl<D: DataMut> ScalarZnx<D> {
     pub fn fill_binary_prob(&mut self, col: usize, prob: f64, source: &mut Source) {
         let choices: [i64; 2] = [0, 1];
         let weights: [f64; 2] = [1.0 - prob, prob];
-        let dist: WeightedIndex<f64> = WeightedIndex::new(&weights).unwrap();
+        let dist: WeightedIndex<f64> = WeightedIndex::new(weights).unwrap();
         self.at_mut(col, 0)
             .iter_mut()
             .for_each(|x: &mut i64| *x = choices[dist.sample(source)]);
@@ -95,7 +106,7 @@ impl<D: DataMut> ScalarZnx<D> {
     }
 
     pub fn fill_binary_block(&mut self, col: usize, block_size: usize, source: &mut Source) {
-        assert!(self.n() % block_size == 0);
+        assert!(self.n().is_multiple_of(block_size));
         let max_idx: u64 = (block_size + 1) as u64;
         let mask_idx: u64 = (1 << ((u64::BITS - max_idx.leading_zeros()) as u64)) - 1;
         for block in self.at_mut(col, 0).chunks_mut(block_size) {
@@ -114,21 +125,13 @@ impl ScalarZnx<Vec<u8>> {
 
     pub fn alloc(n: usize, cols: usize) -> Self {
         let data: Vec<u8> = alloc_aligned::<u8>(Self::alloc_bytes(n, cols));
-        Self {
+        Self { data, n, cols }
-            data: data.into(),
-            n,
-            cols,
-        }
     }
 
     pub fn from_bytes(n: usize, cols: usize, bytes: impl Into<Vec<u8>>) -> Self {
         let data: Vec<u8> = bytes.into();
         assert!(data.len() == Self::alloc_bytes(n, cols));
-        Self {
+        Self { data, n, cols }
-            data: data.into(),
-            n,
-            cols,
-        }
     }
 }
 

backend/src/hal/layouts/vec_znx.rs

@@ -4,11 +4,11 @@ use crate::{
     alloc_aligned,
     hal::{
         api::{DataView, DataViewMut, FillUniform, Reset, ZnxInfos, ZnxSliceSize, ZnxView, ZnxViewMut, ZnxZero},
-        layouts::{Data, DataMut, DataRef, ReaderFrom, WriterTo},
+        layouts::{Data, DataMut, DataRef, ReaderFrom, ToOwnedDeep, WriterTo},
     },
 };
 
-#[derive(PartialEq, Eq, Clone)]
+#[derive(PartialEq, Eq, Clone, Copy)]
 pub struct VecZnx<D: Data> {
     pub(crate) data: D,
     pub(crate) n: usize,
@@ -17,6 +17,19 @@ pub struct VecZnx<D: Data> {
     pub(crate) max_size: usize,
 }
 
+impl<D: DataRef> ToOwnedDeep for VecZnx<D> {
+    type Owned = VecZnx<Vec<u8>>;
+    fn to_owned_deep(&self) -> Self::Owned {
+        VecZnx {
+            data: self.data.as_ref().to_vec(),
+            n: self.n,
+            cols: self.cols,
+            size: self.size,
+            max_size: self.max_size,
+        }
+    }
+}
+
 impl<D: DataRef> fmt::Debug for VecZnx<D> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self)
@@ -87,7 +100,7 @@ impl VecZnx<Vec<u8>> {
     pub fn alloc(n: usize, cols: usize, size: usize) -> Self {
         let data: Vec<u8> = alloc_aligned::<u8>(Self::alloc_bytes(n, cols, size));
         Self {
-            data: data.into(),
+            data,
             n,
             cols,
             size,
@@ -99,7 +112,7 @@ impl VecZnx<Vec<u8>> {
         let data: Vec<u8> = bytes.into();
         assert!(data.len() == Self::alloc_bytes(n, cols, size));
         Self {
-            data: data.into(),
+            data,
             n,
             cols,
             size,
@@ -207,19 +220,6 @@ impl<D: DataMut> VecZnxToMut for VecZnx<D> {
     }
 }
 
-impl<D: DataRef> VecZnx<D> {
-    pub fn clone(&self) -> VecZnx<Vec<u8>> {
-        let self_ref: VecZnx<&[u8]> = self.to_ref();
-        VecZnx {
-            data: self_ref.data.to_vec(),
-            n: self_ref.n,
-            cols: self_ref.cols,
-            size: self_ref.size,
-            max_size: self_ref.max_size,
-        }
-    }
-}
-
 use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
 use rand::RngCore;
 use sampling::source::Source;

backend/src/hal/layouts/vec_znx_dft.rs

@@ -94,7 +94,7 @@ where
         let data: Vec<u8> = alloc_aligned::<u8>(Self::bytes_of(n, cols, size));
         Self {
             data: data.into(),
-            n: n,
+            n,
             cols,
             size,
             max_size: size,
@@ -107,7 +107,7 @@ where
         assert!(data.len() == Self::bytes_of(n, cols, size));
         Self {
             data: data.into(),
-            n: n,
+            n,
             cols,
             size,
             max_size: size,

backend/src/hal/oep/module.rs

@@ -1,5 +1,9 @@
 use crate::hal::layouts::{Backend, Module};
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait ModuleNewImpl<B: Backend> {
     fn new_impl(n: u64) -> Module<B>;
 }

backend/src/hal/oep/scratch.rs

@@ -3,38 +3,74 @@ use crate::hal::{
     layouts::{Backend, DataRef, MatZnx, ScalarZnx, Scratch, ScratchOwned, SvpPPol, VecZnx, VecZnxBig, VecZnxDft, VmpPMat},
 };
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait ScratchOwnedAllocImpl<B: Backend> {
     fn scratch_owned_alloc_impl(size: usize) -> ScratchOwned<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait ScratchOwnedBorrowImpl<B: Backend> {
     fn scratch_owned_borrow_impl(scratch: &mut ScratchOwned<B>) -> &mut Scratch<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait ScratchFromBytesImpl<B: Backend> {
     fn scratch_from_bytes_impl(data: &mut [u8]) -> &mut Scratch<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait ScratchAvailableImpl<B: Backend> {
     fn scratch_available_impl(scratch: &Scratch<B>) -> usize;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait TakeSliceImpl<B: Backend> {
     fn take_slice_impl<T>(scratch: &mut Scratch<B>, len: usize) -> (&mut [T], &mut Scratch<B>);
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait TakeScalarZnxImpl<B: Backend> {
     fn take_scalar_znx_impl(scratch: &mut Scratch<B>, n: usize, cols: usize) -> (ScalarZnx<&mut [u8]>, &mut Scratch<B>);
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait TakeSvpPPolImpl<B: Backend> {
     fn take_svp_ppol_impl(scratch: &mut Scratch<B>, n: usize, cols: usize) -> (SvpPPol<&mut [u8], B>, &mut Scratch<B>);
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait TakeVecZnxImpl<B: Backend> {
     fn take_vec_znx_impl(scratch: &mut Scratch<B>, n: usize, cols: usize, size: usize) -> (VecZnx<&mut [u8]>, &mut Scratch<B>);
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait TakeVecZnxSliceImpl<B: Backend> {
     fn take_vec_znx_slice_impl(
         scratch: &mut Scratch<B>,
@@ -45,6 +81,10 @@ pub unsafe trait TakeVecZnxSliceImpl<B: Backend> {
     ) -> (Vec<VecZnx<&mut [u8]>>, &mut Scratch<B>);
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait TakeVecZnxBigImpl<B: Backend> {
     fn take_vec_znx_big_impl(
         scratch: &mut Scratch<B>,
@@ -54,6 +94,10 @@ pub unsafe trait TakeVecZnxBigImpl<B: Backend> {
     ) -> (VecZnxBig<&mut [u8], B>, &mut Scratch<B>);
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait TakeVecZnxDftImpl<B: Backend> {
     fn take_vec_znx_dft_impl(
         scratch: &mut Scratch<B>,
@@ -63,6 +107,10 @@ pub unsafe trait TakeVecZnxDftImpl<B: Backend> {
     ) -> (VecZnxDft<&mut [u8], B>, &mut Scratch<B>);
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait TakeVecZnxDftSliceImpl<B: Backend> {
     fn take_vec_znx_dft_slice_impl(
         scratch: &mut Scratch<B>,
@@ -73,6 +121,10 @@ pub unsafe trait TakeVecZnxDftSliceImpl<B: Backend> {
     ) -> (Vec<VecZnxDft<&mut [u8], B>>, &mut Scratch<B>);
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait TakeVmpPMatImpl<B: Backend> {
     fn take_vmp_pmat_impl(
         scratch: &mut Scratch<B>,
@@ -84,6 +136,10 @@ pub unsafe trait TakeVmpPMatImpl<B: Backend> {
     ) -> (VmpPMat<&mut [u8], B>, &mut Scratch<B>);
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait TakeMatZnxImpl<B: Backend> {
     fn take_mat_znx_impl(
         scratch: &mut Scratch<B>,
@@ -95,6 +151,10 @@ pub unsafe trait TakeMatZnxImpl<B: Backend> {
     ) -> (MatZnx<&mut [u8]>, &mut Scratch<B>);
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub trait TakeLikeImpl<'a, B: Backend, T> {
     type Output;
     fn take_like_impl(scratch: &'a mut Scratch<B>, template: &T) -> (Self::Output, &'a mut Scratch<B>);

backend/src/hal/oep/svp_ppol.rs

@@ -2,18 +2,34 @@ use crate::hal::layouts::{
     Backend, Module, ScalarZnxToRef, SvpPPolOwned, SvpPPolToMut, SvpPPolToRef, VecZnxDftToMut, VecZnxDftToRef,
 };
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait SvpPPolFromBytesImpl<B: Backend> {
     fn svp_ppol_from_bytes_impl(n: usize, cols: usize, bytes: Vec<u8>) -> SvpPPolOwned<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait SvpPPolAllocImpl<B: Backend> {
     fn svp_ppol_alloc_impl(n: usize, cols: usize) -> SvpPPolOwned<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait SvpPPolAllocBytesImpl<B: Backend> {
     fn svp_ppol_alloc_bytes_impl(n: usize, cols: usize) -> usize;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait SvpPrepareImpl<B: Backend> {
     fn svp_prepare_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
@@ -21,6 +37,10 @@ pub unsafe trait SvpPrepareImpl<B: Backend> {
         A: ScalarZnxToRef;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait SvpApplyImpl<B: Backend> {
     fn svp_apply_impl<R, A, C>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &C, b_col: usize)
     where
@@ -29,6 +49,10 @@ pub unsafe trait SvpApplyImpl<B: Backend> {
         C: VecZnxDftToRef<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait SvpApplyInplaceImpl: Backend {
     fn svp_apply_inplace_impl<R, A>(module: &Module<Self>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where

backend/src/hal/oep/vec_znx.rs

@@ -6,7 +6,7 @@ use crate::hal::layouts::{Backend, Module, ScalarZnxToRef, Scratch, VecZnxToMut,
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [vec_znx_normalize_base2k_tmp_bytes_ref](https://github.com/phantomzone-org/spqlios-arithmetic/blob/32a3f5fcce9863b58e949f2dfd5abc1bfbaa09b4/spqlios/arithmetic/vec_znx.c#L245C17-L245C55) for reference code.
 /// * See [crate::hal::api::VecZnxNormalizeTmpBytes] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxNormalizeTmpBytesImpl<B: Backend> {
     fn vec_znx_normalize_tmp_bytes_impl(module: &Module<B>, n: usize) -> usize;
 }
@@ -14,7 +14,7 @@ pub unsafe trait VecZnxNormalizeTmpBytesImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [vec_znx_normalize_base2k_ref](https://github.com/phantomzone-org/spqlios-arithmetic/blob/32a3f5fcce9863b58e949f2dfd5abc1bfbaa09b4/spqlios/arithmetic/vec_znx.c#L212) for reference code.
 /// * See [crate::hal::api::VecZnxNormalize] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxNormalizeImpl<B: Backend> {
     fn vec_znx_normalize_impl<R, A>(
         module: &Module<B>,
@@ -32,7 +32,7 @@ pub unsafe trait VecZnxNormalizeImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [vec_znx_normalize_base2k_ref](https://github.com/phantomzone-org/spqlios-arithmetic/blob/32a3f5fcce9863b58e949f2dfd5abc1bfbaa09b4/spqlios/arithmetic/vec_znx.c#L212) for reference code.
 /// * See [crate::hal::api::VecZnxNormalizeInplace] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxNormalizeInplaceImpl<B: Backend> {
     fn vec_znx_normalize_inplace_impl<A>(module: &Module<B>, basek: usize, a: &mut A, a_col: usize, scratch: &mut Scratch<B>)
     where
@@ -42,7 +42,7 @@ pub unsafe trait VecZnxNormalizeInplaceImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [vec_znx_add_ref](https://github.com/phantomzone-org/spqlios-arithmetic/blob/32a3f5fcce9863b58e949f2dfd5abc1bfbaa09b4/spqlios/arithmetic/vec_znx.c#L86) for reference code.
 /// * See [crate::hal::api::VecZnxAdd] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxAddImpl<B: Backend> {
     fn vec_znx_add_impl<R, A, C>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &C, b_col: usize)
     where
@@ -54,7 +54,7 @@ pub unsafe trait VecZnxAddImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [vec_znx_add_ref](https://github.com/phantomzone-org/spqlios-arithmetic/blob/32a3f5fcce9863b58e949f2dfd5abc1bfbaa09b4/spqlios/arithmetic/vec_znx.c#L86) for reference code.
 /// * See [crate::hal::api::VecZnxAddInplace] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxAddInplaceImpl<B: Backend> {
     fn vec_znx_add_inplace_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
@@ -65,7 +65,7 @@ pub unsafe trait VecZnxAddInplaceImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [vec_znx_add_ref](https://github.com/phantomzone-org/spqlios-arithmetic/blob/32a3f5fcce9863b58e949f2dfd5abc1bfbaa09b4/spqlios/arithmetic/vec_znx.c#L86) for reference code.
 /// * See [crate::hal::api::VecZnxAddScalarInplace] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxAddScalarInplaceImpl<B: Backend> {
     fn vec_znx_add_scalar_inplace_impl<R, A>(
         module: &Module<B>,
@@ -82,7 +82,7 @@ pub unsafe trait VecZnxAddScalarInplaceImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [vec_znx_sub_ref](https://github.com/phantomzone-org/spqlios-arithmetic/blob/32a3f5fcce9863b58e949f2dfd5abc1bfbaa09b4/spqlios/arithmetic/vec_znx.c#L125) for reference code.
 /// * See [crate::hal::api::VecZnxSub] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxSubImpl<B: Backend> {
     fn vec_znx_sub_impl<R, A, C>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &C, b_col: usize)
     where
@@ -94,7 +94,7 @@ pub unsafe trait VecZnxSubImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [vec_znx_sub_ref](https://github.com/phantomzone-org/spqlios-arithmetic/blob/32a3f5fcce9863b58e949f2dfd5abc1bfbaa09b4/spqlios/arithmetic/vec_znx.c#L125) for reference code.
 /// * See [crate::hal::api::VecZnxSubABInplace] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxSubABInplaceImpl<B: Backend> {
     fn vec_znx_sub_ab_inplace_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
@@ -105,7 +105,7 @@ pub unsafe trait VecZnxSubABInplaceImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [vec_znx_sub_ref](https://github.com/phantomzone-org/spqlios-arithmetic/blob/32a3f5fcce9863b58e949f2dfd5abc1bfbaa09b4/spqlios/arithmetic/vec_znx.c#L125) for reference code.
 /// * See [crate::hal::api::VecZnxSubBAInplace] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxSubBAInplaceImpl<B: Backend> {
     fn vec_znx_sub_ba_inplace_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
@@ -116,7 +116,7 @@ pub unsafe trait VecZnxSubBAInplaceImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [vec_znx_sub_ref](https://github.com/phantomzone-org/spqlios-arithmetic/blob/32a3f5fcce9863b58e949f2dfd5abc1bfbaa09b4/spqlios/arithmetic/vec_znx.c#L125) for reference code.
 /// * See [crate::hal::api::VecZnxSubScalarInplace] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxSubScalarInplaceImpl<B: Backend> {
     fn vec_znx_sub_scalar_inplace_impl<R, A>(
         module: &Module<B>,
@@ -133,7 +133,7 @@ pub unsafe trait VecZnxSubScalarInplaceImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [vec_znx_negate_ref](https://github.com/phantomzone-org/spqlios-arithmetic/blob/32a3f5fcce9863b58e949f2dfd5abc1bfbaa09b4/spqlios/arithmetic/vec_znx.c#L322C13-L322C31) for reference code.
 /// * See [crate::hal::api::VecZnxNegate] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxNegateImpl<B: Backend> {
     fn vec_znx_negate_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
@@ -144,7 +144,7 @@ pub unsafe trait VecZnxNegateImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [vec_znx_negate_ref](https://github.com/phantomzone-org/spqlios-arithmetic/blob/32a3f5fcce9863b58e949f2dfd5abc1bfbaa09b4/spqlios/arithmetic/vec_znx.c#L322C13-L322C31) for reference code.
 /// * See [crate::hal::api::VecZnxNegateInplace] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxNegateInplaceImpl<B: Backend> {
     fn vec_znx_negate_inplace_impl<A>(module: &Module<B>, a: &mut A, a_col: usize)
     where
@@ -154,7 +154,7 @@ pub unsafe trait VecZnxNegateInplaceImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [crate::implementation::cpu_spqlios::vec_znx::vec_znx_rsh_inplace_ref] for reference code.
 /// * See [crate::hal::api::VecZnxRshInplace] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxRshInplaceImpl<B: Backend> {
     fn vec_znx_rsh_inplace_impl<A>(module: &Module<B>, basek: usize, k: usize, a: &mut A)
     where
@@ -164,7 +164,7 @@ pub unsafe trait VecZnxRshInplaceImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [crate::implementation::cpu_spqlios::vec_znx::vec_znx_lsh_inplace_ref] for reference code.
 /// * See [crate::hal::api::VecZnxLshInplace] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxLshInplaceImpl<B: Backend> {
     fn vec_znx_lsh_inplace_impl<A>(module: &Module<B>, basek: usize, k: usize, a: &mut A)
     where
@@ -174,7 +174,7 @@ pub unsafe trait VecZnxLshInplaceImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [vec_znx_rotate_ref](https://github.com/phantomzone-org/spqlios-arithmetic/blob/32a3f5fcce9863b58e949f2dfd5abc1bfbaa09b4/spqlios/arithmetic/vec_znx.c#L164) for reference code.
 /// * See [crate::hal::api::VecZnxRotate] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxRotateImpl<B: Backend> {
     fn vec_znx_rotate_impl<R, A>(module: &Module<B>, k: i64, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
@@ -185,7 +185,7 @@ pub unsafe trait VecZnxRotateImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [vec_znx_rotate_ref](https://github.com/phantomzone-org/spqlios-arithmetic/blob/32a3f5fcce9863b58e949f2dfd5abc1bfbaa09b4/spqlios/arithmetic/vec_znx.c#L164) for reference code.
 /// * See [crate::hal::api::VecZnxRotateInplace] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxRotateInplaceImpl<B: Backend> {
     fn vec_znx_rotate_inplace_impl<A>(module: &Module<B>, k: i64, a: &mut A, a_col: usize)
     where
@@ -195,7 +195,7 @@ pub unsafe trait VecZnxRotateInplaceImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [vec_znx_automorphism_ref](https://github.com/phantomzone-org/spqlios-arithmetic/blob/32a3f5fcce9863b58e949f2dfd5abc1bfbaa09b4/spqlios/arithmetic/vec_znx.c#L188) for reference code.
 /// * See [crate::hal::api::VecZnxAutomorphism] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxAutomorphismImpl<B: Backend> {
     fn vec_znx_automorphism_impl<R, A>(module: &Module<B>, k: i64, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
@@ -206,7 +206,7 @@ pub unsafe trait VecZnxAutomorphismImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [vec_znx_automorphism_ref](https://github.com/phantomzone-org/spqlios-arithmetic/blob/32a3f5fcce9863b58e949f2dfd5abc1bfbaa09b4/spqlios/arithmetic/vec_znx.c#L188) for reference code.
 /// * See [crate::hal::api::VecZnxAutomorphismInplace] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxAutomorphismInplaceImpl<B: Backend> {
     fn vec_znx_automorphism_inplace_impl<A>(module: &Module<B>, k: i64, a: &mut A, a_col: usize)
     where
@@ -216,7 +216,7 @@ pub unsafe trait VecZnxAutomorphismInplaceImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [vec_znx_mul_xp_minus_one_ref](https://github.com/phantomzone-org/spqlios-arithmetic/blob/7160f588da49712a042931ea247b4259b95cefcc/spqlios/arithmetic/vec_znx.c#L200C13-L200C41) for reference code.
 /// * See [crate::hal::api::VecZnxMulXpMinusOne] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxMulXpMinusOneImpl<B: Backend> {
     fn vec_znx_mul_xp_minus_one_impl<R, A>(module: &Module<B>, p: i64, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
@@ -227,7 +227,7 @@ pub unsafe trait VecZnxMulXpMinusOneImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [vec_znx_mul_xp_minus_one_ref](https://github.com/phantomzone-org/spqlios-arithmetic/blob/7160f588da49712a042931ea247b4259b95cefcc/spqlios/arithmetic/vec_znx.c#L200C13-L200C41) for reference code.
 /// * See [crate::hal::api::VecZnxMulXpMinusOneInplace] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxMulXpMinusOneInplaceImpl<B: Backend> {
     fn vec_znx_mul_xp_minus_one_inplace_impl<R>(module: &Module<B>, p: i64, res: &mut R, res_col: usize)
     where
@@ -237,16 +237,10 @@ pub unsafe trait VecZnxMulXpMinusOneInplaceImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [crate::implementation::cpu_spqlios::vec_znx::vec_znx_split_ref] for reference code.
 /// * See [crate::hal::api::VecZnxSplit] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxSplitImpl<B: Backend> {
-    fn vec_znx_split_impl<R, A>(
+    fn vec_znx_split_impl<R, A>(module: &Module<B>, res: &mut [R], res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch<B>)
-        module: &Module<B>,
+    where
-        res: &mut Vec<R>,
-        res_col: usize,
-        a: &A,
-        a_col: usize,
-        scratch: &mut Scratch<B>,
-    ) where
         R: VecZnxToMut,
         A: VecZnxToRef;
 }
@@ -254,9 +248,9 @@ pub unsafe trait VecZnxSplitImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [crate::implementation::cpu_spqlios::vec_znx::vec_znx_merge_ref] for reference code.
 /// * See [crate::hal::api::VecZnxMerge] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxMergeImpl<B: Backend> {
-    fn vec_znx_merge_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: Vec<A>, a_col: usize)
+    fn vec_znx_merge_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &[A], a_col: usize)
     where
         R: VecZnxToMut,
         A: VecZnxToRef;
@@ -265,7 +259,7 @@ pub unsafe trait VecZnxMergeImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [crate::implementation::cpu_spqlios::vec_znx::vec_znx_switch_degree_ref] for reference code.
 /// * See [crate::hal::api::VecZnxSwithcDegree] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxSwithcDegreeImpl<B: Backend> {
     fn vec_znx_switch_degree_impl<R: VecZnxToMut, A: VecZnxToRef>(
         module: &Module<B>,
@@ -279,7 +273,7 @@ pub unsafe trait VecZnxSwithcDegreeImpl<B: Backend> {
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [crate::implementation::cpu_spqlios::vec_znx::vec_znx_copy_ref] for reference code.
 /// * See [crate::hal::api::VecZnxCopy] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxCopyImpl<B: Backend> {
     fn vec_znx_copy_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
@@ -289,16 +283,17 @@ pub unsafe trait VecZnxCopyImpl<B: Backend> {
 
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [crate::hal::api::VecZnxFillUniform] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxFillUniformImpl<B: Backend> {
     fn vec_znx_fill_uniform_impl<R>(module: &Module<B>, basek: usize, res: &mut R, res_col: usize, k: usize, source: &mut Source)
     where
         R: VecZnxToMut;
 }
 
+#[allow(clippy::too_many_arguments)]
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [crate::hal::api::VecZnxFillDistF64] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxFillDistF64Impl<B: Backend> {
     fn vec_znx_fill_dist_f64_impl<R, D: Distribution<f64>>(
         module: &Module<B>,
@@ -313,9 +308,10 @@ pub unsafe trait VecZnxFillDistF64Impl<B: Backend> {
         R: VecZnxToMut;
 }
 
+#[allow(clippy::too_many_arguments)]
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [crate::hal::api::VecZnxAddDistF64] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxAddDistF64Impl<B: Backend> {
     fn vec_znx_add_dist_f64_impl<R, D: Distribution<f64>>(
         module: &Module<B>,
@@ -330,9 +326,10 @@ pub unsafe trait VecZnxAddDistF64Impl<B: Backend> {
         R: VecZnxToMut;
 }
 
+#[allow(clippy::too_many_arguments)]
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [crate::hal::api::VecZnxFillNormal] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxFillNormalImpl<B: Backend> {
     fn vec_znx_fill_normal_impl<R>(
         module: &Module<B>,
@@ -347,9 +344,10 @@ pub unsafe trait VecZnxFillNormalImpl<B: Backend> {
         R: VecZnxToMut;
 }
 
+#[allow(clippy::too_many_arguments)]
 /// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
 /// * See [crate::hal::api::VecZnxAddNormal] for corresponding public API.
-/// * See [crate::doc::backend_safety] for safety contract.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxAddNormalImpl<B: Backend> {
     fn vec_znx_add_normal_impl<R>(
         module: &Module<B>,

backend/src/hal/oep/vec_znx_big.rs

@@ -3,18 +3,35 @@ use sampling::source::Source;
 
 use crate::hal::layouts::{Backend, Module, Scratch, VecZnxBigOwned, VecZnxBigToMut, VecZnxBigToRef, VecZnxToMut, VecZnxToRef};
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigAllocImpl<B: Backend> {
     fn vec_znx_big_alloc_impl(n: usize, cols: usize, size: usize) -> VecZnxBigOwned<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigFromBytesImpl<B: Backend> {
     fn vec_znx_big_from_bytes_impl(n: usize, cols: usize, size: usize, bytes: Vec<u8>) -> VecZnxBigOwned<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigAllocBytesImpl<B: Backend> {
     fn vec_znx_big_alloc_bytes_impl(n: usize, cols: usize, size: usize) -> usize;
 }
 
+#[allow(clippy::too_many_arguments)]
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigAddNormalImpl<B: Backend> {
     fn add_normal_impl<R: VecZnxBigToMut<B>>(
         module: &Module<B>,
@@ -28,6 +45,11 @@ pub unsafe trait VecZnxBigAddNormalImpl<B: Backend> {
     );
 }
 
+#[allow(clippy::too_many_arguments)]
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigFillNormalImpl<B: Backend> {
     fn fill_normal_impl<R: VecZnxBigToMut<B>>(
         module: &Module<B>,
@@ -41,6 +63,11 @@ pub unsafe trait VecZnxBigFillNormalImpl<B: Backend> {
     );
 }
 
+#[allow(clippy::too_many_arguments)]
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigFillDistF64Impl<B: Backend> {
     fn fill_dist_f64_impl<R: VecZnxBigToMut<B>, D: Distribution<f64>>(
         module: &Module<B>,
@@ -54,6 +81,11 @@ pub unsafe trait VecZnxBigFillDistF64Impl<B: Backend> {
     );
 }
 
+#[allow(clippy::too_many_arguments)]
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigAddDistF64Impl<B: Backend> {
     fn add_dist_f64_impl<R: VecZnxBigToMut<B>, D: Distribution<f64>>(
         module: &Module<B>,
@@ -67,6 +99,10 @@ pub unsafe trait VecZnxBigAddDistF64Impl<B: Backend> {
     );
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigAddImpl<B: Backend> {
     fn vec_znx_big_add_impl<R, A, C>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &C, b_col: usize)
     where
@@ -75,6 +111,10 @@ pub unsafe trait VecZnxBigAddImpl<B: Backend> {
         C: VecZnxBigToRef<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigAddInplaceImpl<B: Backend> {
     fn vec_znx_big_add_inplace_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
@@ -82,6 +122,10 @@ pub unsafe trait VecZnxBigAddInplaceImpl<B: Backend> {
         A: VecZnxBigToRef<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigAddSmallImpl<B: Backend> {
     fn vec_znx_big_add_small_impl<R, A, C>(
         module: &Module<B>,
@@ -97,6 +141,10 @@ pub unsafe trait VecZnxBigAddSmallImpl<B: Backend> {
         C: VecZnxToRef;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigAddSmallInplaceImpl<B: Backend> {
     fn vec_znx_big_add_small_inplace_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
@@ -104,6 +152,10 @@ pub unsafe trait VecZnxBigAddSmallInplaceImpl<B: Backend> {
         A: VecZnxToRef;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigSubImpl<B: Backend> {
     fn vec_znx_big_sub_impl<R, A, C>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &C, b_col: usize)
     where
@@ -112,6 +164,10 @@ pub unsafe trait VecZnxBigSubImpl<B: Backend> {
         C: VecZnxBigToRef<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigSubABInplaceImpl<B: Backend> {
     fn vec_znx_big_sub_ab_inplace_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
@@ -119,6 +175,10 @@ pub unsafe trait VecZnxBigSubABInplaceImpl<B: Backend> {
         A: VecZnxBigToRef<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigSubBAInplaceImpl<B: Backend> {
     fn vec_znx_big_sub_ba_inplace_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
@@ -126,6 +186,10 @@ pub unsafe trait VecZnxBigSubBAInplaceImpl<B: Backend> {
         A: VecZnxBigToRef<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigSubSmallAImpl<B: Backend> {
     fn vec_znx_big_sub_small_a_impl<R, A, C>(
         module: &Module<B>,
@@ -141,6 +205,10 @@ pub unsafe trait VecZnxBigSubSmallAImpl<B: Backend> {
         C: VecZnxBigToRef<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigSubSmallAInplaceImpl<B: Backend> {
     fn vec_znx_big_sub_small_a_inplace_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
@@ -148,6 +216,10 @@ pub unsafe trait VecZnxBigSubSmallAInplaceImpl<B: Backend> {
         A: VecZnxToRef;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigSubSmallBImpl<B: Backend> {
     fn vec_znx_big_sub_small_b_impl<R, A, C>(
         module: &Module<B>,
@@ -163,6 +235,10 @@ pub unsafe trait VecZnxBigSubSmallBImpl<B: Backend> {
         C: VecZnxToRef;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigSubSmallBInplaceImpl<B: Backend> {
     fn vec_znx_big_sub_small_b_inplace_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
@@ -170,16 +246,28 @@ pub unsafe trait VecZnxBigSubSmallBInplaceImpl<B: Backend> {
         A: VecZnxToRef;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigNegateInplaceImpl<B: Backend> {
     fn vec_znx_big_negate_inplace_impl<A>(module: &Module<B>, a: &mut A, a_col: usize)
     where
         A: VecZnxBigToMut<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigNormalizeTmpBytesImpl<B: Backend> {
     fn vec_znx_big_normalize_tmp_bytes_impl(module: &Module<B>, n: usize) -> usize;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigNormalizeImpl<B: Backend> {
     fn vec_znx_big_normalize_impl<R, A>(
         module: &Module<B>,
@@ -194,6 +282,10 @@ pub unsafe trait VecZnxBigNormalizeImpl<B: Backend> {
         A: VecZnxBigToRef<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigAutomorphismImpl<B: Backend> {
     fn vec_znx_big_automorphism_impl<R, A>(module: &Module<B>, k: i64, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
@@ -201,6 +293,10 @@ pub unsafe trait VecZnxBigAutomorphismImpl<B: Backend> {
         A: VecZnxBigToRef<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxBigAutomorphismInplaceImpl<B: Backend> {
     fn vec_znx_big_automorphism_inplace_impl<A>(module: &Module<B>, k: i64, a: &mut A, a_col: usize)
     where

backend/src/hal/oep/vec_znx_dft.rs

@@ -3,22 +3,42 @@ use crate::hal::layouts::{
     VecZnxToRef,
 };
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxDftAllocImpl<B: Backend> {
     fn vec_znx_dft_alloc_impl(n: usize, cols: usize, size: usize) -> VecZnxDftOwned<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxDftFromBytesImpl<B: Backend> {
     fn vec_znx_dft_from_bytes_impl(n: usize, cols: usize, size: usize, bytes: Vec<u8>) -> VecZnxDftOwned<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxDftAllocBytesImpl<B: Backend> {
     fn vec_znx_dft_alloc_bytes_impl(n: usize, cols: usize, size: usize) -> usize;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxDftToVecZnxBigTmpBytesImpl<B: Backend> {
     fn vec_znx_dft_to_vec_znx_big_tmp_bytes_impl(module: &Module<B>, n: usize) -> usize;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxDftToVecZnxBigImpl<B: Backend> {
     fn vec_znx_dft_to_vec_znx_big_impl<R, A>(
         module: &Module<B>,
@@ -32,6 +52,10 @@ pub unsafe trait VecZnxDftToVecZnxBigImpl<B: Backend> {
         A: VecZnxDftToRef<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxDftToVecZnxBigTmpAImpl<B: Backend> {
     fn vec_znx_dft_to_vec_znx_big_tmp_a_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &mut A, a_col: usize)
     where
@@ -39,12 +63,20 @@ pub unsafe trait VecZnxDftToVecZnxBigTmpAImpl<B: Backend> {
         A: VecZnxDftToMut<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxDftToVecZnxBigConsumeImpl<B: Backend> {
     fn vec_znx_dft_to_vec_znx_big_consume_impl<D: Data>(module: &Module<B>, a: VecZnxDft<D, B>) -> VecZnxBig<D, B>
     where
         VecZnxDft<D, B>: VecZnxDftToMut<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxDftAddImpl<B: Backend> {
     fn vec_znx_dft_add_impl<R, A, D>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &D, b_col: usize)
     where
@@ -53,6 +85,10 @@ pub unsafe trait VecZnxDftAddImpl<B: Backend> {
         D: VecZnxDftToRef<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxDftAddInplaceImpl<B: Backend> {
     fn vec_znx_dft_add_inplace_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
@@ -60,6 +96,10 @@ pub unsafe trait VecZnxDftAddInplaceImpl<B: Backend> {
         A: VecZnxDftToRef<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxDftSubImpl<B: Backend> {
     fn vec_znx_dft_sub_impl<R, A, D>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &D, b_col: usize)
     where
@@ -68,6 +108,10 @@ pub unsafe trait VecZnxDftSubImpl<B: Backend> {
         D: VecZnxDftToRef<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxDftSubABInplaceImpl<B: Backend> {
     fn vec_znx_dft_sub_ab_inplace_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
@@ -75,6 +119,10 @@ pub unsafe trait VecZnxDftSubABInplaceImpl<B: Backend> {
         A: VecZnxDftToRef<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxDftSubBAInplaceImpl<B: Backend> {
     fn vec_znx_dft_sub_ba_inplace_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
@@ -82,6 +130,10 @@ pub unsafe trait VecZnxDftSubBAInplaceImpl<B: Backend> {
         A: VecZnxDftToRef<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxDftCopyImpl<B: Backend> {
     fn vec_znx_dft_copy_impl<R, A>(
         module: &Module<B>,
@@ -96,6 +148,10 @@ pub unsafe trait VecZnxDftCopyImpl<B: Backend> {
         A: VecZnxDftToRef<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxDftFromVecZnxImpl<B: Backend> {
     fn vec_znx_dft_from_vec_znx_impl<R, A>(
         module: &Module<B>,
@@ -110,6 +166,10 @@ pub unsafe trait VecZnxDftFromVecZnxImpl<B: Backend> {
         A: VecZnxToRef;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VecZnxDftZeroImpl<B: Backend> {
     fn vec_znx_dft_zero_impl<R>(module: &Module<B>, res: &mut R)
     where

backend/src/hal/oep/vmp_pmat.rs

@@ -2,14 +2,26 @@ use crate::hal::layouts::{
     Backend, MatZnxToRef, Module, Scratch, VecZnxDftToMut, VecZnxDftToRef, VmpPMatOwned, VmpPMatToMut, VmpPMatToRef,
 };
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VmpPMatAllocImpl<B: Backend> {
     fn vmp_pmat_alloc_impl(n: usize, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> VmpPMatOwned<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VmpPMatAllocBytesImpl<B: Backend> {
     fn vmp_pmat_alloc_bytes_impl(n: usize, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> usize;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VmpPMatFromBytesImpl<B: Backend> {
     fn vmp_pmat_from_bytes_impl(
         n: usize,
@@ -21,6 +33,10 @@ pub unsafe trait VmpPMatFromBytesImpl<B: Backend> {
     ) -> VmpPMatOwned<B>;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VmpPrepareTmpBytesImpl<B: Backend> {
     fn vmp_prepare_tmp_bytes_impl(
         module: &Module<B>,
@@ -32,6 +48,10 @@ pub unsafe trait VmpPrepareTmpBytesImpl<B: Backend> {
     ) -> usize;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VmpPMatPrepareImpl<B: Backend> {
     fn vmp_prepare_impl<R, A>(module: &Module<B>, res: &mut R, a: &A, scratch: &mut Scratch<B>)
     where
@@ -39,6 +59,11 @@ pub unsafe trait VmpPMatPrepareImpl<B: Backend> {
         A: MatZnxToRef;
 }
 
+#[allow(clippy::too_many_arguments)]
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VmpApplyTmpBytesImpl<B: Backend> {
     fn vmp_apply_tmp_bytes_impl(
         module: &Module<B>,
@@ -52,6 +77,10 @@ pub unsafe trait VmpApplyTmpBytesImpl<B: Backend> {
     ) -> usize;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VmpApplyImpl<B: Backend> {
     fn vmp_apply_impl<R, A, C>(module: &Module<B>, res: &mut R, a: &A, b: &C, scratch: &mut Scratch<B>)
     where
@@ -60,6 +89,11 @@ pub unsafe trait VmpApplyImpl<B: Backend> {
         C: VmpPMatToRef<B>;
 }
 
+#[allow(clippy::too_many_arguments)]
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VmpApplyAddTmpBytesImpl<B: Backend> {
     fn vmp_apply_add_tmp_bytes_impl(
         module: &Module<B>,
@@ -73,6 +107,10 @@ pub unsafe trait VmpApplyAddTmpBytesImpl<B: Backend> {
     ) -> usize;
 }
 
+/// # THIS TRAIT IS AN OPEN EXTENSION POINT (unsafe)
+/// * See TODO for reference code.
+/// * See TODO for corresponding public API.
+/// # Safety [crate::doc::backend_safety] for safety contract.
 pub unsafe trait VmpApplyAddImpl<B: Backend> {
     // Same as [MatZnxDftOps::vmp_apply] except result is added on R instead of overwritting R.
     fn vmp_apply_add_impl<R, A, C>(module: &Module<B>, res: &mut R, a: &A, b: &C, scale: usize, scratch: &mut Scratch<B>)

backend/src/implementation/cpu_spqlios/ffi/module.rs

@@ -5,6 +5,7 @@ pub struct module_info_t {
 pub type module_type_t = ::std::os::raw::c_uint;
 pub use self::module_type_t as MODULE_TYPE;
 
+#[allow(clippy::upper_case_acronyms)]
 pub type MODULE = module_info_t;
 
 unsafe extern "C" {

backend/src/implementation/cpu_spqlios/scratch.rs

@@ -260,7 +260,7 @@ fn take_slice_aligned(data: &mut [u8], take_len: usize) -> (&mut [u8], &mut [u8]
 
             let take_slice: &mut [u8] = &mut *std::ptr::slice_from_raw_parts_mut(ptr.add(aligned_offset), take_len);
 
-            return (take_slice, rem_slice);
+            (take_slice, rem_slice)
         }
     } else {
         panic!(

backend/src/implementation/cpu_spqlios/vec_znx.rs

@@ -34,10 +34,7 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxNormalizeImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxNormalizeImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_normalize_impl<R, A>(
         module: &Module<B>,
         basek: usize,
@@ -77,10 +74,7 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxNormalizeInplaceImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxNormalizeInplaceImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_normalize_inplace_impl<A>(module: &Module<B>, basek: usize, a: &mut A, a_col: usize, scratch: &mut Scratch<B>)
     where
         A: VecZnxToMut,
@@ -106,10 +100,7 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxAddImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxAddImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_add_impl<R, A, C>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &C, b_col: usize)
     where
         R: VecZnxToMut,
@@ -143,10 +134,7 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxAddInplaceImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxAddInplaceImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_add_inplace_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
         R: VecZnxToMut,
@@ -176,10 +164,7 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxAddScalarInplaceImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxAddScalarInplaceImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_add_scalar_inplace_impl<R, A>(
         module: &Module<B>,
         res: &mut R,
@@ -203,23 +188,20 @@ where
             vec_znx::vec_znx_add(
                 module.ptr() as *const module_info_t,
                 res.at_mut_ptr(res_col, res_limb),
-                1 as u64,
+                1_u64,
                 res.sl() as u64,
                 a.at_ptr(a_col, 0),
                 a.size() as u64,
                 a.sl() as u64,
                 res.at_ptr(res_col, res_limb),
-                1 as u64,
+                1_u64,
                 res.sl() as u64,
             )
         }
     }
 }
 
-unsafe impl<B: Backend> VecZnxSubImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxSubImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_sub_impl<R, A, C>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &C, b_col: usize)
     where
         R: VecZnxToMut,
@@ -253,10 +235,7 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxSubABInplaceImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxSubABInplaceImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_sub_ab_inplace_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
         R: VecZnxToMut,
@@ -285,10 +264,7 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxSubBAInplaceImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxSubBAInplaceImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_sub_ba_inplace_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
         R: VecZnxToMut,
@@ -317,10 +293,7 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxSubScalarInplaceImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxSubScalarInplaceImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_sub_scalar_inplace_impl<R, A>(
         module: &Module<B>,
         res: &mut R,
@@ -344,23 +317,20 @@ where
             vec_znx::vec_znx_sub(
                 module.ptr() as *const module_info_t,
                 res.at_mut_ptr(res_col, res_limb),
-                1 as u64,
+                1_u64,
                 res.sl() as u64,
                 a.at_ptr(a_col, 0),
                 a.size() as u64,
                 a.sl() as u64,
                 res.at_ptr(res_col, res_limb),
-                1 as u64,
+                1_u64,
                 res.sl() as u64,
             )
         }
     }
 }
 
-unsafe impl<B: Backend> VecZnxNegateImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxNegateImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_negate_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
         R: VecZnxToMut,
@@ -386,10 +356,7 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxNegateInplaceImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxNegateInplaceImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_negate_inplace_impl<A>(module: &Module<B>, a: &mut A, a_col: usize)
     where
         A: VecZnxToMut,
@@ -409,10 +376,7 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxLshInplaceImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxLshInplaceImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_lsh_inplace_impl<A>(_module: &Module<B>, basek: usize, k: usize, a: &mut A)
     where
         A: VecZnxToMut,
@@ -453,10 +417,7 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxRshInplaceImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxRshInplaceImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_rsh_inplace_impl<A>(_module: &Module<B>, basek: usize, k: usize, a: &mut A)
     where
         A: VecZnxToMut,
@@ -500,10 +461,7 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxRotateImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxRotateImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_rotate_impl<R, A>(_module: &Module<B>, k: i64, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
         R: VecZnxToMut,
@@ -528,10 +486,7 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxRotateInplaceImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxRotateInplaceImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_rotate_inplace_impl<A>(_module: &Module<B>, k: i64, a: &mut A, a_col: usize)
     where
         A: VecZnxToMut,
@@ -545,10 +500,7 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxAutomorphismImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxAutomorphismImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_automorphism_impl<R, A>(module: &Module<B>, k: i64, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
         R: VecZnxToMut,
@@ -575,10 +527,7 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxAutomorphismInplaceImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxAutomorphismInplaceImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_automorphism_inplace_impl<A>(module: &Module<B>, k: i64, a: &mut A, a_col: usize)
     where
         A: VecZnxToMut,
@@ -607,10 +556,7 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxMulXpMinusOneImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxMulXpMinusOneImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_mul_xp_minus_one_impl<R, A>(module: &Module<B>, p: i64, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
         R: VecZnxToMut,
@@ -638,10 +584,7 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxMulXpMinusOneInplaceImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxMulXpMinusOneInplaceImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_mul_xp_minus_one_inplace_impl<R>(module: &Module<B>, p: i64, res: &mut R, res_col: usize)
     where
         R: VecZnxToMut,
@@ -666,18 +609,9 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxSplitImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxSplitImpl<B> for B {
-where
+    fn vec_znx_split_impl<R, A>(module: &Module<B>, res: &mut [R], res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch<B>)
-    B: CPUAVX,
+    where
-{
-    fn vec_znx_split_impl<R, A>(
-        module: &Module<B>,
-        res: &mut Vec<R>,
-        res_col: usize,
-        a: &A,
-        a_col: usize,
-        scratch: &mut Scratch<B>,
-    ) where
         R: VecZnxToMut,
         A: VecZnxToRef,
     {
@@ -685,15 +619,15 @@ where
     }
 }
 
-pub fn vec_znx_split_ref<R, A, B: Backend>(
+pub fn vec_znx_split_ref<R, A, B>(
     module: &Module<B>,
-    res: &mut Vec<R>,
+    res: &mut [R],
     res_col: usize,
     a: &A,
     a_col: usize,
     scratch: &mut Scratch<B>,
 ) where
-    B: CPUAVX,
+    B: Backend + CPUAVX,
     R: VecZnxToMut,
     A: VecZnxToRef,
 {
@@ -720,17 +654,14 @@ pub fn vec_znx_split_ref<R, A, B: Backend>(
             module.vec_znx_switch_degree(bi, res_col, &a, a_col);
             module.vec_znx_rotate(-1, &mut buf, 0, &a, a_col);
         } else {
-            module.vec_znx_switch_degree(bi, res_col, &mut buf, a_col);
+            module.vec_znx_switch_degree(bi, res_col, &buf, a_col);
             module.vec_znx_rotate_inplace(-1, &mut buf, a_col);
         }
     })
 }
 
-unsafe impl<B: Backend> VecZnxMergeImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxMergeImpl<B> for B {
-where
+    fn vec_znx_merge_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &[A], a_col: usize)
-    B: CPUAVX,
-{
-    fn vec_znx_merge_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: Vec<A>, a_col: usize)
     where
         R: VecZnxToMut,
         A: VecZnxToRef,
@@ -739,9 +670,9 @@ where
     }
 }
 
-pub fn vec_znx_merge_ref<R, A, B: Backend>(module: &Module<B>, res: &mut R, res_col: usize, a: Vec<A>, a_col: usize)
+pub fn vec_znx_merge_ref<R, A, B>(module: &Module<B>, res: &mut R, res_col: usize, a: &[A], a_col: usize)
 where
-    B: CPUAVX,
+    B: Backend + CPUAVX,
     R: VecZnxToMut,
     A: VecZnxToRef,
 {
@@ -761,7 +692,7 @@ where
         )
     });
 
-    a.iter().enumerate().for_each(|(_, ai)| {
+    a.iter().for_each(|ai| {
         module.vec_znx_switch_degree(&mut res, res_col, ai, a_col);
         module.vec_znx_rotate_inplace(-1, &mut res, res_col);
     });
@@ -769,10 +700,7 @@ where
     module.vec_znx_rotate_inplace(a.len() as i64, &mut res, res_col);
 }
 
-unsafe impl<B: Backend> VecZnxSwithcDegreeImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxSwithcDegreeImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_switch_degree_impl<R, A>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
         R: VecZnxToMut,
@@ -782,9 +710,9 @@ where
     }
 }
 
-pub fn vec_znx_switch_degree_ref<R, A, B: Backend>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
+pub fn vec_znx_switch_degree_ref<R, A, B>(module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
 where
-    B: CPUAVX,
+    B: Backend + CPUAVX,
     R: VecZnxToMut,
     A: VecZnxToRef,
 {
@@ -817,10 +745,7 @@ where
     });
 }
 
-unsafe impl<B: Backend> VecZnxCopyImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxCopyImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_copy_impl<R, A>(_module: &Module<B>, res: &mut R, res_col: usize, a: &A, a_col: usize)
     where
         R: VecZnxToMut,
@@ -850,10 +775,7 @@ where
     })
 }
 
-unsafe impl<B: Backend> VecZnxFillUniformImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxFillUniformImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_fill_uniform_impl<R>(_module: &Module<B>, basek: usize, res: &mut R, res_col: usize, k: usize, source: &mut Source)
     where
         R: VecZnxToMut,
@@ -870,10 +792,7 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxFillDistF64Impl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxFillDistF64Impl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_fill_dist_f64_impl<R, D: rand::prelude::Distribution<f64>>(
         _module: &Module<B>,
         basek: usize,
@@ -916,10 +835,7 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxAddDistF64Impl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxAddDistF64Impl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_add_dist_f64_impl<R, D: rand::prelude::Distribution<f64>>(
         _module: &Module<B>,
         basek: usize,
@@ -962,10 +878,7 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxFillNormalImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxFillNormalImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_fill_normal_impl<R>(
         module: &Module<B>,
         basek: usize,
@@ -990,10 +903,7 @@ where
     }
 }
 
-unsafe impl<B: Backend> VecZnxAddNormalImpl<B> for B
+unsafe impl<B: Backend + CPUAVX> VecZnxAddNormalImpl<B> for B {
-where
-    B: CPUAVX,
-{
     fn vec_znx_add_normal_impl<R>(
         module: &Module<B>,
         basek: usize,

backend/src/implementation/cpu_spqlios/vec_znx_dft_fft64.rs

@@ -91,9 +91,9 @@ unsafe impl VecZnxDftToVecZnxBigImpl<FFT64> for FFT64 {
                 vec_znx_dft::vec_znx_idft(
                     module.ptr(),
                     res.at_mut_ptr(res_col, j) as *mut vec_znx_big::vec_znx_big_t,
-                    1 as u64,
+                    1_u64,
                     a.at_ptr(a_col, j) as *const vec_znx_dft::vec_znx_dft_t,
-                    1 as u64,
+                    1_u64,
                     tmp_bytes.as_mut_ptr(),
                 )
             });
@@ -120,9 +120,9 @@ unsafe impl VecZnxDftToVecZnxBigTmpAImpl<FFT64> for FFT64 {
                 vec_znx_dft::vec_znx_idft_tmp_a(
                     module.ptr(),
                     res_mut.at_mut_ptr(res_col, j) as *mut vec_znx_big::vec_znx_big_t,
-                    1 as u64,
+                    1_u64,
                     a_mut.at_mut_ptr(a_col, j) as *mut vec_znx_dft::vec_znx_dft_t,
-                    1 as u64,
+                    1_u64,
                 )
             });
             (min_size..res_mut.size()).for_each(|j| {
@@ -146,9 +146,9 @@ unsafe impl VecZnxDftToVecZnxBigConsumeImpl<FFT64> for FFT64 {
                     vec_znx_dft::vec_znx_idft_tmp_a(
                         module.ptr(),
                         a_mut.at_mut_ptr(i, j) as *mut vec_znx_big::vec_znx_big_t,
-                        1 as u64,
+                        1_u64,
                         a_mut.at_mut_ptr(i, j) as *mut vec_znx_dft::vec_znx_dft_t,
-                        1 as u64,
+                        1_u64,
                     )
                 });
             });
@@ -182,9 +182,9 @@ unsafe impl VecZnxDftFromVecZnxImpl<FFT64> for FFT64 {
                     vec_znx_dft::vec_znx_dft(
                         module.ptr(),
                         res_mut.at_mut_ptr(res_col, j) as *mut vec_znx_dft::vec_znx_dft_t,
-                        1 as u64,
+                        1_u64,
                         a_ref.at_ptr(a_col, limb),
-                        1 as u64,
+                        1_u64,
                         a_ref.sl() as u64,
                     )
                 }

backend/src/lib.rs

@@ -17,7 +17,7 @@ pub const GALOISGENERATOR: u64 = 5;
 pub const DEFAULTALIGN: usize = 64;
 
 fn is_aligned_custom<T>(ptr: *const T, align: usize) -> bool {
-    (ptr as usize) % align == 0
+    (ptr as usize).is_multiple_of(align)
 }
 
 pub fn is_aligned<T>(ptr: *const T) -> bool {
@@ -37,6 +37,7 @@ pub fn cast<T, V>(data: &[T]) -> &[V] {
     unsafe { std::slice::from_raw_parts(ptr, len) }
 }
 
+#[allow(clippy::mut_from_ref)]
 pub fn cast_mut<T, V>(data: &[T]) -> &mut [V] {
     let ptr: *mut V = data.as_ptr() as *mut V;
     let len: usize = data.len() / size_of::<V>();

core/benches/external_product_glwe_fft64.rs

@@ -90,7 +90,8 @@ fn bench_external_product_glwe_fft64(c: &mut Criterion) {
         let ggsw_prepared: GGSWCiphertextPrepared<Vec<u8>, FFT64> = ct_ggsw.prepare_alloc(&module, scratch.borrow());
 
         move || {
-            black_box(ct_glwe_out.external_product(&module, &ct_glwe_in, &ggsw_prepared, scratch.borrow()));
+            ct_glwe_out.external_product(&module, &ct_glwe_in, &ggsw_prepared, scratch.borrow());
+            black_box(());
         }
     }
 
@@ -185,7 +186,8 @@ fn bench_external_product_glwe_inplace_fft64(c: &mut Criterion) {
 
         move || {
             let scratch_borrow = scratch.borrow();
-            black_box(ct_glwe.external_product_inplace(&module, &ggsw_prepared, scratch_borrow));
+            ct_glwe.external_product_inplace(&module, &ggsw_prepared, scratch_borrow);
+            black_box(());
         }
     }
 

core/benches/keyswitch_glwe_fft64.rs

@@ -96,7 +96,8 @@ fn bench_keyswitch_glwe_fft64(c: &mut Criterion) {
         let ksk_prepared: GGLWEAutomorphismKeyPrepared<Vec<u8>, _> = ksk.prepare_alloc(&module, scratch.borrow());
 
         move || {
-            black_box(ct_out.automorphism(&module, &ct_in, &ksk_prepared, scratch.borrow()));
+            ct_out.automorphism(&module, &ct_in, &ksk_prepared, scratch.borrow());
+            black_box(());
         }
     }
 
@@ -105,11 +106,11 @@ fn bench_keyswitch_glwe_fft64(c: &mut Criterion) {
 
     let params_set: Vec<Params> = vec![Params {
         log_n: 15,
-        basek: basek,
+        basek,
         k_ct_in: 874 - digits * basek,
         k_ct_out: 874 - digits * basek,
         k_ksk: 874,
-        digits: digits,
+        digits,
         rank_in: 1,
         rank_out: 1,
     }];
@@ -191,7 +192,8 @@ fn bench_keyswitch_glwe_inplace_fft64(c: &mut Criterion) {
         let ksk_prepared: GGLWESwitchingKeyPrepared<Vec<u8>, FFT64> = ksk.prepare_alloc(&module, scratch.borrow());
 
         move || {
-            black_box(ct.keyswitch_inplace(&module, &ksk_prepared, scratch.borrow()));
+            ct.keyswitch_inplace(&module, &ksk_prepared, scratch.borrow());
+            black_box(());
         }
     }
 

core/src/automorphism/gglwe_atk.rs

@@ -10,6 +10,7 @@ use backend::hal::{
 use crate::layouts::{GGLWEAutomorphismKey, GLWECiphertext, Infos, prepared::GGLWEAutomorphismKeyPrepared};
 
 impl GGLWEAutomorphismKey<Vec<u8>> {
+    #[allow(clippy::too_many_arguments)]
     pub fn automorphism_scratch_space<B: Backend>(
         module: &Module<B>,
         n: usize,
@@ -43,7 +44,7 @@ impl GGLWEAutomorphismKey<Vec<u8>> {
 }
 
 impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
-    pub fn automorphism<'a, DataLhs: DataRef, DataRhs: DataRef, B: Backend>(
+    pub fn automorphism<DataLhs: DataRef, DataRhs: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
         lhs: &GGLWEAutomorphismKey<DataLhs>,
@@ -149,7 +150,7 @@ impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
     {
         unsafe {
             let self_ptr: *mut GGLWEAutomorphismKey<DataSelf> = self as *mut GGLWEAutomorphismKey<DataSelf>;
-            self.automorphism(&module, &*self_ptr, rhs, scratch);
+            self.automorphism(module, &*self_ptr, rhs, scratch);
         }
     }
 }

core/src/automorphism/ggsw_ct.rs

@@ -14,6 +14,7 @@ use crate::layouts::{
 };
 
 impl GGSWCiphertext<Vec<u8>> {
+    #[allow(clippy::too_many_arguments)]
     pub fn automorphism_scratch_space<B: Backend>(
         module: &Module<B>,
         n: usize,
@@ -38,6 +39,7 @@ impl GGSWCiphertext<Vec<u8>> {
         ci_dft + (ks_internal | expand)
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn automorphism_inplace_scratch_space<B: Backend>(
         module: &Module<B>,
         n: usize,

core/src/automorphism/glwe_ct.rs

@@ -10,6 +10,7 @@ use backend::hal::{
 use crate::layouts::{GLWECiphertext, Infos, prepared::GGLWEAutomorphismKeyPrepared};
 
 impl GLWECiphertext<Vec<u8>> {
+    #[allow(clippy::too_many_arguments)]
     pub fn automorphism_scratch_space<B: Backend>(
         module: &Module<B>,
         n: usize,

core/src/decryption/glwe_ct.rs

@@ -64,7 +64,7 @@ impl<DataSelf: DataRef> GLWECiphertext<DataSelf> {
         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.basek(), &mut pt.data, 0, &mut c0_big, 0, scratch_1);
+        module.vec_znx_big_normalize(self.basek(), &mut pt.data, 0, &c0_big, 0, scratch_1);
 
         pt.basek = self.basek();
         pt.k = pt.k().min(self.k());

core/src/decryption/lwe_ct.rs

@@ -10,12 +10,12 @@ impl<DataSelf> LWECiphertext<DataSelf>
 where
     DataSelf: DataRef,
 {
-    pub fn decrypt<DataPt, DataSk, B: Backend>(&self, module: &Module<B>, pt: &mut LWEPlaintext<DataPt>, sk: &LWESecret<DataSk>)
+    pub fn decrypt<DataPt, DataSk, B>(&self, module: &Module<B>, pt: &mut LWEPlaintext<DataPt>, sk: &LWESecret<DataSk>)
     where
         DataPt: DataMut,
         DataSk: DataRef,
         Module<B>: VecZnxNormalizeInplace<B>,
-        B: ScratchOwnedAllocImpl<B> + ScratchOwnedBorrowImpl<B>,
+        B: Backend + ScratchOwnedAllocImpl<B> + ScratchOwnedBorrowImpl<B>,
     {
         #[cfg(debug_assertions)]
         {

core/src/encryption/compressed/gglwe_atk.rs

@@ -27,6 +27,7 @@ impl GGLWEAutomorphismKeyCompressed<Vec<u8>> {
 }
 
 impl<DataSelf: DataMut> GGLWEAutomorphismKeyCompressed<DataSelf> {
+    #[allow(clippy::too_many_arguments)]
     pub fn encrypt_sk<DataSk: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
@@ -96,7 +97,7 @@ impl<DataSelf: DataMut> GGLWEAutomorphismKeyCompressed<DataSelf> {
         }
 
         self.key
-            .encrypt_sk(module, &sk, &sk_out, seed_xa, source_xe, sigma, scratch_1);
+            .encrypt_sk(module, sk, &sk_out, seed_xa, source_xe, sigma, scratch_1);
 
         self.p = p;
     }

core/src/encryption/compressed/gglwe_ct.rs

@@ -24,6 +24,7 @@ impl GGLWECiphertextCompressed<Vec<u8>> {
 }
 
 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>,

core/src/encryption/compressed/gglwe_ksk.rs

@@ -33,6 +33,7 @@ impl GGLWESwitchingKeyCompressed<Vec<u8>> {
 }
 
 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>,

core/src/encryption/compressed/gglwe_tsk.rs

@@ -73,7 +73,7 @@ impl<DataSelf: DataMut> GGLWETensorKeyCompressed<DataSelf> {
         let rank: usize = self.rank();
 
         let (mut sk_dft_prep, scratch1) = scratch.take_glwe_secret_prepared(n, rank);
-        sk_dft_prep.prepare(module, &sk, scratch1);
+        sk_dft_prep.prepare(module, sk, scratch1);
 
         let (mut sk_dft, scratch2) = scratch1.take_vec_znx_dft(n, rank, 1);
 

core/src/encryption/compressed/ggsw_ct.rs

@@ -24,6 +24,7 @@ impl GGSWCiphertextCompressed<Vec<u8>> {
 }
 
 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>,

core/src/encryption/compressed/glwe_ct.rs

@@ -23,6 +23,7 @@ impl GLWECiphertextCompressed<Vec<u8>> {
 }
 
 impl<D: DataMut> GLWECiphertextCompressed<D> {
+    #[allow(clippy::too_many_arguments)]
     pub fn encrypt_sk<DataPt: DataRef, DataSk: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
@@ -59,6 +60,7 @@ impl<D: DataMut> GLWECiphertextCompressed<D> {
         );
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub(crate) fn encrypt_sk_internal<DataPt: DataRef, DataSk: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,

core/src/encryption/gglwe_atk.rs

@@ -28,6 +28,7 @@ impl GGLWEAutomorphismKey<Vec<u8>> {
 }
 
 impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
+    #[allow(clippy::too_many_arguments)]
     pub fn encrypt_sk<DataSk: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
@@ -91,7 +92,7 @@ impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
         }
 
         self.key
-            .encrypt_sk(module, &sk, &sk_out, source_xa, source_xe, sigma, scratch_1);
+            .encrypt_sk(module, sk, &sk_out, source_xa, source_xe, sigma, scratch_1);
 
         self.p = p;
     }

core/src/encryption/gglwe_ct.rs

@@ -28,6 +28,7 @@ impl GGLWECiphertext<Vec<u8>> {
 }
 
 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>,

core/src/encryption/gglwe_ksk.rs

@@ -44,6 +44,7 @@ impl GGLWESwitchingKey<Vec<u8>> {
 }
 
 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>,

core/src/encryption/gglwe_tsk.rs

@@ -75,7 +75,7 @@ impl<DataSelf: DataMut> GGLWETensorKey<DataSelf> {
         let rank: usize = self.rank();
 
         let (mut sk_dft_prep, scratch1) = scratch.take_glwe_secret_prepared(n, rank);
-        sk_dft_prep.prepare(module, &sk, scratch1);
+        sk_dft_prep.prepare(module, sk, scratch1);
 
         let (mut sk_dft, scratch2) = scratch1.take_vec_znx_dft(n, rank, 1);
 

core/src/encryption/ggsw_ct.rs

@@ -27,6 +27,7 @@ impl GGSWCiphertext<Vec<u8>> {
 }
 
 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>,

core/src/encryption/glwe_ct.rs

@@ -38,6 +38,7 @@ impl GLWECiphertext<Vec<u8>> {
 }
 
 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>,
@@ -133,6 +134,7 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
         );
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub(crate) fn encrypt_sk_internal<DataPt: DataRef, DataSk: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
@@ -175,6 +177,7 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
         );
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn encrypt_pk<DataPt: DataRef, DataPk: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
@@ -232,6 +235,7 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
         );
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub(crate) fn encrypt_pk_internal<DataPt: DataRef, DataPk: DataRef, B: Backend>(
         &mut self,
         module: &Module<B>,
@@ -307,10 +311,10 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
             );
 
             // ci_big = u * pk[i] + e + m (if col = i)
-            if let Some((pt, col)) = pt {
+            if let Some((pt, col)) = pt
-                if col == i {
+                && col == i
-                    module.vec_znx_big_add_small_inplace(&mut ci_big, 0, &pt.data, 0);
+            {
-                }
+                module.vec_znx_big_add_small_inplace(&mut ci_big, 0, &pt.data, 0);
             }
 
             // ct[i] = norm(ci_big)
@@ -319,6 +323,7 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 pub(crate) fn glwe_encrypt_sk_internal<DataCt: DataMut, DataPt: DataRef, DataSk: DataRef, B: Backend>(
     module: &Module<B>,
     basek: usize,
@@ -373,12 +378,7 @@ pub(crate) fn glwe_encrypt_sk_internal<DataCt: DataMut, DataPt: DataRef, DataSk:
         // ct[i] = uniform
         // ct[0] -= c[i] * s[i],
         (1..cols).for_each(|i| {
-            let col_ct: usize;
+            let col_ct: usize = if compressed { 0 } else { i };
-            if compressed {
-                col_ct = 0;
-            } else {
-                col_ct = i;
-            }
 
             // ct[i] = uniform (+ pt)
             module.vec_znx_fill_uniform(basek, ct, col_ct, k, source_xa);
@@ -415,10 +415,10 @@ pub(crate) fn glwe_encrypt_sk_internal<DataCt: DataMut, DataPt: DataRef, DataSk:
     module.vec_znx_add_normal(basek, &mut c0, 0, k, source_xe, sigma, sigma * SIX_SIGMA);
 
     // c[0] += m if col = 0
-    if let Some((pt, col)) = pt {
+    if let Some((pt, col)) = pt
-        if col == 0 {
+        && col == 0
-            module.vec_znx_add_inplace(&mut c0, 0, &pt.data, 0);
+    {
-        }
+        module.vec_znx_add_inplace(&mut c0, 0, &pt.data, 0);
     }
 
     // c[0] = norm(c[0])

core/src/encryption/glwe_pk.rs

@@ -12,7 +12,7 @@ use sampling::source::Source;
 use crate::layouts::{GLWECiphertext, GLWEPublicKey, Infos, prepared::GLWESecretPrepared};
 
 impl<D: DataMut> GLWEPublicKey<D> {
-    pub fn generate_from_sk<S: DataRef, B: Backend>(
+    pub fn generate_from_sk<S: DataRef, B>(
         &mut self,
         module: &Module<B>,
         sk: &GLWESecretPrepared<S, B>,
@@ -34,7 +34,8 @@ impl<D: DataMut> GLWEPublicKey<D> {
             + VecZnxAddNormal
             + VecZnxNormalize<B>
             + VecZnxSub,
-        B: ScratchOwnedAllocImpl<B>
+        B: Backend
+            + ScratchOwnedAllocImpl<B>
             + ScratchOwnedBorrowImpl<B>
             + TakeVecZnxDftImpl<B>
             + ScratchAvailableImpl<B>
@@ -46,9 +47,8 @@ impl<D: DataMut> GLWEPublicKey<D> {
 
             assert_eq!(self.n(), sk.n());
 
-            match sk.dist {
+            if sk.dist == Distribution::NONE {
-                Distribution::NONE => panic!("invalid sk: SecretDistribution::NONE"),
+                panic!("invalid sk: SecretDistribution::NONE")
-                _ => {}
             }
         }
 

core/src/encryption/glwe_to_lwe_ksk.rs

@@ -26,6 +26,7 @@ impl GLWEToLWESwitchingKey<Vec<u8>> {
 }
 
 impl<D: DataMut> GLWEToLWESwitchingKey<D> {
+    #[allow(clippy::too_many_arguments)]
     pub fn encrypt_sk<DLwe, DGlwe, B: Backend>(
         &mut self,
         module: &Module<B>,

core/src/encryption/lwe_ct.rs

@@ -13,7 +13,7 @@ use crate::{
 };
 
 impl<DataSelf: DataMut> LWECiphertext<DataSelf> {
-    pub fn encrypt_sk<DataPt, DataSk, B: Backend>(
+    pub fn encrypt_sk<DataPt, DataSk, B>(
         &mut self,
         module: &Module<B>,
         pt: &LWEPlaintext<DataPt>,
@@ -25,7 +25,7 @@ impl<DataSelf: DataMut> LWECiphertext<DataSelf> {
         DataPt: DataRef,
         DataSk: DataRef,
         Module<B>: VecZnxFillUniform + VecZnxAddNormal + VecZnxNormalizeInplace<B>,
-        B: ScratchOwnedAllocImpl<B> + ScratchOwnedBorrowImpl<B>,
+        B: Backend + ScratchOwnedAllocImpl<B> + ScratchOwnedBorrowImpl<B>,
     {
         #[cfg(debug_assertions)]
         {

core/src/encryption/lwe_ksk.rs

@@ -26,6 +26,7 @@ impl LWESwitchingKey<Vec<u8>> {
 }
 
 impl<D: DataMut> LWESwitchingKey<D> {
+    #[allow(clippy::too_many_arguments)]
     pub fn encrypt_sk<DIn, DOut, B: Backend>(
         &mut self,
         module: &Module<B>,

core/src/encryption/lwe_to_glwe_ksk.rs

@@ -24,6 +24,7 @@ impl LWEToGLWESwitchingKey<Vec<u8>> {
 }
 
 impl<D: DataMut> LWEToGLWESwitchingKey<D> {
+    #[allow(clippy::too_many_arguments)]
     pub fn encrypt_sk<DLwe, DGlwe, B: Backend>(
         &mut self,
         module: &Module<B>,
@@ -69,7 +70,7 @@ impl<D: DataMut> LWEToGLWESwitchingKey<D> {
         self.0.encrypt_sk(
             module,
             &sk_lwe_as_glwe,
-            &sk_glwe,
+            sk_glwe,
             source_xa,
             source_xe,
             sigma,

core/src/external_product/gglwe_atk.rs

@@ -9,6 +9,7 @@ use backend::hal::{
 use crate::layouts::{GGLWEAutomorphismKey, GGLWESwitchingKey, prepared::GGSWCiphertextPrepared};
 
 impl GGLWEAutomorphismKey<Vec<u8>> {
+    #[allow(clippy::too_many_arguments)]
     pub fn external_product_scratch_space<B: Backend>(
         module: &Module<B>,
         n: usize,

core/src/external_product/gglwe_ksk.rs

@@ -9,6 +9,7 @@ use backend::hal::{
 use crate::layouts::{GGLWESwitchingKey, GLWECiphertext, Infos, prepared::GGSWCiphertextPrepared};
 
 impl GGLWESwitchingKey<Vec<u8>> {
+    #[allow(clippy::too_many_arguments)]
     pub fn external_product_scratch_space<B: Backend>(
         module: &Module<B>,
         n: usize,

core/src/external_product/ggsw_ct.rs

@@ -9,6 +9,7 @@ use backend::hal::{
 use crate::layouts::{GGSWCiphertext, GLWECiphertext, Infos, prepared::GGSWCiphertextPrepared};
 
 impl GGSWCiphertext<Vec<u8>> {
+    #[allow(clippy::too_many_arguments)]
     pub fn external_product_scratch_space<B: Backend>(
         module: &Module<B>,
         n: usize,

core/src/external_product/glwe_ct.rs

@@ -9,6 +9,7 @@ use backend::hal::{
 use crate::layouts::{GLWECiphertext, Infos, prepared::GGSWCiphertextPrepared};
 
 impl GLWECiphertext<Vec<u8>> {
+    #[allow(clippy::too_many_arguments)]
     pub fn external_product_scratch_space<B: Backend>(
         module: &Module<B>,
         n: usize,
@@ -160,7 +161,7 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
     {
         unsafe {
             let self_ptr: *mut GLWECiphertext<DataSelf> = self as *mut GLWECiphertext<DataSelf>;
-            self.external_product(&module, &*self_ptr, rhs, scratch);
+            self.external_product(module, &*self_ptr, rhs, scratch);
         }
     }
 }

core/src/glwe_packing.rs

@@ -55,14 +55,14 @@ impl Accumulator {
 impl GLWEPacker {
     /// Instantiates a new [GLWEPacker].
     ///
-    /// #Arguments
+    /// # Arguments
     ///
     /// * `module`: static backend FFT tables.
     /// * `log_batch`: packs coefficients which are multiples of X^{N/2^log_batch}.
-    ///                i.e. with `log_batch=0` only the constant coefficient is packed
+    ///   i.e. with `log_batch=0` only the constant coefficient is packed
-    ///                and N GLWE ciphertext can be packed. With `log_batch=2` all coefficients
+    ///   and N GLWE ciphertext can be packed. With `log_batch=2` all coefficients
-    ///                which are multiples of X^{N/4} are packed. Meaning that N/4 ciphertexts
+    ///   which are multiples of X^{N/4} are packed. Meaning that N/4 ciphertexts
-    ///                can be packed.
+    ///   can be packed.
     /// * `basek`: base 2 logarithm of the GLWE ciphertext in memory digit representation.
     /// * `k`: base 2 precision of the GLWE ciphertext precision over the Torus.
     /// * `rank`: rank of the GLWE ciphertext.
@@ -71,7 +71,7 @@ impl GLWEPacker {
         let log_n: usize = (usize::BITS - (n - 1).leading_zeros()) as _;
         (0..log_n - log_batch).for_each(|_| accumulators.push(Accumulator::alloc(n, basek, k, rank)));
         Self {
-            accumulators: accumulators,
+            accumulators,
             log_batch,
             counter: 0,
         }
@@ -111,7 +111,7 @@ impl GLWEPacker {
     ///
     /// * `module`: static backend FFT tables.
     /// * `res`: space to append fully packed ciphertext. Only when the number
-    ///          of packed ciphertexts reaches N/2^log_batch is a result written.
+    ///   of packed ciphertexts reaches N/2^log_batch is a result written.
     /// * `a`: ciphertext to pack. Can optionally give None to pack a 0 ciphertext.
     /// * `auto_keys`: a [HashMap] containing the [AutomorphismKeyExec]s.
     /// * `scratch`: scratch space of size at least [Self::scratch_space].
@@ -329,13 +329,11 @@ fn combine<D: DataRef, DataAK: DataRef, B: Backend>(
     let k: usize = a.k();
     let rank: usize = a.rank();
 
-    let gal_el: i64;
+    let gal_el: i64 = if i == 0 {
-
+        -1
-    if i == 0 {
-        gal_el = -1;
     } else {
-        gal_el = module.galois_element(1 << (i - 1))
+        module.galois_element(1 << (i - 1))
-    }
+    };
 
     let t: i64 = 1 << (log_n - i - 1);
 
@@ -390,20 +388,18 @@ fn combine<D: DataRef, DataAK: DataRef, B: Backend>(
                 panic!("auto_key[{}] not found", gal_el);
             }
         }
-    } else {
+    } else if let Some(b) = b {
-        if let Some(b) = b {
+        let (mut tmp_b, scratch_1) = scratch.take_glwe_ct(n, basek, k, rank);
-            let (mut tmp_b, scratch_1) = scratch.take_glwe_ct(n, basek, k, rank);
+        tmp_b.rotate(module, 1 << (log_n - i - 1), b);
-            tmp_b.rotate(module, 1 << (log_n - i - 1), b);
+        tmp_b.rsh(module, 1);
-            tmp_b.rsh(module, 1);
 
-            // a = (b* X^t - phi(b* X^t))
+        // a = (b* X^t - phi(b* X^t))
-            if let Some(key) = auto_keys.get(&gal_el) {
+        if let Some(key) = auto_keys.get(&gal_el) {
-                a.automorphism_sub_ba(module, &tmp_b, key, scratch_1);
+            a.automorphism_sub_ba(module, &tmp_b, key, scratch_1);
-            } else {
+        } else {
-                panic!("auto_key[{}] not found", gal_el);
+            panic!("auto_key[{}] not found", gal_el);
-            }
-
-            acc.value = true;
         }
+
+        acc.value = true;
     }
 }

core/src/glwe_trace.rs

@@ -27,6 +27,7 @@ impl GLWECiphertext<Vec<u8>> {
         gal_els
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn trace_scratch_space<B: Backend>(
         module: &Module<B>,
         n: usize,
@@ -111,12 +112,11 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
         (start..end).for_each(|i| {
             self.rsh(module, 1);
 
-            let p: i64;
+            let p: i64 = if i == 0 {
-            if i == 0 {
+                -1
-                p = -1;
             } else {
-                p = module.galois_element(1 << (i - 1));
+                module.galois_element(1 << (i - 1))
-            }
+            };
 
             if let Some(key) = auto_keys.get(&p) {
                 self.automorphism_add_inplace(module, key, scratch);

core/src/keyswitching/gglwe_ct.rs

@@ -12,6 +12,7 @@ use crate::layouts::{
 };
 
 impl GGLWEAutomorphismKey<Vec<u8>> {
+    #[allow(clippy::too_many_arguments)]
     pub fn keyswitch_scratch_space<B: Backend>(
         module: &Module<B>,
         n: usize,
@@ -88,6 +89,7 @@ impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
 }
 
 impl GGLWESwitchingKey<Vec<u8>> {
+    #[allow(clippy::too_many_arguments)]
     pub fn keyswitch_scratch_space<B: Backend>(
         module: &Module<B>,
         n: usize,

core/src/keyswitching/ggsw_ct.rs

@@ -49,6 +49,7 @@ impl GGSWCiphertext<Vec<u8>> {
         tmp_dft_i + ((tmp_a + vmp) | (tmp_idft + norm))
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn keyswitch_scratch_space<B: Backend>(
         module: &Module<B>,
         n: usize,
@@ -74,6 +75,7 @@ impl GGSWCiphertext<Vec<u8>> {
         res_znx + ci_dft + (ks | expand_rows | res_dft)
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn keyswitch_inplace_scratch_space<B: Backend>(
         module: &Module<B>,
         n: usize,

core/src/keyswitching/glwe_ct.rs

@@ -9,6 +9,7 @@ use backend::hal::{
 use crate::layouts::{GLWECiphertext, Infos, prepared::GGLWESwitchingKeyPrepared};
 
 impl GLWECiphertext<Vec<u8>> {
+    #[allow(clippy::too_many_arguments)]
     pub fn keyswitch_scratch_space<B: Backend>(
         module: &Module<B>,
         n: usize,
@@ -38,7 +39,7 @@ impl GLWECiphertext<Vec<u8>> {
             ksk_size,
         ) + module.vec_znx_dft_alloc_bytes(n, rank_in, in_size);
         let normalize: usize = module.vec_znx_big_normalize_tmp_bytes(n);
-        return res_dft + ((ai_dft + vmp) | normalize);
+        res_dft + ((ai_dft + vmp) | normalize)
     }
 
     pub fn keyswitch_inplace_scratch_space<B: Backend>(
@@ -180,7 +181,7 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
     {
         unsafe {
             let self_ptr: *mut GLWECiphertext<DataSelf> = self as *mut GLWECiphertext<DataSelf>;
-            self.keyswitch(&module, &*self_ptr, rhs, scratch);
+            self.keyswitch(module, &*self_ptr, rhs, scratch);
         }
     }
 }

core/src/layouts/compressed/gglwe_atk.rs

@@ -61,7 +61,7 @@ impl<D: Data> Infos for GGLWEAutomorphismKeyCompressed<D> {
     type Inner = MatZnx<D>;
 
     fn inner(&self) -> &Self::Inner {
-        &self.key.inner()
+        self.key.inner()
     }
 
     fn basek(&self) -> usize {

core/src/layouts/compressed/gglwe_ct.rs

@@ -76,7 +76,7 @@ impl GGLWECiphertextCompressed<Vec<u8>> {
 
         Self {
             data: MatZnx::alloc(n, rows, rank_in, 1, size),
-            basek: basek,
+            basek,
             k,
             rank_out,
             digits,

core/src/layouts/compressed/gglwe_ksk.rs

@@ -54,7 +54,7 @@ impl<D: Data> Infos for GGLWESwitchingKeyCompressed<D> {
     type Inner = MatZnx<D>;
 
     fn inner(&self) -> &Self::Inner {
-        &self.key.inner()
+        self.key.inner()
     }
 
     fn basek(&self) -> usize {

core/src/layouts/compressed/gglwe_tsk.rs

@@ -59,7 +59,7 @@ impl GGLWETensorKeyCompressed<Vec<u8>> {
                 n, basek, k, rows, digits, 1, rank,
             ));
         });
-        Self { keys: keys }
+        Self { keys }
     }
 
     pub fn bytes_of(n: usize, basek: usize, k: usize, rows: usize, digits: usize, rank: usize) -> usize {
@@ -72,7 +72,7 @@ impl<D: Data> Infos for GGLWETensorKeyCompressed<D> {
     type Inner = MatZnx<D>;
 
     fn inner(&self) -> &Self::Inner {
-        &self.keys[0].inner()
+        self.keys[0].inner()
     }
 
     fn basek(&self) -> usize {

core/src/layouts/compressed/ggsw_ct.rs

@@ -76,7 +76,7 @@ impl GGSWCiphertextCompressed<Vec<u8>> {
         Self {
             data: MatZnx::alloc(n, rows, rank + 1, 1, k.div_ceil(basek)),
             basek,
-            k: k,
+            k,
             digits,
             rank,
             seed: Vec::new(),
@@ -123,7 +123,7 @@ impl<D: DataMut> GGSWCiphertextCompressed<D> {
             data: self.data.at_mut(row, col),
             basek: self.basek,
             k: self.k,
-            rank: rank,
+            rank,
             seed: self.seed[row * (rank + 1) + col],
         }
     }

core/src/layouts/compressed/glwe_ct.rs

@@ -96,7 +96,7 @@ impl<D: DataMut> ReaderFrom for GLWECiphertextCompressed<D> {
         self.k = reader.read_u64::<LittleEndian>()? as usize;
         self.basek = reader.read_u64::<LittleEndian>()? as usize;
         self.rank = reader.read_u64::<LittleEndian>()? as usize;
-        reader.read(&mut self.seed)?;
+        reader.read_exact(&mut self.seed)?;
         self.data.read_from(reader)
     }
 }

core/src/layouts/compressed/glwe_to_lwe_ksk.rs

@@ -43,7 +43,7 @@ impl<D: Data> Infos for GLWEToLWESwitchingKeyCompressed<D> {
     type Inner = MatZnx<D>;
 
     fn inner(&self) -> &Self::Inner {
-        &self.0.inner()
+        self.0.inner()
     }
 
     fn basek(&self) -> usize {

core/src/layouts/compressed/lwe_ct.rs

@@ -57,8 +57,8 @@ impl LWECiphertextCompressed<Vec<u8>> {
     pub fn alloc(basek: usize, k: usize) -> Self {
         Self {
             data: VecZnx::alloc(1, 1, k.div_ceil(basek)),
-            k: k,
+            k,
-            basek: basek,
+            basek,
             seed: [0u8; 32],
         }
     }
@@ -103,7 +103,7 @@ impl<D: DataMut> ReaderFrom for LWECiphertextCompressed<D> {
     fn read_from<R: std::io::Read>(&mut self, reader: &mut R) -> std::io::Result<()> {
         self.k = reader.read_u64::<LittleEndian>()? as usize;
         self.basek = reader.read_u64::<LittleEndian>()? as usize;
-        reader.read(&mut self.seed)?;
+        reader.read_exact(&mut self.seed)?;
         self.data.read_from(reader)
     }
 }

core/src/layouts/compressed/lwe_ksk.rs

@@ -44,7 +44,7 @@ impl<D: Data> Infos for LWESwitchingKeyCompressed<D> {
     type Inner = MatZnx<D>;
 
     fn inner(&self) -> &Self::Inner {
-        &self.0.inner()
+        self.0.inner()
     }
 
     fn basek(&self) -> usize {

core/src/layouts/compressed/lwe_to_glwe_ksk.rs

@@ -45,7 +45,7 @@ impl<D: Data> Infos for LWEToGLWESwitchingKeyCompressed<D> {
     type Inner = MatZnx<D>;
 
     fn inner(&self) -> &Self::Inner {
-        &self.0.inner()
+        self.0.inner()
     }
 
     fn basek(&self) -> usize {

core/src/layouts/gglwe_atk.rs

@@ -59,7 +59,7 @@ impl<D: Data> Infos for GGLWEAutomorphismKey<D> {
     type Inner = MatZnx<D>;
 
     fn inner(&self) -> &Self::Inner {
-        &self.key.inner()
+        self.key.inner()
     }
 
     fn basek(&self) -> usize {

core/src/layouts/gglwe_ct.rs

@@ -87,7 +87,7 @@ impl GGLWECiphertext<Vec<u8>> {
 
         Self {
             data: MatZnx::alloc(n, rows, rank_in, rank_out + 1, size),
-            basek: basek,
+            basek,
             k,
             digits,
         }

core/src/layouts/gglwe_tsk.rs

@@ -55,7 +55,7 @@ impl GGLWETensorKey<Vec<u8>> {
         (0..pairs).for_each(|_| {
             keys.push(GGLWESwitchingKey::alloc(n, basek, k, rows, digits, 1, rank));
         });
-        Self { keys: keys }
+        Self { keys }
     }
 
     pub fn bytes_of(n: usize, basek: usize, k: usize, rows: usize, digits: usize, rank: usize) -> usize {
@@ -68,7 +68,7 @@ impl<D: Data> Infos for GGLWETensorKey<D> {
     type Inner = MatZnx<D>;
 
     fn inner(&self) -> &Self::Inner {
-        &self.keys[0].inner()
+        self.keys[0].inner()
     }
 
     fn basek(&self) -> usize {

core/src/layouts/ggsw_ct.rs

@@ -88,7 +88,7 @@ impl GGSWCiphertext<Vec<u8>> {
         Self {
             data: MatZnx::alloc(n, rows, rank + 1, rank + 1, k.div_ceil(basek)),
             basek,
-            k: k,
+            k,
             digits,
         }
     }

core/src/layouts/glwe_ct.rs

@@ -1,6 +1,6 @@
 use backend::hal::{
     api::{FillUniform, Reset},
-    layouts::{Data, DataMut, DataRef, ReaderFrom, VecZnx, VecZnxToMut, VecZnxToRef, WriterTo},
+    layouts::{Data, DataMut, DataRef, ReaderFrom, ToOwnedDeep, VecZnx, VecZnxToMut, VecZnxToRef, WriterTo},
 };
 use sampling::source::Source;
 
@@ -15,6 +15,17 @@ pub struct GLWECiphertext<D: Data> {
     pub k: usize,
 }
 
+impl<D: DataRef> ToOwnedDeep for GLWECiphertext<D> {
+    type Owned = GLWECiphertext<Vec<u8>>;
+    fn to_owned_deep(&self) -> Self::Owned {
+        GLWECiphertext {
+            data: self.data.to_owned_deep(),
+            basek: self.basek,
+            k: self.k,
+        }
+    }
+}
+
 impl<D: DataRef> fmt::Debug for GLWECiphertext<D> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self)
@@ -86,16 +97,6 @@ impl<D: Data> GLWECiphertext<D> {
     }
 }
 
-impl<D: DataRef> GLWECiphertext<D> {
-    pub fn clone(&self) -> GLWECiphertext<Vec<u8>> {
-        GLWECiphertext {
-            data: self.data.clone(),
-            basek: self.basek(),
-            k: self.k(),
-        }
-    }
-}
-
 impl<D: DataMut> SetMetaData for GLWECiphertext<D> {
     fn set_k(&mut self, k: usize) {
         self.k = k

core/src/layouts/glwe_pk.rs

@@ -15,8 +15,8 @@ impl GLWEPublicKey<Vec<u8>> {
     pub fn alloc(n: usize, basek: usize, k: usize, rank: usize) -> Self {
         Self {
             data: VecZnx::alloc(n, rank + 1, k.div_ceil(basek)),
-            basek: basek,
+            basek,
-            k: k,
+            k,
             dist: Distribution::NONE,
         }
     }

core/src/layouts/glwe_pt.rs

@@ -52,7 +52,7 @@ impl GLWEPlaintext<Vec<u8>> {
     pub fn alloc(n: usize, basek: usize, k: usize) -> Self {
         Self {
             data: VecZnx::alloc(n, 1, k.div_ceil(basek)),
-            basek: basek,
+            basek,
             k,
         }
     }

core/src/layouts/glwe_to_lwe_ksk.rs

@@ -39,7 +39,7 @@ impl<D: Data> Infos for GLWEToLWESwitchingKey<D> {
     type Inner = MatZnx<D>;
 
     fn inner(&self) -> &Self::Inner {
-        &self.0.inner()
+        self.0.inner()
     }
 
     fn basek(&self) -> usize {

core/src/layouts/lwe_ct.rs

@@ -64,8 +64,8 @@ impl LWECiphertext<Vec<u8>> {
     pub fn alloc(n: usize, basek: usize, k: usize) -> Self {
         Self {
             data: VecZnx::alloc(n + 1, 1, k.div_ceil(basek)),
-            k: k,
+            k,
-            basek: basek,
+            basek,
         }
     }
 }

core/src/layouts/lwe_ksk.rs

@@ -44,7 +44,7 @@ impl<D: Data> Infos for LWESwitchingKey<D> {
     type Inner = MatZnx<D>;
 
     fn inner(&self) -> &Self::Inner {
-        &self.0.inner()
+        self.0.inner()
     }
 
     fn basek(&self) -> usize {

core/src/layouts/lwe_pt.rs

@@ -14,8 +14,8 @@ impl LWEPlaintext<Vec<u8>> {
     pub fn alloc(basek: usize, k: usize) -> Self {
         Self {
             data: VecZnx::alloc(1, 1, k.div_ceil(basek)),
-            k: k,
+            k,
-            basek: basek,
+            basek,
         }
     }
 }

core/src/layouts/lwe_to_glwe_ksk.rs

@@ -38,7 +38,7 @@ impl<D: Data> Infos for LWEToGLWESwitchingKey<D> {
     type Inner = MatZnx<D>;
 
     fn inner(&self) -> &Self::Inner {
-        &self.0.inner()
+        self.0.inner()
     }
 
     fn basek(&self) -> usize {

core/src/layouts/prepared/gglwe_atk.rs

@@ -37,7 +37,7 @@ impl<D: Data, B: Backend> Infos for GGLWEAutomorphismKeyPrepared<D, B> {
     type Inner = VmpPMat<D, B>;
 
     fn inner(&self) -> &Self::Inner {
-        &self.key.inner()
+        self.key.inner()
     }
 
     fn basek(&self) -> usize {

core/src/layouts/prepared/gglwe_ct.rs

@@ -17,6 +17,7 @@ pub struct GGLWECiphertextPrepared<D: Data, B: Backend> {
 }
 
 impl<B: Backend> GGLWECiphertextPrepared<Vec<u8>, B> {
+    #[allow(clippy::too_many_arguments)]
     pub fn alloc(
         module: &Module<B>,
         n: usize,
@@ -48,12 +49,13 @@ impl<B: Backend> GGLWECiphertextPrepared<Vec<u8>, B> {
 
         Self {
             data: module.vmp_pmat_alloc(n, rows, rank_in, rank_out + 1, size),
-            basek: basek,
+            basek,
             k,
             digits,
         }
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn bytes_of(
         module: &Module<B>,
         n: usize,

core/src/layouts/prepared/gglwe_ksk.rs

@@ -16,6 +16,7 @@ pub struct GGLWESwitchingKeyPrepared<D: Data, B: Backend> {
 }
 
 impl<B: Backend> GGLWESwitchingKeyPrepared<Vec<u8>, B> {
+    #[allow(clippy::too_many_arguments)]
     pub fn alloc(
         module: &Module<B>,
         n: usize,
@@ -36,6 +37,7 @@ impl<B: Backend> GGLWESwitchingKeyPrepared<Vec<u8>, B> {
         }
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn bytes_of(
         module: &Module<B>,
         n: usize,

core/src/layouts/prepared/gglwe_tsk.rs

@@ -41,7 +41,7 @@ impl<D: Data, B: Backend> Infos for GGLWETensorKeyPrepared<D, B> {
     type Inner = VmpPMat<D, B>;
 
     fn inner(&self) -> &Self::Inner {
-        &self.keys[0].inner()
+        self.keys[0].inner()
     }
 
     fn basek(&self) -> usize {

core/src/layouts/prepared/ggsw_ct.rs

@@ -42,7 +42,7 @@ impl<B: Backend> GGSWCiphertextPrepared<Vec<u8>, B> {
         Self {
             data: module.vmp_pmat_alloc(n, rows, rank + 1, rank + 1, k.div_ceil(basek)),
             basek,
-            k: k,
+            k,
             digits,
         }
     }

core/src/layouts/prepared/glwe_ct.rs

@@ -0,0 +1,177 @@
+use backend::hal::{
+    api::{FillUniform, Reset, VecZnxCopy, VecZnxFillUniform},
+    layouts::{Backend, Data, DataMut, DataRef, Module, ReaderFrom, VecZnx, WriterTo},
+};
+use sampling::source::Source;
+
+use crate::layouts::{GLWECiphertext, Infos, compressed::Decompress};
+use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
+use std::fmt;
+
+#[derive(PartialEq, Eq, Clone)]
+pub struct GLWECiphertextCompressed<D: Data> {
+    pub(crate) data: VecZnx<D>,
+    pub(crate) basek: usize,
+    pub(crate) k: usize,
+    pub(crate) rank: usize,
+    pub(crate) seed: [u8; 32],
+}
+
+impl<D: DataRef> fmt::Debug for GLWECiphertextCompressed<D> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self)
+    }
+}
+
+impl<D: DataRef> fmt::Display for GLWECiphertextCompressed<D> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "GLWECiphertextCompressed: basek={} k={} rank={} seed={:?}: {}",
+            self.basek(),
+            self.k(),
+            self.rank,
+            self.seed,
+            self.data
+        )
+    }
+}
+
+impl<D: DataMut> Reset for GLWECiphertextCompressed<D> {
+    fn reset(&mut self) {
+        self.data.reset();
+        self.basek = 0;
+        self.k = 0;
+        self.rank = 0;
+        self.seed = [0u8; 32];
+    }
+}
+
+impl<D: DataMut> FillUniform for GLWECiphertextCompressed<D> {
+    fn fill_uniform(&mut self, source: &mut Source) {
+        self.data.fill_uniform(source);
+    }
+}
+
+impl<D: Data> Infos for GLWECiphertextCompressed<D> {
+    type Inner = VecZnx<D>;
+
+    fn inner(&self) -> &Self::Inner {
+        &self.data
+    }
+
+    fn basek(&self) -> usize {
+        self.basek
+    }
+
+    fn k(&self) -> usize {
+        self.k
+    }
+}
+
+impl<D: Data> GLWECiphertextCompressed<D> {
+    pub fn rank(&self) -> usize {
+        self.rank
+    }
+}
+
+impl GLWECiphertextCompressed<Vec<u8>> {
+    pub fn alloc(n: usize, basek: usize, k: usize, rank: usize) -> Self {
+        Self {
+            data: VecZnx::alloc(n, 1, k.div_ceil(basek)),
+            basek,
+            k,
+            rank,
+            seed: [0u8; 32],
+        }
+    }
+
+    pub fn bytes_of(n: usize, basek: usize, k: usize) -> usize {
+        GLWECiphertext::bytes_of(n, basek, k, 1)
+    }
+}
+
+impl<D: DataMut> ReaderFrom for GLWECiphertextCompressed<D> {
+    fn read_from<R: std::io::Read>(&mut self, reader: &mut R) -> std::io::Result<()> {
+        self.k = reader.read_u64::<LittleEndian>()? as usize;
+        self.basek = reader.read_u64::<LittleEndian>()? as usize;
+        self.rank = reader.read_u64::<LittleEndian>()? as usize;
+        reader.read_exact(&mut self.seed)?;
+        self.data.read_from(reader)
+    }
+}
+
+impl<D: DataRef> WriterTo for GLWECiphertextCompressed<D> {
+    fn write_to<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
+        writer.write_u64::<LittleEndian>(self.k as u64)?;
+        writer.write_u64::<LittleEndian>(self.basek as u64)?;
+        writer.write_u64::<LittleEndian>(self.rank as u64)?;
+        writer.write_all(&self.seed)?;
+        self.data.write_to(writer)
+    }
+}
+
+impl<D: DataMut, B: Backend, DR: DataRef> Decompress<B, GLWECiphertextCompressed<DR>> for GLWECiphertext<D> {
+    fn decompress(&mut self, module: &Module<B>, other: &GLWECiphertextCompressed<DR>)
+    where
+        Module<B>: VecZnxCopy + VecZnxFillUniform,
+    {
+        #[cfg(debug_assertions)]
+        {
+            use backend::hal::api::ZnxInfos;
+
+            assert_eq!(
+                self.n(),
+                other.data.n(),
+                "invalid receiver: self.n()={} != other.n()={}",
+                self.n(),
+                other.data.n()
+            );
+            assert_eq!(
+                self.size(),
+                other.size(),
+                "invalid receiver: self.size()={} != other.size()={}",
+                self.size(),
+                other.size()
+            );
+            assert_eq!(
+                self.rank(),
+                other.rank(),
+                "invalid receiver: self.rank()={} != other.rank()={}",
+                self.rank(),
+                other.rank()
+            );
+        }
+
+        let mut source: Source = Source::new(other.seed);
+        self.decompress_internal(module, other, &mut source);
+    }
+}
+
+impl<D: DataMut> GLWECiphertext<D> {
+    pub(crate) fn decompress_internal<DataOther, B: Backend>(
+        &mut self,
+        module: &Module<B>,
+        other: &GLWECiphertextCompressed<DataOther>,
+        source: &mut Source,
+    ) where
+        DataOther: DataRef,
+        Module<B>: VecZnxCopy + VecZnxFillUniform,
+    {
+        #[cfg(debug_assertions)]
+        {
+            assert_eq!(self.rank(), other.rank())
+        }
+
+        let k: usize = other.k;
+        let basek: usize = other.basek;
+        let cols: usize = other.rank() + 1;
+        module.vec_znx_copy(&mut self.data, 0, &other.data, 0);
+        (1..cols).for_each(|i| {
+            module.vec_znx_fill_uniform(basek, &mut self.data, i, k, source);
+        });
+
+        self.basek = basek;
+        self.k = k;
+    }
+}

core/src/layouts/prepared/glwe_pk.rs

@@ -48,8 +48,8 @@ impl<B: Backend> GLWEPublicKeyPrepared<Vec<u8>, B> {
     {
         Self {
             data: module.vec_znx_dft_alloc(n, rank + 1, k.div_ceil(basek)),
-            basek: basek,
+            basek,
-            k: k,
+            k,
             dist: Distribution::NONE,
         }
     }

core/src/layouts/prepared/glwe_to_lwe_ksk.rs

@@ -15,7 +15,7 @@ impl<D: Data, B: Backend> Infos for GLWEToLWESwitchingKeyPrepared<D, B> {
     type Inner = VmpPMat<D, B>;
 
     fn inner(&self) -> &Self::Inner {
-        &self.0.inner()
+        self.0.inner()
     }
 
     fn basek(&self) -> usize {

core/src/layouts/prepared/lwe_ksk.rs

@@ -15,7 +15,7 @@ impl<D: Data, B: Backend> Infos for LWESwitchingKeyPrepared<D, B> {
     type Inner = VmpPMat<D, B>;
 
     fn inner(&self) -> &Self::Inner {
-        &self.0.inner()
+        self.0.inner()
     }
 
     fn basek(&self) -> usize {

core/src/layouts/prepared/lwe_to_glwe_ksk.rs

@@ -16,7 +16,7 @@ impl<D: Data, B: Backend> Infos for LWEToGLWESwitchingKeyPrepared<D, B> {
     type Inner = VmpPMat<D, B>;
 
     fn inner(&self) -> &Self::Inner {
-        &self.0.inner()
+        self.0.inner()
     }
 
     fn basek(&self) -> usize {

core/src/noise/gglwe_ct.rs

@@ -11,7 +11,7 @@ use backend::hal::{
 use crate::layouts::{GGLWECiphertext, GLWECiphertext, GLWEPlaintext, Infos, prepared::GLWESecretPrepared};
 
 impl<D: DataRef> GGLWECiphertext<D> {
-    pub fn assert_noise<B: Backend, DataSk, DataWant>(
+    pub fn assert_noise<B, DataSk, DataWant>(
         self,
         module: &Module<B>,
         sk: &GLWESecretPrepared<DataSk, B>,
@@ -30,7 +30,7 @@ impl<D: DataRef> GGLWECiphertext<D> {
             + VecZnxBigNormalize<B>
             + VecZnxNormalizeTmpBytes
             + VecZnxSubScalarInplace,
-        B: TakeVecZnxDftImpl<B> + TakeVecZnxBigImpl<B> + ScratchOwnedAllocImpl<B> + ScratchOwnedBorrowImpl<B>,
+        B: Backend + TakeVecZnxDftImpl<B> + TakeVecZnxBigImpl<B> + ScratchOwnedAllocImpl<B> + ScratchOwnedBorrowImpl<B>,
     {
         let digits: usize = self.digits();
         let basek: usize = self.basek();
@@ -47,7 +47,7 @@ impl<D: DataRef> GGLWECiphertext<D> {
         (0..self.rank_in()).for_each(|col_i| {
             (0..self.rows()).for_each(|row_i| {
                 self.at(row_i, col_i)
-                    .decrypt(&module, &mut pt, &sk, scratch.borrow());
+                    .decrypt(module, &mut pt, sk, scratch.borrow());
 
                 module.vec_znx_sub_scalar_inplace(
                     &mut pt.data,

core/src/noise/ggsw_ct.rs

@@ -12,7 +12,7 @@ use backend::hal::{
 use crate::layouts::{GGSWCiphertext, GLWECiphertext, GLWEPlaintext, Infos, prepared::GLWESecretPrepared};
 
 impl<D: DataRef> GGSWCiphertext<D> {
-    pub fn assert_noise<B: Backend, DataSk, DataScalar, F>(
+    pub fn assert_noise<B, DataSk, DataScalar, F>(
         &self,
         module: &Module<B>,
         sk_prepared: &GLWESecretPrepared<DataSk, B>,
@@ -36,7 +36,7 @@ impl<D: DataRef> GGSWCiphertext<D> {
             + VecZnxDftToVecZnxBigTmpA<B>
             + VecZnxAddScalarInplace
             + VecZnxSubABInplace,
-        B: TakeVecZnxDftImpl<B> + TakeVecZnxBigImpl<B> + ScratchOwnedAllocImpl<B> + ScratchOwnedBorrowImpl<B>,
+        B: Backend + TakeVecZnxDftImpl<B> + TakeVecZnxBigImpl<B> + ScratchOwnedAllocImpl<B> + ScratchOwnedBorrowImpl<B>,
         F: Fn(usize) -> f64,
     {
         let basek: usize = self.basek();
@@ -65,7 +65,7 @@ impl<D: DataRef> GGSWCiphertext<D> {
                 }
 
                 self.at(row_i, col_j)
-                    .decrypt(module, &mut pt_have, &sk_prepared, scratch.borrow());
+                    .decrypt(module, &mut pt_have, sk_prepared, scratch.borrow());
 
                 module.vec_znx_sub_ab_inplace(&mut pt_have.data, 0, &pt.data, 0);
 
@@ -81,7 +81,7 @@ impl<D: DataRef> GGSWCiphertext<D> {
 }
 
 impl<D: DataRef> GGSWCiphertext<D> {
-    pub fn print_noise<B: Backend, DataSk, DataScalar>(
+    pub fn print_noise<B, DataSk, DataScalar>(
         &self,
         module: &Module<B>,
         sk_prepared: &GLWESecretPrepared<DataSk, B>,
@@ -104,7 +104,7 @@ impl<D: DataRef> GGSWCiphertext<D> {
             + VecZnxDftToVecZnxBigTmpA<B>
             + VecZnxAddScalarInplace
             + VecZnxSubABInplace,
-        B: TakeVecZnxDftImpl<B> + TakeVecZnxBigImpl<B> + ScratchOwnedAllocImpl<B> + ScratchOwnedBorrowImpl<B>,
+        B: Backend + TakeVecZnxDftImpl<B> + TakeVecZnxBigImpl<B> + ScratchOwnedAllocImpl<B> + ScratchOwnedBorrowImpl<B>,
     {
         let basek: usize = self.basek();
         let k: usize = self.k();
@@ -132,7 +132,7 @@ impl<D: DataRef> GGSWCiphertext<D> {
                 }
 
                 self.at(row_i, col_j)
-                    .decrypt(module, &mut pt_have, &sk_prepared, scratch.borrow());
+                    .decrypt(module, &mut pt_have, sk_prepared, scratch.borrow());
 
                 module.vec_znx_sub_ab_inplace(&mut pt_have.data, 0, &pt.data, 0);
 

core/src/noise/glwe_ct.rs

@@ -15,7 +15,7 @@ use crate::{
 };
 
 impl<D: DataRef> GLWECiphertext<D> {
-    pub fn assert_noise<B: Backend, DataSk, DataPt>(
+    pub fn assert_noise<B, DataSk, DataPt>(
         &self,
         module: &Module<B>,
         sk_prepared: &GLWESecretPrepared<DataSk, B>,
@@ -35,7 +35,7 @@ impl<D: DataRef> GLWECiphertext<D> {
             + VecZnxNormalizeTmpBytes
             + VecZnxSubABInplace
             + VecZnxNormalizeInplace<B>,
-        B: TakeVecZnxDftImpl<B> + TakeVecZnxBigImpl<B> + ScratchOwnedAllocImpl<B> + ScratchOwnedBorrowImpl<B>,
+        B: Backend + TakeVecZnxDftImpl<B> + TakeVecZnxBigImpl<B> + ScratchOwnedAllocImpl<B> + ScratchOwnedBorrowImpl<B>,
     {
         let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(self.n(), self.basek(), self.k());
 
@@ -46,7 +46,7 @@ impl<D: DataRef> GLWECiphertext<D> {
             self.k(),
         ));
 
-        self.decrypt(module, &mut pt_have, &sk_prepared, scratch.borrow());
+        self.decrypt(module, &mut pt_have, sk_prepared, scratch.borrow());
 
         module.vec_znx_sub_ab_inplace(&mut pt_have.data, 0, &pt_want.data, 0);
         module.vec_znx_normalize_inplace(self.basek(), &mut pt_have.data, 0, scratch.borrow());

core/src/noise/mod.rs

@@ -2,6 +2,7 @@ mod gglwe_ct;
 mod ggsw_ct;
 mod glwe_ct;
 
+#[allow(clippy::too_many_arguments)]
 #[allow(dead_code)]
 pub(crate) fn var_noise_gglwe_product(
     n: f64,
@@ -33,6 +34,7 @@ pub(crate) fn var_noise_gglwe_product(
     noise
 }
 
+#[allow(clippy::too_many_arguments)]
 #[allow(dead_code)]
 pub(crate) fn log2_std_noise_gglwe_product(
     n: f64,
@@ -62,6 +64,7 @@ pub(crate) fn log2_std_noise_gglwe_product(
     noise.log2().min(-1.0).max(-(a_logq as f64)) // max noise is [-2^{-1}, 2^{-1}]
 }
 
+#[allow(clippy::too_many_arguments)]
 #[allow(dead_code)]
 pub(crate) fn noise_ggsw_product(
     n: f64,
@@ -95,6 +98,7 @@ pub(crate) fn noise_ggsw_product(
     noise.log2().min(-1.0) // max noise is [-2^{-1}, 2^{-1}]
 }
 
+#[allow(clippy::too_many_arguments)]
 #[allow(dead_code)]
 pub(crate) fn noise_ggsw_keyswitch(
     n: f64,

core/src/scratch.rs

@@ -41,6 +41,7 @@ pub trait TakeGLWEPt<B: Backend> {
 }
 
 pub trait TakeGGLWE {
+    #[allow(clippy::too_many_arguments)]
     fn take_gglwe(
         &mut self,
         n: usize,
@@ -54,6 +55,7 @@ pub trait TakeGGLWE {
 }
 
 pub trait TakeGGLWEPrepared<B: Backend> {
+    #[allow(clippy::too_many_arguments)]
     fn take_gglwe_prepared(
         &mut self,
         n: usize,
@@ -113,6 +115,7 @@ pub trait TakeGLWEPkPrepared<B: Backend> {
 }
 
 pub trait TakeGLWESwitchingKey {
+    #[allow(clippy::too_many_arguments)]
     fn take_glwe_switching_key(
         &mut self,
         n: usize,
@@ -126,6 +129,7 @@ pub trait TakeGLWESwitchingKey {
 }
 
 pub trait TakeGLWESwitchingKeyPrepared<B: Backend> {
+    #[allow(clippy::too_many_arguments)]
     fn take_glwe_switching_key_prepared(
         &mut self,
         n: usize,
@@ -292,8 +296,8 @@ where
         );
         (
             GGLWECiphertext {
-                data: data,
+                data,
-                basek: basek,
+                basek,
                 k,
                 digits,
             },
@@ -353,8 +357,8 @@ where
         );
         (
             GGLWECiphertextPrepared {
-                data: data,
+                data,
-                basek: basek,
+                basek,
                 k,
                 digits,
             },

core/src/tests/generics/automorphism/gglwe_atk.rs

@@ -23,7 +23,8 @@ use crate::{
     noise::log2_std_noise_gglwe_product,
 };
 
-pub fn test_gglwe_automorphism_key_automorphism<B: Backend>(
+#[allow(clippy::too_many_arguments)]
+pub fn test_gglwe_automorphism_key_automorphism<B>(
     module: &Module<B>,
     p0: i64,
     p1: i64,
@@ -65,7 +66,8 @@ pub fn test_gglwe_automorphism_key_automorphism<B: Backend>(
         + SvpPPolAlloc<B>
         + VecZnxBigAddInplace<B>
         + VecZnxSubScalarInplace,
-    B: ScratchOwnedAllocImpl<B>
+    B: Backend
+        + ScratchOwnedAllocImpl<B>
         + ScratchOwnedBorrowImpl<B>
         + ScratchAvailableImpl<B>
         + TakeScalarZnxImpl<B>
@@ -186,7 +188,8 @@ pub fn test_gglwe_automorphism_key_automorphism<B: Backend>(
     });
 }
 
-pub fn test_gglwe_automorphism_key_automorphism_inplace<B: Backend>(
+#[allow(clippy::too_many_arguments)]
+pub fn test_gglwe_automorphism_key_automorphism_inplace<B>(
     module: &Module<B>,
     p0: i64,
     p1: i64,
@@ -241,7 +244,8 @@ pub fn test_gglwe_automorphism_key_automorphism_inplace<B: Backend>(
         + VecZnxCopy
         + VmpPMatAlloc<B>
         + VmpPrepare<B>,
-    B: ScratchOwnedAllocImpl<B>
+    B: Backend
+        + ScratchOwnedAllocImpl<B>
         + ScratchOwnedBorrowImpl<B>
         + ScratchAvailableImpl<B>
         + TakeScalarZnxImpl<B>

core/src/tests/generics/automorphism/ggsw_ct.rs

@@ -24,7 +24,8 @@ use crate::{
     noise::noise_ggsw_keyswitch,
 };
 
-pub fn test_ggsw_automorphism<B: Backend>(
+#[allow(clippy::too_many_arguments)]
+pub fn test_ggsw_automorphism<B>(
     p: i64,
     module: &Module<B>,
     basek: usize,
@@ -72,7 +73,8 @@ pub fn test_ggsw_automorphism<B: Backend>(
         + VecZnxSwithcDegree
         + VecZnxAutomorphismInplace
         + VecZnxAutomorphism,
-    B: TakeVecZnxDftImpl<B>
+    B: Backend
+        + TakeVecZnxDftImpl<B>
         + TakeVecZnxBigImpl<B>
         + ScratchOwnedAllocImpl<B>
         + ScratchOwnedBorrowImpl<B>
@@ -178,10 +180,11 @@ pub fn test_ggsw_automorphism<B: Backend>(
         ) + 0.5
     };
 
-    ct_out.assert_noise(module, &sk_prepared, &pt_scalar, &max_noise);
+    ct_out.assert_noise(module, &sk_prepared, &pt_scalar, max_noise);
 }
 
-pub fn test_ggsw_automorphism_inplace<B: Backend>(
+#[allow(clippy::too_many_arguments)]
+pub fn test_ggsw_automorphism_inplace<B>(
     p: i64,
     module: &Module<B>,
     basek: usize,
@@ -229,7 +232,8 @@ pub fn test_ggsw_automorphism_inplace<B: Backend>(
         + VecZnxSwithcDegree
         + VecZnxAutomorphismInplace
         + VecZnxAutomorphism,
-    B: TakeVecZnxDftImpl<B>
+    B: Backend
+        + TakeVecZnxDftImpl<B>
         + TakeVecZnxBigImpl<B>
         + ScratchOwnedAllocImpl<B>
         + ScratchOwnedBorrowImpl<B>
@@ -325,5 +329,5 @@ pub fn test_ggsw_automorphism_inplace<B: Backend>(
         ) + 0.5
     };
 
-    ct.assert_noise(module, &sk_prepared, &pt_scalar, &max_noise);
+    ct.assert_noise(module, &sk_prepared, &pt_scalar, max_noise);
 }

core/src/tests/generics/automorphism/glwe_ct.rs

@@ -23,7 +23,8 @@ use crate::{
     noise::log2_std_noise_gglwe_product,
 };
 
-pub fn test_glwe_automorphism<B: Backend>(
+#[allow(clippy::too_many_arguments)]
+pub fn test_glwe_automorphism<B>(
     module: &Module<B>,
     basek: usize,
     p: i64,
@@ -63,7 +64,8 @@ pub fn test_glwe_automorphism<B: Backend>(
         + VecZnxAutomorphismInplace
         + VmpPMatAlloc<B>
         + VmpPrepare<B>,
-    B: TakeVecZnxDftImpl<B>
+    B: Backend
+        + TakeVecZnxDftImpl<B>
         + TakeVecZnxBigImpl<B>
         + TakeSvpPPolImpl<B>
         + ScratchOwnedAllocImpl<B>
@@ -150,7 +152,8 @@ pub fn test_glwe_automorphism<B: Backend>(
     ct_out.assert_noise(module, &sk_prepared, &pt_want, max_noise + 1.0);
 }
 
-pub fn test_glwe_automorphism_inplace<B: Backend>(
+#[allow(clippy::too_many_arguments)]
+pub fn test_glwe_automorphism_inplace<B>(
     module: &Module<B>,
     basek: usize,
     p: i64,
@@ -189,7 +192,8 @@ pub fn test_glwe_automorphism_inplace<B: Backend>(
         + VecZnxAutomorphismInplace
         + VmpPMatAlloc<B>
         + VmpPrepare<B>,
-    B: TakeVecZnxDftImpl<B>
+    B: Backend
+        + TakeVecZnxDftImpl<B>
         + TakeVecZnxBigImpl<B>
         + TakeSvpPPolImpl<B>
         + ScratchOwnedAllocImpl<B>

core/src/tests/generics/conversion.rs

@@ -21,7 +21,7 @@ use crate::layouts::{
     prepared::{GLWESecretPrepared, GLWEToLWESwitchingKeyPrepared, LWEToGLWESwitchingKeyPrepared, PrepareAlloc},
 };
 
-pub fn test_lwe_to_glwe<B: Backend>(module: &Module<B>)
+pub fn test_lwe_to_glwe<B>(module: &Module<B>)
 where
     Module<B>: VecZnxDftAllocBytes
         + VecZnxBigNormalize<B>
@@ -51,7 +51,8 @@ where
         + VecZnxBigNormalizeTmpBytes
         + VecZnxSwithcDegree
         + VecZnxAutomorphismInplace,
-    B: TakeVecZnxDftImpl<B>
+    B: Backend
+        + TakeVecZnxDftImpl<B>
         + TakeVecZnxBigImpl<B>
         + TakeSvpPPolImpl<B>
         + ScratchOwnedAllocImpl<B>
@@ -131,7 +132,7 @@ where
     assert_eq!(glwe_pt.data.at(0, 0)[0], lwe_pt.data.at(0, 0)[0]);
 }
 
-pub fn test_glwe_to_lwe<B: Backend>(module: &Module<B>)
+pub fn test_glwe_to_lwe<B>(module: &Module<B>)
 where
     Module<B>: VecZnxDftAllocBytes
         + VecZnxBigNormalize<B>
@@ -161,7 +162,8 @@ where
         + VecZnxBigNormalizeTmpBytes
         + VecZnxSwithcDegree
         + VecZnxAutomorphismInplace,
-    B: TakeVecZnxDftImpl<B>
+    B: Backend
+        + TakeVecZnxDftImpl<B>
         + TakeVecZnxBigImpl<B>
         + TakeSvpPPolImpl<B>
         + ScratchOwnedAllocImpl<B>

core/src/tests/generics/encryption/gglwe_atk.rs

@@ -21,7 +21,7 @@ use crate::layouts::{
     prepared::{GLWESecretPrepared, PrepareAlloc},
 };
 
-pub fn test_gglwe_automorphisk_key_encrypt_sk<B: Backend>(
+pub fn test_gglwe_automorphisk_key_encrypt_sk<B>(
     module: &Module<B>,
     basek: usize,
     k_ksk: usize,
@@ -60,7 +60,8 @@ pub fn test_gglwe_automorphisk_key_encrypt_sk<B: Backend>(
         + VecZnxCopy
         + VmpPMatAlloc<B>
         + VmpPrepare<B>,
-    B: ScratchOwnedAllocImpl<B>
+    B: Backend
+        + ScratchOwnedAllocImpl<B>
         + ScratchOwnedBorrowImpl<B>
         + ScratchAvailableImpl<B>
         + TakeScalarZnxImpl<B>
@@ -114,7 +115,7 @@ pub fn test_gglwe_automorphisk_key_encrypt_sk<B: Backend>(
         .assert_noise(module, &sk_out_prepared, &sk.data, sigma);
 }
 
-pub fn test_gglwe_automorphisk_key_compressed_encrypt_sk<B: Backend>(
+pub fn test_gglwe_automorphisk_key_compressed_encrypt_sk<B>(
     module: &Module<B>,
     basek: usize,
     k_ksk: usize,
@@ -153,7 +154,8 @@ pub fn test_gglwe_automorphisk_key_compressed_encrypt_sk<B: Backend>(
         + VecZnxCopy
         + VmpPMatAlloc<B>
         + VmpPrepare<B>,
-    B: ScratchOwnedAllocImpl<B>
+    B: Backend
+        + ScratchOwnedAllocImpl<B>
         + ScratchOwnedBorrowImpl<B>
         + ScratchAvailableImpl<B>
         + TakeScalarZnxImpl<B>