core refactoring (#69)

core/src/layouts/prepared/gglwe_atk.rs

@@ -0,0 +1,97 @@
+use backend::hal::{
+    api::{VmpPMatAlloc, VmpPMatAllocBytes, VmpPMatPrepare},
+    layouts::{Backend, Data, DataMut, DataRef, Module, Scratch, VmpPMat},
+};
+
+use crate::layouts::{GGLWEAutomorphismKey, Infos, prepared::GGLWESwitchingKeyExec};
+
+#[derive(PartialEq, Eq)]
+pub struct GGLWEAutomorphismKeyExec<D: Data, B: Backend> {
+    pub(crate) key: GGLWESwitchingKeyExec<D, B>,
+    pub(crate) p: i64,
+}
+
+impl<B: Backend> GGLWEAutomorphismKeyExec<Vec<u8>, B> {
+    pub fn alloc(module: &Module<B>, n: usize, basek: usize, k: usize, rows: usize, digits: usize, rank: usize) -> Self
+    where
+        Module<B>: VmpPMatAlloc<B>,
+    {
+        GGLWEAutomorphismKeyExec::<Vec<u8>, B> {
+            key: GGLWESwitchingKeyExec::alloc(module, n, basek, k, rows, digits, rank, rank),
+            p: 0,
+        }
+    }
+
+    pub fn bytes_of(module: &Module<B>, n: usize, basek: usize, k: usize, rows: usize, digits: usize, rank: usize) -> usize
+    where
+        Module<B>: VmpPMatAllocBytes,
+    {
+        GGLWESwitchingKeyExec::bytes_of(module, n, basek, k, rows, digits, rank, rank)
+    }
+
+    pub fn from<DataOther: DataRef>(module: &Module<B>, other: &GGLWEAutomorphismKey<DataOther>, scratch: &mut Scratch<B>) -> Self
+    where
+        Module<B>: VmpPMatAlloc<B> + VmpPMatPrepare<B>,
+    {
+        let mut atk_exec: GGLWEAutomorphismKeyExec<Vec<u8>, B> = Self::alloc(
+            module,
+            other.n(),
+            other.basek(),
+            other.k(),
+            other.rows(),
+            other.digits(),
+            other.rank(),
+        );
+        atk_exec.prepare(module, other, scratch);
+        atk_exec
+    }
+}
+
+impl<D: Data, B: Backend> Infos for GGLWEAutomorphismKeyExec<D, B> {
+    type Inner = VmpPMat<D, B>;
+
+    fn inner(&self) -> &Self::Inner {
+        &self.key.inner()
+    }
+
+    fn basek(&self) -> usize {
+        self.key.basek()
+    }
+
+    fn k(&self) -> usize {
+        self.key.k()
+    }
+}
+
+impl<D: Data, B: Backend> GGLWEAutomorphismKeyExec<D, B> {
+    pub fn p(&self) -> i64 {
+        self.p
+    }
+
+    pub fn digits(&self) -> usize {
+        self.key.digits()
+    }
+
+    pub fn rank(&self) -> usize {
+        self.key.rank()
+    }
+
+    pub fn rank_in(&self) -> usize {
+        self.key.rank_in()
+    }
+
+    pub fn rank_out(&self) -> usize {
+        self.key.rank_out()
+    }
+}
+
+impl<D: DataMut, B: Backend> GGLWEAutomorphismKeyExec<D, B> {
+    pub fn prepare<DataOther>(&mut self, module: &Module<B>, other: &GGLWEAutomorphismKey<DataOther>, scratch: &mut Scratch<B>)
+    where
+        DataOther: DataRef,
+        Module<B>: VmpPMatPrepare<B>,
+    {
+        self.key.prepare(module, &other.key, scratch);
+        self.p = other.p;
+    }
+}

core/src/layouts/prepared/gglwe_ct.rs

@@ -0,0 +1,132 @@
+use backend::hal::{
+    api::{VmpPMatAlloc, VmpPMatAllocBytes, VmpPMatPrepare},
+    layouts::{Backend, Data, DataMut, DataRef, Module, Scratch, VmpPMat},
+};
+
+use crate::layouts::{GGLWECiphertext, Infos};
+
+#[derive(PartialEq, Eq)]
+pub struct GGLWECiphertextExec<D: Data, B: Backend> {
+    pub(crate) data: VmpPMat<D, B>,
+    pub(crate) basek: usize,
+    pub(crate) k: usize,
+    pub(crate) digits: usize,
+}
+
+impl<B: Backend> GGLWECiphertextExec<Vec<u8>, B> {
+    pub fn alloc(
+        module: &Module<B>,
+        n: usize,
+        basek: usize,
+        k: usize,
+        rows: usize,
+        digits: usize,
+        rank_in: usize,
+        rank_out: usize,
+    ) -> Self
+    where
+        Module<B>: VmpPMatAlloc<B>,
+    {
+        let size: usize = k.div_ceil(basek);
+        debug_assert!(
+            size > digits,
+            "invalid gglwe: ceil(k/basek): {} <= digits: {}",
+            size,
+            digits
+        );
+
+        assert!(
+            rows * digits <= size,
+            "invalid gglwe: rows: {} * digits:{} > ceil(k/basek): {}",
+            rows,
+            digits,
+            size
+        );
+
+        Self {
+            data: module.vmp_pmat_alloc(n, rows, rank_in, rank_out + 1, size),
+            basek: basek,
+            k,
+            digits,
+        }
+    }
+
+    pub fn bytes_of(
+        module: &Module<B>,
+        n: usize,
+        basek: usize,
+        k: usize,
+        rows: usize,
+        digits: usize,
+        rank_in: usize,
+        rank_out: usize,
+    ) -> usize
+    where
+        Module<B>: VmpPMatAllocBytes,
+    {
+        let size: usize = k.div_ceil(basek);
+        debug_assert!(
+            size > digits,
+            "invalid gglwe: ceil(k/basek): {} <= digits: {}",
+            size,
+            digits
+        );
+
+        assert!(
+            rows * digits <= size,
+            "invalid gglwe: rows: {} * digits:{} > ceil(k/basek): {}",
+            rows,
+            digits,
+            size
+        );
+
+        module.vmp_pmat_alloc_bytes(n, rows, rank_in, rank_out + 1, rows)
+    }
+}
+
+impl<D: Data, B: Backend> Infos for GGLWECiphertextExec<D, B> {
+    type Inner = VmpPMat<D, B>;
+
+    fn inner(&self) -> &Self::Inner {
+        &self.data
+    }
+
+    fn basek(&self) -> usize {
+        self.basek
+    }
+
+    fn k(&self) -> usize {
+        self.k
+    }
+}
+
+impl<D: Data, B: Backend> GGLWECiphertextExec<D, B> {
+    pub fn rank(&self) -> usize {
+        self.data.cols_out() - 1
+    }
+
+    pub fn digits(&self) -> usize {
+        self.digits
+    }
+
+    pub fn rank_in(&self) -> usize {
+        self.data.cols_in()
+    }
+
+    pub fn rank_out(&self) -> usize {
+        self.data.cols_out() - 1
+    }
+}
+
+impl<D: DataMut, B: Backend> GGLWECiphertextExec<D, B> {
+    pub fn prepare<DataOther>(&mut self, module: &Module<B>, other: &GGLWECiphertext<DataOther>, scratch: &mut Scratch<B>)
+    where
+        DataOther: DataRef,
+        Module<B>: VmpPMatPrepare<B>,
+    {
+        module.vmp_prepare(&mut self.data, &other.data, scratch);
+        self.basek = other.basek;
+        self.k = other.k;
+        self.digits = other.digits;
+    }
+}

core/src/layouts/prepared/gglwe_ksk.rs

@@ -0,0 +1,123 @@
+use backend::hal::{
+    api::{VmpPMatAlloc, VmpPMatAllocBytes, VmpPMatPrepare},
+    layouts::{Backend, Data, DataMut, DataRef, Module, Scratch, VmpPMat},
+};
+
+use crate::layouts::{GGLWESwitchingKey, Infos, prepared::GGLWECiphertextExec};
+
+#[derive(PartialEq, Eq)]
+pub struct GGLWESwitchingKeyExec<D: Data, B: Backend> {
+    pub(crate) key: GGLWECiphertextExec<D, B>,
+    pub(crate) sk_in_n: usize,  // Degree of sk_in
+    pub(crate) sk_out_n: usize, // Degree of sk_out
+}
+
+impl<B: Backend> GGLWESwitchingKeyExec<Vec<u8>, B> {
+    pub fn alloc(
+        module: &Module<B>,
+        n: usize,
+        basek: usize,
+        k: usize,
+        rows: usize,
+        digits: usize,
+        rank_in: usize,
+        rank_out: usize,
+    ) -> Self
+    where
+        Module<B>: VmpPMatAlloc<B>,
+    {
+        GGLWESwitchingKeyExec::<Vec<u8>, B> {
+            key: GGLWECiphertextExec::alloc(module, n, basek, k, rows, digits, rank_in, rank_out),
+            sk_in_n: 0,
+            sk_out_n: 0,
+        }
+    }
+
+    pub fn bytes_of(
+        module: &Module<B>,
+        n: usize,
+        basek: usize,
+        k: usize,
+        rows: usize,
+        digits: usize,
+        rank_in: usize,
+        rank_out: usize,
+    ) -> usize
+    where
+        Module<B>: VmpPMatAllocBytes,
+    {
+        GGLWECiphertextExec::bytes_of(module, n, basek, k, rows, digits, rank_in, rank_out)
+    }
+
+    pub fn from<DataOther: DataRef>(module: &Module<B>, other: &GGLWESwitchingKey<DataOther>, scratch: &mut Scratch<B>) -> Self
+    where
+        Module<B>: VmpPMatAlloc<B> + VmpPMatPrepare<B>,
+    {
+        let mut ksk_exec: GGLWESwitchingKeyExec<Vec<u8>, B> = Self::alloc(
+            module,
+            other.n(),
+            other.basek(),
+            other.k(),
+            other.rows(),
+            other.digits(),
+            other.rank_in(),
+            other.rank_out(),
+        );
+        ksk_exec.prepare(module, other, scratch);
+        ksk_exec
+    }
+}
+
+impl<D: Data, B: Backend> Infos for GGLWESwitchingKeyExec<D, B> {
+    type Inner = VmpPMat<D, B>;
+
+    fn inner(&self) -> &Self::Inner {
+        self.key.inner()
+    }
+
+    fn basek(&self) -> usize {
+        self.key.basek()
+    }
+
+    fn k(&self) -> usize {
+        self.key.k()
+    }
+}
+
+impl<D: Data, B: Backend> GGLWESwitchingKeyExec<D, B> {
+    pub fn rank(&self) -> usize {
+        self.key.data.cols_out() - 1
+    }
+
+    pub fn rank_in(&self) -> usize {
+        self.key.data.cols_in()
+    }
+
+    pub fn rank_out(&self) -> usize {
+        self.key.data.cols_out() - 1
+    }
+
+    pub fn digits(&self) -> usize {
+        self.key.digits()
+    }
+
+    pub fn sk_degree_in(&self) -> usize {
+        self.sk_in_n
+    }
+
+    pub fn sk_degree_out(&self) -> usize {
+        self.sk_out_n
+    }
+}
+
+impl<D: DataMut, B: Backend> GGLWESwitchingKeyExec<D, B> {
+    pub fn prepare<DataOther>(&mut self, module: &Module<B>, other: &GGLWESwitchingKey<DataOther>, scratch: &mut Scratch<B>)
+    where
+        DataOther: DataRef,
+        Module<B>: VmpPMatPrepare<B>,
+    {
+        self.key.prepare(module, &other.key, scratch);
+        self.sk_in_n = other.sk_in_n;
+        self.sk_out_n = other.sk_out_n;
+    }
+}

core/src/layouts/prepared/gglwe_tsk.rs

@@ -0,0 +1,131 @@
+use backend::hal::{
+    api::{VmpPMatAlloc, VmpPMatAllocBytes, VmpPMatPrepare},
+    layouts::{Backend, Data, DataMut, DataRef, Module, Scratch, VmpPMat},
+};
+
+use crate::layouts::{GGLWETensorKey, Infos, prepared::GGLWESwitchingKeyExec};
+
+#[derive(PartialEq, Eq)]
+pub struct GGLWETensorKeyExec<D: Data, B: Backend> {
+    pub(crate) keys: Vec<GGLWESwitchingKeyExec<D, B>>,
+}
+
+impl<B: Backend> GGLWETensorKeyExec<Vec<u8>, B> {
+    pub fn alloc(module: &Module<B>, n: usize, basek: usize, k: usize, rows: usize, digits: usize, rank: usize) -> Self
+    where
+        Module<B>: VmpPMatAlloc<B>,
+    {
+        let mut keys: Vec<GGLWESwitchingKeyExec<Vec<u8>, B>> = Vec::new();
+        let pairs: usize = (((rank + 1) * rank) >> 1).max(1);
+        (0..pairs).for_each(|_| {
+            keys.push(GGLWESwitchingKeyExec::alloc(
+                module, n, basek, k, rows, digits, 1, rank,
+            ));
+        });
+        Self { keys }
+    }
+
+    pub fn bytes_of(module: &Module<B>, n: usize, basek: usize, k: usize, rows: usize, digits: usize, rank: usize) -> usize
+    where
+        Module<B>: VmpPMatAllocBytes,
+    {
+        let pairs: usize = (((rank + 1) * rank) >> 1).max(1);
+        pairs * GGLWESwitchingKeyExec::bytes_of(module, n, basek, k, rows, digits, 1, rank)
+    }
+
+    pub fn from<D: DataRef>(
+        module: &Module<B>,
+        other: &GGLWETensorKey<D>,
+        scratch: &mut Scratch<B>,
+    ) -> GGLWETensorKeyExec<Vec<u8>, B>
+    where
+        Module<B>: VmpPMatAlloc<B> + VmpPMatPrepare<B>,
+    {
+        let mut tsk_exec: GGLWETensorKeyExec<Vec<u8>, B> = Self::alloc(
+            module,
+            other.n(),
+            other.basek(),
+            other.k(),
+            other.rows(),
+            other.digits(),
+            other.rank(),
+        );
+        tsk_exec.prepare(module, other, scratch);
+        tsk_exec
+    }
+}
+
+impl<D: Data, B: Backend> Infos for GGLWETensorKeyExec<D, B> {
+    type Inner = VmpPMat<D, B>;
+
+    fn inner(&self) -> &Self::Inner {
+        &self.keys[0].inner()
+    }
+
+    fn basek(&self) -> usize {
+        self.keys[0].basek()
+    }
+
+    fn k(&self) -> usize {
+        self.keys[0].k()
+    }
+}
+
+impl<D: Data, B: Backend> GGLWETensorKeyExec<D, B> {
+    pub fn rank(&self) -> usize {
+        self.keys[0].rank()
+    }
+
+    pub fn rank_in(&self) -> usize {
+        self.keys[0].rank_in()
+    }
+
+    pub fn rank_out(&self) -> usize {
+        self.keys[0].rank_out()
+    }
+
+    pub fn digits(&self) -> usize {
+        self.keys[0].digits()
+    }
+}
+
+impl<D: DataMut, B: Backend> GGLWETensorKeyExec<D, B> {
+    // Returns a mutable reference to GLWESwitchingKey_{s}(s[i] * s[j])
+    pub fn at_mut(&mut self, mut i: usize, mut j: usize) -> &mut GGLWESwitchingKeyExec<D, B> {
+        if i > j {
+            std::mem::swap(&mut i, &mut j);
+        };
+        let rank: usize = self.rank();
+        &mut self.keys[i * rank + j - (i * (i + 1) / 2)]
+    }
+}
+
+impl<D: DataRef, B: Backend> GGLWETensorKeyExec<D, B> {
+    // Returns a reference to GLWESwitchingKey_{s}(s[i] * s[j])
+    pub fn at(&self, mut i: usize, mut j: usize) -> &GGLWESwitchingKeyExec<D, B> {
+        if i > j {
+            std::mem::swap(&mut i, &mut j);
+        };
+        let rank: usize = self.rank();
+        &self.keys[i * rank + j - (i * (i + 1) / 2)]
+    }
+}
+
+impl<D: DataMut, B: Backend> GGLWETensorKeyExec<D, B> {
+    pub fn prepare<DataOther>(&mut self, module: &Module<B>, other: &GGLWETensorKey<DataOther>, scratch: &mut Scratch<B>)
+    where
+        DataOther: DataRef,
+        Module<B>: VmpPMatPrepare<B>,
+    {
+        #[cfg(debug_assertions)]
+        {
+            assert_eq!(self.keys.len(), other.keys.len());
+        }
+        self.keys
+            .iter_mut()
+            .zip(other.keys.iter())
+            .for_each(|(a, b)| {
+                a.prepare(module, b, scratch);
+            });
+    }
+}

core/src/layouts/prepared/ggsw_ct.rs

@@ -0,0 +1,129 @@
+use backend::hal::{
+    api::{VmpPMatAlloc, VmpPMatAllocBytes, VmpPMatPrepare},
+    layouts::{Backend, Data, DataMut, DataRef, Module, Scratch, VmpPMat},
+};
+
+use crate::layouts::{GGSWCiphertext, Infos};
+
+#[derive(PartialEq, Eq)]
+pub struct GGSWCiphertextExec<D: Data, B: Backend> {
+    pub(crate) data: VmpPMat<D, B>,
+    pub(crate) basek: usize,
+    pub(crate) k: usize,
+    pub(crate) digits: usize,
+}
+
+impl<B: Backend> GGSWCiphertextExec<Vec<u8>, B> {
+    pub fn alloc(module: &Module<B>, n: usize, basek: usize, k: usize, rows: usize, digits: usize, rank: usize) -> Self
+    where
+        Module<B>: VmpPMatAlloc<B>,
+    {
+        let size: usize = k.div_ceil(basek);
+        debug_assert!(digits > 0, "invalid ggsw: `digits` == 0");
+
+        debug_assert!(
+            size > digits,
+            "invalid ggsw: ceil(k/basek): {} <= digits: {}",
+            size,
+            digits
+        );
+
+        assert!(
+            rows * digits <= size,
+            "invalid ggsw: rows: {} * digits:{} > ceil(k/basek): {}",
+            rows,
+            digits,
+            size
+        );
+
+        Self {
+            data: module.vmp_pmat_alloc(n, rows, rank + 1, rank + 1, k.div_ceil(basek)),
+            basek,
+            k: k,
+            digits,
+        }
+    }
+
+    pub fn bytes_of(module: &Module<B>, n: usize, basek: usize, k: usize, rows: usize, digits: usize, rank: usize) -> usize
+    where
+        Module<B>: VmpPMatAllocBytes,
+    {
+        let size: usize = k.div_ceil(basek);
+        debug_assert!(
+            size > digits,
+            "invalid ggsw: ceil(k/basek): {} <= digits: {}",
+            size,
+            digits
+        );
+
+        assert!(
+            rows * digits <= size,
+            "invalid ggsw: rows: {} * digits:{} > ceil(k/basek): {}",
+            rows,
+            digits,
+            size
+        );
+
+        module.vmp_pmat_alloc_bytes(n, rows, rank + 1, rank + 1, size)
+    }
+
+    pub fn from<DataOther: DataRef>(
+        module: &Module<B>,
+        other: &GGSWCiphertext<DataOther>,
+        scratch: &mut Scratch<B>,
+    ) -> GGSWCiphertextExec<Vec<u8>, B>
+    where
+        Module<B>: VmpPMatAlloc<B> + VmpPMatPrepare<B>,
+    {
+        let mut ggsw_exec: GGSWCiphertextExec<Vec<u8>, B> = Self::alloc(
+            module,
+            other.n(),
+            other.basek(),
+            other.k(),
+            other.rows(),
+            other.digits(),
+            other.rank(),
+        );
+        ggsw_exec.prepare(module, other, scratch);
+        ggsw_exec
+    }
+}
+
+impl<D: Data, B: Backend> Infos for GGSWCiphertextExec<D, B> {
+    type Inner = VmpPMat<D, B>;
+
+    fn inner(&self) -> &Self::Inner {
+        &self.data
+    }
+
+    fn basek(&self) -> usize {
+        self.basek
+    }
+
+    fn k(&self) -> usize {
+        self.k
+    }
+}
+
+impl<D: Data, B: Backend> GGSWCiphertextExec<D, B> {
+    pub fn rank(&self) -> usize {
+        self.data.cols_out() - 1
+    }
+
+    pub fn digits(&self) -> usize {
+        self.digits
+    }
+}
+
+impl<DataSelf: DataMut, B: Backend> GGSWCiphertextExec<DataSelf, B> {
+    pub fn prepare<DataOther>(&mut self, module: &Module<B>, other: &GGSWCiphertext<DataOther>, scratch: &mut Scratch<B>)
+    where
+        DataOther: DataRef,
+        Module<B>: VmpPMatPrepare<B>,
+    {
+        module.vmp_prepare(&mut self.data, &other.data, scratch);
+        self.k = other.k;
+        self.basek = other.basek;
+        self.digits = other.digits;
+    }
+}

core/src/layouts/prepared/glwe_pk.rs

@@ -0,0 +1,92 @@
+use backend::hal::{
+    api::{VecZnxDftAlloc, VecZnxDftAllocBytes, VecZnxDftFromVecZnx},
+    layouts::{Backend, Data, DataMut, DataRef, Module, Scratch, VecZnxDft},
+};
+
+use crate::{
+    dist::Distribution,
+    layouts::{GLWEPublicKey, Infos},
+};
+
+#[derive(PartialEq, Eq)]
+pub struct GLWEPublicKeyExec<D: Data, B: Backend> {
+    pub(crate) data: VecZnxDft<D, B>,
+    pub(crate) basek: usize,
+    pub(crate) k: usize,
+    pub(crate) dist: Distribution,
+}
+
+impl<D: Data, B: Backend> Infos for GLWEPublicKeyExec<D, B> {
+    type Inner = VecZnxDft<D, B>;
+
+    fn inner(&self) -> &Self::Inner {
+        &self.data
+    }
+
+    fn basek(&self) -> usize {
+        self.basek
+    }
+
+    fn k(&self) -> usize {
+        self.k
+    }
+}
+
+impl<D: Data, B: Backend> GLWEPublicKeyExec<D, B> {
+    pub fn rank(&self) -> usize {
+        self.cols() - 1
+    }
+}
+
+impl<B: Backend> GLWEPublicKeyExec<Vec<u8>, B> {
+    pub fn alloc(module: &Module<B>, n: usize, basek: usize, k: usize, rank: usize) -> Self
+    where
+        Module<B>: VecZnxDftAlloc<B>,
+    {
+        Self {
+            data: module.vec_znx_dft_alloc(n, rank + 1, k.div_ceil(basek)),
+            basek: basek,
+            k: k,
+            dist: Distribution::NONE,
+        }
+    }
+
+    pub fn bytes_of(module: &Module<B>, n: usize, basek: usize, k: usize, rank: usize) -> usize
+    where
+        Module<B>: VecZnxDftAllocBytes,
+    {
+        module.vec_znx_dft_alloc_bytes(n, rank + 1, k.div_ceil(basek))
+    }
+
+    pub fn from<DataOther>(module: &Module<B>, other: &GLWEPublicKey<DataOther>, scratch: &mut Scratch<B>) -> Self
+    where
+        DataOther: DataRef,
+        Module<B>: VecZnxDftAlloc<B> + VecZnxDftFromVecZnx<B>,
+    {
+        let mut pk_exec: GLWEPublicKeyExec<Vec<u8>, B> =
+            GLWEPublicKeyExec::alloc(module, other.n(), other.basek(), other.k(), other.rank());
+        pk_exec.prepare(module, other, scratch);
+        pk_exec
+    }
+}
+
+impl<D: DataMut, B: Backend> GLWEPublicKeyExec<D, B> {
+    pub fn prepare<DataOther>(&mut self, module: &Module<B>, other: &GLWEPublicKey<DataOther>, _scratch: &mut Scratch<B>)
+    where
+        DataOther: DataRef,
+        Module<B>: VecZnxDftFromVecZnx<B>,
+    {
+        #[cfg(debug_assertions)]
+        {
+            assert_eq!(self.n(), other.n());
+            assert_eq!(self.size(), other.size());
+        }
+
+        (0..self.cols()).for_each(|i| {
+            module.vec_znx_dft_from_vec_znx(1, 0, &mut self.data, i, &other.data, i);
+        });
+        self.k = other.k;
+        self.basek = other.basek;
+        self.dist = other.dist;
+    }
+}

core/src/layouts/prepared/glwe_sk.rs

@@ -0,0 +1,69 @@
+use backend::hal::{
+    api::{SvpPPolAlloc, SvpPPolAllocBytes, SvpPrepare, ZnxInfos},
+    layouts::{Backend, Data, DataMut, DataRef, Module, SvpPPol},
+};
+
+use crate::{dist::Distribution, layouts::GLWESecret, trait_families::GLWESecretExecModuleFamily};
+
+pub struct GLWESecretExec<D: Data, B: Backend> {
+    pub(crate) data: SvpPPol<D, B>,
+    pub(crate) dist: Distribution,
+}
+
+impl<B: Backend> GLWESecretExec<Vec<u8>, B> {
+    pub fn alloc(module: &Module<B>, n: usize, rank: usize) -> Self
+    where
+        Module<B>: GLWESecretExecModuleFamily<B>,
+    {
+        Self {
+            data: module.svp_ppol_alloc(n, rank),
+            dist: Distribution::NONE,
+        }
+    }
+
+    pub fn bytes_of(module: &Module<B>, n: usize, rank: usize) -> usize
+    where
+        Module<B>: GLWESecretExecModuleFamily<B>,
+    {
+        module.svp_ppol_alloc_bytes(n, rank)
+    }
+}
+
+impl<B: Backend> GLWESecretExec<Vec<u8>, B> {
+    pub fn from<D>(module: &Module<B>, sk: &GLWESecret<D>) -> Self
+    where
+        D: DataRef,
+        Module<B>: GLWESecretExecModuleFamily<B>,
+    {
+        let mut sk_dft: GLWESecretExec<Vec<u8>, B> = Self::alloc(module, sk.n(), sk.rank());
+        sk_dft.prepare(module, sk);
+        sk_dft
+    }
+}
+
+impl<D: Data, B: Backend> GLWESecretExec<D, B> {
+    pub fn n(&self) -> usize {
+        self.data.n()
+    }
+
+    pub fn log_n(&self) -> usize {
+        self.data.log_n()
+    }
+
+    pub fn rank(&self) -> usize {
+        self.data.cols()
+    }
+}
+
+impl<D: DataMut, B: Backend> GLWESecretExec<D, B> {
+    pub(crate) fn prepare<O>(&mut self, module: &Module<B>, sk: &GLWESecret<O>)
+    where
+        O: DataRef,
+        Module<B>: GLWESecretExecModuleFamily<B>,
+    {
+        (0..self.rank()).for_each(|i| {
+            module.svp_prepare(&mut self.data, i, &sk.data, i);
+        });
+        self.dist = sk.dist
+    }
+}

core/src/layouts/prepared/glwe_to_lwe_ksk.rs

@@ -0,0 +1,91 @@
+use backend::hal::{
+    api::{VmpPMatAlloc, VmpPMatAllocBytes, VmpPMatPrepare},
+    layouts::{Backend, Data, DataMut, DataRef, Module, Scratch, VmpPMat},
+};
+
+use crate::layouts::{GLWEToLWESwitchingKey, Infos, prepared::GGLWESwitchingKeyExec};
+
+#[derive(PartialEq, Eq)]
+pub struct GLWEToLWESwitchingKeyExec<D: Data, B: Backend>(pub(crate) GGLWESwitchingKeyExec<D, B>);
+
+impl<D: Data, B: Backend> Infos for GLWEToLWESwitchingKeyExec<D, B> {
+    type Inner = VmpPMat<D, B>;
+
+    fn inner(&self) -> &Self::Inner {
+        &self.0.inner()
+    }
+
+    fn basek(&self) -> usize {
+        self.0.basek()
+    }
+
+    fn k(&self) -> usize {
+        self.0.k()
+    }
+}
+
+impl<D: Data, B: Backend> GLWEToLWESwitchingKeyExec<D, B> {
+    pub fn digits(&self) -> usize {
+        self.0.digits()
+    }
+
+    pub fn rank(&self) -> usize {
+        self.0.rank()
+    }
+
+    pub fn rank_in(&self) -> usize {
+        self.0.rank_in()
+    }
+
+    pub fn rank_out(&self) -> usize {
+        self.0.rank_out()
+    }
+}
+
+impl<B: Backend> GLWEToLWESwitchingKeyExec<Vec<u8>, B> {
+    pub fn alloc(module: &Module<B>, n: usize, basek: usize, k: usize, rows: usize, rank_in: usize) -> Self
+    where
+        Module<B>: VmpPMatAlloc<B>,
+    {
+        Self(GGLWESwitchingKeyExec::alloc(
+            module, n, basek, k, rows, 1, rank_in, 1,
+        ))
+    }
+
+    pub fn bytes_of(module: &Module<B>, n: usize, basek: usize, k: usize, rows: usize, digits: usize, rank_in: usize) -> usize
+    where
+        Module<B>: VmpPMatAllocBytes,
+    {
+        GGLWESwitchingKeyExec::<Vec<u8>, B>::bytes_of(module, n, basek, k, rows, digits, rank_in, 1)
+    }
+
+    pub fn from<DataOther: DataRef>(
+        module: &Module<B>,
+        other: &GLWEToLWESwitchingKey<DataOther>,
+        scratch: &mut Scratch<B>,
+    ) -> Self
+    where
+        Module<B>: VmpPMatAlloc<B> + VmpPMatPrepare<B>,
+    {
+        let mut ksk_exec: GLWEToLWESwitchingKeyExec<Vec<u8>, B> = Self::alloc(
+            module,
+            other.0.n(),
+            other.0.basek(),
+            other.0.k(),
+            other.0.rows(),
+            other.0.rank_in(),
+        );
+        ksk_exec.prepare(module, other, scratch);
+        ksk_exec
+    }
+}
+
+impl<D: DataMut, B: Backend> GLWEToLWESwitchingKeyExec<D, B> {
+    pub fn prepare<DataOther>(&mut self, module: &Module<B>, other: &GLWEToLWESwitchingKey<DataOther>, scratch: &mut Scratch<B>)
+    where
+        DataOther: DataRef,
+        Module<B>: VmpPMatPrepare<B>,
+    {
+        self.0.prepare(module, &other.0, scratch);
+    }
+}

core/src/layouts/prepared/lwe_ksk.rs

@@ -0,0 +1,86 @@
+use backend::hal::{
+    api::{VmpPMatAlloc, VmpPMatAllocBytes, VmpPMatPrepare},
+    layouts::{Backend, Data, DataMut, DataRef, Module, Scratch, VmpPMat},
+};
+
+use crate::layouts::{Infos, LWESwitchingKey, prepared::GGLWESwitchingKeyExec};
+
+#[derive(PartialEq, Eq)]
+pub struct LWESwitchingKeyExec<D: Data, B: Backend>(pub(crate) GGLWESwitchingKeyExec<D, B>);
+
+impl<D: Data, B: Backend> Infos for LWESwitchingKeyExec<D, B> {
+    type Inner = VmpPMat<D, B>;
+
+    fn inner(&self) -> &Self::Inner {
+        &self.0.inner()
+    }
+
+    fn basek(&self) -> usize {
+        self.0.basek()
+    }
+
+    fn k(&self) -> usize {
+        self.0.k()
+    }
+}
+
+impl<D: Data, B: Backend> LWESwitchingKeyExec<D, B> {
+    pub fn digits(&self) -> usize {
+        self.0.digits()
+    }
+
+    pub fn rank(&self) -> usize {
+        self.0.rank()
+    }
+
+    pub fn rank_in(&self) -> usize {
+        self.0.rank_in()
+    }
+
+    pub fn rank_out(&self) -> usize {
+        self.0.rank_out()
+    }
+}
+
+impl<B: Backend> LWESwitchingKeyExec<Vec<u8>, B> {
+    pub fn alloc(module: &Module<B>, n: usize, basek: usize, k: usize, rows: usize) -> Self
+    where
+        Module<B>: VmpPMatAlloc<B>,
+    {
+        Self(GGLWESwitchingKeyExec::alloc(
+            module, n, basek, k, rows, 1, 1, 1,
+        ))
+    }
+
+    pub fn bytes_of(module: &Module<B>, n: usize, basek: usize, k: usize, rows: usize, digits: usize) -> usize
+    where
+        Module<B>: VmpPMatAllocBytes,
+    {
+        GGLWESwitchingKeyExec::<Vec<u8>, B>::bytes_of(module, n, basek, k, rows, digits, 1, 1)
+    }
+
+    pub fn from<DataOther: DataRef>(module: &Module<B>, other: &LWESwitchingKey<DataOther>, scratch: &mut Scratch<B>) -> Self
+    where
+        Module<B>: VmpPMatAlloc<B> + VmpPMatPrepare<B>,
+    {
+        let mut ksk_exec: LWESwitchingKeyExec<Vec<u8>, B> = Self::alloc(
+            module,
+            other.0.n(),
+            other.0.basek(),
+            other.0.k(),
+            other.0.rows(),
+        );
+        ksk_exec.prepare(module, other, scratch);
+        ksk_exec
+    }
+}
+
+impl<D: DataMut, B: Backend> LWESwitchingKeyExec<D, B> {
+    pub fn prepare<DataOther>(&mut self, module: &Module<B>, other: &LWESwitchingKey<DataOther>, scratch: &mut Scratch<B>)
+    where
+        DataOther: DataRef,
+        Module<B>: VmpPMatPrepare<B>,
+    {
+        self.0.prepare(module, &other.0, scratch);
+    }
+}

core/src/layouts/prepared/lwe_to_glwe_ksk.rs

@@ -0,0 +1,92 @@
+use backend::hal::{
+    api::{VmpPMatAlloc, VmpPMatAllocBytes, VmpPMatPrepare},
+    layouts::{Backend, Data, DataMut, DataRef, Module, Scratch, VmpPMat},
+};
+
+use crate::layouts::{Infos, LWEToGLWESwitchingKey, prepared::GGLWESwitchingKeyExec};
+
+/// A special [GLWESwitchingKey] required to for the conversion from [LWECiphertext] to [GLWECiphertext].
+#[derive(PartialEq, Eq)]
+pub struct LWEToGLWESwitchingKeyExec<D: Data, B: Backend>(pub(crate) GGLWESwitchingKeyExec<D, B>);
+
+impl<D: Data, B: Backend> Infos for LWEToGLWESwitchingKeyExec<D, B> {
+    type Inner = VmpPMat<D, B>;
+
+    fn inner(&self) -> &Self::Inner {
+        &self.0.inner()
+    }
+
+    fn basek(&self) -> usize {
+        self.0.basek()
+    }
+
+    fn k(&self) -> usize {
+        self.0.k()
+    }
+}
+
+impl<D: Data, B: Backend> LWEToGLWESwitchingKeyExec<D, B> {
+    pub fn digits(&self) -> usize {
+        self.0.digits()
+    }
+
+    pub fn rank(&self) -> usize {
+        self.0.rank()
+    }
+
+    pub fn rank_in(&self) -> usize {
+        self.0.rank_in()
+    }
+
+    pub fn rank_out(&self) -> usize {
+        self.0.rank_out()
+    }
+}
+
+impl<B: Backend> LWEToGLWESwitchingKeyExec<Vec<u8>, B> {
+    pub fn alloc(module: &Module<B>, n: usize, basek: usize, k: usize, rows: usize, rank_out: usize) -> Self
+    where
+        Module<B>: VmpPMatAlloc<B>,
+    {
+        Self(GGLWESwitchingKeyExec::alloc(
+            module, n, basek, k, rows, 1, 1, rank_out,
+        ))
+    }
+
+    pub fn bytes_of(module: &Module<B>, n: usize, basek: usize, k: usize, rows: usize, digits: usize, rank_out: usize) -> usize
+    where
+        Module<B>: VmpPMatAllocBytes,
+    {
+        GGLWESwitchingKeyExec::<Vec<u8>, B>::bytes_of(module, n, basek, k, rows, digits, 1, rank_out)
+    }
+
+    pub fn from<DataOther: DataRef>(
+        module: &Module<B>,
+        other: &LWEToGLWESwitchingKey<DataOther>,
+        scratch: &mut Scratch<B>,
+    ) -> Self
+    where
+        Module<B>: VmpPMatAlloc<B> + VmpPMatPrepare<B>,
+    {
+        let mut ksk_exec: LWEToGLWESwitchingKeyExec<Vec<u8>, B> = Self::alloc(
+            module,
+            other.0.n(),
+            other.0.basek(),
+            other.0.k(),
+            other.0.rows(),
+            other.0.rank(),
+        );
+        ksk_exec.prepare(module, other, scratch);
+        ksk_exec
+    }
+}
+
+impl<D: DataMut, B: Backend> LWEToGLWESwitchingKeyExec<D, B> {
+    pub fn prepare<DataOther>(&mut self, module: &Module<B>, other: &LWEToGLWESwitchingKey<DataOther>, scratch: &mut Scratch<B>)
+    where
+        DataOther: DataRef,
+        Module<B>: VmpPMatPrepare<B>,
+    {
+        self.0.prepare(module, &other.0, scratch);
+    }
+}

core/src/layouts/prepared/mod.rs

@@ -0,0 +1,21 @@
+mod gglwe_atk;
+mod gglwe_ct;
+mod gglwe_ksk;
+mod gglwe_tsk;
+mod ggsw_ct;
+mod glwe_pk;
+mod glwe_sk;
+mod glwe_to_lwe_ksk;
+mod lwe_ksk;
+mod lwe_to_glwe_ksk;
+
+pub use gglwe_atk::*;
+pub use gglwe_ct::*;
+pub use gglwe_ksk::*;
+pub use gglwe_tsk::*;
+pub use ggsw_ct::*;
+pub use glwe_pk::*;
+pub use glwe_sk::*;
+pub use glwe_to_lwe_ksk::*;
+pub use lwe_ksk::*;
+pub use lwe_to_glwe_ksk::*;